- 1. 相关概念
- 1.1 形式参数/实际参数
- 1.2 位置参数/关键字参数
- 1.3 参数数目可以不确定
- 1.3.1 使用星号*
- 1.3.2 使用双星号**
- 1.3.3。 *与**的作用
- 1.4. 命名关键字参数
- 1.5. 参数组合
- 1.6. 返回值
- 1.7. DocStrings
- 1.8. 函数起别名
- 1.9. 函数式编程
- 2. 高阶函数
- 2.1. 变量可以指向函数
- 2.2. 函数名也是变量
- 2.3. 传入函数
- 2.4. 返回函数
- 3. 匿名函数lambda
- 4. 装饰器
- 5. 偏函数
1. 相关概念
以如下一段程序为例
def add(a,b=0): # a和b是形式参数，形式参数可以定义默认值比如b=0
c = a+b # c是局部变量
global d, e # d和e是全局变量
d = a*b
e = a+b
x=8
y=9
add(x, y) # x和y是实际参数
1.1 形式参数/实际参数
形式参数: 函数定义时写的，系统没有为其分配内存空间，但是在定义里面可以使用的参数。例如：def(a, b=0)。
实际参数：函数调用的时候传给函数的变量。这个是系统实实在在分配了内存空间的变量。
1）形参可以定义默认值 def func(a, b=5, c=10), 但只有在形参表末尾的那些参数可以有默认参数值，例如def func(a, b=5)是有效的，def func(a=5, b)是无效的；
2）带默认值的参数要出现在参数列表后面，如果出现在无默认值参数的前面会报错；
1.2 位置参数/关键字参数
位置参数：传入的值按照位置顺序依次赋给函数的形参。比如power(x, n)，
关键字参数：通过命名为参数赋值的一种参数,不用考虑位置。比如func(25, c=24)；
使用关键字参数的好处：
1）不用担心参数顺序；
2）如果其它参数都有默认值，我们可以只给我们想要的参数赋值；
1.3 参数数目可以不确定
1.3.1 使用星号*
定义函数时，在参数前加一个*号，则参数接收到的是一个tuple
>>> def calc(*numbers):
... s = 0
... for n in numbers: # numbers是一个tuple，遍历它，不能使用星号
... s += n**2
... return s
...
>>> L0 = [0,1,2,3]
>>>
>>> # 调用函数时：在list/tuple前加一个*号，把list/tuple元素变成可变参数传入
>>> calc(*L0)
14
>>> # 直接传一个List，在参数解析时没问题，但List整体作为一个参数，不符合预期
>>> # 在函数内部对参数做加法时会报告list不能与int做幂运算。
>>> calc(L0)
Traceback (most recent call last):
File "", line 1, in
File "", line 4, in calc
TypeError: unsupported operand type(s) for ** or pow(): 'list' and 'int'
在普通语句中不能使用星号
>>> *L0
File "", line 1
SyntaxError: can't use starred expression here
>>> a,b,c,d = *L0
File "", line 1
SyntaxError: can't use starred expression here
>>> a,b,c,d = (*L0)
File "", line 1
SyntaxError: can't use starred expression here
>>> (a,b,c,d) = (*L0)
File "", line 1
SyntaxError: can't use starred expression here
>>>
注意：
- *numbers 这种写法只能出现在两种语句中：函数参数列表、调用函数时传参。普通语句（包括函数内部语句）中使用星号会报错。
- 用在函数参数列表中：表示这个地方实际上有多个参数，但在函数内部合并到一个tuple中使用。
- 用在调用函数传参时使用：表示将待传递增的List/Tuple打散后再传，因为函数的参数不是List/Tuple而是它的元素。
- *numbers写在普通语句中，会报告语法错误： can’t use starred（标星号的） expression here。
1.3.2 使用双星号**
使用**kw, 传入0个或多个含参数名的参数，这些关键字参数在函数内部组装为一个dict。
使用关键字参数可以扩展函数的功能；
>>> def person(name, age, **kw):
... print(‘name:’, name, ‘, age’, age, ‘, others:’ kw)
...
>>> person(‘Michael’, 30) #只传入关键字参数
name:Michael, age:30, others:{}
>>>
>>> person(‘Adam’, 45, gender=’M’, job=’Engineer’) # 后面两个参数会组装成一个dict。
name:Adam, age:45, others:{‘gender’:’M’, ‘job’:’Engineer’}
>>>
>>> extra = {‘gender’:’M’, ‘job’:’Engineer’}
>>> person(‘Adam’, 45, **extra) #在dict前加**，把dict变成关键字参数传入；
name:Adam, age:45, others:{‘gender’:’M’, ‘job’:’Engineer’}
1.3.3。 *与**的作用
一般*与**只用在给函数传参数时，在函数参数外使用作用不大（还可能报错）
比如：
foo(1, 2, 3) 相当于foo(*[1, 2, 3])
bar(a=1, b=2, c=3) 相当于bar(**{‘a’:1, ‘b’:2, ‘c’:3})
*L0 可以认为是把列表（元组）L0拆散后的结果 。
*的作用：将列表拆散为元素。
L0 = [0, 1, 2, 3] # L0是list，是一个整体，把L0传递给函数，函数得到的是1个参数。
*L0 # L0是4个元素，把L0传递给函数，函数得到的是4个参数。
**的作用，将dict拆散为一系列键值对。
D0 = {‘a’:0, ‘b’:1} # D0是dict，直接传递给函数， 函数得到的是1个参数。
D0 # 是两个键值对， 把D0传递给函数，函数得到的是2个参数。
1.4. 命名关键字参数
使用**kw：可以传递任意名称的关键字作为参数；
使用*, city, job：可以限制关键字参数的名字，比如只接收city和job作为关键字参数；
- 对应的参数传参时必须传入参数名(使用’city’=’Chengdu’这种方式传参)，没有参数名时，会被认为是位置参数，可能导致Error；
- 如果在定义函数时给默认值，调用时就可以不传这个参数。
>> def person(name, age, *, city, job):
.. print(name, age, city, job)
..
>> person(‘Jon’, 30, city=’Chengdu’, job=’Engineer’) # 通过参数名传参数，正常运行；
on 30 Chendu, Engineer
>>
>> extra = {‘city’:’Shenzhen’, ‘job’:’Art’}
>> person(‘Bill’, 9, **extra) # 通过dict传入参数，正常运行；
ill 9 Shenzhen Art
>>>
>>> extra ={‘job’:’Art’}
>>> person(‘Bill’, 9, **extra) # 通过dict传入参数，会报错：缺少city参数；
TypeError: person() missing 1 required keyword-only arg: ‘city’
>>>
>>> extra = {‘length’:6, ‘job’:’Art’}
>>> person(‘Bill’, 9, **extra) # 通过dict传入参数，会报错：不能使用length这个参数；
TypeError: person() got a unexpected keyword arg: ‘length’
1.5. 参数组合
Python函数的5种参数可以任意组合使用, 参数定义的顺序必须为：
- 必选参数
- 默认参数
- 可变参数
- 命名关键字参数
- 关键字参数
比如：
def f1(a, b, c=0, *args, **kw):
pass
def f2(a, b, c=0, *, d, **kw):
pass
任意函数，都可以通过类似func(*args, **kw)的形式（一个元组和一个字典）调用它，无论它的参数是如何定义的。
1.6. 返回值
- 使用return从函数返回（跳出），也可以返回一个值。
- python程序默认返回None
- return可以返回多个值（实际上是返回一个元组，省略括号，直接赋值给多个变量）
def move(x0, y0, s=0, angle=0):
x1=x0+s*math.cos(angle)
y1=y0+s*math.sin(angle)
return x1,y1
x,y = move(100,100, 50, math.pi*(1/3))
1.7. DocStrings
- 可以在函数中嵌入说明语句.
- 使用三引号可以跨行写说明，不需要续行符
- 使用__doc__方法，可以调用到说明语句。
>>> def max(x,y):
... '''''Return the max of two number.
... The two number must be integer.'''
... if a>b:
... return a
... else:
... return b
...
>>> print max(1,2)
>>> print max.__doc__
1.8. 函数起别名
函数名其实是指向一个函数的引用，所以可以把函数名赋给一个变量，然后可以后这个变量调用函数：
>>> a = abs # 变量a指向abs函数
>>> print(a(-1))
1
>>> print(a)
1.9. 函数式编程
Python对函数式编程提供部分支持；
由于Python允许使用变量，所以Python不是纯函数式编程语言；
2. 高阶函数
2.1. 变量可以指向函数
>>> x = abs(-10) # 调用函数，并获得函数调用结果;
>>> f = abs # 把函数赋值给变量
>>> print(f) #
>>> f(-10) # 变量f指向abs，f(-10)与abs(-10)完全相同
2.2. 函数名也是变量
函数名其实就是指向函数的变量。
比如abs()这个函数，abs就是一个变量，指向计算绝对值的函数；
>>> import builtins
>>> builtins.abs
>>> builtins.abs = 10 # 可以把abs函数的指向改变
2.3. 传入函数
一个函数A可以接收另一个函数B作为参数，这种函数A就称之为高阶函数；
>>> def func_add(f, x, y):
... return f(x)+f(y)
...
>>> abs_add(abs, 5, -6)
11
map()、reduce()、都是高阶函数
2.4. 返回函数
高阶函数除了可以接受函数做为参数外，还可以把函数做为结果值返回；
3. 匿名函数lambda
- lambda 定义了一个匿名函数
- lambda 并不会带来程序运行效率的提高，只会使代码更简洁。
- lambda 只能有一个表达式，不用写return，返回值就是该表达式的值；
- 如果可以使用for...in...if来完成的，坚决不用lambda。
- 如果使用lambda，lambda内不要包含循环，如果有，宁愿定义函数来完成，使代码获得可重用性和更好的可读性。
>>> foo = [2,18,9,22]
>>> list(filter(lambda x:x%3==0, foo)) #列表中可以被3整除的数；
[18, 9]
>>> list(map(lambda x:x*2+10, foo)) #将原列表元素做*2+10；
[14, 46, 28, 54]
>>> list(map(lambda x:[x,x*2], foo)) #将列表元素映射为list；
[[2, 4], [18, 36], [9, 18], [22, 44]]
>>> functools.reduce(lambda x,y:x+y, foo) # 返回数值，将原列表相加；
51
上述filter可以改写为：[x for x in foo if x%x==0]
上述map可以改写为：[x*2+10 for x in foo]
4. 装饰器
作用：增强函数的功能，但又不修改函数定义本身；
例1：
定义一个装饰器，它可以打印当前调用函数的名称，它接受一个函数作为参数，并返回一个函数
>>> def log(func):
... def wrapper(*args, **kwargs):
... print(‘call func: {name}: ’.format(name=func.__name__))
... return func(*args, **kwargs)
... return wrapper
把装饰器（log）作用到其它函数（now）上，相当于now=log(now)：
调用now()，在执行now本身之前，会先打印一行log
>>> @log
... def now():
... print(datetime.datetime.now())
...
>>> import datetime #可以在调用now之前才import它需要用到的模块
>>> now()
call func: now
2018-07-27 11:29:18.239895
例2，定义一个装饰器，打印函数调用的次数和函数执行时间
import time
def timer(func):
lst = [0, 0] # 使用一个list保存要记录的内容，在每次调用时，lst指向同一地址；
def wrapper(*args, **kwargs):
start = time.time()
r = func(*args, **kwargs) #调用函数，并保留返回值
end = time.time()
delta = end –start
lst[0] += 1 # lst[0]记录函数执行的次数
lst[1] += delta # lst[1]记录函数执行的时间
print(f‘cnt: {lst[0]}, time: {lst[1]}, {delta}’)
return r # 返回函数的结果，这里有个局限性，只能处理返回单个值的函数；
return wrapper # 返回包了壳的函数
测试：
>>> @timer
>>> def my_sum(n): #定义一个函数
... r = 0
... for i in range(n):
... r += i
... return r
...
>>> for i in range(10):
... r = my_sum(10000000)
...
cnt 1, time 0.937***, 0.937***
cnt 2, time 1.852***, 0.914***
cnt 3, time 2.747***, 0.895***
cnt 4, time 3.681***, 0.934***
cnt 5, time 4.601***, 0.919***
cnt 6, time 5.563***, 0.962***
cnt 7, time 6.494***, 0.930***
cnt 8, time 7.403***, 0.909***
cnt 9, time 8.374***, 0.970***
cnt 10, time 9.280***, 0.906***
5. 偏函数
- 语法：functools.partial(函数对象, *args, **kwargs)
- 参数：函数对象、位置参数、命名参数
Python的functools模块提供了很多功能，其中一个是偏函数（Partial Function）;
functools.partial功能：帮忙我们创建一个偏函数，但不需要我们自己定义偏函数；
例如：将2进制字符串转为10进制整数，可以定义一个函数int2
def int2(x, base=2):
return int(x, base=base)
这样默认处理2进制字符串.
但我们不需要自己定义函数int2，可以使用偏函数达到目的：
>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2(‘00010000’)
16
functools.partial的作用：把函数的某些参数给固定住（即设置默认值），返回一个新的函数；
但是调用int2时，仍然可以给它指定base参数为其它值：
>>> int2(‘00010000’，base=10)
10000
例1：
>>> int2 = functools.partial(int, base=2)
>>> int2(‘00010000’)
>>>
>>> #相当于：
>>> kwargs = {‘base’:2} # 将’base’:2作为kwargs的一部分
>>> int(‘00010000’, **kwargs)
例2：
>>> max_with_10 = functools.partial(max, 10)
>>> max_with_10(5, 6, 7)
>>>
>>> #相当于：
>>> args=(10, 5, 6, 7) # 将10作为*args的一部分自动加到左边
>>> max(*args)