生成器迭代器推导式

Posted 2020-11-28 saoqiang

可迭代对象和迭代器

# 可以进行循环更新的一个实实在在值。
# 如何判断一个对象是否是可迭代对象： 利用内置函数：dir()可以查看对象内部方法
# 有__iter__方法的对象，都是可迭代对象。
# print('__iter__' in dir(str))


# 如何判断一个对象是迭代器： 可更新迭代的工具
# 在python中，内部含有'__iter__'方法并且含有'__next__'方法的对象就是迭代器。
# print('__iter__' in dir(str) and '__next__' in dir(str))

# 可迭代对象转化成迭代器：
# 利用内置函数iter()
# obj = iter(l1)
# object.__iter__()

# 迭代器可以迭代取值。利用next()进行取值（节省内存）或者转为list 元祖等等取值
# 一个next()取一个值 且会记录位置
# 迭代器一条路走到底，不走回头（记录位置）。
# 取完了再next()会报错(StopIteration) 我们可以用try处理 万能异常（Exception）

while模拟for循环

s = 'gkffdsa;lfkdsk;lafkds;laldgjfd'
obj = iter(s)
while 1:
    try:
        print(next(obj))
    except StopIteration:
        break

可迭代对象与迭代器的对比

• 可迭代对象是一个操作方法比较多，比较直观，存储数据相对少（几百万个对象，8G内存是可以承受的）的一个数据集。
• 当你侧重于对于数据可以灵活处理，并且内存空间足够，将数据集设置为可迭代对象是明确的选择。
• 是一个非常节省内存，可以记录取值位置，可以直接通过循环+next方法取值，但是不直观，操作方法比较单一的数据集。
• 当你的数据量过大，大到足以撑爆你的内存或者你以节省内存为首选因素时，将数据集设置为迭代器是一个不错的选择。

小练习
https://www.cnblogs.com/saoqiang/p/11402159.html

生成器

# return作用 返回值 单个或多个 终止函数
# 结束函数，给函数的执行者返回值(多个值通过元组的形式返回)。
# 将return换为yield就是生成器函数
# 只要函数中出现了yield那么他就不是函数，它是生成器函数。
# 不结束函数，对应着给 next 返回值(多个值通过元组的形式返回)。 会记录位置
def func():
    yield 2,4,5
    print(11)
    yield 3
    print(22)
    print(33)
    yield 4
    yield 5
ret = func()  # 生成器对象
# print(ret)
# print(next(ret))
# print(next(ret))
# print(next(ret))
# yield : 对应next给next返回值

yield from

# yield from 将一个可迭代对象的每一个元素返回给next
# yield from 节省代码，提升效率（代替了for循环）
# def func():
#     l1 = [1, 2, 3]
#     yield from l1#就是下面的简写
#     '''
#     yield 1
#     yield 2
#     yield 3
#     '''
# ret = func()
# print(next(ret))

出错题

def eat_baozi_gen():
    for i in range(1,5):
        yield f'{i}号包子'
        print(11)
ret1 = eat_baozi_gen()
for i in ret1:
    print(i)

生成器表达式，列表推导式

# 两种构建方式：
# 1.循环模式： [变量(加工后的变量) for 变量 in iterable]
# print([i**2 for i in range(1, 11)])
# 2.筛选模式： [变量(加工后的变量) for 变量 in iterable if 条件]
# print([i**2 for i in range(1, 11)])

# 列表推导式的优缺点：
# 优点：
    # 1， 简单，快捷，装b。
# 缺点：
    # 2. 可读性不高，不好排错。
# 慎用，不要入迷。

# 生成器表达式： 小括号
# 与列表推导式几乎一模一样。
# 循环模式，筛选模式。
# obj = (i for i in range(1, 11))
# 字典推导式，集合推导式：  两种模式： 循环模式，筛选模式
l1 = ['小潘', '怼怼哥','西门大官人', '小泽ml亚']
# {0： '小潘', 1： '怼怼哥', 2: '西门大官人'}
# dic = {}
# for index in range(len(l1)):
#     dic[index] = l1[index]
# print(dic)
# print({i:l1[i] for i in range(len(l1))})

匿名函数

一句话函数 一般与内战函数结合

# 匿名函数：没有名字的函数
# 匿名函数只能构建简单的函数，一句话函数。
# func2 = lambda 形参: 返回值
# func2 = lambda x,y: x + y

面试题

i改变了指向
func_list = []
for i in range(10):
    func_list.append(lambda x:x+i)
v1 = func_list[0](2)
v2 = func_list[5](1)
print(v1,v2)

func_list = []
for i in range(10):
    func_list.append(lambda x:x+i)
for i in range(0,len(func_list)):
    result = func_list[i](i)
    print(result)
 
 
 
result = []
for i in range(10):
    func = lambda : i      # 注意：函数不执行，内部代码不会执行。
    result.append(func)
print(i)#9
print(result)
v1 = result[0]()
v2 = result[9]()
print(v1,v2)

def func(num):
    def inner():
        print(num)
    return inner
result = []
for i in range(10):
    f = func(i)
    result.append(f)
print(i)
print(result)
v1 = result[0]()
v2 = result[9]()
print(v1,v2)

如 10.3.9.12 转换规则为二进制：
        10            00001010
         3            00000011
         9            00001001
        12            00001100
再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？
# IP地址转换为int
# 思路IP按照split进行分隔成4个部分,然后每个部分都转换为二进制类型.
# 然后将这些二进制进行拼接成一个32位的大的二进制字符串.
# 最后将这个二进制数,转换成对应的int类型
def ipToInt(ip_str):
    # 分隔
    ip_list = ip_str.split('.')
    # 拼接
    bin_str = ""
    # 遍历,然后求出每一个二进制数,(注意切割,舍弃0b),还要把它弄成8位.再相加
    for i in ip_list:
        part = bin(int(i))[2:]
        # 将part前面补充0
        part = part.zfill(8)
        bin_str += part
    # 最后将这个二进制数转换为整数
    ip_int = int(bin_str, 2)
    return ip_int
    

v = [lambda :x for x in range(10)]
print(v)
print(v[0])
print(v[0]())

v = (lambda :x for x in range(10))
print(v)
print(next(v))
print(next(v)())

def num():
    return [lambda x:i*x for i in range(4)]
print([m(2)for m in num()])