Python函数详解

定义与使用

# coding:utf-8

if __name__ == '__main__':
    # 定义与使用
    '''
    函数通过def+函数名(无参|参数.......)定义
    通过函数名(无参|参数......)调用
    '''
    def talk(name):
        print(name)
    talk('func')  # func

参数种类

# coding:utf-8

if __name__ == '__main__':

    '''
    例1:必填参数，不填则报错。声明:def 函数名(参数)
    例2:非必填参数，不填则使用默认值。声明:def 函数名 (参数=默认值)
    例3:可变元组参数，将调用函数时，未被匹配的参数且传参格式不是参数名=参数值的所有参数形成tuple。声明:def 函数名(*参数名)
    例4:可变字典参数, 将调用函数时, 未被匹配的参数且传参格式是参数名=参数值的所有参数名，参数值形成dict。声明:def 函数名(**参数名)
    推荐的函数参数声明顺序是:def 函数名(必填参数......,非必填参数......,可变元组参数，可变字典参数)
    '''

    # 例1
    def talk(name):
        print(name)
    talk('func')  # func
    # talk() Error 必填参数一定要填

    # 例2
    def talk(name='func'):
        print(name)
    talk()  # func
    talk('ok')  # ok

    # 例3
    def talk(*args):
        print(args)
    talk(1, 2, 3)  # (1, 2, 3)

    # 例4
    def look(**kwargs):
        print(kwargs)

    look(name='xie', sex='man')  # {'name': 'xie', 'sex': 'man'}

参数匹配顺序

# coding:utf-8

if __name__ == '__main__':

    '''
    例1:在未出现参数名=参数值的传参形式时，参数从左往右匹配
    例2:在出现参数名=参数值的传参形式后，按照参数名进行匹配，其后参数也需要使用参数名=参数值的传参形式，否则报错
    例3:在可变元组参数前使用过参数名=参数值的传参形式导致可变元组参数无法赋值,报错
    例4:在可变字典参数前使用过参数名=参数值的传参形式并不会影响可变字典参数的赋值
    '''

    # 例1
    def see(a, b=0, c=1):
        print(f'a is {a},b is {b} ,c is {c}')
    see(1, 2, 3)  # a is 1,b is 2 ,c is 3

    # 例2
    see(c=3, b=2, a=1)  # a is 1,b is 2 ,c is 3
    # see(a=1, 2, 3) Error 后面的传参格式也要使用参数名=参数值的形式

    # 例3
    def ps(a, b=0, c=1, *args):
        print(f'a is {a},b is {b} ,c is {c},args is {args}')
    ps(1, 2, 3, 4, 5)  # a is 1,b is 2 ,c is 3,args is (4, 5)
    # ps(1, b=2, c=3, 4, 5)  Error 可变元组参数前使用过参数名=参数值的传参形式导致无法赋值给可变元组参数

    # 例4
    def ks(a, b=0, c=1, **kwargs):
        print(f'a is {a},b is {b} ,c is {c},kwargs is {kwargs}')
    ks(1, 2, 3, name='xie', sex='man')  # a is 1,b is 2 ,c is 3,kwargs is {'name': 'xie', 'sex': 'man'}
    ks(a=1, b=2, c=3, name='xie', sex='man')

元组转为可变元组参数

# coding:utf-8

if __name__ == '__main__':

    '''
    通过*tuple将元组变为可变元组参数
    *tuple能够将自身元素依次当作参数传入函数
    tp(参数......,*(1,2......)) 等价于 tp(参数......,1,2......)
    '''
    def tp(a, *args):
        print(f'a is {a},args is {args}')
    tp(1, 2, 3)  # a is 1,args is (2, 3)
    tp(1, (2, 3))  # a is 1,args is ((2, 3),)
    tp(1, *(2, 3))  # a is 1,args is (2, 3)

    def tp(a, b):
        print(a, b)

    tp(*(1, 2))  # 1 2

字典转为可变字典参数

# coding:utf-8

if __name__ == '__main__':

    '''
    通过*dict将字变为可变字典参数
    **dict能将字典元素的key=>value依次当做参数传入函数
    dp(参数......,**{key1:value1,key2:value2......}) 等价于 dp(参数......,key1=value1,key2=value2......)
    '''
    def dp(a, **kwargs):
        print(f'a is {a},kwargs is {kwargs}')
    dp(1, name='xie', sex='man')  # a is 1,kwargs is {'name': 'xie', 'sex': 'man'}
    dp(1, **{'name': 'xie', 'sex': 'man'})  # a is 1,kwargs is {'name': 'xie', 'sex': 'man'}

    def dp(name, sex):
        print(f'name is {name}, sex is {sex}')
    dp(**{'name': 'xie', 'sex': 'man'})

参数类型约定

# coding:utf-8

if __name__ == '__main__':

    '''
    通过参数:类型(python3.7以后才有) 来告诉别人参数的类型，给人看的，python并不会去验证
    '''
    def lsp(name: bool):
        print(name)

    lsp('ok')  # ok 并不会报错

lamdba函数

# coding:utf-8

if __name__ == '__main__':

    #lambda函数
    '''
    定义 lambda 参数1,参数2...... : 简单的逻辑(无需添加return,添加return则报错)
    调用 将lambda赋值给变量后通过变量(参数1...,参数2......)调用
    '''
    f = lambda x,y=0: x+y
    print(f(1, 2))  # 3
    print(f(2))  # 2
    # f = lambda x,y: return x + y Error 不需要return