12三大神器

三大神器

1.迭代器

# 1. 什么是迭代器（iter）

迭代器是容器：程序中无法直接创建一个迭代器，只能将别的序列转换成迭代器。

特点：打印迭代器无法查看所有的元素、也无法获取元素的个数：获取元素的时候每次只能获取最前面的元素，而且元素取一个就少一个。

i1 = iter('abc123')
print(i1)  # <str_iterator object at 0x0000000002534B20>
# print(len(i1)) 报错！ 无法统计个数
i2 = iter ([10,23,45])
print(i2)  # <list_iterator object at 0x0000000001D96730>

i3 = iter({'a':10,'b':20})
print(i3)  # <dict_keyiterator object at 0x0000000002533720>

2.查 - 获取元素

迭代器不管以什么样的方式获取到某个元素，那么这个元素一点会从迭代器中消失

1)查单个： next(迭代器） - 获取迭代器中最前面的元素

2）遍历

print(next(i1))  # a
print(next(i1))  # b
print(next(i1))  # c

print(next(i2))  # 10
print(next(i2))  # 23
print(next(i2))  # 45
# print(next(i2))  报错

print(list(i1))  # ['1','2','3']  abc已被取出
print(list(i2))  # []

print(list(i3))  # ['a''b']
# print(next(i3)) # 报错 数据已被取出

# 遍历
i4 = iter('hello')
for x in i4:
    print('x:',x)

# print(next(i4))

2 .生成器

1.什么是生成器

生成器也是容器，其他容器是直接保存多个数据，生成器保存的是产生多个数据的算法

生成器获取数据的方式和特点和迭代器一样。

2.创建生成器

调用一个带有yield关键字的函数就可以得到一个生成器的对象

def func():
    print('++++')
    print('=====')
    return 100
    yield


result = func()
print('x:', result)  # x: <generator object func at 0x0000000001DFB740>

3.控制生成器产生数据的个数和值

一个生成器产生的数据的个数和值由创建生成器调用的那个函数体在执行的时候会遇到几次yield以及每次yield后面的值来决定

个数： 由遇到的yield的次数决定

值： 由yield后面的数据决定

def create1():
    yield 100
    yield 200
    yield 300


gen2 = create1()
# print(list(gen2))   # [100, 200, 300]
print(next(gen2))   # 100
print(next(gen2))   # 200
print(next(gen2))   # 300
# print(next(gen2))  报错


def create1():
    x = 0
    while True:
        yield x
        x += 1


gen2 = create1()
print(next(gen2))
print(next(gen2))
print(next(gen2))

# 练习：写一个生成器可以创建某个python班级学号，学号的范围是：python0001~python1000


def func1(subject):
    x = 1
    while x <= 1000:
        yield f'{subject}{x:0>4}'
        x += 1


python_id = func1('python')
java_id = func1('java')
print(next(python_id))
print(next(java_id))
print(next(java_id))
for _ in range(10):
    print(next(python_id))

4.生成器创建数据的原理

每次获取生成器的数据的时候，就回去执行创建这个生成器的函数体，但是每次执行都只会执行到yield就停下来

def func2():
    print('+++++')
    yield 100
    print('=====')
    yield 200
    print('!!!!')
    yield 300


gen2 = func2()

print('1:', next(gen2))   # +++++   100
print('2:', next(gen2))   # ====    200
print('3:', next(gen2))   # ！！！   300


print('-------------------------------------------')
nums = 'abc'
result = map(lambda x: x*2, nums)

print(next(result))  # aa
print(next(result))  # bb
print(next(result))  # cc

3 .装饰器

1. 无参装饰器语法

语法：
def 装饰器名(原函数)：
    def 添加完功能的新函数(*args,**kwargs):
        调用原函数
        添加新功能
    return 添加完功能的新功能
    
def 装饰器名(f):
    def new_f ((*args,**kwargs):
        result = f (*args,**kwargs)
        新增功能
        return result
    :return new_f
        
装饰器名 - 根据新增的功能来命名

# 练习1：写一个装饰器，在函数调用之前打印:'千锋教育欢迎你’
def add_tag(f):
    def new_f(*args, **kwargs):
        print('千锋欢迎你')
        result = f(*args, **kwargs)
        return result
    return new_f


@add_tag  # hello = add_tag(hello)  -> hello = new_f
def hello():
    print('hello world')


hello()


@add_tag   # nums = add_tag(nums)
def nums(num1, num2):
    return num1 + num2


print('和：',nums(10,20))

print('-------------------------------------------')
# 练习2： 写一个装饰器在函数调用结束的时候打印'=====end====='


def equal(f):
    def new_f(*args, **kwargs):
        result = f(*args, **kwargs)
        print('=======')
        return result
    return new_f


@equal
def hello():
    print('hello world')


hello()

# 练习3：写一个装饰器将返回值是数字的函数的返回值变成原来返回值的100倍。  3 -> 300;  'abc' -> 'abc'; 1.23  -> 123
def nums1(f):
    def new_f(*args, **kwargs):
        result = f(*args, **kwargs)
        if type(result) in (int,float):
            return result*100
        else:
            return result
    return new_f


@nums1
def func2(x):
    return x


print(func2(2))

2 .有参装饰语法

有参装饰器语法细化：
def func1(参数列表）：
    def 无参装饰器(f):
        def new_f ((*args,**kwargs):
            result = f (*args,**kwargs)
            新增功能
            return result
        return new_f
    :return 无参装饰器
    
参数列表 - 看实现装饰器新增功能需不需要额外的数据，需要几个

# 练习3：写一个装饰器将返回值是数字的函数的返回值变成原来返回值的n倍。


def nums1(n):
    def temp(f):
        def new_f(*args, **kwargs):
            result = f(*args, **kwargs)
            if type(result) in (int,float):
                return result*n
            else:
                return result
        return new_f
    return temp


@nums1(100)
def nums(x):
    return 2


print(nums(2))  # -200


# 练习2：写一个装饰器，用法如下
# 没有装饰器返回值如果是: 100      @tag(p)  -> '<p>100</p>'
# 没有装饰器返回值如果是: 'abc'   @tag(a)  -> <a>abc</a>
def tag(n):
    def temp(f):
        def new_f(*args,**kwargs):
            result = f(*args, **kwargs)
            return f'<{n}>{result}</{n}>'
        return new_f
    return temp


@tag('a')
def nums(x):
    return x


print(nums('abc'))





# 练习3： 写一个装饰器(针对返回值是数字的函数)，用法如下
# 12  ->  @operation('+'， 100)   -> 112
# 12  ->  @operation('-'， 20)    -> -8
# 12  -> @operation('*'， 3)      -> 36
# 12  -> @operation('/'， 3)      -> 4.0

def operation(x,y):
    def temp(f):
        def new_f(*args,**kwargs):
            result = f(*args,**kwargs)
            return eval(f'{result}{x}{y}')
        return new_f
    return temp

@operation('+',100)
def nums(x):
    return x


print(nums(12))