Python---- 一闭三器

一闭三器

• 闭包

• 装饰器

• 迭代器

• 生成器
  
  

闭包

保证数据安全

闭包 结构

内层函数对外层函数的局部变量的使用，内层函数被称为闭包函数

闭指的是：该函数的内部函数

包指的是：内部函数在外部被引用

 

构成条件

1、函数嵌套

2、外部函数返回内部函数名

3、内部函数使用外部函数的变量

def external():
    var = "我是闭包"

    # 函数嵌套
    def inside():
        # 内部函数使用外部函数变量
        print(var)
    # 外部函数返回内部函数名
    return inside


res = external()
# external()的返回值为inside,所以res() == inside()
res()

def external():
    name = "外层函数"

    def inside():
        print("我是内部函数")
        return name

    return inside


res = external()
r1 = res()
print(r1)

装饰器

装饰器的本质是闭包

装饰器是 Python 的一个重要部分。简单地说：他们是不改变函数功能的基础上，给函数增加一些功能。他们有助于让我们的代码更简短，也更有范儿。

1、函数可以作为参数进行传递

def demo():
    print("我是demo函数")


def func(insert):
    insert()


func(demo)

def demo():
    return 10


def func(demo):
    print(demo + 15)


func(demo())
# 输出结果为25

 

2、装饰器实例

# 写好闭包结构 外部函数提供一个自由参数
def external(func):
    def inside():
        print("开启外挂")
        func()
        print("关闭外挂")
        print("-" * 25)
    return inside


# func()代表我们需要装饰的函数，在需要装饰的函数前@装饰器的外部函数名
@external
def play_lol():
    print("德玛西亚草丛三兄弟已就位")


@external
def play_wow():
    print("兽人永不为奴")


play_lol()
play_wow()

 2、装饰器的参数

def external(func):
    def inside(*args, **kwargs):
        print("开启外挂")
        func(*args, **kwargs)
        print("关闭外挂")
        print("-" * 25)

    return inside


@external
def play_lol(username, password):
    print(f"账号:{username}登录成功，德玛西亚草丛三兄弟已就位")


@external
def play_wow(username, password, hero):
    print(f"账号:{username},英雄{hero}登录成功\n欢迎来到艾泽拉斯！")


play_lol("python", 123456)
play_wow("wow", 123456, "牛头人")

  2、装饰器的返回值

def external(func):
    def inside(*args, **kwargs):
        print("开启外挂")
        res = func(*args, **kwargs)
        print("关闭外挂")
        return res
    return inside


@external
def play_wow(username, password, hero):
    print(f"账号:{username},英雄{hero}登录成功\n欢迎来到艾泽拉斯！")
    return "霜之哀伤"


demo = play_wow("wow", 123456, "牛头人")
print(demo)

 

迭代器

迭代器是一种对象，该对象包含值的可计数数字。

迭代器是可迭代的对象，这意味着您可以遍历所有值。

从技术上讲，在 Python 中，迭代器是实现迭代器协议的对象，它包含方法 __iter__() 和 __next__()。

迭代器与可迭代对象

列表、元组、字典和集合都是可迭代的对象。它们是可迭代的容器，您可以从中获取迭代器（Iterator）。

所有这些对象都有用于获取迭代器的 iter() 方法：

str1 = iter("python")
print(str1)

str2 = "hello,word".__iter__()
print(str2)

 从迭代器中拿到数据 使用next()

str1 = iter(["张三", "李四"])
print(next(str1))
print(next(str1))

str2 = "你好啊".__iter__()
print(str2.__next__())
print(str2.__next__())
print(str2.__next__())

使用while循环模拟for循环从迭代器中拿去数据

li = ["张三", "李四", "万五", "赵六"]
new_li = iter(li)
# new_li = li.__iter__()
while True:
    # 有可能出现的异常的代码放入try中
    try:
        data = next(new_li)
        # data = new_li.__next__()
        print(data)
    # 用except捕获异常，然后终止程序
    except StopIteration:
        break

生成器

生成器的本质就是迭代器

创建生成器的方案

生成器函数中有一个关键字 yield

生成器函数执行的时候，并不会执行函数，得到的是生成器对象

 

只要函数中出现了yield，那他就是一个生成器函数

可以返回数据，可以分段执行函数的内容，通过next，执行到下一个yield的位置

def func():
    print("我是一个函数")
    yield "你好，一个函数"
    print("我是两个函数")
    yield "你好,两个函数"


res = func()
# 生成器的本质是迭代器，所以可以用next()取值
# yield的内容输出，需要使用print
# 在生成器函数中，print打印的就是yield之后的东西
print(res.__next__())
print(res.__next__())

和 return 相比，yield 除了可以返回相应的值，还有一个更重要的功能，即每当程序执行完该语句时，程序就会暂停执行。

不仅如此，即便调用生成器函数，Python 解释器也不会执行函数中的代码，它只会返回一个生成器（对象）

return是一次性把所有数据全部存储到内存中，yield是分段存储，当第一段数据从内存释放后，在存储第二段

需要处理数据比较少的时候用return,需要处理的数据比较大的时候使用yield。

def steamed_bun():
    li = []
    for num in range(1, 10):
        li.append(f"这是第{num}个馒头")
    yield li


res = steamed_bun()
print(res.__next__())