八函数

Posted 2020-10-15

在这之前写的代码存在的问题：

1. 　　可读性差
2. 　　代码冗余
3. 　　可扩展性差

函数是什么：

　　在生活中，修车、盖房等等我们都会提前准备好工具，用的时候直接拿，可以一直用

　　函数就是程序中的工具

　　准备工具的过程就是定义函数的过程

使用原则：

　　函数必须先定义，再调用！！！！！就像变量定义一样，变量名指向变量名，函数名指向了内存中的函数名，所有必须定义了才能使用

 

---

 

函数的分类和定义

　　内置函数：　　　比如print()、len()，这些是python事先定义好的，直接用

print(max)    #   <built-in function max>

　　自定义函数（语法）：

def 函数名([参数],[参数1]):
    """注释"""
    函数体
    return 返回值

　　简单的例子：

def print_msg():
    """打印信息"""
    print(‘这是一条信息‘)

print_msg()              # 这是一条信息
print_msg()              # 这是一条信息

　　三种定义函数的形式：

　　　　无参函数:　　不需要调用者传参就能执行，如下该函数只是用来调用其他函数，控制逻辑　

def main():
    foo(123)
    foo1(‘shuai‘)

　　　　有参函数：　　需要调用者提供参数才执行

def foo(x,y):
    return x+y

　　　　空函数：　　函数体是pass，用于先把需要的功能占坑，实现程序结构体系，后续实现功能

def func():
    pass

　　

---

 

函数的调用：

　　函数名加 ()  调用执行

　　定义时无参数，调用也无无需参数

def main():
    foo(123)
    foo1(‘shuai‘)

main()

　　定义时有参，调用就必须传参数

def foo(x,y):
    return x+y
s = foo(5,6)
print(s)                # 11

返回值return：

　　无return：　　返回None

　　return 1个值：　　返回1个值

　　return 逗号分隔多个值：　　返回元组形式

　　一个函数只能return一次

　　return执行了，就代表函数终止

什么时候该有返回值？
　　　　调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值
　　　　通常有参函数需要有返回值，输入参数，经过计算，得到一个最终的结果
什么时候不需要有返回值？
　　　　调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需有返回值
　　　　通常无参函数不需要有返回值

　　

---

 

函数的参数：

　　形参、实参：

　　　　形参就是定义函数时括号内的变量名；

　　　　实参就是调用时传入的参数；

　　参数的使用：

　　　　一、位置参数

def foo(x,y,z):
    print(x,y,z)
foo(3,6,9)                   # 3 6 9 

位置形参：必需传参数
位置实参：按照位置给形参传值，从左到右一一对应

　　　　二、关键字参数

def foo(x,y,z):
    print(x,y,z)
foo(3,z=6,y=9)    #  3 9 6


def foo(x,y,z):
    print(x,y,z)
foo(3,y=6,9)    #  SyntaxError: positional argument follows keyword argument


无需按照位置为形参传值
按照ket=value的形式指定传参
注意：
       1. 关键字实参必须在位置实参右面
        2. 对同一个形参不能重复传值  

　　　　三、默认参数

def foo(z,x=2,y=3):
    print(x,y,z)
foo(x=6,z=8)    #  6 3 8

def foo(x=2,y=3,z):   # SyntaxError: non-default argument follows default argument
    print(x,y,z)
foo(x=6,z=8)  

注意：
        1. 只在定义时赋值一次
        2. 默认参数的定义应该在位置形参右面
        3. 默认参数通常应该定义成不可变类型

　　　　四、不定长参数

def foo(*args, **kwargs):
    print(args, kwargs)
foo(6,9,a=1,b=2)          # (6, 9) {‘a‘: 1, ‘b‘: 2}


实参有按位置和按关键字两种形式定义，针对这两种形式的形参，对应有两种解决方案来完整地存放它们：*args，**kwargs

*和**用来接收参数，然后赋值给后面的是变量名
打包参数：
    *用来接收位置实参，实参会按位置包在一个元组中
    **用来接收关键字实参，实参会被包在一个字典中

解包参数：
    *用来解包列表或者元组，将单个元素传人函数（位置参数）
    list1 = [1,2,3]
    def foo(a,b,c):
        print(a,b,c)
    foo(*list1)       # 1 2 3
    
    **用来解包字典，将键值对传入参数（关键字参数）
     dict1 = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
    def foo(a, b, c):
        print(a, b, c)
    foo(**dict1)           # 1 2 3

　　　　五、命名关键字参数

def foo(a,*b,c=1,d):
    print(a, b, c,d)
foo(1,2,d=6)         # 1 (2,) 1 6

def foo(a,*b,c=1,d):
    print(a, b, c,d)
foo(1,2,6)         # TypeError: foo() missing 1 required keyword-only argument: ‘d‘


*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递

　　

---

 

函数嵌套
　　　嵌套定义：

def f1():
    def f2():
        def f3():
            print(‘f3‘)
        f3()
    f2()
f1()                           # f3

　　　　 嵌套调用：

def max(x,y):
    return x if x > y else y
def max4(a,b,c,d):
    res1=max(a,b)
    res2=max(res1,c)
    res3=max(res2,d)
    return res3
print(max4(1,2,3,4))         # 4