python -【四】函数

函数

一、函数的基础

函数：是组织好的，可以重复使用的，用来实现特定功能的代码段

语法

def 函数名(入参):
    return 出参

# 定义函数
def out_hello():print('hello ~~~')# 调用/使用/执行函数
out_hello()

练习题

自定义一个函数，返回一个整型数字，输入一个字符串

# 定义函数
def convert(str_):print(f'输入的内容是：{str_}, 类型：{type(str_)}')return int(str_)# 执行函数
v = convert('123')
print(f'输出的内容是：{v}, 类型：{type(v)}')"""
输入的内容是：123, 类型：<class 'str'>
输出的内容是：123, 类型：<class 'int'>
"""

二、函数的参数

def add(x, y):z = x + yprint(f' {x} + {y} = {z}')add(5, 5)"""
x, y : 形参
5, 5: 实参
输出结果：5 + 5 = 10
"""

三、函数的返回值

def add(x, y):return x + yv = add(5, 5)
print(v)"""
输出结果：10
"""

def none_func_1():print('')def none_func_2():print('')return Noneres = none_func_2()
print(f'无返回值的函数返回结果是：{res}, 返回结果类型是：{type(res)}')
res2 = none_func_1()
print(f'无返回值的函数返回结果是：{res2}, 返回结果类型是：{type(res2)}')"""
无返回值的函数1返回结果是：None, 返回结果类型是：<class 'NoneType'>
无返回值的函数2返回结果是：None, 返回结果类型是：<class 'NoneType'>
"""

四、None 使用场景

None：在函数内，无论有没有写 return 语句，默认都是有 return 语句的，只是 return None

# 1. 声明变量的初始值为 None
name = None# 2. None 用于条件表达式
def check_age(age):if age >= 18:return 'SUCCESS'else:# 3. 函数的返回值return Noneresult = check_age(16)
# 表示 None 的时候进入，False 
if not result:print('未成年，无法入内 ...')

五、函数的注释

def add(x, y):"""两数之和:param x: x:param y: y:return: x + y"""z = x + yprint(f' {x} + {y} = {z}')

六、函数的嵌套

def func_1():print(1)def func_2():print(2)def func_3():print(3)def func():func_1()func_2()func_3()func()"""
1
2
3
"""

七、局部变量

局部变量：函数内的变量，作用在函数内，函数调用结束后局部变量失效

def test_num():num = 100# 正常输出print(f'函数内部 num={num}')test_num()
# NameError: name 'num' is not defined. Did you mean: 'sum'?
print(f'函数外部 num={num}')

八、全局变量

全局变量：函数内和函数外都能使用该变量

# 定义全局变量 num
num = 100# 函数内使用 num 变量
def test_num():print(f'函数内部 num={num}')# 执行 test_num 函数
test_num()
# 函数外部访问 num
print(f'函数外部 num={num}')

九、global 关键字

global 关键字作用：在函数体内修改全局变量，会导致该全局变量在外部无法文档修改后的内容，效果如下：

count = 200def read_count():print(f'read_count 函数内 count = {count}')def modify_count():count = 3000print(f'modify_count 函数内 count = {count}')# 1. 读取函数，count = 200
read_count()
# 2. 修改，count = 3000
modify_count()
# 3. count = 200 第二步种修改的无法作用到函数外
print(f'函数外 count = {count}')"""
read_count 函数内 count = 200
modify_count 函数内 count = 3000
函数外 count = 200
"""

在 modify_count 函数内，加上 global 关键字后
global 语法：global 被指定的全局变量名

count = 200def read_count():print(f'read_count 函数内 count = {count}')def modify_count():# 如下：将 count 本次的修改指向全局global countcount = 3000print(f'modify_count 函数内 count = {count}')read_count()
modify_count()
print(f'函数外 count = {count}')"""
read_count 函数内 count = 200
modify_count 函数内 count = 3000
函数外 count = 3000
"""

十、函数综合案例

"""
综合案例：ATM 机主菜单
----------主菜单-----------
张三，您好，欢迎进入 ATM 系统，请选择：
查询余额    [输入1]
取款       [输入2]
取款       [输入3]
退出       [输入4]
请输入您的选择：查询余额----------查询余额-----------
张三，您好，您的余额剩余：100元----------存款-----------
张三，您好，您存款 200元
张三，您好，您的余额剩余：300元----------取款-----------
张三，您好，您取款 200元
张三，您好，您的余额剩余：100元
"""money = 0def read_in(str_):return int(input(str_))def main_menu():menu = """----------主菜单-----------张三，您好，欢迎进入 ATM 系统，请选择：查询余额    [输入1]存款       [输入2]取款       [输入3]退出       [输入4]"""print(menu)def query_money():menu = f"""----------查询余额-----------张三，您好，您的余额剩余：{money}元"""print(menu)def save_money(m: float):global moneymoney += mmenu = f"""----------存款-----------张三，您好，您存款 {m}元张三，您好，您的余额剩余：{money}元"""print(menu)def draw_money(m: float):global moneymoney -= mmenu = f"""----------取款-----------张三，您好，您取款 {m}元张三，您好，您的余额剩余：{money}元"""print(menu)def main_func():while True:main_menu()op = read_in('请输入您的选择: ')if op == 1:query_money()elif op == 2:m = read_in('请输入您的存款金额: ')save_money(m)elif op == 3:m = read_in('请输入您的取款金额: ')draw_money(m)elif op == 4:breakprint('已退出ATM系统...')if __name__ == '__main__':main_func()

十一、函数多返回值

def multi_result():return 1, 2x, y = multi_result()
print(f'x={x}, y={y}')def multi_result_2():return 1, '哈哈哈', [1, 2, 3], Truea, b, c, d = multi_result_2()
print(f'a={a}, b={b}, c={c}, d={d}')"""
x=1, y=2
a=1, b=哈哈哈, c=[1, 2, 3], d=True
"""

十二、参数传递

函数 ‘建=值’ 传参

# 不能省略的参数
def params(name, age, worker):print(f'params函数内：name={name}, age={age}, worker={worker}')# 缺省参数：设置缺省参数必要让被指定的参数在形参列表中最后面，否则会报错，如下
# def params_2(name='王五', age, worker):
def params_2(name, age, worker='码农'):print(f'params_2函数内：name={name}, age={age}, worker={worker}')# 调用方式1，顺序传参
params('张三', 20, '码农')
# 方式2：k=v传参，无序顺序指定
params(age=25, worker='码农', name='张三')
# 缺省参数
params_2(age=30, name='李四')

不定长参数

不定长参数:
位置不定长：*args 元组
参数不定长：**kwargs k=v

# 位置不定长
def args_func(*args):print(f'位置不定长:{args}, 类型是：{type(args)}')# 参数不定长
def kwargs_func(**kwargs):print(f'参数不定长:{kwargs}, 类型是：{type(kwargs)}')args_func('张三', 18.0, '码农', ['alibaba', 'bytedance'])
kwargs_func(name='张三', age=18.0, worker='码农', company=['alibaba', 'bytedance'])"""
位置不定长:('张三', 18.0, '码农', ['alibaba', 'bytedance']), 类型是：<class 'tuple'>
参数不定长:{'name': '张三', 'age': 18.0, 'worker': '码农', 'company': ['alibaba', 'bytedance']}, 类型是：<class 'dict'>
"""

函数作为参数传递

"""
函数作为参数进行传递
"""def calc(x, y):return x + ydef test_calc(calc_func):print(f'calc的类型是：{type(calc_func)}')return calc_func(2, 1)res = test_calc(calc)
print(f'计算结果：{res}')

lambda 匿名函数

lambda 函数
语法：lambda 传入参数：函数体(一行代码)
lambda 函数体只能写一行，且不可重复调用

def test_lambda(add_func):print(f'add_func 的类型是：{type(add_func)}')return add_func(2, 1)# 调用匿名函数
result = test_lambda(lambda x, y: x + y)
print(f'匿名函数返回结果：{result}')# 定义多参数的匿名函数
def test_lambda_2(add_func):print(f'add_func 的类型是：{type(add_func)}')return add_func(2, 1, 3, 4)# 调用匿名函数
result = test_lambda_2(lambda x, y, z, a: x + y + z + a)
print(f'匿名函数返回结果：{result}')
result_2 = test_lambda_2(lambda x, y, z, a: x + y + z - a)
print(f'匿名函数返回结果：{result_2}')"""
calc的类型是：<class 'function'>
计算结果：3
add_func 的类型是：<class 'function'>
匿名函数返回结果：3
add_func 的类型是：<class 'function'>
匿名函数返回结果：10
add_func 的类型是：<class 'function'>
匿名函数返回结果：2
"""

十三、类型注释

13.1 基础类型的类型注解

帮助第三方 IDE 工具对代码进行类型推断，协助做代码提示
帮助开发者自身对变量进行类型注释
不会对程序有任何影响，只是作为提示，仅此而已

方式1：指定变量类型            语法：变量名：类型 = 值

方式2：使用注释指定类型     语法：i = 10 # type: int

"""
方式1：变量名：类型 = 值
"""# 容器的类型注解
my_list: list[int] = [1, 2, 3, 4]
my_tuple: tuple[str, int, bool] = ('a', 1, True)
my_set: set[int] = {1, 2, 3, 4}
my_dict: dict[str, int] = {'a': 1, 'b': 2}
my_str: str = '123456'# 基础类型的注解
va_1: int = 10
va_2: str = '123456'
va_3: bool = True
va_4: float = 2.3# 类的注解
class Path:passpa: Path = Path()

"""
方式2：i = 10 # type: int
"""m = random.randint(1, 100)  		# type: int
j = json.loads('{"name":"张三"}')  	# type: dict[str, str]def func():return 1f = func() 									 # type: int

13.2 函数的类型注解

# data: dict[str, int]  表示输入的类型是 dict[str, int]
#  idx: int  表示输入的类型是 int
# -> list[str]  表示返回值的类型是 list[str]
def func(data: dict[str, int], idx: int) -> list[str]:print(f'dict:{data}, idx:{idx}')return list(data.keys())

13.3 Union 类型注解

首先看一个例子：

my_list = [1, 2, 3, 4, '北京', 'GPT4', True]
以上的 my_list 是一个复合类型的容器，想要表述这种类型就需要用到 Union 类型的注解

from typing import Union# 在变量中展示
# 在变量中展示
my_list: list[Union[str, int, bool]] = [1, 2, 3, 4, '北京', 'GPT4', True]my_dict: dict[str, Union[str, int, bool]] = {'name': '张三','age': 20,'good_student': True
}# 在函数中展示
def func(data: Union[str, int]) -> Union[str, int]:return dataprint(f'func(1) 返回值类型是：{type(func(1))}') # func(1) 返回值类型是：<class 'int'>
print(f'func("哈") 返回值类型是：{type("哈")}') # func("哈") 返回值类型是：<class 'str'>