functions-函数-蒲公英云

python  functions
    函数分类：
        内建函数   max() reversed()
        库函数     math.ceil()
    定义：
        def 函数名 (参数列表):
            函数体(代码块)
            [return 返回值]
        1) 函数名就是标识符，命名要求一样
        2) 语句块必须缩进，约定4个空格
        3) 若没有return语句，隐式会返回一个None
        4) 定义中的参数列表，形参
    调用:
        调用时写的参数是实际参数，实实在在传入的值，实参
    callable() 是否可调用 True/False
    函数参数：
        位置参数：
            def f(x,y,z) 调用使用f(1,3,5)
            按照顺序传入实参
        关键字参数：
            def f(x,y,z) 调用使用f(x=1,y=3,z=5)
            使用形参的名字，传入实参的方式，顺序可以改变
        f(y=5,z=6,2) #位置参数必须在关键字参数之前传入。
    参数默认值：
        def add(x = 4, y = 5):
            return x+y
    调用：
-----------------------------------------------------------------
add(6,10): 6+10 = 16
add(6, y=7): 6+7 = 13
add(x=5): 5+5 = 10
add() :  4+5 = 9
add(y = 7): 4+7 = 11
add(x = 5, 6) #Error (positional argument follows keyword argument:位置参数遵循关键字参数)  位置参数必须在关键字参数之前传入 
add(y = 8, 4) #Error (positional argument follows keyword argument:位置参数遵循关键字参数)  位置参数必须在关键字参数之前传入
add(x = 5, y = 6) 5+6 = 11
add(y = 6, x = 5) 5+5 = 10
-----------------------------------------------------------------
    作用：
        参数的默认值在未传入足够的实参时，对没有给定的参数赋值默认值
        参数多，不需要用户每次都输入所有的参数，简化调用
    例：
        定义一个函数login，参数名为：host 、 port 、 username 、 password
            def login(host = '127.0.0.1', port='80', username='test', password='test'):
                print('{}:{}@{}/{}'.format(host, port, username, password))
        1)login()
            127.0.0.1:80@test/test  默认 主机名：端口@用户名/密码
        2)login('127.0.0.1',80,'tom','tom')
            127.0.0.1:80@tom/tom  位置参数传入
        3)login('127.0.0.1',username='root')
            127.0.0.1:80@root/test 指定一个位置参数和关键字参数
        4)login(port=80, password='test',host='www')
            www:80@test/test        使用关键字参数传入，没有传入的使用默认值
    可变参数：
    1)位置可变
        def add(*nums):
            sum = 0
            for x in nums:
                sum+=x
            return sum
        传入一个可迭代对象
        add([1,3,5])   12
        add((1,3,5))   12
        一个形参可以匹配任意个实参
        在形参前使用* 表示该形参是可变参数，可以接收多个实参
        生成一个tuple
    2)关键字可变
        def showconfig(**kwargs):
            for k,v in kwargs.items():
                print('{}={}'.format(k,v))
        showconfig(host='localhost', port='80', username='test', password='test')
        ----------------------------
            password=test
            host=localhost
            username=test
            port=80
        ----------------------------
        形参前使用**，表示可接收多个关键字参数
        生成一个dict
    3)可变参数的混合使用：
        1.    def showconfig(username,password,**kwargs)
                for k ,v in kwargs.items():
                    print('{}={}'.format(k,v))
            >>>showconfig('test','test')
            >>>test
            >>>test
            >>>showconfig('test','test',x=1,y=2)
            >>>test
            >>>test
            >>>x=1
            >>>y=2
        2. def showconfig(username,*args,**kwargs):
                print(username)
                 print(args)
                for k, v in kwargs.items():
                       print('{}={}'.format(k,v))
            >>>showconfig('test','test','zzz',x=2)
            >>>test
            >>>('test','zzz')
            >>>x=2
-----------------------------------------------------------------------------------
上例中，*args和*kwargs是可变参数，*args表示多个无名参数(位置参数)，它是一个tuple；
**kwargs表示关键字参数，它是一个dict。同时使用*args和**kwargs时，必须将*args写在
**kwargs前面，否则会出错
def showconfig (username,**kwargs,*args)
这是错误的。这样调用 提示语法错误：
SyntaxError: non-keyword arg after keyword arg
-----------------------------------------------------------------------------------
    可变参数分为：位置可变参数和关键字可变参数
    位置可变参数要在形参前加*
    关键字可变参数要在形参前加**
    位置可变参数生成的是tuple，关键字可变参数生成的是dict
    位置可变参数要放在关键字可变参数前
    keyword-only 参数
        如果在一个星号参数后，或者一个位置可变参数后，出现的普通参数变成了keyword-only参数
        keyword-only 后常跟默认值
        def fn(*args,x):
            print(x)
            print(args)
        fn(3,5)  args已经截断了所有的位置参数，如果x不使用关键字参数就拿不到实参 所以这里error
        >>>can't assign to function call  不能分配函数调用
        fn(3,6,x=1) 
        >>>1
        >>>3,6
        def fn(**kwargs,x)  kwargs截断所有的关键字参数，x永远也获取不到值
    keyword-only 第二种形式：
        def fn(*,x,y):
            print(x,y)
        fn(x=1,y=2)
        >>>1 2
    *后面，形参都变成了keyword-only参数 必须指定关键字传参
    可变参数和参数默认值：
    1.
        def fn(*args,x=5):
            print(x)
            print(args)
        fn()
        >>> 5
        >>> ()
        fn(6)
        >>>5
        >>>(6,)
        fn(x=9)
        >>>9
        >>>()
        fn(1,2,5,x=10)
        >>>10
        >>>(1,2,3)
        不指定关键字参数，x使用默认值 位置参数就赋值args
    2.
        def fn(y,*args,x=5):
            print('x={},y={}'.format(x,y))
            print(args)
        fn()
        >>>missing 1 required positional argument: 'y'  缺少y参数传值
        fn(6)
        >>> x=5,y=6
        >>>()
        fn(x=6)
        >>>missing 1 required positional argument: 'y'  缺少y参数传值
        fn(1,2,3,x=10)
        >>>x=10,y=1
        >>>(2,3)
        fn(y=10,2,3,x=10)
        >>>positional argument follows keyword argument 位置参数要放在关键字参数前面
        fn(1,2,y=3,x=10)
        >>>fn() got multiple values for argument 'y'  y被赋值2次
    3.
        def fn(x=5,*kwargs):
            print('x={}'.format(x))
            print(kwargs)
        fn()
        >>>x=5
        >>>{}
        fn(6)
        >>>x = 6
        >>>{}
        fn(x=9)
        >>>x=9
        >>>{}
        fn(y=3,x=10)
        >>>x=10
        >>>{'y':3}
        fn(3,y=10)
        >>>x=3
        >>>{'y':10}
    函数参数一般顺序：
        普通参数 -> 缺省参数 -> 可变位置参数 -> keyword-only参数(可带缺省值) -> 可变关键字参数
        def fn(x, y, z=3, *args, m=4, n, **kwargs)
        x，y 普通参数
        z=3  缺省参数
        *args 可变位置参数
        m，n  keyword-only参数
        **kwargs 可变关键字参数