python day11 有参装饰器、迭代器、生成器

day11 有参装饰器、迭代器、生成器

复习

1、装饰器模板

def deco(func):
    def wrapper(*args,**kwargs):
        res = func(*args,**kwargs)
        return res
    return wrapper

2、叠加多个装饰器

1.有参装饰器

def outer1(mode):
    def outer(func):
        def wrapper(*args, **kwargs):
            user = input('用户名：').strip()
            pwd = input('密码：').strip()
            if mode == 'file':
                if user == 'hina' and pwd == '123':
                    res = func(*args, **kwargs)
                    return res
                else:
                    print('登录失败')
            elif mode == 'mysql':
                print('from mysql register')
            elif mode == 'ldap':
                print('from ldap register')
            else:
                print('from others register')

        return wrapper

    return outer


# outer = outer1('mysql')

@outer1('mysql')  # @outer  # index = outer(index)  # index = wrapper
def index():
    print('from index')


index()


@outer1('ldap')
def home(name):
    print(f'name is {name}')


home('hina')

2.wraps装饰器

from functools import wraps

def outer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        res = func(*args, **kwargs)
        return res

    return wrapper

@outer
def index():
    """
    from index
    :return:
    """
    print('=====>index')


print(index.__name__)
print(index.__doc__)

3.总结有参装饰器模板

def outter2(xxx):
    def outter(func):
        def wrapper(*args, **kwargs):
            print(xxx)
            res = func(*args, **kwargs)
            return res
        return wrapper
    return outter

@outter2('xxx')
def index():
    print('index')

4.迭代器

1. 什么是迭代器

   迭代器是迭代取值的工具，什么是迭代？

   ​ 迭代是一个重复的过程，但是每次重复都是基于上一次的结果而来

2. 为何要用迭代器

   1. 为了找到一种新的、统一的取值方式（可以不依赖于索引以及key的）
   2. 惰性计算，不耗费内存

3. 如何用迭代器

   1. 可迭代对象iterable
      1. 内置有__ iter __方法
   2. 迭代器对象iterator
      1. 内置有__ iter __方法 # 让for循环底层原理更简洁
      2. 内置有__ next __方法

   调用：可可迭代对象.__ iter __()——> 返回迭代器对象

   调用：迭代器对象.__ next __()——> 返回的是下一个

   for循环原理：迭代器循环

   msg = {'hi': 1, 'rui': 2, 'nazi': 3}
   
   iter_obj = iter(msg)
   
   while True:
       try:
           print(next(iter_obj))
       except StopIteration:
           break
           
   for k in msg:
       print(k)
   

   基于同一个迭代器，取完值后就没了

   for k in iter_obj:
       print(k)
   print('*'*50)
   for k in iter_obj:
       print(k)
   
   print('='*50)
   
   for k in obj:
       print(k)
   print('*'*50)
   for k in obj:
       print(k)
   
   >>>>
   hi
   rui
   nazi
   **************************************************
   ==================================================
   hi
   rui
   nazi
   **************************************************
   hi
   rui
   nazi
   

总结迭代器对象优缺点：

优点：

1. 为了找到一种新的、统一的取值方式（可以不依赖于索引以及key的）
2. 惰性计算，不耗费内存

缺点：

1. 取值不够灵活
2. 一次性的，只能往后取，无法预知数据的个数

5、自定义迭代器

函数但凡出现yield关键字，再调用函数不会执行函数体代码，会得到一个生成器对象

生成器就是一种自定义的迭代器

def func():
    print('hello1')
    yield 1
    print('hello2')
    yield 2
    print('hello3')
    yield 3

g = func()

res1 = next(g)
print(res1)


res2 = next(g)
print(res2)

res3 = next(g)
print(res3)

yeild 与 return

相同点：返回值层面都一样

不同点：return只能返回一次值函数就立即结束，而yeild可以返回多次值

def func():
    start = 0
    while True:
        yield start
        start += 1

res = func()
print(res)
print(next(res))
print(next(res))
print(next(res))
print(next(res))

伪range函数

def my_range(start, end, step=1):
    while start < end:
        yield start
        start += step

6.生成式

# 三元表达式
def max_2(x, y):
    return x if x > y else y

res = max_2(2, 5)
print(res)

# 列表生成式
names = ['hina_nb', 'rui_sb', 'naz_sb']

new_l = [name for name in names if name.endswith('_sb')]
print(new_l)

# 字典生成式
print({i: i * 2 for i in range(5)})
items = [('k1', 111), ('k2', 222)]
print({k: v for k, v in items})

# 集合生成式
print({i for i in range(5)})

# 生成器表达式
res = (i for i in range(6))
print(res, type(res))
>>>>
<generator object <genexpr> at 0x00000210F8189510> <class 'generator'>
# 迭代器

print(next(res))
print(next(res))
>>>>
0
1

for i in res:
    print(i)
for i in res:
    print(i)
>>>>
0
1
2
3
4
5

print(list(res))
print(list(res))
>>>>
[0, 1, 2, 3, 4, 5]
[]

with open('user.txt', 'r', encoding='utf-8') as f:
    # data = f.read()
    # print(len(data))
    print(sum(len(line) for line in f))

7.面向过程编程

是一种编程思想or编程范式

​ 面向过程的核心是"过程"二字，过程就是流程，流程就是先干什么，再干什么，后干什么

​ 基于面向过程编写程序就好比在设计一条流水线

​ 优点：复杂的问题流程化，进而简单化

​ 缺点：牵一发而动全身，扩展性差