函数
一、函数的基础
函数:是组织好的,可以重复使用的,用来实现特定功能的代码段
语法
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 + y
print(f' {x} + {y} = {z}')
add(5, 5)
"""
x, y : 形参
5, 5: 实参
输出结果:5 + 5 = 10
"""
三、函数的返回值
def add(x, y):
return x + y
v = add(5, 5)
print(v)
"""
输出结果:10
"""
def none_func_1():
print('')
def none_func_2():
print('')
return None
res = 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 None
result = check_age(16)
# 表示 None 的时候进入,False
if not result:
print('未成年,无法入内 ...')
五、函数的注释
def add(x, y):
"""
两数之和
:param x: x
:param y: y
:return: x + y
"""
z = x + y
print(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 = 200
def read_count():
print(f'read_count 函数内 count = {count}')
def modify_count():
count = 3000
print(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 = 200
def read_count():
print(f'read_count 函数内 count = {count}')
def modify_count():
# 如下:将 count 本次的修改指向全局
global count
count = 3000
print(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 = 0
def 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 money
money += m
menu = f"""
----------存款-----------
张三,您好,您存款 {m}元
张三,您好,您的余额剩余:{money}元
"""
print(menu)
def draw_money(m: float):
global money
money -= m
menu = 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:
break
print('已退出ATM系统...')
if __name__ == '__main__':
main_func()
十一、函数多返回值
def multi_result():
return 1, 2
x, y = multi_result()
print(f'x={x}, y={y}')
def multi_result_2():
return 1, '哈哈哈', [1, 2, 3], True
a, 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 + y
def 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:
pass
pa: 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 1
f = 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 data
print(f'func(1) 返回值类型是:{type(func(1))}') # func(1) 返回值类型是:<class 'int'>
print(f'func("哈") 返回值类型是:{type("哈")}') # func("哈") 返回值类型是:<class 'str'>