python进阶之函数进阶~
- 2026-07-02 16:47:30
进阶篇开始~
1.高阶函数 当一个函数的参数为函数或者返回值是函数的时候，该函数就是高阶函数
def open():
print("opne")
def caller(f):
print("call函数开始调用")
f()
caller(open)
意义：
代码复用性高：可以把行为“独立出去”，传入不同函数实现不同逻辑。
能让函数更灵活，更通用。
高阶函数是：装饰器、闭包的基础。
js中学过闭包的肯定都知道
def info(msg):
return ("info"+msg)
def success(msg):
return (msg)
def warning(msg):
return (msg)
def news(fun,msg):
print(fun(msg))
news(info,"info")
news(success,"success")
news(warning,"warning")
JS中的三目运算
let b=0
a=10;
b= a==10?'1':'2'
python中的三目运算
age=17
结果1 if 条件 else 结果2
text="成年"if age>19 else'未成年'
print(text)
匿名函数:没有名字的函数，无需用def定义
使用lambda 参数：表达式来定义
当一个函数只用一次、只做一点点小事，使用匿名函数会更简洁
def operation(func,a,b):
print(func(a,b))
operation(lambda a,b:a+b,10,20)#30
operation(lambda a,b:a-b,20,10)#10
匿名函数+表达式
age=18
isAge=lambda age:'成年'if age>=18 else"未成年"
print(isAge(18))
print(isAge(17))
数据处理函数：map() filter() sorted() reduce() map()对数据进行处理
lists=[10,20,30,40]
result=map(lambda a:a*2,lists)
print(list(result))
print(lists)
names=('python','java','web')
resiults=map(lambda x:x.upper(),names)
print(tuple(resiults))
str_number={'1','2','3'}
strult=map(lambda x:int(x),str_number)
print(set(strult))
filter函数：筛选符合条件的元素
lists=[10,20,30,40,50]
result=filter(lambda x:x>30,lists)
print(list(result))
persons = [
{'name':'张三', 'age':15, 'gender':'男'},
{'name':'李四', 'age':16, 'gender':'女'},
{'name':'王五', 'age':17, 'gender':'男'},
{'name':'李华', 'age':18, 'gender':'女'},
{'name':'赵六', 'age':19, 'gender':'女'},
{'name':'孙七', 'age':20, 'gender':'男'}
]
result=filter(lambda x:x["age"]>18,persons)
print(list(result))
names=["zz",None,"ss"]
results=filter(lambda x:x,names)
print(list(results))
sorted()排序
sorted(可迭代对象, key=xxx, reverse=xxx)
nums=[10,20,14]
result=sorted(nums,reverse=False)
print(list(result))
#长度排序
names=["java","vue","python"]
results=sorted(names,key=len,reverse=False)
print(list(results))
#年龄排序
persons = [
{'name':'张三', 'age':15, 'gender':'男'},
{'name':'李四', 'age':16, 'gender':'女'},
{'name':'王五', 'age':17, 'gender':'男'},
{'name':'李华', 'age':18, 'gender':'女'},
{'name':'赵六', 'age':19, 'gender':'女'},
{'name':'孙七', 'age':20, 'gender':'男'}
]
res=sorted(persons,key=lambda x:x['age'],reverse=False)
print(list(res))
reduce:将一组数据合并，成一个新的数组
reduce(合并函数, 可迭代对象, 初始值)。
# 从 functools 模块中引入 reduce
from functools import reduce
nums=[1,2,3,4,6]
res=reduce(lambda x,y:x+y,nums,10)
print((res))
text=["ab","cd","ef"]
ress=reduce(lambda x,y:x+y,text)
print(ress)
列表推导式：用一条简洁语句，从可迭代对象中，生成新列表的语法结构。
[ 表达式 for 变量 in 可迭代对象 ]
nums=[1,2,3]
res=[x*2 for x in nums]
print(res)
# 字典推导式
names = ['张三', '李四', '王五']
scores = [60, 70, 80]
ress={names[i]:scores[i] for i in range(len(names))}
print(ress)
# 集合推导式
names1 = ['张三', '李四', '王五']
resd={i+'!'for i in names1}
print(resd)
常用内置函数
print 输出指定内容
objects 要输出的内容
sep 输出多个内容时的分隔符
end 结尾追加的内容
file 输出位置（默认控制台）
flush 是否立即刷新输出
input() 获取用户输入
int() 转为整数
float() 转为浮点数
str() 转为字符串
bool() 转为布尔值
list() 转为列表
tuple() 转为元组
set() 转为集合
dict() 转为字典
abs() 取绝对值
round() 银行家舍入法：小于5舍，大于5入，等于5看奇偶（奇入偶舍）
pow(a, b) 计算 a 的 b 次方
pow(a, b, c) 计算 a 的 b 次方后，再对 c 取模
divmod(a, b) 返回 (商, 余数)
max() 最大值（支持 key）
min() 最小值（支持 key）
sum() 求和
map() 加工一组数据
filter() 按条件过滤数据
reduce() 合并计算（需 functools.reduce）
sorted() 排序（支持 key）
len() 获取容器中元素个数
range() 生成数字序列（常用于循环）
enumerate() 为序列添加索引
zip() 将多个序列一一配对
type() 查看对象类型
isinstance(obj, type) 判断对象是否属于某个类型
issubclass(A, B) 判断类 A 是否为类 B 的子类
id() 查看对象的内存地址
all() 所有元素为真时返回 True
any() 至少一个为真返回 True
ord() 获取字符的 Unicode 编码值
chr() 将 Unicode 编码值转换为字符
浅拷贝和深拷贝
说起拷贝，就是赋值 b=a
但是如果b和a指向同一个可变对象时候，b修改了，a也会变化
nums=[1,2,3]
nums1=nums
nums1[0]=45
print(nums)#[45, 2, 3]
print(nums1)#[45, 2, 3]
浅拷贝
import copy
nums=[1,2,3]
nums1=copy.copy(nums)
nums1[0]=45
print(nums)#[1, 2, 3]
print(nums1)#[45, 2, 3]
浅拷贝存在的问题：嵌套数据仍然是共享的，修改嵌套数据会互相影响
import copy
nums=[1,2,3,[4,5]]
nums1=copy.copy(nums)
nums1[3][0]=45
print(nums)#[1, 2, 3, [45, 5]]
print(nums1)#[1, 2, 3, [45, 5]]
这个时候就需要深拷贝了
创建一个新的外层容器，同时对内部所有【可变对象】进行递归复制（不可变对象不复制，继续引用）。
import copy
nums=[1,2,3,[4,5]]
nums1=copy.deepcopy(nums)
nums1[3][0]=45
print(nums)#[1, 2, 3, [4, 5]]
print(nums1)#[1, 2, 3, [45, 5]]
特点：
深拷贝可以彻底消除数据之间的相互影响。
深拷贝遇到【不可变对象】不会复制，会直接引用。
注意点：
深拷贝只复制可变对象，不可变对象会直接引用。
元组中如果只包含不可变对象，则深拷贝没有效果。
a=10
a=20
b=copy.deepcopy(a)
print(b)
nums=(10,20,[10,30])
bs=copy.deepcopy(nums)
print(id(nums))
print(id(bs))
四种作用域
Local（局部作用域）
Enclosing（外层作用域）
Global（全局作用域）
Built-in（内建作用域）
当访问一个变量时，Python 会按以下顺序查找： Local => Enclosing => Global => Built-in
局部作用域
定义：函数的内部就是局部作用域，局部作用域中的变量，只在该函数内部可见。
特点：
● 每次调用函数都会创建一个新的局部作用域。
● 函数运行结束后，局部作用域会随之销毁。
● 局部作用域优先级最高，即：查找一个变量时，Python 会首先 在局部作用域中查找。
def test():
x = 10 # x 在局部作用域
print(x) # 可以访问
print(x) # 报错：x 在局部之外不可见
外层作用域
定义：如果函数中又定义了函数，那么外层函数的作用域，就是内层函数的 Enclosing 作用域。
特点：
● 只有当函数“嵌套定义”时才会出现。
● 内层函数可以读取外层函数变量。
● 想修改外层变量必须使用nonlocal。
def outer():
y = 20 # outer 的局部变量 → inner 的 Enclosing 变量
def inner():
print(y) # 内层函数读取外层变量
inner()
全局作用域：在各个位置都可以访问
a = 100 # 全局变量
def test():
print(a) # 可以读取
test()
print(a) # 在本文件任何位置都可以访问
内建作用域（Built-in）
定义：Python 预先定义好的东西，会放在内建作用域中，所有.py文件都可以直接使用。
特点：
● 所有.py文件都能直接使用其中的名称。
● 例如：print、len、range、sum、max 等。
● 查找优先级最低，即：查找一个变量时，内建作用域是“最后一道防线”。
print('hello')
len([1, 2, 3])
闭包
● 闭包 = 内层函数 + 被内层函数引用的外层变量。
● 产生闭包的三个条件如下：
必须有函数嵌套
内层函数使用了外层函数的变量
外层函数返回内层函数
本应该随着outer函数调用结束而死去的num，并没有死去，并且inner函数依然可以对num进行读取和修改。所以我们观察如下的代码形式，完全符合上述的闭包产生条件，所以此时就出现了闭包。
def sum():
nums=10
def inner():
nonlocal nums
nums+=1
print(nums)
return inner
f=sum()
f()#11
f()#12
f()#13
闭包是如何保存外层变量的？
外层变量会被保存到 闭包单元（cell）中，例如上面代码中，那些被 inner函数所使用到的sum函数中的局部变量，会被封存在闭包单元（cell） 中，这些cell组成一个 closure 元组，保存在了inner函数上。
内层函数不会保存外层函数所有数据
注意：每次获得新的闭包时候，互不影响
外层变量为可变对象时仍互不影响。
def outer():
nums = []
def inner(value):
nums.append(value)
print(nums)
return inner
# 每次调用 outer() 都创建一个新的 nums
f1 = outer()
f1(10)
f1(20)
f1(30)
print('**********************')
f2 = outer()
f2(666)
优点：
1. 可以“记住”状态：不用全局变量，也不用写类，就能在多次调用之间保存数据。
2. 可以做“配置过的函数”：先传一部分参数，把环境固定住，得到一个定制版函数。
3. 可以实现简单的“数据隐藏”：外层变量对外不可见，只能通过内层函数访问。
4. 是装饰器（decorator）等高级用法的基础。
缺点：
1. 理解成本较高：对初学者不太友好，滥用会让代码难读。
2. 如果闭包里引用了很大的对象，又长期不释放，可能会增加内存占用。
3. 很多场景下，其实用【类 + 实例属性】会更清晰，闭包不一定是最优解。
装饰器：
装饰器是一种在【不修改原函数代码】的前提下，对函数进行【增强】的工具。 它是 Python 中非常强大的语法特性，常用于：日志、校验、计时、缓存、权限控制等。
def add(func):
def wrapper(*args,**kwargs):
print("计算")
return func(*args,**kwargs)
return wrapper(func)
定义装饰器核心规则：
接收被装饰的函数、同时返回新函数（wrapper）
装饰器“吐出来”的是 wrapper 函数，以后别人调用的也是 wrapper 函数。
为了保证参数的兼容性，wrapper 函数要通过 *args 和 **kwargs 接收参数。
wrapper 函数中主要做的是：调用原函数（被装饰的函数）、执行其它逻辑，但要记得将原函数的返回值 return 出去。
使用函数装饰器（语法糖 @）
def adds(func):
def wrapper(*args,**kwargs):
print("计算")
return func(*args,**kwargs)
return wrapper
@adds
def add(a,b):
res=a+b
return res;
@adds
def adds(a,b):
res=a-b
return res;
ress=add(10,20)
ress1=adds(10,20)
print(ress)
print(ress1)
多层嵌套
def say_hello(msg):
def outer(func):
def wrapper(*args, **kwargs):
print(f'你好，我要开始{msg}计算了')
return func(*args, **kwargs)
return wrapper
return outer
@say_hello("加法")
def add(a,b):
return a+b
@say_hello("减肥")
def sub(a,b):
return a-b
ress=add(1,2)
res=sub(1,1)
print(ress)
print(res)
多个函数装饰器一起使用
核心：注意装饰顺序，距离函数最近的装饰器，会先工作。
def test1(func):
print('我是test1装饰器')
def wrapper(*args, **kwargs):
res = func(*args, **kwargs)
print('test1追加的逻辑')
return res
return wrapper
def test2(func):
print('我是test2装饰器')
def wrapper(*args, **kwargs):
res = func(*args, **kwargs)
print('test2追加的逻辑')
return res
return wrapper
@test1
@test2
def add(x,y):
return x+y
res=add(1,3)
print(res)
类修饰器：和之前一样
class SayHello:
def __call__(self, func):
def wrapper(*args, **kwargs):
print('你好，我要开始计算了')
return func(*args, **kwargs)
return wrapper
变量和函数类型注解：
num:int=12
test:str="12"
nums:float=32.1
citys: set[str] = {'北京', '上海', '深圳'}
# citys 是集合，并且集合中所有元素可以是：str 或 float 或 bool 类型
citys: set[str | float | bool] = {'北京', '上海', '深圳'}
# persons 是字典，键是 str 类型，值是 int 类型
persons: dict[str, int] = {'张三': 18, '李四': 19, '王五': 20}
# persons 是字典，键是 str 或 int 类型，值是 int 类型
persons: dict[str | int, int] = {'张三': 18, '李四': 19, '王五': 20}
citys: set[str] = {'北京', '上海', '深圳'}
# citys 是集合，并且集合中所有元素可以是：str 或 float 或 bool 类型
citys: set[str | float | bool] = {'北京', '上海', '深圳'}
# persons 是字典，键是 str 类型，值是 int 类型
persons: dict[str, int] = {'张三': 18, '李四': 19, '王五': 20}
# persons 是字典，键是 str 或 int 类型，值是 int 类型
persons: dict[str | int, int] = {'张三': 18, '李四': 19, '王五': 20}
语法格式：函数名(参数1: 类型, 参数2: 类型) -> 返回值类型:
1️⃣给参数和返回值加类型注解
def add(x: int, y: int) -> int:
return x + y
2️⃣ 带默认值的参数，可以不写注解
def add(x=1, y=1) -> int:
return x + y
3️⃣ 设置多个返回值的类型注解
def show_nums_info(nums: list[int]) -> tuple[int, int, float]:
max_v = max(nums)
min_v = min(nums)
return max_v, min_v, max_v / min_v
4️⃣ 可变参数类型注解
# 设置 *args 的类型注解，要求 args 中的每个参数都必须是 int 类型
def add(*args: int) -> int:
return sum(args)
# 设置 **kwargs 的类型注解，要求 kwargs 中的每组参数的值，必须是 str 或 int 类型
def show_info(**kwargs: str | int):
print(kwargs)
5️⃣获取函数的注解信息
print(add.__annotations__)
