函数
话不多说，python函数定义是以def开头，例如：
def sum(a,b):
print('%s + %s = %s' % (a,b,a+b))
sum(1,2)
> 1 + 2 = 3以上就包含了简单的定义函数、调用函数。
当然python中提供了很多自带的内置函数，例如len()，print()。
这些可以在python官网查看文档。
https://docs.python.org/3/library/functions.html
val = 'abcd'
print(len(val))
> 4数据类型转换
python内部常用的函数还包括数据类型转换函数，比如int(),str()，具体使用如下：
print(int('123'))
> 123
print(float('123.4'))
> 123.4
print(bool('123.4'))
> True
print(bool(''))
> False
print(str(99))
> "99"
print(hex(16))
> 0x10定义函数
具体的定义函数要是用def开头，并依次写出函数名、括号、参数、冒号、和具体实现。就如上面的sum函数一样。
例如我们实现一个十进制转换为二进制的函数：
def Dec2Bin(num):
L = [] #存储二进制
while num > 0:
L.insert(0, int(num % 2))
num = int(num / 2)
print(L)
Dec2Bin(16)
> [1, 0, 0, 0, 0] #打印出存储二进制空函数
函数体写一个pass，例如：
def nop():
passpass代表什么都不错，可以用来做占位符，类似于C++中空函数体。
参数检查
当我们给函数传入不合适的参数时，应该能给出合理的打印信息，帮助使用者正确使用该函数，例如我们实现一个绝对值函数，并且和python内置的abs做对比：
def myabs(num):
if num >= 0:
print(num)
else:
print(-num)
print(abs_int('A'))
print(abs('A'))
#分别打印错误信息
#myabs
> TypeError: '>=' not supported between instances of 'str' and 'int'
#abs
>TypeError: bad operand type for abs(): 'str'所以为了打印合理的信息，我们需要修改一下myabs的函数，使用isinstance()作为类型检查：
def myabs(num):
if not isinstance(num, (int, float)):
raise TypeError('bad operator type for myabs() : %s' % type(num))
if num >= 0:
print(num)
else:
print(-num)
print(myabs('A'))
> TypeError: bad operator type for myabs() : <class 'str'>返回多个值
例如在一个平面上生成一些随机点，可以使用一个函数来完成这个功能。
import random
def randomPoint():
return random.random() * 100, random.random() * 100
print(randomPoint())
> (73.30794748743236, 41.20707185275483)以上是生成100以内的随机数。其实从打印结果我们看出它是不是和tuple的输出结果一样呢？
我们可以使用type()函数测试一下
print(type(randomPoint()))
> <class 'tuple'>果然他是个tuple。在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。
函数参数
位置参数
我们前面写了一个十进制转换为二进制的，但是我们如果想要十进制转换为8进制、16进制或者其他的呢。
直接实现Dec2Oct或者Dec2Hex显然不太方便，不如我们实现
一个函数实现这些功能。所以我们可以传入第二个参数，如下：
def Dec2Bin(num, n): #函数名应该换一下
L = []
while num > 0:
L.insert(0, int(num % n))
num = int(num / n)
print(L)
Dec2Bin(16, 8)我们可以很轻松的十进制转换八进制。
例如num，n这种参数，是按顺序给出的，我们称为位置参数。
默认参数
但是我们每次都需要输出第二个参数，能不能方便点呢，于是默认参数诞生了。
def Dec2Bin(num, n = 2):
L = []
while num > 0:
L.insert(0, int(num % n))
num = int(num / n)
print(L)
Dec2Bin(16)
Dec2Bin(16, 8)
> [1, 0, 0, 0, 0]
> [2, 0]虽然这样很方便，但是使用默认参数也有一些需要注意的地方，那就是修改参数的时候。
例如，定义一个函数给list增加结束标识：
#先定义一个函数，传入一个list，添加一个END再返回：
def add_end(L=[]):
L.append('END')
return L
#正常使用中
add_end([1, 2, 3])
> [1, 2, 3, 'END']
add_end(['x', 'y', 'z'])
> ['x', 'y', 'z', 'END']
add_end()
> ['END']
#似乎是一切正常，但是
add_end()
> ['END', 'END']
add_end()
> ['END', 'END', 'END']原因解释如下：
Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。
所以，定义默认参数要牢记一点：默认参数必须指向不变对象！
要修改上面的例子，我们可以用None这个不变对象来实现：
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。
可变参数
在python中还可以定义可变参数，例如C语言的printf函数。可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。
举个例子，我们计算一组数的和，可以使用list、tuple这些，但是调用的时候还是需要凑一个list、或者tuple我们可以简化一下：
def sum(*numbers):
all = 0
for i in numbers:
all += i
print(all)
sum(1,2,3,4,5)
> 15是不是很方便，只需要在参数前加’*’即可。
关键字参数
可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
def student(name, id, **kw):
print('Student: name', name, ' id: ', id, ' other: ', kw)
student('Jack', 100)
student('Jack', 100, home='ShangHai', sex='Man')
> Student: name Jack id: 100 other: {}
> Student: name Jack id: 100 other: {'home': 'ShangHai', 'sex': 'Man'}函数可以传入必选参数name和id，kw可选传入，但是必须是关键字参数。也可以直接传入一个字典。
d = {'home':'ShangHai', 'sex':'Man'}
student('Jack', 100, city='Beijing')
student('Jack', 100, **d)
> Student: name Jack id: 100 other: {'city': 'Beijing'}
> Student: name Jack id: 100 other: {'home': 'ShangHai', 'sex': 'Man'}**d 表示把d这个dict的所有key-value用关键字参数传入到函数的 **kw参数，kw将获得一个dict，注意kw获得的dict是d的一份拷贝，对kw的改动不会影响到函数外的d。
命名关键字参数
对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查。
以person()函数为例，我们希望检查是否有city和job参数：
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)和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符，后面的参数被视为命名关键字参数。
调用方式如下：
person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
def person(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个位置参数。
命名关键字参数可以有缺省值，从而简化调用：
def person(name, age, *, city='Beijing', job):
print(name, age, city, job)由于命名关键字参数city具有默认值，调用时，可不传入city参数：
person('Jack', 24, job='Engineer')
> Jack 24 Beijing Engineer使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数：
def person(name, age, city, job):
# 缺少 *，city和job被视为位置参数
pass参数组合
在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
例如：
def func(a, b, c = 0, *args, **kwargs):
print(a, b, c, ' args: ',args, ' kwargs: ', kwargs)
func(1,2)
func(1,2,3,'a','b',{'c':'d'}, e='f')
> 1 2 0 args: () kwargs: {}
> 1 2 3 args: ('a', 'b', {'c': 'd'}) kwargs: {'e': 'f'}很神奇的是可以通过一个tuple和一个dict调用上述函数
tup = (1,2,3,4)
dic = {'1': 10, '2':20}
func(*tup, **dic)
> 1 2 3 args: (4,) kwargs: {'1': 10, '2': 20}很有必要研究一下这个输出：123作为abc的参数传入，而4作为一个tuple传入，最后传入一个字典。
所以，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。
总结
Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。
默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！
要注意定义可变参数和关键字参数的语法：
*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的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。
命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。
定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。
