python函数（一）

 函数定义

def 函数名(参数1,参数2,*args,默认参数,**kwargs):
        """注释：函数功能和参数说明"""
        函数体
        ……
        return 返回值

注意

1.定义：def 关键词开头，空格之后接函数名称和圆括号()。
2.参数：圆括号用来接收参数。若传入多个参数，参数之间用逗号分割。
　　　　参数可以定义多个，也可以不定义。
　　　　参数有很多种，如果涉及到多种参数的定义，应始终遵循==>位置参数、*args、默认参数、**kwargs顺序定义。
　　　　如上述定义过程中某参数类型缺省，其他参数依旧遵循上述排序
3.注释：函数的第一行语句应该添加注释。
4.函数体：函数内容以冒号起始，并且缩进。
5.返回值：return [表达式] 结束函数。不带表达式的return相当于返回 None

 

对参数的思考

1.实参与形参

参数还有分别：

调用函数时传递的这个实际值被称为实际参数，因为这个是实际的要交给函数的内容，简称实参。

定义函数时的（）里的，只是一个变量的名字，被称为形式参数，因为在定义函数的时候它只是一个形式，表示这里有一个参数，简称形参。

2.位置参数和默认参数

位置参数

1.按照位置传值

def mymax(x,y):
    #此时x=10,y=20
    the_max = x if x > y else y
    return the_max

ma = mymax(10,20)
print(ma)
OK

2.按照关键字传参

def mymax(x,y):
    #此时x = 20,y = 10
    print(x,y)
    the_max = x if x > y else y
    return the_max

ma = mymax(y = 10,x = 20)
print(ma)
OK

3.位置传参和关键字传参混合使用

def mymax(x,y):
    #此时x = 10,y = 20
    print(x,y)
    the_max = x if x > y else y
    return the_max

ma = mymax(10,y = 20)  =>ok
ma = mymax(x = 10,20)  =>error 
ma = mymax(10,x = 20)  =>error  
print(ma)

　　　　正确用法

　　　　　　问题一:位置参数必须在关键字参数的前面

　　　　　　问题二:对于一个形参只能赋值一次　

默认参数

　　　为什么要有默认参数：将变化比较小的值设置成默认参数

def stu_info(name,sex = "male"):
    """打印学生信息函数，由于班中大部分学生都是男生，
        所以设置默认参数sex的默认值为'male'
    """
    print(name,sex)


stu_info('wang')
stu_info('liuyifei','female')

　　当默认参数是一个可变数据类型存在参数陷阱：

def defult_param(a,l = []):
    l.append(a)
    print(l)

defult_param('wang')        #['wang']
defult_param('qingbin')      #['wang', 'qingbin']

 

3.动态参数
*args&**kw

*args是非关键字参数，位置传参，用于元组。**kw是关键字参数，接受“=“对，用于字典。《Python 核心编程》

*args
 
def tupleArgs(arg1, arg2= 'B', *arg3):
    print('arg 1:%s ' % arg1)
    print('arg 2:%s ' % arg2)
    for eachArgNum in range(len(arg3)):
        print('the %d in arg 3 :%s ' % (eachArgNum,arg3[eachArgNum]))
if __name__ == '__main__':
    tupleArgs('A')      
    #   arg 1:A 
    #   arg 2:B 
    tupleArgs('23','C')
    #   arg 1:23 
    #   arg 2:C
    tupleArgs('12','A','GF','L')
    #   arg 1:12 
    #   arg 2:A 
    #   the 0 in arg 3 :GF 
    #   the 1 in arg 3 :L 
     
  
**kw   
  
def dictArgs(kw1, kw2= 'B', **kw3):
    print('kw 1:%s ' % kw1)
    print('kw 2:%s ' % kw2)
    for eachKw in kw3:
        print('the %s ---->:%s ' % (eachKw,kw3[eachKw]))
if __name__ == '__main__':
    dictArgs('A')
    #   kw 1:A 
    #   kw 2:B 
    dictArgs('23','C')
    #   kw 1:23 
    #   kw 2:C 
    dictArgs('12','A', c = 'C',d = '12121212')
    #   kw 1:12 
    #   kw 2:A 
    #   the d ---->:12121212 
    #   the c ---->:C 
    dictArgs('kw',c = 'C',d = '12121212',kw = 'KW')
    #   kw 1:kw 
    #   kw 2:B 
    #   the kw ---->:KW 
    #   the d ---->:12121212 
    #   the c ---->:C

 　　一起看看

def testArg(kw1, kw2= 'B',*args, **kwargs):
    print('kw 1:%s ' % kw1)
    print('kw 2:%s ' % kw2)
    print(type(args))
    for eachArgNum in range(len(args)):
        print('the %d in arg 3 :%s ' % (eachArgNum, args[eachArgNum]))
    print(type(kwargs))
    for eachKw in kwargs:
        print('the %s ---->:%s ' % (eachKw,kwargs[eachKw]))

testArg(1,2,3,a=4,c=5)
# kw 1:1 
# kw 2:2 
# <class 'tuple'>
# the 0 in arg 3 :3 
# <class 'dict'>
# the a ---->:4 
# the c ---->:5 

 对返回值的思考

1.不写return的情况下，会默认返回一个None。很多函数是对某个对象本身改变并没有返回值，所以没有必要用变量去接。在这里经常会犯错。

2.return None =不写 return=只写return后面不写其他内容。

3.在函数中一旦遇到return，结束整个函数。

4.可以返回任意多个、任意数据类型的值

　　返回的多个值会被组织成元组被返回，也可以用多个值来接收

 

def ret_demo2():
    return 1,['a','b'],3,4

#返回多个值，用一个变量接收
ret2 = ret_demo2()
print(ret2)
# (1, ['a', 'b'], 3, 4)

#返回多个值，用多个变量接收
a,b,c,d = ret_demo2()
print(a,b,c,d)

#用多个值接收返回值：返回几个值，就用几个变量接收
a,b,c,d = ret_demo2()
print(a,b,c,d)

# 1 ['a', 'b'] 3 4
# 1 ['a', 'b'] 3 4

原因：

>>> 1,2  #python中把用逗号分割的多个值就认为是一个元组。
(1, 2)
>>> 1,2,3,4
(1, 2, 3, 4)

#自动拆包
>>> a,b,c,d = (1,2,3,4)


>>> a,_,_,d=(1,2,3,4)
>>> a
>>> d

>>> a,*_=[1,2,3,4]
>>> *_,d={1,2,3,4}
>>> a
>>> d

a,*_=[1,2,3,4]
print(_)
print(*_)
# [2, 3, 4]
# 2 3 4

#也适用于字符串、列表、字典、集合
#当字典的时候是key
>>> a,b = {'name':'wang','age':18} 
>>> a
'name'
>>> b
'age'