廖雪峰Python 函数

廖雪峰Python 函数

函数

函数参数

1
函数调用时可以按位置参数传参，也可以写明参数名传参
1
2
3
4
5
6
7
8
9
python函数可以返回多个值(其实是一个值，返回的一个tuple)，sql和java类函数只能返回一个值

>>> r = move(100, 100, 60, math.pi / 6)
>>> print(r)
(151.96152422706632, 70.0)

>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print(x, y)
151.96152422706632 70.0
1
2
3
4
5
6
7
8
9
10
位置参数：函数调用时传参顺序要和函数定义时的参数顺序一样
必选参数：调用时必须传值的参数
默认参数：默认参数放在必选参数后面

可变参数：*nums，函数内部nums变成了tuple，可以用循环迭代，参数list，tuple在前面*
def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
1
2
3
4
5
6
7
8
关键字参数：**kw，函数内部自动把kw变成字典
def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
    
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
1
2
3
4
5
6
7
8
9
10
11
命名关键字参数：关键字参数的缺点，调用时可能参数不受限制不想要的参数。如果要限制关键字参数的名字，就可以用命名关键字参数

def person(name, age, *, city, job):
    print(name, age, city, job)
    
>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
def person(name, age, *args, city, job):
    print(name, age, args, city, job)
1
函数名是一个变量指向函数，可以将另外的变量指向函数，函数也可以指向其它类型的值 
1
java的函数只能在类里面，sql可以单独定义函数

递归函数

高阶函数

1
函数名作为传入参数

map、reduce

1
2
3
4
5
6
7
8
map返回iterator、reduce函数 

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
1
2
3
4
5
6
7
8
9
from functools import reduce

DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

def char2num(s):
    return DIGITS[s]

def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))

filter

1
2
3
4
5
6
7
8
和map差不多，传入函数作用于每一个元素，结果为True的保留

def is_odd(n):
    return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]

sorted()

闭包 nonlocal

1
使用闭包时，对外层变量赋值前，需要先使用nonlocal声明该变量不是当前函数的局部变量。

匿名函数

1
lambda

装饰器

偏函数

递归

1
尾递归