python基础补漏系列（二）
函数
一般自行编写函数的时候，需要额外注意一下传入参数的类型正确与否，我们自行编写的函数解释器会检查参数数量的正确与否，但是不会检查到参数类型的正确与否，我们需要自行添加相关的检查。（内置函数可以类型）
def my_abs(x):
if not isinstance(x, (int, float)):
raise TypeError('bad operand type') #检查需要是整数
if x >= 0:
return x
else:
return -x别名
函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：
>>> a = abs # 变量 a 指向 abs 函数
>>> a(-1) # 所以也可以通过 a 调用 abs 函数
1占位符
编写了一个函数的时候，如果内容没有想好可以先写一个pass，让代码能够正常运行。
参数与返回值
def 函数名(...，形参名，形参名=默认值)：
代码块函数是可以返回多个值的，
def move(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny看似python函数是可以直接返回多个值的，但是其实其返回的仍然是单一值，其返回值是一个元组。
>>> def move(x, y, step, angle=0):
... nx = x + step * math.cos(angle)
... ny = y - step * math.sin(angle)
... return nx, ny
...
>>> r = move(100, 100, 60, math.pi / 6)
>>> print (r)
(151.96152422706632, 70.0)可变参数
通过在参数前面加一个*，可以设置参数为可变参数。可以传入任意多个参数。本质是是让参数接收到一个tuple。可以传入列表或者元组。
关键字参数
关键字参数允许你传入 0 个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个 dict。
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'}当然关键字参数也可以通过直接传入一个字典来构造。
命名关键字参数
如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收 city 和 job 作为关键字参数。这种方式定义的函数如下：（使用*号作为分隔符，不是参数而是特殊分隔符）
def person(name, age, *, city, job):
print(name, age, city, job)但是调用参数的时候，一定要带上参数名，否则解释器会把多出的参数视为位置参数。
参数组合
参数定义的顺序必须是：必选参数、默认参数、可变参数/命名关键字参数和关键字参数。
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)不可变对象
当调用默认参数的时候，如果是可变对象的话，可能会出现叠加效果。
>>> def add_end(L=[]):
... L.append('end')
... return L
...
>>> add_end()
['end']
>>> add_end()
['end', 'end']
>>> add_end()
['end', 'end', 'end']修改调整的方法可以用如下方式解决：
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L递归函数
递归函数需要注意防治栈溢出，函数调用是通过栈来实现的，每当进入一个函数调用栈就会增加一层栈帧，每当函数返回，栈就会减一层栈帧，递归的次数过多就会导致栈溢出。
解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。
尾递归是指，在函数返回的时候，调用自身本身，并且，return 语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
>>> fact(1000)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 4, in fact
...
File "<stdin>", line 4, in fact
RuntimeError: maximum recursion depth exceeded in comparison尾递归优化改成：
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)遗憾的是，大多数编程语言没有针对尾递归做优化， Python 解释器也没
有做优化，所以，即使把上面的 fact(n)函数改成尾递归方式，也会导
致栈溢出。
