1. python内置了很多有用的函数，可以直接调用。
abs() 求绝对值，只传入一个参数
max() 接收任意多个参数，并返回最大的那个
2. 数据类型转换
python内置的常用函数包括数据类型转换函数。
int() 可以把其它数据类型转换为整数
float() 把其它数据类型转换为浮点数
str() 把其它数据类型转换为字符型
hex() 把整数转换成十六进制表示
3. 函数名是指向一个函数对象的引用，完全可以把函数名赋给一个变量
>>>a = abs # 变量a指向abs函数
>>>a(-1) # 所以也可以通过a调用abs函数
1
4. 在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
defmy_abs(x):
if x >= 0:
return x
else:
return -x
注意def语句最后的:
函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。
如果你已经把my_abs()的函数定义保存为abstest.py文件了，那么，可以在该文件的当前目录下启动Python解释器，用from abstest import my_abs来导入my_abs()函数，注意abstest是文件名（不含.py扩展名）。
5. 空函数
定义一个什么事也不做的空函数，可以用pass语句：
defnop():
pass
pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass,让代码能运行起来。
pass还可以用在其他语句里，比如：
ifage >= 18:
pass
6.参数检查
调用函数时，如果参数个数不对，Python解释器会自动检查出来，并抛出TypeError。但是如果参数类型不对，内置函数abs会检查出参数错误，而我们定义的my_abs没有参数检查，会导致if语句出错，出错信息和abs不一样。
修改一下my_abs的定义，对参数类型做检查，只允许整数和浮点数类型的参数。数据类型检查可以用内置函数isinstance()实现：
defmy_abs(x):
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
if x >= 0:
return x
else:
return -x
7. 返回多个值
从一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的新的坐标：
importmath
defmove(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
importmath语句表示导入math包，并允许后续代码引用math包里的sin、cos等函数。
然后，我们就可以同时获得返回值：
>>>x, y = move(100, 100, 60, math.pi / 6)
>>>print(x, y)
151.9615242270663270.0
但其实这只是一种假象，Python函数返回的仍然是单一值：
>>>r = move(100, 100, 60, math.pi / 6)
>>>print(r)
(151.96152422706632,70.0)
原来返回值是一个tuple！但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。
8. 定义一个函数quadratic(a, b, c)，接收3个参数，返回一元二次方程：ax2 + bx + c = 0的两个解。
importmath
defquadratic(a,b,c):
base=b*b-4*a*c
if base<0:
return '无解'
else:
x1=(-b+math.sqrt(base))/(2*a)
x2=(-b-math.sqrt(base))/(2*a)
return x1,x2
print('请输入一元二次方程的系数：')
a=float(input('输入a='))
b=float(input('输入b='))
c=float(input('输入c='))
x,y=quadratic(a,b,c)
print(x,y)
9. Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。
10. 位置参数
计算xn:
defpower(x, n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
对于这个power(x, n)函数，可以计算任意n次方：
>>>power(5, 2)
25
>>>power(5, 3)
125
power(x,n)函数有两个参数：x和n，这两个参数都是位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n。
11. 默认参数
由于我们经常计算x2，所以，完全可以把第二个参数n的默认值设定为2：
defpower(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
当n不输入，使用默认值n=2，若指定n，按指定n计算
当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。
有多个默认参数时，调用的时候，可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。
默认参数必须指向不变对象！像list不适合作为默认参数。
12. 可变参数
在Python函数中，还可以定义可变参数。可变参数就是传入的参数个数是可变的。
由于参数个数不确定，可以把a，b，c……作为一个list或tuple传进来，这样，函数可以定义如下：
defcalc(numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
但是调用的时候，需要先组装出一个list或tuple：
>>>calc([1, 2, 3])
14
>>>calc((1, 3, 5, 7))
84
可变参数在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变：
defcalc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
调用该函数时，可以传入任意个参数，包括0个参数：
>>>calc(1, 2)
5
>>>calc()
0
Python允许在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：
>>>nums = [1, 2, 3]
>>>calc(*nums)
14
*nums表示把nums这个list的所有元素作为可变参数传进去。
13. 关键字参数
关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
defperson(name, age, **kw):
print('name:', name, 'age:', age, 'other:',kw)
函数person除了必选参数name和age外，还接受关键字参数kw。在调用该函数时，可以只传入必选参数：
>>>person('Michael', 30)
name:Michael age: 30 other: {}
也可以传入任意个数的关键字参数：
>>>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'}
和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：
>>>extra = {'city': 'Beijing', 'job': 'Engineer'}
>>>person('Jack', 24, **extra)
name:Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
14. 命名关键字参数
要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：
defperson(name, age, *, city, job):
print(name, age, city, job)
和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。
调用方式如下：
>>>person('Jack', 24, city='Beijing', job='Engineer')
Jack24 Beijing Engineer
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
defperson(name, age, *args, city, job):
print(name, age, args, city, job)
命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错：
>>>person('Jack', 24, 'Beijing', 'Engineer')
Traceback(most recent call last):
File "<stdin>", line 1, in<module>
TypeError:person() takes 2 positional arguments but 4 were given
由于调用时缺少参数名city和job，Python解释器把这4个参数均视为位置参数，但person()函数仅接受2个位置参数。
使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。
15. 参数组合
在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
比如定义一个函数，包含上述若干种参数：
deff1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args=', args, 'kw =', kw)
deff2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =',d, 'kw =', kw)
在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。
>>>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': '#'}
16. 函数参数总结
默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
以及调用函数时如何传入可变参数和关键字参数的语法：
可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1,2, 3))；
关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})。
使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。
命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。
定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。
17. 递归函数
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n =(n-1)! x n = fact(n-1) x n：
def fact(n):
ifn==1:
return 1
return n * fact(n - 1)
使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。
解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的。尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。
def fact(n):
return fact_iter(n, 1)
def fact_iter(num, product):
ifnum == 1:
return product
return fact_iter(num - 1, num * product)
可以看到，return fact_iter(num -1, num * product)仅返回递归函数本身，num - 1和num * product在函数调用前就会被计算，不影响函数调用。fact(5)对应的fact_iter(5, 1)的调用如下：
===> fact_iter(5, 1)
===> fact_iter(4, 5)
===> fact_iter(3, 20)
===> fact_iter(2, 60)
===> fact_iter(1, 120)
===> 120
尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。
