调用函数
1、内置函数： python内置了很多有用的函数，我们可以直接调用。要调用一个函数，需要知道函数的名称和参数，对于相关函数的帮助信息除了可以直接从python官网上查看相应文档外，还可以在交互命令行 中通过help()来查看函数的帮助信息，比如求绝对值的函数abs，我们可以使用help(abs)来查看帮助信息。
调用函数的时候，如果传入的参数数量或者参数类型不对的话，会报TypeError的错误。而max() 函数可以接收任意多个参数，并返回最大的那个：
>>>max(1,2)
2
>>>max(2, 3, 1, -5)
3
2、数据类型转换： python内置的常用函数还包括数据类型转换函数 ，比如int()函数可以把其他数据类型转换为整数：
>>>int('123') # '123'是str类型
123
>>>int(12.34)
12
>>>float('12.34')
12.34
>>>str(1.23)
'1.23'
>>>str(100)
'100'
>>>bool(1)
True
>>>bool('')
False
函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：
>>>a = abs #变量a指向abs()函数
>>>a(-1) #所以也可以通过a调用abs函数
1
定义函数
1、如何自定义函数： 在python中定义一个函数要使用def语句 ，依次写出函数名 、括号 、括号中的参数 和冒号： ，然后在缩进块中编写函数体 ，函数的返回值用return语句返回，比如自定义一个求绝对值的my_abs函数为例：
def my_abs(x):
if x >= 0:
return x
else:
return -x
注意： 如果没有return语句，函数执行完毕后会返回结果，只是结果为None，return None可以简写为return。
2、空函数： 如果想定义一个什么也不做的空函数，可以用pass语句 :
def nop():
pass
pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass,让代码能运行起来。
3、参数检查： 调用内置函数时，如果参数类型或数量出现错误，python解释器会自动检查出来，并抛出TypeError。而对于我们自定义的函数比如my_abs就没有参数检查，会导致if语句出错，出错信息和abs的不一样。因此这个函数定义是不够完善的。让我们修改以下my_abs的定义，对参数类型做检查 ，只允许整数和浮点数类型的参数。数据类型检查可以用内置函数isinstance() 来实现：
def my_abs(x):
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
if x >=0:
return x
else:
retunr -x
4、返回多个值： 函数可以返回多个值吗？答案是肯定的。比如在游戏中经常需要从一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的坐标：
import math # 导入math包，并允许后续代码引用math包里的sin、cos等函数
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.97152422 7.0
# 其实上述只是一种假象，python函数返回的仍然是单一值：
>>>r = move(100, 100, 60, math.pi/6)
>>>print(r)
(151.97152422, 70.0)
原来返回值是一个tuple！但是，在语法上。返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以python的函数返回多值其实就是返回一个tuple，但写起来更方便。
小结：
- 定义一个函数时，需要确定函数名和参数个数；
- 如果有必要，可以先对参数的数据类型做检查；
- 函数体内部可以用return随时返回函数结果；
- 函数执行完毕也没有return语句时，自动return None。
- 函数可以返回多个值，但其实就是一个tuple。
函数的参数
python的函数定义非常简单，但是灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数 、可变参数 和关键字参数 ，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。
1、位置参数：对于位置参数，在调用函数时，传入的多个值按照位置顺序来依次赋值给参数，比如定义一个指数函数：
def power(x, n):
s = 1
while n > 0:
n = n -1
s = s*x
return s
2、默认参数： 对于上述的函数使用默认参数来对x的指数指定一个默认次数2，如下：
def power(x, n = 2):
s = 1
while n > 0:
n = n -1
s = s*x
return s
对于默认参数的设置有以下两点需要注意，一是必选参数 在前，默认参数 在后，否则python的解释器会报错；二是当函数有多个参数时，把变化大的参数 放前面，变化小的参数 放在后面，变化小的参数就可以作为默认参数。
可以不按顺序提供部分默认参数： 当不按顺序提供部分默认参数时，需要把参数名写上。比如：
def enroll(name, gender, age=6, city='beijing'):
print(name, gender, age, city)
# 只有与默认参数不符的时候才需要提供额外的信息
enroll('Bob', 'M', 7)
enroll('Adma', 'M', city='tianjin')
默认参数的坑： 定义如下函数，传入一个list，添加一个END再返回：
def add_end(L=[]): # L的默认参数是[]
L.append('END')
return L
>>>add_end()
['END']
>>>add_end()
['END', 'END']
>>>add_end()
['END', 'END', 'END']
对于上述函数的调用，默认参数是[],但是函数似乎每次都“记住了”上次添加了'END'后的list，原因解释如下：
python函数在定义的时候，默认函数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[] ，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了！
所以，定义默认参数要牢记一点：默认参数必须指向不变对象！
要修改上面的例子，我们可以用None这个不变对象来实现：
def add_end(L=None): # L的默认参数是None
L.append('END')
return L
#现在，无论调用多少次，都不会有问题：
>>>add_end();
['END']
>>>add_end();
['END']
为什么要设计str、None这样的不变对象 呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。 我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。
3、可变参数： 在python中，还可以定义可变参数，要定义出这个函数，我们必须确定输入的参数。由于参数个数不确定，我们首先想到可以把参数作为一个list或tuple传进来，因此函数可以这样定义：
def calc(numbers): # numbers是python内置的
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
所以，可以把函数的参数改为可变参数 ：
def calc(*numbers): # 多加了一个星号*
sum = 0
for n in numbers:
sum = sum + n*n
return sum
>>>calc(1, 2)
5
>>>calc()
0
定义可变参数和定义一个lit或tuple参数相比，仅仅在参数前面加了一个星号。在函数内部，参数numbers接收到的是一个tuple，因此函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数。
如果已经有一个list或者tuple时，python允许在list或tuple前面加一个星号，把list或tuple的元素变成可变参数传进去：
>>>nums = [1, 2, 3]
>>>calc(*nums) # 和calc(nums[0], nums[1], nums[2])效果一样
14
4、关键字参数： 可变参数 允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple 。而关键字参数 允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict :
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw) #函数除了必选参数外，还接受关键字参数kw
# 在调用函数时，可以只传入必选参数
>>>person('Michael', 30)
name:Michael age: 30 other: {}
# 也可以传入任意个数的关键字参数
>>>person('Bob', 35, city='beijing')
name:Bob age:35 other:{'city:' 'beijing'}
和可变参数 类似，也可以组装出一个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 = {'city': 'beijing', 'job': 'engineer'}
>>>person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'beijing','job': 'engineer'}
**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的关键字参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
5、命名关键字参数： 对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查：
def person(name, age, **kw):
if 'city' in kw:
pass
if 'job' in kw:
pass
print('name:', name, 'age:', age, kw)
# 但是调用者仍然可以传入不受限制的关键字参数：
>>>person('Jack', 24, city='beijing', addr='chaoyang')
如果要限制关键字参数的名字，就可以用命名关键字参数 ，例如，只接收city和job作为关键字参数，这种方式定义的函数如下：
def person(name, age, *, city, job):
print(name, age, city, job)
和关键字参数**kw 不同，命名关键字参数需要一个特殊分隔符*, 星号后面的参数被视为命名关键字参数 。调用方式如下：
>>>person('Jack', 24, 'beijing', 'engineer')
Jack 24 beijing engineer
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了；如果没有可变参数，就必须加一个星号作为特殊分隔符，这点需要特别注意：
def person(name, age, *args, city, job):
print(name, age, args, city, job)
# 命名关键字参数可以有缺省值
def person(name, age, *args, city='beijing', job):
print(name, age, args, city, job)
命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将会报错：
>>>person('Jack', 24, 'beijing', 'engineer')
Traceback (most recent call last):
6、参数组合： 在python中定义函数，可以用必选参数 、默认参数 、可变参数 、关键字参数 和命名关键字参数 ，这5种参数都可以组合使用。但是请注意，参数定义的顺序 必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！