Python--函数

Posted 2021-01-23 mr-chenshuai

函数解决的问题：

• 代码可读性差
• 代码冗余
• 代码可扩展性差

---

 

什么是函数：

• 在生活中，修车、盖房等等我们都会提前准备好工具，用的时候直接拿，可以一直用
• 函数就是程序中的工具
• 定义函数就是准备工具的过程

---

 

使用原则：

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

---

 

函数分类：

　　函数分为内置函数（如：len()、print()等等，都是Python事先定义好的，直接用即可）和自定义函数（就是自己写的）

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

　　

---

 

定义函数：

　　语法

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

　　例：一个打印信息的函数

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

　　

---

 

三种函数形式：

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

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

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

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

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

def func():
    pass

　　

---

 

函数的调用

　　函数名加 ()  调用执行

# 调用无参函数，无需传值

def foo():
    foo(123)
    foo1(‘bone‘)
 
foo()


---------------------------------------------------------------

# 调用有参函数，必须提供参数

def foo():
    foo(123)
    foo1(‘bone‘)
 
foo()

　　

---

 

返回值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