1、函数的定义及调用

In [173]: def add(x,y):
     ...:     print(x+y)
     ...:     return x + y
     ...: 

In [174]: add(3,5)
8
Out[174]: 8

2、函数的参数

In [177]: def add(x,y):
     ...:     ret = x + y
     ...:     print(‘{} + {} = {}‘.format(x,y,ret))
     ...:     return ret
     ...:     
     ...: 

In [178]: add(3,5)  #参数按照定义的顺序传入，这样的传参方法叫位置参数
3 + 5 = 8
Out[178]: 8

In [179]: 

In [179]: add(y=3,x=5) #参数按照定义时的变量名传递，这样的传参方法叫关键字参数
5 + 3 = 8
Out[179]: 8


In [181]: def inc(base,x=1):     #x=1就代表是默认值参数
     ...:     return base + x
     ...: 

In [182]: inc(3)
Out[182]: 4

In [183]: inc(3,2)
Out[183]: 5

可变参数
In [184]: def sum(*lst):
     ...:     print(type(lst))
     ...:     ret = 0
     ...:     for x in lst:
     ...:         ret += x
     ...:     return ret
     ...: 
#*lst   参数前加一个星号，表示这个参数是可变的，也就是可以接受任意多个参数，这些参数将
构成一个元组,此时只能通过位置参数传参
     
In [185]: sum(1,2,3)
<class ‘tuple‘>
Out[185]: 6


In [186]: def connect(**kwargs):
     ...:     print(type(kwargs))
     ...:     for k,v in kwargs.items():
     ...:         print(‘{} => {}‘.format(k,v))
     ...:         

#**kwargs  参数前面加两个星号，表示这个参数是可变的，可以接受任意多个参数，这些参数构成
一个字典，此时只能通过关键字参数传参
In [187]: connect(host=‘127.0.0.1‘,port=3306)
<class ‘dict‘>
port => 3306
host => 127.0.0.1

可变参数两种形式：
位置可变参数 ： 参数名前加一个星号， 构成元组， 传参只能以位置参数的形式
关键字可变参数： 参数名前加两个信号， 构成字典， 传参只能以关键字参数的形式

In [190]: def fn(x,y,*args,**kwargs):
     ...:     print(x)
     ...:     print(y)
     ...:     print(args)
     ...:     print(kwargs)
     ...:     

In [191]: fn(1,2,3,4,5,a=1,b=2)
1
2
(3, 4, 5)
{‘a‘: 1, ‘b‘: 2}

通常来说：
默认参数靠后
可变参数靠后
默认参数和可变参数不同时出现

3、参数解构

In [192]: def add(x,y):
     ...:     ret =  x + y
     ...:     print(‘{} + {} = {}‘.format(x,y,ret))
     ...:     return ret
     ...: 

In [193]: add(1,2)
1 + 2 = 3
Out[193]: 3

In [194]: t = 1,2

In [195]: t
Out[195]: (1, 2)

In [196]: add(t[0],t[1])
1 + 2 = 3
Out[196]: 3

In [197]: 

In [197]: add(*t)
1 + 2 = 3
Out[197]: 3

#*t 位置参数解构，加一个星号，可以把可迭代对象解构成位置参数

In [198]: add(*range(2))
0 + 1 = 1
Out[198]: 1

In [199]: 

In [199]: d = {‘x‘:1,‘y‘:2}

In [200]: add(**d)
1 + 2 = 3
Out[200]: 3

#**d 关键字参数解构，加两个星号，可以把字典解构成关键字参数

参数解构的两种形式
一个星号 解构的对象：可迭代对象 解构的结果：位置参数
两个星号 解构的对象：字典 解构的结果：关键字参数

keyword-only参数
In [201]: def fn(*,y):
     ...:     print(y)
     ...:     

#* 星号之后的参数只能通过关键字参数传递，交过keyword-only参数
In [202]: fn(y=3)
3

4、参数的作用域

In [203]: def fn():
     ...:     x = 1
     ...:     print(x)
     ...:     def inner():
     ...:         print(x)
     ...:     inner()
     ...:     

In [204]: fn()
1
1

#上级作用域对下级可见

5、匿名函数

In [208]: lambda x: x+1
Out[208]: <function __main__.<lambda>>

In [209]: (lambda x: x+1)(3)
Out[209]: 4

In [210]: f = lambda x: x+2

In [211]: f(2)
Out[211]: 4

lambda 来定义
参数列表不需要用小括号
冒号不是用来开启新语句块
没有return， 最后一个表达式的值即返回值

6、生成器

In [212]: def g():
     ...:     for x in range(10):
     ...:         yield x   #yield表示弹出一个值
     ...:         

In [213]: r = g()  #函数已经执行完成，函数的现场应该已经被销毁，但是事实上，函数的现场
并没有被销毁

In [214]: r
Out[214]: <generator object g at 0x7f3d60330938>

In [215]: next(r)
Out[215]: 0

In [216]: next(r)
Out[216]: 1

In [217]: next(r)
Out[217]: 2


In [218]: def gen():
     ...:     print(‘a‘)
     ...:     yield 1
     ...:     print(‘b‘)
     ...:     yield 2
     ...:     return 3
     ...: 

In [219]: g = gen() #执行生成器函数的时候，函数体并没有被执行

In [220]: next(g) #执行到第一个yield，停止执行
a
Out[220]: 1

In [221]: next(g)  #从第一个yield之后开始执行， 在第二个yield的时候停止
b
Out[221]: 2

带yield语句的函数称之为生成器函数， 生成器函数的返回值是生成器
生成器函数执行的时候，不会执行函数体
当next生成器的时候， 当前代码执行到之后的第一个yield，会弹出值，并且暂停函数
当再次next生成器的时候，从上次暂停处开始往下执行
当没有多余的yield的时候，会抛出StopIteration异常，异常的value是函数的返回值

In [226]: def counter():
     ...:     x = 0
     ...:     while True:
     ...:         x += 1
     ...:         yield x
     ...:         

In [227]: def inc(c):
     ...:     return next(c)
     ...: 

In [228]: c = counter()

In [229]: inc(c)
Out[229]: 1

In [230]: inc(c)
Out[230]: 2


In [231]: d = counter()

In [232]: next(d)
Out[232]: 1

In [233]: next(d)
Out[233]: 2

In [234]: next(d)
Out[234]: 3

In [242]: def make_inc():
     ...:     def counter():
     ...:         x = 0
     ...:         while True:
     ...:             x += 1
     ...:             yield x
     ...:     c = counter()
     ...:     return lambda: next(c)
     ...:     
     ...:     
     ...: 

In [243]: incr = make_inc()

In [244]: incr
Out[244]: <function __main__.make_inc.<locals>.<lambda>>

In [245]: incr()
Out[245]: 1

In [246]: incr()
Out[246]: 2

本文出自 “厚德载物” 博客，谢绝转载！

Python函数基础