2020-12-08

可迭代对象

1.我们已经知道可以对list,tuple,dict,set,str等类型的数据使用for....in...的循环语法，从其中依次拿到数据进行使用，我们把这样的的过程称为遍历，也叫迭代。
2.把可以通过for....in...这类语句迭代读取一条数据供我们使用的对象称之为可迭代对象（Iterator）。

推导式

推导式

1.推导式分为 列表推导式、字典推导式、集合推导式等。在这⾥我们主要说其中 ⼀种也是⽤的Y多列表推导式 
列表推导式是Python构建列表（list）的⼀种快捷⽅式,可以使⽤简洁的代码就 创建出⼀个列表简单理解就是由⼀个旧的列表来构建出⼀个新的列表

语法

1 [表达式 for 变量 in 旧列表] 
2 [表达式 for 变量 in 旧列表 if 条件]

⽣成器*

⽣成器

背景

通过列表推导式我们可以直接创建出⼀个列表，但是受到内存的限制，我们不 可能创造出⼀个⽆限⼤的列表。⽽且创建⼀个有200万个元素的列表，会占⽤很 ⼤的内存空间，⽽这个时候我们仅仅需要访问列表中⼏个元素，那么后⾯的元
素就占⽤着空间就是⼀种浪费的⾏为。那么我们可不可以⽤⼏个元素就创建出 ⼏个元素。这样在⼀定程度上就优化了内存。那么在Python中有⼀种⼀边循环 ⼀边计算的机制就是⽣成器

创建⽣成器的⽅式
通过列表推导式的⽅式

1 g = (x * 3 for x in range(10))

通过函数的⽅式

1 def fu():
2    n = 0 
3    while True:
4        n += 1 
5        yield n

只要在函数中出现yield关键字它就是⼀个⽣成器函数

迭代器

关系对应图

迭代器

1.迭代器是访问集合元素的⼀种⽅式。迭代器是⼀个  可以记住遍历位置的对   象。
2.迭代器对象从集合的第⼀个元素开始访问，指导所有元素被访问完结束。 
3.可以被next()函数调⽤并不断返回下⼀个值的对象称为迭代器Iterator 
4.⽣成器是可迭代的，也是迭代器
5.列表是可迭代的，但不是迭代器 
6.通过iter()函数可以将可迭代的变成⼀个迭代器

闭包

# 闭包构成的三大条件
# 1. 函数嵌套
# 2. 内部函数使用外部函数的参数或者变量
# 3. 外部函数返回内部函数的函数对象


# 函数需要运行代码，调用函数
# fun_out 函数对象   fun_out()调用函数
# def fun_out(num1):
#     def fun_inner(num2):
#         res = num1 + num2
#         print(res)
#
#     return fun_inner


# f = fun_out(1)  # f = fun_inner
# f(2)
# fun_out(1)(2)  # 函数  的调用等于函数的返回值  fun_out()()  = fun_inner()
# f = fun_out(1)   # f = fun_inner
# f(2)

# 闭包的特性：保持外部函数的变量不被销毁
# python关键是使用，python是类似与脚本型语言，用起来舒服，但是底层实现的就很复杂


# 装饰器
def fun_out(fn):
    def fun_inner(*args, **kwargs):
        print('函数开始执行')
        r = fn(*args, **kwargs)  # r = add1()
        print(r)
        print('函数执行结束')

    return fun_inner


def fun(fn):
    def wrapper(*args, **kwargs):
        print('我是第二个装饰器')
        r = fn(*args, **kwargs)
        print(r)
    return wrapper


@fun
@fun_out  # @fun_out == fun_out(add1)  # 语法糖的写法
def add1(a, b):
    return a + b


# f = fun_out(add1)
# f(1, 2)
add1(1, 2)



# def qiuji():
#     print(111)
#
# # 装饰函数
# def fun(fn):
#     print('函数开始执行')
#     fn()
#     print('函数执行结束')
#
# fun(qiuji)

列表推导式

# 找到长度大于3的名字

# 中文是占两个字符


# def fun(lis):
#     new_list = []
#     for i in list1:
#         if len(i) > 3:
#             new_list.append(i)
#
#     return new_list
#
#
# r = fun(list1)
# print(r)


# 列表推导式语法
# [表达式 for 变量 in 旧列表]
# list3 = [i for i in range(10)]
# print(list3)
# # [表达式 for 变量 in 旧列表 if 条件]
# list1 = ['cheney', 'jerry', '居然', 'amy']
# list2 = [i*2 for i in list1 if len(i) > 3]  # list2 = [i1, i2, i3, i4]
# print(list2)

# 1-100之间能被4整除的数据放到新列表中  还要能被6整除的数
# list4 = [i for i in range(1, 101) if i % 4 == 0]
# list5 = [i for i in list4 if i % 6 == 0]
# 对于某某某在某某某中间，然后我们干嘛
list4 = [name+1 for name in range(1, 101) if name % 4 == 0 and name % 6 == 0]
print(list4)

迭代器

# 通过不同得可迭代对象可以转换为迭代器，但是对象本质不同
# 可迭代对象  实现了iter()这个方法
# 迭代器对象  实现了 next()、iter()方法
list1 = [1, 2, 3, 4, 5]
tuple1 = (1, 2, 3, 4, 5)
iterate = iter(list1)  # list_iterator
iterate = iter(tuple1)  # tuple_iterator
# print(itra)
# print(itra1)
list2 = [i for i in itra]
print(list2)
print(next(itra))
# list3 = [i for i in itra]
# print(list3)
# print(next(itra))

# 迭代器可以完成得事情，生成器都可以完成，而且生成器更加得灵活

print('ssssss%s' % 'ha')


class A(object):
    def __init__(self):
        self.a = 1

    def __iter__(self):
        return self

    def next(self):
        pass

生成器

# 方法一：推导式的方式获得
# 得到从1-100之间得到能整除4的列表
# list1 = [i for i in range(1, 101) if i % 4 == 0]
# print(list1)
# gen = (i for i in range(1, 101) if i % 4 == 0)
# print(gen, type(gen))   # generator 生成器
# 生成器是一个特殊的迭代器， 是一种容器, 数据取完了就没了， 如果没取完，生成器会记住上次取数据的位置，下次你在取得时候，就会从这个位置开始取数据
print(next(gen))
# print(next(gen))
# print(next(gen))
# print(next(gen))
# list1 = [i for i in gen]
# print(list1)
# print(next(gen))
# print(len(gen))
# list1 = [i for i in gen]
# print(list1)

# 使用函数得方式来得到生成器  yield

# 函数只要有调用，就会进入到函数内部执行程序  没有return打印一个None
# 但是，此时，这个函数已经不是一个函数了，它变成了一个生成器


def fun():

    def fun1():
        pass
    i = 0
    while True:
        i += 1
        yield i  # yield和return有同样得返回得效果, yield有阻塞程序得效果
        print(i)


r = fun()
# print(r)
print(next(r))
print(next(r))
print(next(r))

list()

作业

# 请使用装饰器实现已存在的函数的执行所花费的时间。

import time


def get_time(fn):
    def fun_inner():
        begin = time.time()
        fn()
        end = time.time()
        print('函数得执行时间为%s' % (end - begin))

    return fun_inner


@get_time
def fun():
    for i in range(20000000):
        pass


fun()