函数的参数

#在前面我们已经了解了如何定义函数，不过只讲述了定义简单函数，还有一类函数是带参数的，称为带参数的函数。本节将探讨如何定义带参数的函数及其使用。

（1）、必须参数；

（2）、关键字参数；

（3）、默认参数；

（4）、可变参数；

（5）、组合参数。

1、必须参数

#必须参数必须以正确的顺序传入函数。调用时数量必须和声明时一样。
        #定义如下函数并执行：
#! /usr/bin/python3
#-*- conding:UTF8 -*-
#def函数_必须参数


def paramone(str):
    print('the param is:',str)
    print('传入参数是：',str)
paramone('hello,world')
        #执行结果如下：
============== RESTART: C:/Users/DL He/Desktop/def_示例模板_必须参数.py ==============
the param is: hello,world
传入参数是： hello,world
        #我们定义了一个必须传入一个参数的函数paramone(str)，传入的参数为str，结果是将’hello，world‘传给str。
        #对于上例，若不传入参数或传入一个以上的参数，结果会怎么杨，例如：
#! /usr/bin/python3
#-*- conding:UTF8 -*-
#def函数_必须参数


def paramone(str):   #不输入参数
    print('the param is:',str)
    print('传入参数是：',str)
paramone()  #不输入参数
        #执行结果如下：
Traceback (most recent call last):
  File "C:/Users/DL He/Desktop/def_示例模板_必须参数.py", line 9, in <module>
    paramone()  #不输入参数
TypeError: paramone() missing 1 required positional argument: 'str'     #paramone()缺少1个需要的位置参数:“str”
        #执行结果告诉我们，paramone()函数缺少一个必需的定位参数，参数类型为：str。
        #再例如：
#! /usr/bin/python3
#-*- conding:UTF8 -*-
#def函数_必须参数


def paramone(str):  
    print('the param is:',str)
    print('传入参数是：',str)
paramone('hello','world')  #超过一个参数
        #执行结果如下：
Traceback (most recent call last):
  File "C:/Users/DL He/Desktop/def_示例模板_必须参数.py", line 9, in <module>
    paramone('hello','world')  #超过一个参数
TypeError: paramone() takes 1 positional argument but 2 were given     #paramone()接受1个位置参数，但给出了2
        #执行结果告诉我们，paramone()函数只接受一个位置参数却给了两个。
        #通过示例可以看到，对于定义的paramone()函数，不传入参数或传入一个以上参数，都会报错。所以对于此类函数，必须传递对应正确个数的参数。

2、关键字参数

 #关键字参数和函数调用关系紧密，函数调用使用关键字参数确定传入的参数值。
        #使用关键字参数允许调用函数时参数的顺序与声明时不一致，因为Python解释器能够用参数名匹配参数值。
        #定义如下函数并执行：
#! /usr/bin/python3
#-*- conding:UTF8 -*-
#def函数_关键字参数

def personinfo(age,name):
    print('年龄：',age)
    print('名字：',name)
    return

print('------按参数顺序传入参数------')
personinfo(21,'小明')
print('------不按参数顺序传入参数，指定参数名------')
personinfo(name='小明',age=21)
print('------按参数顺序传入参数，并指定参数名------')
personinfo(age=21,name='小明')
        #调用函数执行结果如下：
============= RESTART: C:/Users/DL He/Desktop/def_示例模板_关键字参数.py =============
------按参数顺序传入参数------
年龄： 21
名字： 小明
------不按参数顺序传入参数，指定参数名------
年龄： 21
名字： 小明
------按参数顺序传入参数，并指定参数名------
年龄： 21
名字： 小明
        #由以上输出结果可以看到，对于personinfo()函数，只要指定参数名，结果就没有影响，都能得到正确的结果。

3、默认参数

    #调用函数时，如果没有传递函数，就会使用默认函数。
        #使用默认函数，就是在定义函数时，给参数一个默认值，如果没有给调用的函数的参数赋值，调用的函数就会使用这个默认值。
        #例如，定义如下函数并执行：
#! /usr/bin/python3
#-*- conding:UTF8 -*-
#def函数_默认参数


def defaultparam(name,age=23):
    print('你好，我叫：',name)
    print('我今年：',age)
    return
defaultparam('小明')
        #调用函数执行结果如下:
============== RESTART: C:/Users/DL He/Desktop/def_示例模板_默认参数.py ==============
你好，我叫： 小明
我今年： 23
        #从以上示例可以看到，在函数调用时没有对age赋值，在输出结果中使用了函数定义时的默认值。如果我们对age赋值，最后的结果会是使用哪个值？
#! /usr/bin/python3
#-*- conding:UTF8 -*-
#def函数_默认参数


def defaultparam(name,age=23):
    print('你好，我叫：',name)
    print('我今年：',age)
    return
defaultparam('小明',21)    #age函数默认值是23
        #得到的执行结果如下：
============== RESTART: C:/Users/DL He/Desktop/def_示例模板_默认参数.py ==============
你好，我叫： 小明
我今年： 21
        #通过执行函数我们看到，执行结果使用的是我们传入的参数。由此得知，当对默认参数传值时，函数执行时调用的是我们传入的值。
        #把函数的默认参数放在前面是否可行？定义如下函数并执行：
#! /usr/bin/python3
#-*- conding:UTF8 -*-
#def函数_默认参数


def defaultparam(age=23,name):
    print('你好，我叫：',name)
    print('我今年：',age)
    return
defaultparam('小明')
        #执行结果如下：
SystaxError:non-default argument follows default argument    #非默认参数遵循默认参数
        #执行结果是编译不通过，错误信息是：非默认参数跟在默认参数后面了。
        #这里提醒我们，默认参数一定要放在非默认参数后面，如果需要多个默认参数，该如何操作呢，再来看以下几个示例：
        #示例1，默认参数在必须参数前：
#! /usr/bin/python3
#-*- conding:UTF8 -*-
#def函数_默认参数


def defaultparam1(name,age=23,addr='广东'):
    print('你好，我叫：',name)
    print('我今年：',age)
    print('我现在在：',addr)
    return
defaultparam1(age=21,name='小明')

def defaultparam2(age=23,addr='广东',name):
    print('你好，我叫：',name)
    print('今年：',age)
    print('我现在在：',addr)
    return
defaultparam2(age=21,name='小明',addr='北京')
        #执行结果如下：
SystaxError:non-default argument follows default argument    #非默认参数遵循默认参数
        #示例2
#! /usr/bin/python3
#-*- conding:UTF8 -*-
#def函数_默认参数

def defaultparam(name,age=23,addr='广东'):
    print('你好，我叫：',name)
    print('我今年：',age)
    print('我现在在：',addr)
    return
print('------传入必须参数------')
defaultparam('小明')
print('------传入必须参数，更改第一个默认参数值------')
defaultparam('小明',21)
print('------传入必须参数，默认参数值都更改------')
defaultparam('小明',21,'北京')
print('------传入必须参数，指定默认参数名并更改参数值------')
defaultparam('小明',addr='北京',)
print('------传入必须参数，指定参数名并更改值------')
defaultparam('小明',age=21,addr='北京')
print('------第一默认参数不带参数名，第二个带------')
defaultparam('小明',21,addr='北京')
print('------两个默认参数都带参数名------')
defaultparam('小明',age=21,addr='北京')
#print('------第一个默认参数带参数名，第二个不带，报错------')
defaultparam('小明',age=23,'北京')
        #执行结果如下：
============== RESTART: C:/Users/DL He/Desktop/def_示例模板_默认参数.py ==============
------传入必须参数------
你好，我叫： 小明
我今年： 23
我现在在： 广东
------传入必须参数，更改第一个默认参数值------
你好，我叫： 小明
我今年： 21
我现在在： 广东
------传入必须参数，默认参数值都更改------
你好，我叫： 小明
我今年： 21
我现在在： 北京
------传入必须参数，指定默认参数名并更改参数值------
你好，我叫： 小明
我今年： 23
我现在在： 北京
------传入必须参数，指定参数名并更改值------
你好，我叫： 小明
我今年： 21
我现在在： 北京
------第一默认参数不带参数名，第二个带------
你好，我叫： 小明
我今年： 21
我现在在： 北京
------两个默认参数都带参数名------
你好，我叫： 小明
我今年： 21
我现在在： 北京
------第一个默认参数带参数名，第二个不带，报错------
SyntaxError:positional argument follows keyword argument  #位置参数遵循关键字参数
        #从以上执行结果可以发现：
        （1）、无论有多少默认参数，默认参数都不能在必须参数之前。
        （2）、无论有多少默认值，若不传入默认参数值，则使用默认值。
        （3）、若要更改某一个默认参数值，又不想传入其他默参数，且该默认参数的位置不是第一个，则可以通过参数名更改想要更改的默认参数值。        
        （4）、若有一个默认参数通过传入参数名给改参数值，则其他想要更改默认参数都需要传入参数名更改参数值，否则报错。
        （5）、更改默认参数值时，传入默认参数的顺序不需要根据定义的函数中的默认参数的顺序传入，不过最好同时传入参数名，否则容易出现执行结果与预期不一致的结果。
        #通过以上示例可以看到，默认参数是比较有用的，通过默认参数可以帮助我们少写不少代码，比如使用上面的代码帮助某单位录入人员信息，如果有很多人的addr相同，就不需要传入每个人的addr值了。不过使用默认参数是需要小心谨慎。

4、可选参数

#如果需要一个函数能够处理的参数声明时更多，这些参数叫作可变参数。和前面所述两个参数不同，可变参数声明时不会命名。基本语法如下：
def functionname([formal_ages,]*var_ages_tuple):
      "函数_文档字符串"
      function_suite
      return[expression]
        #加了星号（*）的变量名会存放所有未命名的变量参数。如果变量参数在函数调用时没有指定参数，就是一个空元组。我们也可以不向可变函数传递未命名的变量。
        #下面通过示例说明可变函数的使用，定义如下函数并执行：
# /usr/bin/python3
#!-*- coding:UTF8 -*-
#def_示例模板_可选参数

def personinfo(age,*vartuple):
    print(age)
    for var in vartuple:
        print('我属于不定长参数部分:',var)
    return

print('------不带可变参数------')
personinfo('小明')
print('------带两个可变参数------')
personinfo('小明',21,'广东')
print('------带五个可变参数------')
personinfo('小明',21,'广东',123,'梅州','happy')
        #执行结果如下：
============== RESTART: C:/Users/DL He/Desktop/def_示例模板_可选参数.py ==============
------不带可变参数------
小明
------带两个可变参数------
小明
我属于不定长参数部分: 21
我属于不定长参数部分: 广东
------带五个可变参数------
小明
我属于不定长参数部分: 21
我属于不定长参数部分: 广东
我属于不定长参数部分: 123
我属于不定长参数部分: 梅州
我属于不定长参数部分: happy
        #这段代码看起来很不可思议，在定义函数时只定义了两个参数，调用时却可以传入那么多参数？
        #这其实就是可变参数的好处，我们在参数前面加了一个星号，在函数内部，参数前的星号将所有值放在同一个元组中，通过这种方式将这些值收集起来，然后使用。参数vartuple接受的是一个元组，调用函数时可以传入任意个数的参数，也可以不传。
        #在这个示例中使用了前面的for循环，通过for循环遍历元组。
        #通过这种方式定义函数，调用时比较方便。
        #也可以使用这种方式处理前面学习的关键字参数，例如：
# /usr/bin/python3
#!-*- coding:UTF8 -*-
#def_示例模板_可选参数_1


other={'城市':'广东','爱好':'编程'}
def personinfo(name,number,**kw):
    print('名称：',name,'学号：',number,'其他：',kw)
personinfo('小明',1001,城市=other['城市'],爱好=other['爱好'])
        #执行结果如下：
============= RESTART: C:/Users/DL He/Desktop/def_示例模板_可选参数_1.py =============
名称： 小明 学号： 1001 其他： {'城市': '广东', '爱好': '编程'}
        #由函数执行结果看到，可以使用两个“*”号，即使用“**”处理关键字参数，函数调用时可以用更简单的方式调用，简单形式如下：
# /usr/bin/python3
#!-*- coding:UTF8 -*-
#def_示例模板_可选参数_1


other={'城市':'广东','爱好':'编程'}
def personinfo(name,number,**kw):
    print('名称：',name,'学号：',number,'其他：',kw)
personinfo('小明',1001,**other)
        #执行结果如下：
============= RESTART: C:/Users/DL He/Desktop/def_示例模板_可选参数_1.py =============
名称： 小明 学号： 1001 其他： {'城市': '广东', '爱好': '编程'}
        #执行结果和前面一样，写法上却简单了不少。此处**other表示把other这个字典的所有key-value用关键字参数传入函数的**kw参数，kw将获得一个字典，注意kw获得的字典时other复制的，对kw的改动不会影响函数外的other。

5、组合参数

 #在Python中定义函数可以用必须参数、关键字参数、默认参数和可变关键字参数、这四种参数可以组合使用。注意定义参数的顺序必须是必须参数、默认参数、可变参数和关键字参数。
        #下面介绍组合参数的使用，如下函数：
# /usr/bin/python3
#!-*- coding:UTF8 -*-
#def_示例模板_组合参数

def exp(p1,p2,df=0,*var,**kw):
    print('p1=','p2=','df=','var',var,'kw=',kw)

exp(1,2)
exp(1,2,c=3)
exp(1,2,3,'a','b')
exp(1,2,3,'abc',x=9)
        #执行结果如下：
============== RESTART: C:/Users/DL He/Desktop/def_示例模板_组合参数.py ==============
p1= 1 p2= 2 df= 0 var= () kw= {}
p1= 1 p2= 2 df= 0 var= () kw= {'c': 3}
p1= 1 p2= 2 df= 3 var= ('a', 'b') kw= {}
p1= 1 p2= 2 df= 3 var= ('abc',) kw= {'x': 9}
        #由输出结果看到，使用了组合参数，在调用函数时，Python解释器会自动按照参数位置和参数名对应的参数传进去。
        #此处还可以用tuple和dict调用上述函数，使用方式如下：
# /usr/bin/python3
#!-*- coding:UTF8 -*-
#def_示例模板_组合参数

def exp(p1,p2,df=0,*var,**kw):
    print('p1=','p2=','df=','var',var,'kw=',kw)

args=(1,2,3,4)
kw={'x':'8','y':'9'}
exp(*args,**kw)
        #执行结果如下：
============== RESTART: C:/Users/DL He/Desktop/def_示例模板_组合参数.py ==============
p1= 1 p2= 2 df= 3 var= (4,) kw= {'x': '8', 'y': '9'}
        #由执行结果看到，任意函数都可以通过类似func（*args,**kw）的形式调用，无论参数是如何定义的.

end