函数的变量作用域、返回值、参数

函数的变量作用域以及访问、修改全局变量

 1 '''
 2 函数往往涉及2类变量：
 3     1. 全部变量，直接访问，修改需要使用global关键字
 4     2. 局部变量，函数内部定义的变量
 5 '''
 6 
 7 # 1. 全局变量
 8 name = 'Allen'
 9 
10 
11 # 1.1 定义函数
12 def print_name():
13     print(name)  # 全局变量，直接访问，输出：Allen
14 
15 
16 # 1.2. 调用函数
17 print_name()
18 
19 
20 # 修改全局变量
21 def modify_name():
22     global name  # 修改全局变量
23     name = 'Allen_Hao'
24     print(name)
25 
26 
27 # 调用函数修改全局变量，验证是否修改
28 modify_name()
29 print(name)  # Allen_Hao，验证是否修改了
30 
31 
32 def custom_var():
33     desc = '函数内部定义的变量，属于局部变量'  # 局部变量作用域：在函数内，出了函数，无法直接使用
34     print(desc)
35 
36 # print(desc)  # 超出局部变量的作用域，Unresolved reference 'desc'

函数的返回值

如果函数没有return指定返回值，默认是None，return 后面可以跟任意类型的数据

 1 '''
 2 函数的返回值
 3 '''
 4 
 5 
 6 # 1. 如果⼀个函数有两个return ，如此例，只有第1个生效，因为return会结束函数的执行的
 7 def get_num():
 8     return 1
 9     return 2
10 
11 
12 print(get_num())  # 1
13 
14 # 2. 返回一个元组对象
15 def get_num2():
16     return 1, 2  # 返回一个元组
17 
18 
19 print(get_num2())  # (1, 2)
20 
21 # 3. 使用Union类型指定多种返回类型： 使用typing.Union来指定函数可能返回的多种类型。Union[type1, type2, ...]表示函数可以返回type1、type2等类型中的一个
22 from typing import Union
23 
24 
25 def divide(x: float, y: float) -> Union[float, str]:  # 返回值类型为浮点、字符串类型
26     """除法函数"""
27     if y == 0:
28         return "除数不能为0"  # 返回字符串类型表示错误情况，返回字符串
29 
30     return x / y  # 返回浮点型
31 
32 
33 result = divide(10, 2)  # 调用函数，返回结果: 5.0
34 error_message = divide(10, 0)  # 调用函数，返回结果: "除数不能为0"
35 print(result)
36 print(error_message)
37 
38 # 4， 使用Optional类型： 返回2种类型，一种是None
39 # 使用typing.Optional来指定函数返回的类型可以是某个特定类型或None。Optional[type]相当于Union[type, None]
40 from typing import Optional
41 
42 def find_index(lst: list, item) -> Optional[int]:  # 指定返回类型是int或None
43     """查找元素在列表中的索引"""
44     if item in lst:
45         return lst.index(item)
46 
47     return None  # 在lst找到就返回None
48 
49 my_list = [1, 2, 3, 4, 5]
50 index = find_index(my_list, 3)  # 调用函数，返回结果: 2
51 not_found = find_index(my_list, 6)  # 调用函数，返回结果: None
52 # 5. 使用类继承和多态性： 如果函数可能返回多种类型的对象，并且这些对象之间存在共同的基类或接口，可以使用类继承和多态性来实现不同类型的对象作为函数返回值。
53 class Shape:
54     def area(self):
55         pass
56 
57 class Circle(Shape):
58     def __init__(self, radius):
59         self.radius = radius
60 
61     def area(self):
62         return 3.14 * self.radius * self.radius
63 
64 class Rectangle(Shape):
65     def __init__(self, width, height):
66         self.width = width
67         self.height = height
68 
69     def area(self):
70         return self.width * self.height
71 
72 def get_shape_area(shape_type):
73     """根据形状类型返回面积"""
74     if shape_type == "circle":
75         return Circle(5)
76     elif shape_type == "rectangle":
77         return Rectangle(4, 6)
78 
79 circle_area = get_shape_area("circle").area()  # 调用函数，返回结果: 78.5
80 print(circle_area)
81 rectangle_area = get_shape_area("rectangle").area()  # 调用函数，返回结果: 24
82 print(rectangle_area)

函数的参数即形参

 1 '''
 2 函数的参数即形参
 3 1. 位置参数：调⽤函数时根据函数定义的参数位置来传递参数
 4 2. 关键字参数：调用函数时，指定形参的名字即形参名=实参
 5 3. 缺省参数（默认参数）
 6 4. 可变参数（不定长参数）
 7 '''
 8 
 9 
10 # 1. 位置参数（顺序）：调⽤函数时根据函数定义的参数位置来传递参数
11 # 注意：传递和定义参数的顺序及个数必须⼀致。
12 def get_user_info(name, age, gender):
13     return f"name={name},age={age},gender={gender}"
14 
15 
16 # 'Allen'对应name，30对应age，'男'对应gender
17 print(get_user_info('Allen', 30, '男'))  # name=Allen,age=30,gender=男
18 
19 # 2. 关键字参数
20 # 注意：函数调⽤时，如果有位置参数时，位置参数必须在关键字参数的前⾯，但关键字参数之间可以不存在先后顺序
21 # print(get_user_info(age=18, gender='女', '露丝'))  # SyntaxError: positional argument follows keyword argument
22 print(get_user_info('露丝', age=18, gender='女'))  # 按位置参数的顺序，可以用关键字参数，也可以不用
23 print(get_user_info(age=18, gender='女', name='露丝'))  # 全部使用关键字参数，就可以不考虑顺序了
24 
25 
26 # 3. 缺省参数
27 # 缺省参数也叫默认参数，⽤于定义函数，为参数提供默认值，调⽤函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调⽤）
28 def get_user_info2(name, age, gender='男'):  # 默认参数必须放在最后面
29     return f"name={name},age={age},gender={gender}"
30 
31 
32 # 函数调⽤时，如果为缺省参数传值则修改默认参数值；否则使⽤这个默认值。
33 print(get_user_info2('tt', 18))  # name=tt,age=18,gender=男
34 print(get_user_info2('xx', 30, '女'))  # name=xx,age=30,gender=女
35 
36 
37 # 4. 不定长参数，也叫可变参数
38 # 不定⻓参数也叫可变参数。⽤于不确定调⽤的时候会传递多少个参数(不传参也可以)的场景。
39 # 此时，可⽤包裹(packing)位置参数，或者包裹关键字参数，来进⾏参数传递，会显得⾮常⽅便
40 # 4.1 包裹位置传递
41 
42 def get_user_info(*args):  # 不定长位置参数，接收实参后，args变成了一个元组
43     print(args)
44 
45 
46 get_user_info('Allen')  # ('Allen',)
47 get_user_info('Allen', 18, '男')  # ('Allen', 18, '男')
48 
49 
50 # 注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为⼀个元组(tuple)，args是元组类型，这就是包裹位置传递。
51 
52 # 4.2 包裹关键字传递
53 def get_user_info(**kwargs):  # 不定长关键字参数，接受实参后，kwargs变成了一个字典
54     print(kwargs)  # {'age': 18, 'gender': '女', 'name': '露丝'}
55 
56 
57 get_user_info(age=18, gender='女', name='露丝')
58 
59 # 4.3 综上：⽆论是包裹位置传递还是包裹关键字传递，都是⼀个组包的过程。元组、字典