python 函数的定义及传参

函数是一个通用的程序结构部件，是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

定义一个简单的函数：

>>> def test(a):        #创建一个函数，函数名是test。
	for i in a:
            print(i)
>>> test((1,2,3,4,5))   #使用test()调用函数，同时往里面传一个参数（元组）。
1
2
3
4
5
>>> test(['a','b','c','d']) #使用test()调用函数，往里面传一个参数（列表）。
a
b
c
d

---

参数形式：

不传参数

>>> def fun1():       #定义一个不传参的函数。
    print('不能传参数:')
    for i in range(1,10):
        print(i)

        
>>> fun1()              #调用函数。
不能传参数:
1
2
3
4
5
6
7
8
9
>>> fun1('a')        #传一个参数，结果会报错。
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    fun1('a')
TypeError: fun1() takes 0 positional arguments but 1 was given
>>>  

必备参数

>>> def fun2(a):    #这个函数必须传参数
    print('必须传参数:')
    for i in range (2,a):
        print(i)

        
>>> fun2(8)         #调用函数，并且传一个参数。函数里面的range(2,a)，传入参数 '8'，就变成了range(2,8)
必须传参数:
2
3
4
5
6
7
>>> 

默认参数

>>> def fun2(a=6):    #定义一个可选参数的函数，因为参数默认有值。
    print('默认参数:')
    for i in range (2,a):
        print(i)

        
>>> fun2()         #调用函数，没有传参数。
默认参数:
2
3
4
5
>>> fun2(8)    #也可以定义一个参数。
默认参数:
2
3
4
5
6
7
>>> fun2(a=12)  #也可以使用 “a=12” 这种方式传参数。
默认参数:
2
3
4
5
6
7
8
9
10
11
>>> 

可选参数：包装成元组

def fun4(*arg)，这里重要的是  " * 号 "，后边的arg只是一个约定俗成的名称。注意：调用函数时也可以添加 “* 号”这样可以对参数进行 “解包”

>>> def fun4(*arg):    #有 “* 号” 开始的参数，意味着可以在这个函数里传多个或者0个参数。
	print('可传0个或者多个参数：',arg)
	
>>> fun4()            #调用函数，不传参数
可传0个或者多个参数： ()

>>> fun4(1)      #（1，）证明是元组，因为元素1后边有个 ',号'
可传0个或者多个参数： (1,)            
>>> fun4(1,'a')        #传多个参数
可传0个或者多个参数： (1, 'a')  
       
>>> fun4(1,{'a':1})
可传0个或者多个参数： (1, {'a': 1})  

>>> fun4(1,*{'a':1})   #这里调用函数时，在其中一个字典参数前面添加了一个 "* 号"(*{'a':1})，这个"* 号"把里面的壳去掉，结果指输出字典的 “键”
 可传0个或者多个参数： (1, 'a')

 >>> fun4(1,['a',1])
 可传0个或者多个参数： (1, ['a', 1])

 >>> fun4(1,*['a',1])   #这使用"* 号"把列表里面的壳去掉（解包）。
 可传0个或者多个参数： (1, 'a', 1)

关键字参数：包装成字典

>>> def fun(**kwarg):    #这里 " ** 号 "是重点，参数名kwarg是一个约定俗称，也可以这样定义 def fun(**abc):
	print('关键字参数：',kwarg)

>>> fun()                #调用函数，不传参数时，返回一个空的字典。
关键字参数： {}
>>> fun(a=1,b=2,c=3)     #可以传多个参数，因为返回的是字典，所以参数需要时键值对的格式。
关键字参数： {'a': 1, 'b': 2, 'c': 3}
>>> fun(**{'y':1,'b':8})   #如果不加 " ** 号 "，调用函数时会报错。
关键字参数： {'y': 1, 'b': 8}
>>> 

---

参数混合的时候，关键字参数放最后；根据定义的顺序，确保必备参数能拿到值，并且只能拿到一个值。

必备参数 + 默认参数

>>> def fun(a,b=1):   #默认参数b，必须放在必备参数a前面。
	print('必备参数是：%s，默认参数是：%s'%(a,b))

	
>>> fun(2)          #调用函数时，只需要给必备参数赋值
必备参数是：2，默认参数是：1
>>> fun(a=3,b=5)    #也可以这样调用函数，(a=3,b=5)像关键字参数赋值一样。
必备参数是：3，默认参数是：5
>>> fun(3,5)        #也可以不使用变量名
必备参数是：3，默认参数是：5
>>> fun(a=1,3)        #这样就会报错，关键字参数(a=1)的赋值方式要放在后边。
SyntaxError: positional argument follows keyword argument
>>> fun(3,a=1)        #也会报错，需要根据函数里传参的顺序来定义。按照传参的顺序，此时必备参数已经取到值3了，但是后边又以a=1这种关键字参数的方式又给a赋值了一次。
Traceback (most recent call last):
  File "<pyshell#100>", line 1, in <module>
    fun(3,a=1)      
TypeError: fun() got multiple values for argument 'a'
>>> 

必备参数 + 默认参数 + 关键字参数。

关键字参数放最后；根据定义的顺序传参。

def fun(a,b=1,*abc):   #函数里面必备参数是a,默认参数是b=1，可选参数是：*abc
	print('必备参数是：%s,默认参数是：%s，可选参数是：%s'%(a,b,abc))

	
>>> fun(8)  #调用函数时，只需要给必备参数赋值。
必备参数是：8,默认参数是：1，可选参数是：()
>>> fun(8,b=9,1,2,3)#因为最后是 “ 关键字参数*abc ”，理论上这样调用函数是可以的，但是结果会报错。因为“ b=9 ”会被当成关键字参数放在最后，这样调用函数的顺序就不对了。
SyntaxError: positional argument follows keyword argument
>>> fun(8,1,2,3,b=9) #这种调用方式也不对，当必备参数 a 取到8后，接着默认参数 b 就会取1，然后关键字参数 *abc 取2和3，而最后又来一个默认参数b=9；结果顺序就错了。
Traceback (most recent call last):
  File "<pyshell#121>", line 1, in <module>
    fun(8,1,2,3,b=9) 
TypeError: fun() got multiple values for argument 'b'
>>> 
>>> 
>>> fun(5,8,2,3,9)   #必备参数a取5,默认参数b取8，可选参数*abc取(2, 3, 9)
必备参数是：5,默认参数是：8，可选参数是：(2, 3, 9)
>>>