Python——函数

Posted 2021-01-06 xc_718

1. 函数 　　

（1）特点

　　可读性强、复用性强

（2）定义

　　def funcname():　　

　　　　funcbody　　

　　　　return　　

（3）调用

　　funcname()

（4）注释

def func():
    ‘‘‘
    这个函数实现了什么功能
    参数1：解释
    参数2：解释
    ...
    :return: 返回值类型
    ‘‘‘
    #funcbody函数体

（5）注意事项

　　只定义不调用就一定不执行

　　先定义后调用

2. 返回值

　　返回的重要性---不能使用函数调用结束的结果进行其他操作

　　函数名()——不接收返回值

　　返回值 = 函数名()——接收返回值

（1）没有返回值：

　　默认返回None

　　<1>不写return：函数内的代码执行完毕，自动结束

def func():
    l = [‘xc‘,‘gx‘]
    for i in l:
        print(i)    #xc     gx
        if i==‘gx‘:
            pass
    print(‘lalala‘)    #lalala
rt = func()
print(rt)   #None

　　<2>只写return：结束一个函数

def func():
    l = [‘xc‘,‘gx‘]
    for i in l:
        print(i)        #xc     gx
        if i==‘gx‘:
            return
    print(‘lalala‘)　　#return之后函数结束，不再继续执行这句话
rt = func() print(rt) #None

　　<3>return None——不常用

def func():
    l = [‘xc‘,‘gx‘]
    for i in l:
        print(i)       #xc     gx
        if i==‘gx‘:
            return None
    print(‘lalala‘) #return之后函数结束，不再继续执行这句话
rt = func()
print(rt)   #None

（2）返回一个值

　　结束了函数且返回一个值，可以是任意的值

　　　　<1>可以返回任何数据类型

　　　　<2>只要返回就可以接收到

　　　　<3>如果在一个程序中有多个return，只执行第一个

def func():
    return
print(func())   #None

def func1():
    return [1,2,3,4]
print(func1())  #[1, 2, 3, 4]

def func2():
    return {‘k‘,‘v‘}
    return 1    #在前一个return已经结束函数了，此条语句不执行
print(func2())  #{‘v‘, ‘k‘}

（3）返回多个值

　　多个值之间用逗号隔开，可以用一个(返回元祖)或者等量的多个变量接收

def func():
    return 1,2
rt1,rt2 = func()
print(rt1,rt2)  #1 2
r = func()
print(r)    #(1, 2)

3. 参数

　　没有参数——定义和调用函数的时候，括号里不写内容
　　有一个参数——传什么就是什么
　　有多个参数——位置参数

（1）形参和实参

def my_len(s):   #接收参数——形式参数，形参
    i = 0
    for k in s:
        i += 1
    return i
s = ‘金老板小护士‘
rt = my_len(s)  #传递参数(传参)——实际参数，实参
rt1 = my_len(‘班主任星儿最好看‘)
print(rt)   #6
print(rt1)  #8

（2）形参——定义函数的时候

　　<1>位置参数：必须传，且有几个参数传几个值

　　<2>默认参数：可以不传，不传就使用默认的，传什么用什么

　　　　默认参数的陷阱：

　　　　　　默认参数的值是可变数据类型,那么每一次调用函数的时候,如果不传值就公用这个数据类型的资源

#(1)
def qqxing(l = []):     
    l.append(1)
    print(l)
qqxing()    #[1]
qqxing([])  #[1]
qqxing()    #[1, 1]
qqxing()    #[1, 1, 1]
qqxing([])  #[1]
#(2)
def qqxing(l = {}):
    l[‘k‘] = ‘v‘
    print(l)
qqxing()    #{‘k‘: ‘v‘}
qqxing({})  #{‘k‘: ‘v‘}
qqxing()    #{‘k‘: ‘v‘}
qqxing({})  #{‘k‘: ‘v‘}

#(3)
def qqxing(k,l = {}):
    l[k] = ‘v‘
    print(l)
qqxing(1)    #{1: ‘v‘}
qqxing(5,l = {‘k3‘:‘v3‘})   #{‘k3‘: ‘v3‘, 5: ‘v‘}
qqxing(2)     #{1: ‘v‘, 2: ‘v‘}
qqxing(22)    #{1: ‘v‘, 2: ‘v‘, 22: ‘v‘}
qqxing(6,l = {‘k3‘:‘v3‘})   #{‘k3‘: ‘v3‘, 6: ‘v‘}
qqxing(3)    #{1: ‘v‘, 2: ‘v‘, 3: ‘v‘}
qqxing(33)   #{1: ‘v‘, 2: ‘v‘, 22: ‘v‘, 3: ‘v‘, 33: ‘v‘}
qqxing(333)  #{1: ‘v‘, 2: ‘v‘, 22: ‘v‘, 3: ‘v‘, 33: ‘v‘, 333: ‘v‘}
qqxing(7,l = {‘k3‘:‘v3‘})   #{‘k3‘: ‘v3‘, 7: ‘v‘}
qqxing(3,l = {‘k3‘:‘v3‘})   #{‘k3‘: ‘v3‘, 3: ‘v‘}
qqxing(8,l = {‘k3‘:‘v3‘})   #{‘k3‘: ‘v3‘, 8: ‘v‘}

　　<3>动态参数：可以接收任意个参数

　　　　　　　　  *args：接收的是按照位置传参的值，组织成一个元祖

　　　　　　　　   **kwargs：接收的是按照关键字传参的值，组织成一个字典

　　　　　　　　   args必须在kwargs之前

# 动态传参（*args）
def func00(*args):    #站在形参的角度，给变量加上*，就是组合所有的值
    print(args)
func00(1,2,3,4,5) #(1, 2, 3, 4, 5)
l = [1,2,3,4,5]
func00(*l)    #(1, 2, 3, 4, 5) 站在实参的角度，给一个序列加上*，就是将这个序列按照顺序打散

def func1(**kwargs):    #可以接收任意多个按关键字传的参数
    print(kwargs)
func1(a=1,b=2,c=3)  #{‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
func1(a=1,b=2)      #{‘a‘: 1, ‘b‘: 2}
func1(a=1)          #{‘a‘: 1}

def func11(**kwargs):
    print(kwargs)
func11(a=1,b=2) #{‘a‘: 1, ‘b‘: 2}
d = {‘a‘:1,‘b‘:2}
func11(**d)     #{‘a‘: 1, ‘b‘: 2}

def func2(*args,**kwargs):
    print(args,kwargs)
func2(1,2,3,a = ‘addc‘, b = ‘csdsv‘)    #(1, 2, 3) {‘a‘: ‘addc‘, ‘b‘: ‘csdsv‘}

　　<4>混合使用

# 位置参数+默认参数
def classmate(name,sex=‘男‘):
    print(‘%s:%s‘%(name,sex))
classmate(‘二哥‘)     #二哥:男——位置参数+默认参数（未传值）
classmate(‘小梦‘,‘女‘)     #小梦:女——位置参数+默认参数（传值）
classmate(‘大猛‘)     #大猛:男——位置参数+默认参数（未传值）

# 动态参数（*args）+关键字参数
def func0(*args,l=[]):
    print(args,l)
func0()  #() []
func0(1,2,‘str‘,[‘lst‘,1])   #(1, 2, ‘str‘, [‘lst‘, 1]) []
func0(1,2,‘str‘,l = [‘lst‘,1])   #(1, 2, ‘str‘) [‘lst‘, 1]

　特点：　

　　<1>位置参数：必须传

　　<2>*args：动态参数，可以接收任意多个按位置传的参数

　　<3>默认参数：可以不传——陷阱

　　<4>**kwargs：动态参数，可以接收任意多个按关键字传的参数

　　定义函数的时候

　　　　位置参数：直接定义参数

　　　　默认参数：关键字参数，参数名 = ‘默认的值’

　　　　动态参数：可以接收任意多个参数

　　　　　　定义方式：*变量名（习惯用*args）

　　　　　　　　　　   **变量名（习惯用**kwargs）

　　　　顺序：位置参数，*args，默认参数，**kwargs

（3）实参——调用函数的时候

　　<1>按照位置传参数

　　<2>按照关键字传参数　　　　　

def my_sum(a,b):
    print(a,b)  #1  2
    res = a+b
    return res
rt = my_sum(1,2)    #按照位置传参
rt1 = my_sum(b = 2,a = 1)   #按照关键字传参
rt2 = my_sum(1,b = 2)   #混合使用（位置传参在前，关键字传参在后）
print(rt)   #3
print(rt1)   #3
print(rt2)   #3

　　特点：

　　　　可以混用 位置必须在关键字之前
　　　　不能对一个参数重复赋值

　　调用函数的时候：

　　　　按照位置传：直接写参数的值 

　　　　按照关键字传：关键字 = 值