四大器

Posted 2022-07-04 guyouyin123

目录

• 一、迭代器
  • 1.一个简单的迭代器：
  • 2.迭代异常处理（迭代完了，没有了,try）
• 二、生成器
  • yield与return的区别：
• 三、装饰器
  • 1.无参模板（二层）
  • 2.有参模板（三层）
• 四、@property装饰器

一、迭代器

迭代器：迭代取值的工具 ——（用__iter__生成迭代器对象）

优点：1.不依赖与索引取值

　　　2.内存中只占一份空间，不会内存溢出，节约空间，运行效率更高*（执行一次__next__取值一次，而不是一次全部取值）*

缺点：1.不能获取指定的元素

　　 2.只能依次往后取值

1.一个简单的迭代器：

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

2.迭代异常处理（迭代完了，没有了,try）

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

二、生成器

优点：节约内存，不会内存溢出

生成器：使用yield自定义的迭代器叫生成器

yield:

? 1.后面不跟值，默认返回None,可以返回多个值

? 2.帮你将函数的运行状态暂停住

? 3.可以返回值，多个也可以

yield与return的区别：

? 1.yield配合迭代器使用__next__一个一个取值，return一次性全取

? 2.yield可以返回多次值，return返回一次立即结束函数

? 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  # 固定搭配

例子：给lookup添加登录认证的功能

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.有参模板（三层）

# 有参模板
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首先创建一个age对象，所以@setter、@deleter要加函数名
：这里的age是装饰方法的名称

@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

结果：删除时触发的内容