函数初识

Posted 2020-11-09 yangmeng1990

函数
1. 函数的定义
    函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
    函数能提高应用的模块性，和代码的重复利用率。
2. 函数的定义与调用
    def 关键字 函数名():
        函数体
    函数执行：函数名()
    定义：def 关键词开头，空格之后接函数名称和圆括号()，最后还有一个":"。
　　def 是固定的，不能变，他就是定义函数的关键字。                                空格：为了将def关键字和函数名分开，必须空(四声)，当然你可以空2格、3格或者你想空
多少都行，但正常人还是空1格。
　　函数名：函数名只能包含字符串、下划线和数字且不能以数字开头。虽然函数名可以随便起，但我们给函数起名字还是要尽量简短，并能表达函数功能
　　括号：是必须加的，先别问为啥要有括号，总之加上括号就对了！
注释：每一个函数都应该对功能和参数进行相应的说明，应该写在函数下面第一行。以增强代码的可读性。
     调用：就是 函数名() 要记得加上括号。

3. 函数的返回值
    return
    （1）终止函数。
    （2）给函数的执行者返回值。
            return  或者 return None
            return 单个值
                def my_test():
                    return 1
                a = my_test()
                print(a)
                >>>1
            return 多个值 会将多个值放到一个元组中，将元组返回个函数的执行者;可以返回任意多个、任意数据类型的值;返回的多个值会被组织成元组被返回，也可以用多个值来接收
                def my_test():
                    return 1, 2, 3, 4
                a,b,c,d = my_test()
                print(a,b,c,d)
                >>>1 2 3 4

四、函数的参数
    
    1. 参数定义：以简单函数举例
        def mylen(s1):
        """计算s1的长度"""
        length = 0
        for i in s1:
            length = length+1
        return length
        str_len = mylen("hello world")        我们告诉mylen函数要计算的字符串是谁，这个过程就叫做传递参数，简称传参；
        我们调用函数时传递的这个“hello world”和定义函数时的s1就是参数。
        参数可以传递多个，多个参数之间用逗号分割。
    
    2. 实参和形参          我们调用函数时传递的这个“helloworld”被称为实际参数，因为这个是实际的要交给    函数的内容，简称实参。
    定义函数时的s1，只是一个变量的名字，被称为形式参数，因为在定义函数的时候它
    只是一个形式，表示这里有一个参数，简称形参。
    
    3. 参数的区分—实参角度
        3.1 位置参数
            按照位置传值，必须按照位置顺序一一对应。
            举例：
                def func1(a,b,c):
                    print(a,b,c)
                func1(1,2,‘alex‘)
                >>>1 2 alex
            当位置参数数量不一致时，报错：TypeError: func1() takes x positional arguments but x were given

        3.2 关键字参数
            按照关键字传递参数，一一对应。
            举例：
                def func1(a,b,c):
                    print(a,b,c)
                func1(a=1, b=2, c=‘alex‘)
                >>>1 2 alex    
                
        3.3 混合参数
            位置参数与关键字参数混合使用，关键字参数必须在位置参数的后面,一个形参只能
            赋值一次。
            举例：
                def func1(a,b,c):
                    print(a,b,c)
                func1(1, 2, c=‘alex‘)
                >>>1 2 alex
            当关键字参数在位置参数之前时，报错如下：
                func1(1,b=‘alex‘,3)
                >>>SyntaxError: positional argument follows keyword argument    
            当关键字与位置参数不对应时，报错如下：
                func1(1, 2,b=3)
                >>>TypeError: func1() got multiple values for argument ‘b‘
    
    4. 参数的区分—形参角度
        
        4.1 位置参数
            与实参的位置参数一致，按顺序保持一一对应即可。
        
        4.2 默认参数
            形参可以采用某一默认值，当实参中不传入参数时，执行默认值；传入时，
            执行传输参数。默认参数必须在位置参数的后面。
            例一：实参不传入参数
            def func1(name,age,sex=‘男‘):
                print(‘{}:{}:{}‘.format(name,age,sex))
            func1(‘alex‘,‘22‘)
            >>>alex:22:男
            例二：实参传入参数
            def func1(name,age,sex=‘男‘):
                print(‘{}:{}:{}‘.format(name,age,sex))
            func1(‘alex‘,‘22‘,‘女‘)
            >>>alex:22:女
            
            如果默认参数是一个可变的数据类型，那么他在内容中永远是一个。
            举例：
            def extendList(val,list=[]):
                list.append(val)
                return list
            list1 = extendList(10)
            list2 = extendList(123,[])
            list3 = extendList(‘a‘)
            print(list1,list2,list3)
            >>>[10, ‘a‘] [123] [10, ‘a‘]
        
        4.3 动态参数（万能参数）
            1. 定义：
            动态参数，也叫不定长传参，就是你需要传给函数的参数很多，不
            定个数，那这种情况下，你就用*args，**kwargs接收，args是元祖形式，
            接收除去键值对以外的所有参数，kwargs接收的只是键值对的参数，并保
            存在字典中。    
            动态参数。 *args, **kwargs 万能参数。
            args:所有的位置参数，放在一个元组中。
            kwargs:所有的关键字参数，放在一个字典中。
            例一：当实参全部为位置参数时，使用args接收，结果以元组形式返回。
            def func1(*args):
                print(args)
            func1(1,2,3)
            >>>(1, 2, 3)
            例二：当实参全部为关键字参数时，使用kwargs接收，结果以字典形式返回。
            def func1(**kwargs):
                print(kwargs)
            func1(a=1,b=2,c=3)
            >>>{‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
            例三：当实参为混合参数时，使用args和kwargs共同接收
            def func1(*args,**kwargs):
                print(args)
                print(kwargs)
            func1(1,2,3,a=4,b=5,c=6)
            >>> (1, 2, 3)
                {‘a‘: 4, ‘b‘: 5, ‘c‘: 6}
            2. *在定义和执行时的不同含义
            *在定义时，代表聚合，也就是把所有的位置参数聚合成一个元组，把所有的
            关键字参数聚合成一个元组
            *在执行时，代表离散，也就是把列表，元组，集合按照元素打散成位置参数，
            把字典按照元素打散成关键字参数
            例一：定义时的聚合
            def func1(*args,**kwargs):
                print(args)
                print(kwargs)
            func1(1,2,3,a=4,b=5,c=6)
            >>> (1, 2, 3)
                {‘a‘: 4, ‘b‘: 5, ‘c‘: 6}
            例二：执行时的离散(前后对比）
            def func1(*args,**kwargs):
                print(args)
                print(kwargs)
            func1([1,2,3],{‘a‘:4,‘b‘:5,‘c‘:6})
            >>>([1, 2, 3], {‘a‘: 4, ‘b‘: 5, ‘c‘: 6})
                {}
            func1(*[1,2,3],**{‘a‘:4,‘b‘:5,‘c‘:6})
            >>>(1, 2, 3)
                {‘a‘: 4, ‘b‘: 5, ‘c‘: 6}
            3. 形参的顺序
            位置参数 *args 默认参数 **kwargs
            def func5(a,b,*args,sex=‘男‘,**kwargs):
                print(a,b,)
                print(args)
                print(sex)
                print(kwargs)