意义
定义函数，可以简化调用者代码。封装
位置参数和默认参数就很有意思了，慢慢体会到高级语言的方便性。
人生苦短，我学python
位置参数
比如定义一个计算x**2的函数：
def power(x):
return x * x但局限性很大，只能够计算x2无法计算x3，或者更改次方。
所以，写一个通用性更大的函数
def power(x, n):
s = 1
while n > 0:
n -= 1
s = s * x
return s解决了通用性，但是，又一个问题应运而生，这使得之前的power（2），即之前的调用出现了问题。这是因为函数加了一个参数，使得之前的调用出现了问题，解决方法就是使用默认参数。
默认参数
先看错误提示
>>> power(5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: power() missing 1 required positional argument: 'n'提示缺少一个位置参数n
因为x**2经常计算，所以可以把第二个参数的值改成2，即默认情况下（只传一个参数的情况下），计算平方。
def power(x, n = 2):
s = 1
while n > 0:
n -= 1
s *= x
return s此时问题就解决了
>>> power(5)
25
>>> power(5, 2)
25那对于n大于2的情况下，就必须传入指定的n即可。
但是注意：
一是必选参数在前，默认参数在后（必须），否则Python的编译器会报错，肯定的，默认参数在前，使得传参的顺序发生了歧义，这与定义的传参方式相冲突了。
二是如何设置默认参数
那么默认参数的设置，就是变化小的做默认参数。
使用默认参数有什么好处？最大的好处是能降低调用函数的难度。
例如，写一个一年级小学生注册的函数，需要传入name和gender两个参数：
def enroll(name, gender):
print('name:', name)
print('gender:', gender)这样，存在问题，因为一年级小学生注册，基本上年龄在6岁，且对于当地的学生，城市信息一般不需要更改，所以，如果每次传参都要传入这些变化很小的参数，就会显得繁琐，重复，这不符合高级语言越来越简便的趋势。
那么，代码设计如下
def enroll(name, gender, age=6, city='Beijing'):
print('name:', name)
print('gender:', gender)
print('age:', age)
print('city:', city)这样，就简便得多
>>> enroll('Sarah', 'F')
name: Sarah
gender: F
age: 6
city: Beijing只有与默认参数不符的学生才需要提供额外的信息：
enroll('Bob', 'M', 7)
enroll('Adam', 'M', city='Tianjin')默认参数的存在和设置，大大减低了函数调用的难度，这使得无论是简单调用还是复杂调用，函数只需要定义一个。
有多个默认参数时，调用的时候，既可以按顺序提供默认参数，比如调用enroll(‘Bob’, ‘M’, 7)，意思是，除了name，gender这两个参数外，最后1个参数应用在参数age上，city参数由于没有提供，仍然使用默认值。
也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。比如调用enroll(‘Adam’, ‘M’, city=‘Tianjin’)，意思是，city参数用传进去的值，其他默认参数继续使用默认值。（这时需要指定改变的是哪个默认参数）
虽然默认参数好处多，但是也存在巨大的坑
代码比如：
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']发生了变化，这里的L不再是【】，而是每次都记住了上次的结果。
原因是因为对象每次都发生改变，而L只是变量。最开始学的时候，都知道，面向对象，面向数据对象，变量只是指向了数据对象而已，数据对象和变量本身没什么关系，数据对象每次都插入end，使得L指向的这个默认数据对象一直在改变，所以：
如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。
== 定义默认参数要牢记一点：默认参数必须指向不变对象！==
修改：
def add_end(L = None):
if L is None:
L = []
L.append('END')
return L这样就不会出现问题。
不变对象存在的意义
不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象就不需要加锁，同时读一点问题没有。所以，在编写程序的时候，如果可以设计一个不变对象，那就尽量设计成不变对象。（不需要加锁这个意义其实蛮重要的，因为加锁容易造成阻塞，以及有死锁的风险，又要解决死锁等，会很麻烦。）
可变参数
这里我想到了python是脚本语言，好像脚本语言都没有指针是吗？反正现在遇到的脚本语言没有指针，这使得其传可变参数就稍微不同了。
脚本语言：无需编译，直接顺序解释执行就行。
那么可变，自然相到list，tuple（因为tuple中可以有list？，也不能这么说）
上代码
def calc(numbers):
sum = 0;
for n in numbers:
sum += n*n
return sum但是，在调用的时候，就要先组装出一个list或者tuple
>>>calc([1, 2, 3])
>14
>>>calc((1, 2, 3))
>14那就会比较麻烦，那如果是用的可遍参数，调用就会变成这样：
>>> calc(1, 2, 3)
14
>>> calc(1, 3, 5, 7)
84所以，将函数的参数写成可变参数：
def calc(*numbers):
sum = 0
for n in numbers:
sum += n * n
return sum这是传参就不需要组装list或者tuple了
>>> calc(1, 2)
5
>>> calc()
0那么问题又来了，你想传入可变参数怎么办呢？
第一种写法
>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
14这还不如不定义，所以，python允许在list或者tuple前面加一个==*==号，把list变成可变参数传进去
上代码
>>>nums = [1, 2, 3]
>>>calc(*nums)
>14那这样就方便多了
关键字参数
可变参数允许你传入0个或者任意给参数，这些可变参数在函数调用时自动组装成为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
比如
def person(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'}看到这里，那么关键字参数有什么用呢？还没有体会
它可以扩展函数的功能。比如，在person函数里，我们保证能接受到name和age两个参数，但是如果调用者愿意提供更多的参数，我们也能收到。比如说，正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的要求。
哦，明白了，这样就和数据库对上了。和实际开发对上了。
同样，传可变参数也可以先组装出一个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参数中，kw将获得一个dict。但是，kw获得的只是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
命名关键字参数
对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。值语到底传入了哪些，就需要在函数内部通过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)到这，没看和关键字参数有任何不同
如果要限制关键字参数的名字，就可以用命名关键字参数。比如，只接受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那如果不按照city和job来调用呢
>>>person('Jack', 24, job = 'Beijing', city = 'Engineer')
>Jack 24 Engineer Beijing结果可以输出
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
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（）函数只接受两个位置参数。
同时，命名关键字参数可以有缺省值，简化调用
def person(name, age, *, city='Beijing', job):
print(name, age, city, job)==注意：使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少星号，那么Python解释器就视为位置参数了。
参数组合
顾名思义，上述的参数类型，可以组合使用。
在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
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}老实说，有点乱，不过还是能体会其中
调用的神奇之处func(*args, **kw)
>>> 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': '#'}这里，怎么说呢，我只做了解，这样搞，会太复杂了，感觉还是要把函数接口写得容易调用一些。
练习
以下函数允许计算两个数的乘积，请稍加改造，变成可接收一个或多个数并计算乘积：
def product(x, y):
return x * y自然想到使用可变参数
改后：
def product(*args):
p = 1
for n in args:
p *= n
return p
if __name__ == '__main__':
print(product(5))
print(product(5, 6))
print(product(5, 6, 7))
print(product(5, 6, 7, 9))
print(product(5, 6, 7, 9, 10))小结
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的习惯写法，可以用其他参数名，但是最好用这个。约定俗成嘛，讲究。
以及定义命名关键字参数时候，在没有可变参数的情况下，需要加*号作为分隔符
那么总结
位置参数，就正常的参数
默认参数，在定义时候指出缺省值（有坑的，面向对象思想）
可变参数，*参数名，传入的时候自动组装成list或者tuple，可变嘛
关键字参数， 两个星号+参数名，传入组装成dict
命名关键字参数，如果没有可变参数的情况下，那么就要加一个星号分隔开。并且这个参数值是直接相对于key-value的。
参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
