函数
调用函数
Python内置了很多有用的函数，我们可以直接调用。
绝对值的函数abs
>>> abs(-20)
20
max函数max()可以接收任意多个参数，并返回最大的那个
>>> max(2,3,1, -5)
3
int()函数可以把其他数据类型转换为整数，float()函数可以把其他数据类型转换为数，str()函数把其他数据类型转换为字符，bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> bool(1)
True
>>> bool('')
False
定义函数
定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号: （冒号不能忘！）
def my_abs(x):
if x >= 0:
return x
else:
return -x
在Python交互环境中定义函数时，注意Python会出现...的提示。函数定义结束后需要按两次回车重新回到>>>提示符下：
>>> def my_abs(x):
... if x>=0:
... return x
... else:
... return -x
...
>>> my_abs(-9)
9
把my_abs()的函数定义保存为abstest.py文件了，那么，可以在该文件的当前目录下启动Python解释器，用from abstest（文件名） import my_abs（函数名）来导入my_abs()函数。
>>> from hello import my_abs
>>> my_abs(-9)
定义后不能直接输入x，需要输入函数（x）
空函数
pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来
if age >=18:
pass
参数检查
参数个数不对，Python解释器会自动检查出来，并抛出TypeError。
参数类型不对，Python解释器就无法帮我们检查。
数据类型检查可以用内置函数isinstance()实现：
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)
>>> print(x, y)
151.96152422706632 70.0
python函数返回的仍然是单一值，是一个tuple。Python的函数返回多值其实就是返回一个tuple。
>>> r = move(100,100,60, math.pi /6)
>>> print(r)
(151.96152422706632,70.0)
作业
import math
def quadratic(a,b,c):
if not isinstance(a,(int, float)):#先进行参数类型检查
raise TypeError('the bad operand type of a')
elif not isinstance(b,(int, float)):
raise TypeError('the bad operand type of b')
elif not isinstance(c,(int, float)):
raise TypeError('the bad operand type of c')
elif b*b-4*a*c<0:
return('方程无解')
else:
x1=(-b+math.sqrt(b*b-4*a*c))/2*a
x2=(-b-math.sqrt(b*b-4*a*c))/2*a
return x1,x2
>>> from hello import quadratic
>>> quadratic(4,6,1)
（命令行导入函数）
函数的参数
除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。
def power(x):
return x * x
def power(x,n):
s=1
while n>0:
n=n-1
s=s*x
return s
修改后的power(x, n)函数有两个参数：x和n，这两个参数都是位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n。
默认参数
新的power(x, n)函数定义没有问题，但是，旧的调用代码失败了，原因是我们增加了一个参数，导致旧的代码因为缺少一个参数而无法正常调用。
默认参数就排上用场了。由于我们经常计算x2，所以，完全可以把第二个参数n的默认值设定为2：
def power(x, n=2):
s =1
while n >0:
n = n -1
s = s * x
return s
def enroll(name, gender, age=6, city='Beijing'):
print('name:', name)
print('gender:', gender)
print('age:', age)
print('city:', city）
大多数学生注册时不需要提供年龄和城市，只提供必须的两个参数。
定义默认参数要牢记一点：默认参数必须指向不变对象！
可变参数
求平方和
def calc(numbers):
sum =0
for n in numbers:
sum = sum + n * n
return sum
利用可变参数，在参数前面加*号。在调用该函数的时候，可以传入任意个参数，包括0个参数。
def calc(*numbers):
sum =0
for n in numbers:
sum = sum + n * n
return sum
把list中的所有元素作为可变参数传进去
>>> nums = [1,2,3]
>>> calc(*nums)
14
关键字参数
扩展函数。能收到调用者愿意提供更多的参数。
def person(name, age, **kw):
print('name:', name,'age:', age,'other:', kw)
调用成功后，
>>> person('Michael',30)
name: Michael age:30 other: {}
>>> person('Bob',35, city='Beijing')
name: Bob age:35other: {'city':'Beijing'}
>>> person('Adam',45, gender='M', job='Engineer')
name: Adam age:45 other: {'gender':'M','job':'Engineer'}
先组装出一个dict，然后，把该dict转换为关键字参数传进去
>>> extra = {'city':'Beijing','job':'Engineer'}
>>> person('Jack',24, city=extra['city'], job=extra['job'])
name: Jack age:24 other: {'city':'Beijing','job':'Engineer'}
**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra：
>>> extra = {'city':'Beijing','job':'Engineer'}
>>> person('Jack',24, **extra)
name: Jack age:24 other: {'city':'Beijing','job':'Engineer'}
命名关键词参数
def person(name, age, **kw):
if 'city' in kw: # 有city参数
pass
if 'job' in kw: # 有job参数
pass
print('name:', name,'age:', age,'other:', kw)
调用者仍可以传入不受限制的关键字参数：
>>> person('Jack',24, city='Beijing', addr='Chaoyang', zipcode=123456)
如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下，*后面的参数被视为命名关键字参数：
def person(name, age, *, city, job):
print(name, age, city, job)
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了，*后面的参数都被视为可变参数。
参数组合
参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
在函数调用的时候，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}
通过一个tuple和dict，也可以调用上述函数：
>>> 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':'#'}
对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。
作业
可接收一个或多个数计算乘积
def product(x,*nums):
for y in nums:
x=x*y
return x
递归函数
连乘
def fact(n):
if n==1:
return1
return n * fact(n -1)
使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。上述代码无法实现fact(1000)。
解决递归调用栈溢出的方法是通过尾递归优化
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)
return fact_iter(num - 1, num * product)仅返回递归函数本身
作业
汉诺塔的移动可以用递归函数非常简单地实现。
请编写move(n, a, b, c)函数，它接收参数n，表示3个柱子A、B、C中第1个柱子A的盘子数量，然后打印出把所有盘子从A借助B移动到C的方法
def hanoi(n, x, y, z):
if n == 1:
print(x, '-->', z)
else:
hanoi(n-1, x, z, y)# 将前n-1个盘子从x移动到y上
print(x, '-->', z)# 将最底下的最后一个盘子从x移动到y上
hanoi(n-1, y, x, z)# 将y上的n-1个盘子移动到z上
n = int(input('请输入汉诺塔的层数:'))
hanoi(n, 'x', 'y', 'z')