python基础补漏2

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)函数改成尾递归方式，也会导
致栈溢出。