参考：

http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001374738449338c8a122a7f2e047899fc162f4a7205ea3000

########################################################

函数参数：必选参数、默认参数、可选参数、关键字参数

########################################################

默认参数：放在必选参数之后

计算x平方的函数：

1. def power(x):
2. return x*x

power(5)

计算x的立方

1. def power(x):
2. return x*x*x

这样的话每次计算不同幂函数都要重写函数，非常麻烦，可使用以下代码计算：

1. def power(x, n):
2. s= 1
3. while n> 0:
4. n=n -1
5. s=s*x
6. return s

使用修改后的power函数，可以计算任意n次方

不过每次调用函数必须输入两个参数，使用默认参数可以进一步简化函数：

1. def power(x, n=2):
2. s= 1
3. while n> 0
4. n=n -1
5. s=s*x
6. return s

设置默认参数时注意事项：必选参数在前，默认参数在后

默认参数最大好处：降低调用函数的难度

学生注册，需要传入name和gender:

1. def enroll(name, gender):
2. print 'name :',name
3. print 'gender :',gender

把年龄、城市设为默认参数可以简化函数：

1. def enroll(name, gender, age=6, city='Beijing'):
2. print 'name :',name
3. print 'gender :',gender
4. print 'age :',age
5. print 'city :',city

有多个默认参数化时，调用的时候，既可以按顺序提供默认参数，比如调用enroll('zj', 'M', 8)；也可以不按顺序提供部分默认参数，如enroll('Ad', 'a', city='dad')

默认参数也有缺陷的地方：

1. def add_end(L=[]):
2. L.append( 'END')
3. return L

原因：函数在定义时，默认参数L所制定的地址已经确定，而L是一个list，所以每次调用该函数时，如果改变了L的内容，则下次调用时，默认参数的内容就会改变

note: 默认参数必须指向不变对象！！！

如上代码可使用None实现：

1. def add_end(L=None):
2. if L is None:
3. L=[]
4. L.append( 'END')
5. return L

##################################################################

可变参数：就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个

在参数前面加上*就是可变参数。在函数内部，参数numbers接收得到的是一个tuple，调用该函数时，可以传入任意个参数，包括0个参数：

1. def calc(*numbers):
2. sum= 0
3. for n in numbers:
4. sum= sum+n*n
5. return sum

如何调用一个list或者tuple，可以如上所示，在list或tuple前面加上一个*号，把list或tuple的元素变成可变参数传进去

####################################################################

关键字参数

允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装成一个dict

使用**表示关键字参数

函数person不仅可以只传入必选参数，也可以传入任意个数的关键字参数

也可以类似可变参数，先组装一个dict，然后，把该dict转换为关键字参数传进去：

1. kw={ 'city': 'Beijing', 'job': 'Engineer'}
2. person( 'Jack', 24, city=kw[ 'city'], job=kw[ 'job'])
3. person( 'Jack' , 24, **kw)

#############################################################

参数组合

参数定义的顺序：必选参数、默认参数、可变参数和关键字参数

#######################################################

in summary:

默认参数一定要用不可变对象，如果是可变对象，运行会有逻辑错误！

*args是可变参数，args接收的是一个tuple;

**kw是关键字参数，kw接收的是一个dict

Python函数默认参数设置（超级详细）

我们知道，在调用函数时如果不指定某个参数，Python 解释器会抛出异常。为了解决这个问题，Python 允许为参数设置默认值，即在定义函数时，直接给形式参数指定一个默认值。这样的话，即便调用函数时没有给拥有默认值的形参传递参数，该参数可以直接使用定义函数时设置的默认值。

Python 定义带有默认值参数的函数，其语法格式如下：

def 函数名(...，形参名，形参名=默认值)：
    代码块

注意，在使用此格式定义函数时，指定有默认值的形式参数必须在所有没默认值参数的最后，否则会产生语法错误。

下面程序演示了如何定义和调用有默认参数的函数：

#str1没有默认参数，str2有默认参数
def dis_str(str1,str2 = "http://www.456.com/"):
    print("str1:",str1)
    print("str2:",str2)
dis_str("http://www.123.com/")
dis_str("http://www.123.com/","http://www.789.com/")

运行结果为：

str1: http://www.123.com/
str2: http://www.456.com/
str1: http://www.123.com/
str2: http://www.789.com/

上面程序中，dis_str() 函数有 2 个参数，其中第 2 个设有默认参数。这意味着，在调用 dis_str() 函数时，我们可以仅传入 1 个参数，此时该参数会传给 str1 参数，而 str2 会使用默认的参数，如程序中第 6 行代码所示。

当然在调用 dis_str() 函数时，也可以给所有的参数传值（如第 7 行代码所示），这时即便 str2 有默认值，它也会优先使用传递给它的新值。

同时，结合关键字参数，以下 3 种调用 dis_str() 函数的方式也是可以的：

dis_str(str1 = "http://www.123.com/")
dis_str("http://www.123.com/",str2 = "http://www.123.com/")
dis_str(str1 = "http://www.123.com/",str2 = "http://www.123.com/")

再次强调，当定义一个有默认值参数的函数时，有默认值的参数必须位于所有没默认值参数的后面。因此，下面例子中定义的函数是不正确的：

#语法错误
def dis_str(str1="http://www.123.com/",str2,str3):
    pass

显然，str1 设有默认值，而 str2 和 str3 没有默认值，因此 str1 必须位于 str2 和 str3 之后。

有读者可能会问，对于自己自定义的函数，可以轻易知道哪个参数有默认值，但如果使用 Python 提供的内置函数，又或者其它第三方提供的函数，怎么知道哪些参数有默认值呢？

Pyhton 中，可以使用“函数名.defaults”查看函数的默认值参数的当前值，其返回值是一个元组。以本节中的 dis_str() 函数为例，在其基础上，执行如下代码：

print(dis_str.__defaults__)

程序执行结果为：

('http://www.123.com/',)

Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数，

1 默认参数

• 定义形式：def calc(para1，para2=None):其中para2是默认参数。
• 意义：可变参数就是传入的参数个数是可变的。可以是1个、2个到任意个，还可以是0个。

• 设置默认参数需要注意的点：

  • 必选参数在前，默认参数在后；否则不知道你传进的值是给谁，引起歧义，Python的解释器会报错。
  • 当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。
  • 默认参数的好处：降低调用函数的难度
  • 定义默认参数要牢记一点：默认参数必须指向不变对象！，因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。例如，做如下定义：
    

    
    #功能：对输入的列表的最后加一个‘'END'’
    
    
    #这里默认参数L指向的可变对象[];
    
    def add_end(L=[]):  #正确的做法应该是L= None
    L.append('END')
    return L
    
    add_end([1,2])#使用普通调用，不会出错
    
    add_end()
    add_end()#连续使用两次默认参数调用时，结果出错
    Out[9]: ['END', 'END']

2 可变参数

• 定义形式：def calc(*numbers):
• 意义：可变参数就是传入的参数个数是可变的。并用numbers元组接收。在调用calc函数时，括号里的参数任意个，还可以是0个。

• 例子：

  1. 给定一组数字a，b，c，……（个数任意）

  写calc（）函数，计算 a + b + c + …

  def calc(*numbers):
      print(type(numbers)) #numbers为tuple类型
      return sum(numbers)
  calc(1,2)
           #calc内参数可以设置任意个
           #实质：numbers接收这任意个实值并变成tuple
  <class 'tuple'>
  Out[3]: 3

3 关键字参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

• 定义形式：可以传入0或任意个数的关键字参数

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

person('Adam', 45, gender='M', job='Engineer')

OUTPUT:
name: Adam age: 45 
other: {'gender': 'M', 'job': 'Engineer'}

另一种调用方法：

extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **extra)#注意是**extra

**extra表示把extra这个dict的所有key-value
用关键字参数传入到函数的**kw参数，kw将获得
extra的一份拷贝，对kw的改动不会影响到函数外的extra

4 命名关键字参数

定义一个函数后，在调用时如果需要对关键字参数的名字进行限制，可以使用以下定义。

def person(name, age, *, city, job):
    print(name, age, city, job)

和关键字参数*kw不同，命名关键字参数需要一个特殊分隔符，*后面的参数被视为命名关键字参数

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

由于位置参数只能定义在可变参数前面，所以，city，job视为命名
关键字参数，这说明在调用的时候应该采用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

5 参数组合

在Python中，请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。（越来越复杂的顺序）

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

>>> args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)
# 注意，定义一个tuple和一个dict，可以使用以上对f1函数

详细参阅：廖雪峰老师—-函数的参数