4つのデバイス

まず、イテレータ

反復子：反復値のツール - （__iter__イテレータオブジェクトによって生成されます）

利点：1、インデックス値に依存しません

　　　2.（一度値ではなく、すべてのより__next__値に1回実行される）メモリ、省スペースが不足することなく専用メモリ空間、高い動作効率*

短所：1.指定された要素を取得できません

　　 2.値は元に戻すことができます

1.シンプルなイテレータ：

k = [1, 2, 3]
# 生成迭代器对象
k1 = k.__iter__()
#迭代器取值，调用__next__()
print(k1.__next__())
print(k1.__next__())
print(k1.__next__())

（いや、してみてください、以上の繰り返し）を取り扱う2.反復例外

k = [1,2,3]
k1 = k.__iter__()while True:
    try:
        print(k1.__next__())
    except StopIteration:
        print("没有了")
        break

第二に、発電機

利点：メモリがオーバーフローしない、メモリを節約

ビルダー：ビルダーと呼ばれるイテレータの定義からの収量を使用

産出：

1.デフォルトなしで返された値が続いていない、複数の値を返すことができます。

2.あなたは生きて一時停止する状態関数を実行するのに役立ちます

3.戻り値、複数であってもよいです

収量との違いを返します。

イテレータ__next__値を持つ1.yield、すべての使い捨てを取って返します

2.yieldは、関数終了を返し、複数の値を返すすぐに返すことができます

3.yieldは、外部からの着信値を受け入れることができます

def func():
    print("first")
    yield 1, 2, 3  # 函数内如果有yield，执行函数时不会执行函数代码

k = func()  # 将函数转化为迭代器
k2 = k.__next__()  # 取值
print(k2)

再び値を取るために、

def func():
    print('第一次')
    yield 1, 2, 3
    print('第二次')
    yield 2
    print('第三次')
    yield 3
    print('第四次')
    yield
    yield
k = func()  # 转化为迭代器
# k1 = k.__iter__()  # 这里不用生成迭代对象，函数自身可被迭代
print(k.__next__())
print(k.__next__())
print(k.__next__())
print(k.__next__())

第三に、デコレータ

定義：新しい機能を追加し、呼び出し、ソースコードの機能を変更しないでください

1.なし基準テンプレートない（二階）

from functools import wraps   #  语法糖


def outter(func):   # 固定搭配
    @wraps(func)  # 固定搭配   语法糖
    def inner(*args, **kwargs):   # 固定搭配
        
        # 装饰前做的事
        return func(*args, **kwargs)  # 固定搭配
        # 装饰后做的事
    
    return inner  # 固定搭配

例：ログイン認証ルックアップ機能を追加します

user_info = {
    'user':None
}

def login():

    user = input('请输入用户名>>>:')
    passwd = input('请输入密码>>>:')
    passwd_d = input('请再次输入密码>>>:')
    if passwd == passwd_d:
        user_info['user'] = user
        print('登录成功')
    else:
        print('登录失败')


def register():

    user = input('请输入用户名>>>:')
    passwd = input('请输入密码>>>:')
    passwd_d = input('请再次输入密码>>>:')
    if passwd == passwd_d:
        with open(r'user', 'w')as f:
            f.write(user)
            f.write(passwd)
    else:
        print('重新输入')

# 装饰器
def outter(func):

    def inner(*args, **kwargs):
        if user_info['user']:
            print('hello')
            return func(*args, **kwargs)
        else:
            print('请先登录')
            login()  # 添加login的功能
    return inner


@outter
def lookup():
    with open(r'user','r')as f:
        print(f.read())



def run():
    while True:
        print('''
请选择你的功能>>>：
1.注册
2.登录
3.查看信息''')
        choice = input('>>>:')
        if not choice.isdigit():
            print('请输入数字')
            continue

        msg = {'1': register,
               '2': login,
               '3': lookup}
        msg[choice]()

run()

2.参照テンプレート（3つ）

# 有参模板
from functools import wraps

def wrappers(params1,params2,params3):
    def outter(func):
        @wraps(func)
        def inner(*args, **kwargs):
            
            # 装饰前做的事
                return func(*args, **kwargs)
            # 装饰后做的事
            
        return inner
    return outter

四、@プロパティデコレータ

デコレータ：一貫した方法で呼び出すためには、ユーザーフレンドリーな
機能名を追加するセッター、@削除手段@よう@propertyは、まず、年齢オブジェクトを作成します
：ここで年齢が飾るメソッドの名前です。

共有財産として偽装方法は、通常、一貫性のある（ユーザーフレンドリーコール）関数名と属性：@property（プライベート取得）
（プライベート修正）関数名.setter @：関数名と一貫性のある名前属性
関数名.deleter @を（コントロール）を削除：

class A:
    def __init__(self, name, age):
        self.name =  name
        self.__age = age

    @property   # 获取属性时，触发下面
    # 获取伪装成普通属性，通常函数名伪装成属性名
    def age(self):
        return self.__age

    @age.setter  # 修改属性时，触发下面
    def age(self, new_age):
        self.__age = new_age
        print('修改成功')

    @age.deleter  # 删除属性时，触发下面
    def age(self):
        print('删除时触发的内容')

1.私有財産をチェック

a = A('jeff', 50)

print(a.name)
print(a.age)

结果：jeff   50

2.プライベートプロパティを変更します。

a = A('jeff', 50)   # 定义初始

a.age = 100  #修改
print(a.age)

结果：修改成功   100

3.私有財産のトリガーを削除します。

a = A('jeff', 50)

del a.age

结果：删除时触发的内容