函数单数的使用

Posted 2021-01-08 outofcontrol

# _*_ coding: utf-8 _*_

# 一、函数的参数分为两大类：
#     形式参数（形参）：在定义函数阶段，括号内定义的参数为形参
#     实际参数（实参）：在调用函数阶段，括号内传入的值成为实参
# tips：
#     在调用函数阶段会将实参的值绑定给形参，这种绑定关系只在调用函数时生效，
#     在函数执行完毕后就会解除绑定
#
    # e.g.
    # def function(x, y):
    #     print(x, y)
    #
    # function(1,2)
    #     ##1 2
    # print(‘%s %s‘ %(x,y))
    # # NameError: name ‘x‘ is not defined

二、细分：
    1. 位置参数
        1.1 位置形参
        在定义阶段，按照从左到右的顺序依次定义的形参称之为位置形参
        特点：
            按照位置定义的形参，必须被传值，多一个不行少一个也不行
        e.g.
            def function0(x,y,z):
                print(x,y,z)
            function0(1,2)
            # TypeError: function0() missing 1 required positional argument: ‘z‘
            function0(1,2,3)
            # 1 2 3
            function0(1,2,3,4)
            # TypeError: function0() takes 3 positional arguments but 4 were given
        1.2 位置实参
        在调用阶段，按照从左到右的顺序依次传入的值称之为位置实参
        特点：
            与形参一一对应
        e.g.
            def function1(x,y,z):
                print(x,y,z)
            function1(2,1,3)
            # 2 1 3
    2. 关键字实参
    在调用阶段，按照key ： value的形式定义的实参称之为关键字实参
    特点：
        可以完全打乱顺序，但仍旧依然能为指定的形参传值
        指名道姓的为指定的形参传值
    e.g.
        def function2(x,y,z):
            print(x,y,z)
        function2(y=1,z=2,x=3)
        # 3 1 2

    实参的形式可以是位置实参与关键字实参混合使用，但必须遵循原则
        # 位置实参必须放在关键字实参的前面
        # 不能对同一个形参重复传值
    e.g.
        function2(1,z = 3, y = 2)
        # 1 2 3
        function2(z = 3,1,y=2)
        # SyntaxError: positional argument follows keyword argument
        function2(1,z = 2, y=3,x=4)
        # TypeError: function2() got multiple values for argument ‘x‘

    3. 默认形参
    在定义阶段，就已经为形参赋值，该形参称之为默认参数
    特点：
        # 定义阶段就已经有值意味着调用阶段可以不用传值
        # 位置形参必须放到默认形参的前面
        # 默认形参的值在函数定义阶段就已经固定死了，定义阶段之后的改动不会影响该值
        # 默认形参的值通常应该是不可变类型
    e.g.
        def function3(x,y,z=100):
            print(x,y,z)

        function3(10,20)
        # 10 20 100
        function3(10,20,300)
        # 10 20 300

    e.g.
        def register(name,age,sex=‘male‘):
            print(name,age,sex)
        register(‘oOC‘,22,)
        register(‘egon‘,32,)
        register(‘nick‘,42,)
        register(‘cherry‘,52,‘female‘)
        # oOC 22 male
        # egon 32 male
        # nick 42 male
        # cherry 52 female

    e.g.
        def function4(x,z=100,y): #(x,y,z=100) right
            print(x,y,z)
        function4(1,2,3)
        # SyntaxError: non-default argument follows default argument

     e.g.
        m = 10
        def function4(x, z, y = m):
            print(x, z, y)
        function4(1,2)
        # 1 2 10

    e.g.
        m = 10
        def function5(x, z, y=m):
            y = 20
            print(x, z, y)
        m = 100
        function5(1, 2)
        # 1 2 20

    e.g.
        def add_hobby(name,x,hobbies = None):
            if hobbies is None:
                hobbies=[]
            hobbies.append(x)
            print(‘%s 的爱好有 %s‘ %(name,hobbies))

        add_hobby(‘ooc‘,‘read‘,)
        add_hobby(‘wxx‘,‘eat‘,)
        add_hobby(‘fff‘,‘drink‘)

        # ooc 的爱好有 [‘read‘]
        # wxx 的爱好有 [‘eat‘]
        # fff 的爱好有 [‘drink‘]


    e.g.
        def add_hobby(name, x, hobbies=[]):
            # if hobbies is None:
            #     hobbies = []
            hobbies.append(x)
            print(‘%s 的爱好有 %s‘ % (name, hobbies))


        add_hobby(‘ooc‘, ‘read‘, )
        add_hobby(‘wxx‘, ‘eat‘, )
        add_hobby(‘fff‘, ‘drink‘)

        # ooc 的爱好有 [‘read‘]
        # wxx 的爱好有 [‘read‘, ‘eat‘]
        # fff 的爱好有 [‘read‘, ‘eat‘, ‘drink‘]

    4. 可变长参数
    指的是在调用阶段，实参值个数是不固定的，
    实参值为非两种形式（位置，关键字实参）对应形参也必须有两种解决方案来
    分别接收溢出位置实参或者关键字实参

    * --> 溢出的位置实参
    ** --> 溢出的关键字实参

    e.g.
        def sum2(*x):
        res = 0
        for i in x:
            res += i
        return res
        print(sum2(1,2,3,4,5))

        4.1 *的用法
        在形参前加*：*会将溢出的位置实参存成元组的形式，然后赋值给*后的形参名
    e.g.
        def function(x,y,*z):
            print(x,y,z)
        function(1,2,3,4,5)
        # 1,2,(3,4,5)

        在实参前加*：但凡碰到实参中带*的，先将实参打散成位置实参再与形参做对应
    e.g.
        def func(x, y, z):
            print(x, y, z)
        func(1, 2, [3, 4, 5])
        func(*[1, 2, 3, 4, 5])  # 先打散，再于形参做一一对应func(1,2,3,4,5)
        func(*[1, 2, 3])  # func(1,2,3)

    e.g.
        def func(x,y,*z):
            print(x,y,z)

        func(1111,2222,*[1,2,3,4,5]) #func(1111,2222,1,2,3,4,5)
        #1111 2222 (1, 2, 3, 4, 5)

        4.2 **的用法
        在形参前加**：**会将溢出的关键字实参存成字典的形式，然后赋值给**后的形参名
    e.g.
        def func(x,y,**z): #z={‘c‘:3,‘b‘:2,‘a‘:1}
            print(x,y,z)
        func(1,y=2,a=1,b=2,c=3)
        # 1 2 {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}

        在实参前加**：但凡碰到实参中带**的，先将实参打散成关键字实参再与形参做对应
    e.g.
        def func(x,y,z):
            print(x,y,z)

        func(1,**{‘y‘:2,‘z‘:3}) #func(1,z=3,y=2)
        # 1 2 3
        func(1,**{‘a‘:2,‘y‘:333,‘z‘:3})
        #func(1,a=2,y=333,z=3) # 错误
    e.g.
        def func(x,y,**z):
            print(x,y,z)

        func(**{‘y‘:1,‘x‘:2,‘a‘:1111,‘b‘:2222})
        #func(y=1,x=2,a=1111,b=2222)

    默认参数
    形参中：*args，**kwargs
    def func(x,*args):
        print(x)
        print(args)
    func(1, 2, 3, 4, 5)
    # 1
    # (2, 3, 4, 5)

    def func(x,**kwargs):
        print(x)
        print(kwargs)
    func(1, a=2, c=3,d=4,r=5)
        # 1
        # {‘a‘: 2, ‘c‘: 3, ‘d‘: 4, ‘r‘: 5}

    *与**的应用：
    def index(name,age,sex):
        print(‘index=====>‘,name,age,sex)

    # 会将wrapper函数接收的参数格式原封不动地转嫁给其内部的index函数，必须要遵循的是index的参数规则
    def wrapper(*args,**kwargs): #args=(‘egon‘,) kwargs={‘sex‘:‘male‘,‘age‘:18}
        # print(args)
        # print(kwargs)
        index(*args,**kwargs) #index(*(‘egon‘,),**{‘sex‘:‘male‘,‘age‘:18}) #index(‘egon‘,sex=‘male‘,age=18)

    # wrapper(1,2,3,4,5,a=1,b=2,c=3)
    wrapper(‘egon‘,sex=‘male‘,age=18)