Python(十四)---装饰器和内建函数

FeiYi

自学Python

发布于：2023年6月23日

次浏览

字数：1.4k字

时长：5分钟

函数装饰器

作用

装饰器本质上是一个函数，它可以让其他函数在不需要做任何变动的前提下增加额外的功能，装饰器的返回值也是一个函数对象。

应用场景

记录日志、性能测试、权限校验等。

通俗理解就是，在不改变源代码的基础上给源函数增加新的代码。

无参数示例

源函数

def source():
    print("我是原函数")

装饰器

def decorator(func):    # 定义装饰器函数名字，传参为一个函数名
    def f():            # 定义一个嵌套函数，用于给原函数新增功能
        print("开始执行原函数")     # 新增功能
        func()                    # 执行传参进来的原函数
        print("原函数结束了")      # 新增功能
    return f                      # 返回结果

源函数使用装饰器

result = decorator(source)
result()

以上的方法是根据嵌套函数的方法来使用的，Python 提供了语法糖(@)来优化装饰器代码。

# 定义装饰器
def decorator(func):
    def f():
        print("开始执行原函数")
        func()
        print("原函数结束了")
    return f

# 使用语法糖@引用装饰器，装饰器引用必须不隔行定义功能函数
@decorator
def source():
    print("我是原函数")
source()

带参数示例

我学到的就是因为语法糖的存在而方便的在使用装饰器的情况下，原函数携带参数

def decorator(func):
    def f(msg):    # 用于原函数传参
        print("开始执行原函数")
        func(msg)  # 原函数传参
        print("原函数结束了")
    return f

@decorator
def source(msg):   # 原函数需要的参数
    print(msg)

source("FeiYi")

内建函数

字面意思，Python 自带函数

高阶函数

能接收一个或者多个函数作为输入

输出一个函数

map()

根据提供的函数处理序列中的元素，处理完后返回一个迭代器对象。可以用于对序列中的每个元素进行相同的操作，从而简化代码。

使用方法：map(函数, 可迭代对象)

# 列表内都乘以2，传统方法
num = range(1,11)

for i in num:
    print(i * 2)

# 高阶函数
num = range(1,11)
def a(n):
    return n * 2
result = map(a, num)
print(result)
# 输出结果为
<map object at 0x000002A6ADCEE208>   # 是一个map对象，需要转换
# 可视化迭代器对象
print(list(result))
# 输出结果为
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

匿名函数特殊示例

num = range(1,11)
result = list(map(lambda n: n * 2, num))
print(result)

lambda n: n * 2：lambda用来创建一个匿名函数(没有名字的函数)，n是它的参数，这个函数执行的内容是n*2，即这个函数返回的结果。以下就是lambda具象化后的样子，但是实际不能这么写

def (n):
    return n * 2

map(lambda n: n * 2, num)：map传参里面以冒号为分割，冒号之前lambda n是定义匿名函数，冒号之后n * 2是函数执行内容，逗号后面num是传参。这也符合map(函数, 传参)的使用方法。

filter()

用于过滤序列，过滤不符合条件的元素，处理完后返回一个迭代器对象。使用方法和map()一样。

例：将列表中的奇数过滤出来

# 匿名函数示例
num = range(1, 11)
result = list(filter(lambda n :n % 2 != 0, num))
print(result)
# 非匿名函数示例
num = range(1, 11)
def a(n):
    if n % 2 != 0:
        return n
result = list(filter(a, num))
print(result)

sorted()

对所有可迭代对象进行排序操作

num = [1, 7, 2, 6, 4, 10]
alphabet = ['abc', 'cba', 'acd']
print(sorted(num))
print(sorted(alphabet))

# 字典排序
dict = {'a': 12, 'cd': 86, 'ih': 78}
# 后面使用匿名函数只对字典中的key或者value排序
result = sorted(dict.items(), key=lambda x:x[0])
print(result)

reversed()

返回一个反向(将本身的顺序反向)的可迭代对象

num = [1, 7, 2, 6, 4, 10]
print(list(reversed(num)))

min()、max()、sum()

num = [1, 7, 2, 6, 4, 10]

print(min(num))
print(max(num))
print(sum(num))

zip()

对多个可迭代对象创建一个聚合，返回一个元组的迭代器，其实就是合并多个列表成为字典，传参前者为key，后者为value

num = [1, 7, 2, 6, 4, 10]
alphabet = ['abc', 'cba', 'acd']

print(list(zip(num, alphabet)))
# 使用场景
for x,y in zip(num, alphabet):
    print(f"num列表值：{x},字母列表值：{y}")

变量范围函数

locals()：字典格式返回当前范围的局部变量

globals()：字典格式返回当前范围的全局变量

a = 1
def b():
    c = 2
    print("局部变量 %s" % locals())
b()
print("全局变量 %s" % globals())

博客内容遵循 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 协议

本文永久链接是：https://www.feiyiblog.com/2023/06/23/Python(%E5%8D%81%E5%9B%9B)---%E8%A3%85%E9%A5%B0%E5%99%A8%E5%92%8C%E5%86%85%E5%BB%BA%E5%87%BD%E6%95%B0/

更新于：2023年11月14日

Python

字数：1.4k字

时长：5分钟