Python函数

（摘录自https://www.liaoxuefeng.com/）

【内置函数】

如abs()，max()等。详见：https://docs.python.org/3/library/functions.html

【数据类型转换】

 int('123') = 123，int(12.34) = 12，int(-12.34) = -12。

float('12.34') = 12.34。

str(1.23) = '1.23'。

bool(1) = True，bool('') = False。

【函数更名】

a = abs, a(-1) = 1。

【自定义函数】

定义简单，灵活度大。

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

如果没有return语句，也会返回None。

导入自定义函数（文件名不含后缀）：

from <文件名> import <函数名>

pass语句：什么都不做。作为占位符。

参数检查：

def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x

返回多个值：

import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

x, y = move(100, 100, 60, math.pi / 6)

实际上对于多个返回值，函数返回的是一个tuple。

默认参数：

def enroll(name, gender, age=6, city='Beijing'):
    print('name:', name)
    print('gender:', gender)
    print('age:', age)
    print('city:', city)
enroll('Sarah', 'F')  # age=6, city='Beijing'
enroll('Bob', 'M', 7) # city='Beijing'
enroll('Adam', 'M', city='Tianjin') #不按顺序提供默认参数时要写上参数名

注意：（1）必选参数在前，默认参数在后。（2）变化小的参数放在后边。（3）默认参数必须指向不变对象。

可变参数：

定义时，在参数前加上*，则将a, b, c, …作为参数传入时，函数接收到的是一个tuple。

调用时，在list或者tuple变量前加上*，可将list或者tuple元素变成可变参数传入。

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
calc(1, 2, 3) # 14
nums = [1, 2, 3]
calc(*nums)   # 14

关键字参数：

定义时，在参数前加上**，则将A=a, B=b, …作为参数传入时，函数接收到的是一个dict。

调用时，在dict变量前加上**，可将dict所有键值对变成关键字参数传入（得到一份拷贝）。

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
person('Michael', 30) # name: Michael age: 30 other: {}
person('Adam', 45, gender='M', job='Engineer') # name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **extra) # name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

命名关键字参数：

在需要限制关键字参数的名字时使用。命名关键字参数需要用分隔符*，*后面的参数被视为命名关键字参数。如：

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)

在调用时，命名关键字参数必须传入参数名。

命名关键字参数可以有缺省值。

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

参数组合：

在Python中定义函数时，必选参数、默认参数、可变参数、关键字参数和命名关键字参数都可以组合使用，但是顺序必须是：必选->默认->可变->命名关键字参数->关键字参数。

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

>>> f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
>>> f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

>>> args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
>>> args = (1, 2, 3)
>>> kw = {'d': 88, 'x': '#'}
>>> f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

【递归函数】

尾递归：返回时调用本身，且return语句不能包含表达式。

def fact(n):
    return fact_iter(n, 1)

def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)