标签搜索

目 录CONTENT

文章目录

Python的列表推倒式、生成器及迭代器.md

小小城
2021-08-22 / 0 评论 / 0 点赞 / 4 阅读 / 7,541 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2022-05-02,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

Python的列表推倒式、生成器及迭代器

@[toc]

一、列表推倒式

从母鸡下蛋的故事讲起

1 老母鸡 = ('鸡蛋%s'%i for i in range(10))
2 print(老母鸡)
3 for 蛋 in 老母鸡:
4     print(蛋)
5 g = (i*i for i in range(10))
6 for i in g:
7     print(i)
  •  ①把列表解析的[]换成()得到的就是生成器表达式
  •  ②列表解析与生成器表达式都是一种便利的编程方式,只不过生成器表达式更加节省内存空间
  •  ③Python不但使用迭代器协议,让for循环变得更加通用。大部分内置函数,也是使用迭代器协议访问对象的。

  例如sum函数是python的内置函数,该函数使用迭代器协议访问对象,而生成器实现了迭代器协议。

1 sum(i*2 for i in range(4))

1.列表推导式

 例一:30以内所有能被3整除的数  

1 # 列推导式
2 # [满足条件的元素相关的操作 for 元素 in  可迭代数据类型 if 元素相关的条件]
3 # 30以为所有能被3整除的数字
4 print([i for i in range(30) if i%3 == 0]) # 完整的列表推导式
例二:30以内所有能被3整除的数的平方

1 # 30以为所有能被3整除的平方
2 print([i*i for i in range(30) if i%3 == 0]) # 完整的列表推导式
例三:找到嵌套列表中名字包含‘e’的所有名字

1 # 找到嵌套列表中名字中含有'e'的所有名字
2 names = [['Tom','Billy','Jefferson','Andrew','Wesley','Steven','Joe'],
3         ['Alice','Jill','Ana','Wendy','Jennifer','Sherry','Eva']]
4 ret = [name for lst in names for name in lst if name.count('e') == 2]
5 print(ret)

2.字典推导式

例一:将一个字典的key和value对调

1 # 将一个字典的key和value对调
2 mcase = {'a':10,'b':34}
3 mcase_frequency = {mcase[k]:k for k in mcase}
4 print(mcase_frequency)

例二:合并大小写对应的value值,讲key统一成大写

1 # 合并大小写对应的value值,将key统一成小写
2 # {'a':10+7,'b':34,'z':3}
3 mcase = {'a':10,'b':34,'A':7,'Z':3}
4 mcase_frequency = {k.lower():mcase.get(k.lower(),0)+mcase.get(k.upper(),0) for k in mcase}

3.集合推导式

例子:计算列表中每个值的平方,自带去重复的功能

1 # 集合推导式 自带去重功能
2 squared = {x**2 for x in [1,-1,2]}
3 print(squared)

二、生成器

  •  通过列表生成式,我们可以直接创建一个列表。但是,受到内存限制,列表容量肯定是有限的。而且,创建一个包含100万个元素的列表,不仅占用很大的存储空间,
  •  如果我们仅仅需要访问前面几个元素,那后面绝大多数元素占用的空间都白白浪费了
  •  所以,如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素呢?
  •  这样就不必创建完整的list,从而节省大量的空间。在Python中,这种一边循环一边计算的机制,称为生成器:generator。
  •  要创建一个generator,有很多种方法。第一种方法很简单,只要把一个列表生成式的[]改成(),就创建了一个generator

生成器的创建方式

  1. 类似于列表生成式
  2. 函数中使用yield关键字

函数有了yield之后

  1. 函数调用之后就得到了一个生成器,
  2. return 在生成器里,代表生成器的中止,直接报错
  3. yield的作用是:返回数据 ,并冻结(暂停)当前的执行过程 ,下一次从暂停处继续执行

类似于列表生成式创建

L = [x * x for x in range(10)]
gen_L = (x * x for x in range(10))  # 生成器存放计算公式

print(L)
print(gen_L)
print(next(gen_L))  # 取值
print(next(gen_L))

"""
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
<generator object <genexpr> at 0x0000000001DFDF10>  generator 就是生成器的意思
0
1
"""
  •  generator保存的是算法,每次调用next(g)就计算出g的下一个元素的值,直到计算到最后一个元素,没有更多的元素时,抛出StopIteration的错误,不调next函数并不会生层元素,就会节省内存,使用for循环可以解决异常
g = (x * x for x in range(10))
for n in g:
    print(n)
  •  generator非常强大。如果推算的算法比较复杂,用类似列表生成式的for循环无法实现的时候,还可以用函数来实现。
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print('before yield')
        yield b  # 把函数的执行过程冻结在这一步,并且把b的值 返回给外面的next()
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

f = fib(15)  # turn function into a generator
next(f)  # first time call next()  next 唤醒冻结的函数执行过程,继续执行,直到遇到下一个yield
next(f)  # first time call next()

"""
before yield
1
before yield
"""

注意a, b = b, a + b 相当于

a, b = 0, 1
a, b = b, a + b
print(a, b)
a, b = 0, 1
t = a
a = b
b = t + b
print(a, b)

"""
1 1
1 1
"""

函数方式创建

def range2(n):

    count = 0
    while count < n :
        print(count)
        stop_flag = yield count #中断并返回
        
        return count
        if stop_flag == 'stop':
            print('stop iteration...')
            break
        count += 1

b = range2(5) # 得到生成器
next(b)
next(b)
"""
0
Traceback (most recent call last):
  File "C:/Users/jingjing/PycharmProjects/py3Project", line 53, in <module>
    next(b)
StopIteration: 0
"""

生成器常用方法

next()  # 唤醒生成器并继续执行
send("stop") 
"""
1. 唤醒并继续执行
2. 发送一个信息到生成器内部
注意生成器在刚开始,函数没有执行到yield成为挂起状态时,不能调用send("stop") 
只能send('None')相当于next()使函数执行到yield
"""

send方法使用举例

send方法第一次调用必须传递一个None参数,后续才可以传递自定义参数

def range2(n):

    count = 0
    while count < n:
        print('count', count)
        count += 1
        sign = yield count  # return
        if sign == 'stop':
            print("---sign", sign)
            break
        print('sin...', sign)
    return 3333

new_range = range2(3)

next(new_range)
new_range.send(None)
new_range.send("stop")
"""
count 0
sin... None
count 1
---sign stop
Traceback (most recent call last):
  File "C:/Users/jingjing/PycharmProjects/py3Project.py", line 22, in <module>
    new_range.send("stop")
StopIteration: 3333
"""

生产者与消费者问题

import time


def consume(name):
    print("%s 准备吃包子啦!" % name)
    while True:
        y = yield
        print("包子[%s]来了,被[%s]吃了!" % (y, name))


def producer(name):
    c = consume(name)
    next(c)  # 函数执行到yield
    for i in range(1, 3):
        time.sleep(1)
        print("做了{}个包子!".format(i))
        c.send(i)  # 把i传到yield


producer('qian')

"""
qian 准备吃包子啦!
做了1个包子!
包子[1]来了,被[qian]吃了!
做了2个包子!
包子[2]来了,被[qian]吃了!
"""

日志记录

def logger(filename):
    """
    日志方法
    :param filename: log filename 
    :param channel:  输出的目的地,屏幕(terminal),文件(file),屏幕+文件(both)
    :return: 
    """
    print('start logger')
    while True:
        msg = yield
        print("msg", msg)


l = logger('USER.TXT')
l.__next__()

l.send('hi')
l.send('hi,file')

计算移动平均值

# 必须先用next再用send
def average():
    total=0 #总数
    day=0 #天数
    average=0 #平均数
    while True:
        day_num = yield average   #average=0
        print('average', average)
        total += day_num
        day += 1
        average = total/day
avg=average() #直接返回生成器
next(avg)#激活生成器,avg.send(None),什么都不传的时候send和next的效果一样
print(avg.send(10))
print(avg.send(20))#send   1.传值 2.next
print(avg.send(30))
"""
average 0
10.0
average 10.0
15.0
average 15.0
20.0
"""

带装饰器的计算移动平均值

# 让装饰器去激活
def wrapper(func):
    def inner(*args, **kwargs):
        print('execute wrapper')
        a = func(*args, **kwargs)
        next(a)
        return a
    return inner


@wrapper
def average():
    total=0 #总数
    day=0 #天数
    average=0 #平均数
    while True:
        day_num = yield average   #average=0
        print('average', average)
        total += day_num
        day += 1
        average = total/day

avg = average()
print(avg.send(10))
print(avg.send(20))#send   1.传值 2.next
print(avg.send(30))
"""
execute wrapper
average 0
10.0
average 10.0
15.0
average 15.0
20.0
"""

yield from

def gen1():
    for c in 'AB':
        yield c
    for i in range(3):
        yield i
print(gen1())
print(list(gen1()))

def gen2():
    yield from 'AB'  # 相当于  for c in 'AB': yield c
    yield from range(3)
print(gen2())
print(list(gen2()))

处理异常

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print('before yield')
        yield b  # 把函数的执行过程冻结在这一步,并且把b的值 返回给外面的next()
        a, b = b, a + b
        n = n + 1
    return 'done'


g = fib(6)
while True:
    try:
        x = next(g)
        print('g:', x)
    except StopIteration as e:
        print('Generator return value:', e.value)
        break

三、迭代器

可迭代对象与迭代器

  1. 迭代:可以将某个数据集内的数据“一个挨着一个的取出来”,就叫做迭代。就像for循环一样取值。

  2. 可迭代协议:可以被迭代要满足要求的就叫做可迭代协议。内部实现了__iter__方法

  3. iterable:可迭代的------对应的标志

  4. 字符串、列表、元组、字典、集合都可以被for循环,说明他们都是可迭代的

  5. 可以使用isinstance()判断一个对象是否是Iterable对象

  6. 可以被next函数调用并且返回下一个值的对象叫迭代器

from collections import Iterable

print(isinstance([], Iterable))
print(isinstance(123, Iterable))
print(isinstance('345', Iterable))
# """
# True
# False
# True
# """

可迭代和迭代器区别

1. 区别:

  •  可迭代的结构并不代表一定是一个迭代器,如:列表是可迭代的但不是迭代器;生层式是可迭代的也是迭代器
  •  可以通过系统函数iter()将一个可迭代的结构变成一个迭代器

2.迭代器:

生成器不但可以作用于for循环,还可以被next()函数不断调用并返回下一个值,直到最后抛出StopIteration错误表示无法继续返回下一个值了

  •  迭代器协议:内部实现了__iter__,__next__方法。

3. 迭代器的优点

如果用了迭代器,节约内存,方便操作,生成器是一种特殊的迭代器(Iterator)

4.相同点与不同点:

  •  可迭代和迭代器的相同点:都可以用for循环
  •  可迭代和迭代器的不同点:就是迭代器内部多实现了一个__next__方法

5.判断迭代器和可迭代的方法

  •  第一种:判断内部是不是实现了__next__方法
  •  print('next' in dir(range(12))) #查看'next'是不是在range()方法执行之后内部是否有__next__
  •  print('iter' in dir(range(12))) #查看'next'是不是在range()方法执行之后内部是否有__next__
  •  第二种:
  •  Iterable 判断是不是可迭代对象
  •  Iterator 判断是不是迭代器
from collections import Iterable  
from collections import Iterator

#比如给一个字符串
s='abc'
print(isinstance(s,Iterable))#isinstance判断类型的
print(isinstance(s,Iterator))

判断range函数和map函数

在这里插入图片描述

深入了解Iterator对象

生成器都是Iterator对象,但list、dict、str虽然是Iterable,却不是Iterator。

把list、dict、str等Iterable变成Iterator可以使用iter()函数:

在这里插入图片描述

你可能会问,为什么list、dict、str等数据类型不是Iterator?

  •  这是因为Python的Iterator对象表示的是一个数据流,Iterator对象可以被next()函数调用并不断返回下一个数据,
  •  直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列,但我们却不能提前知道序列的长度,
  •  只能不断通过next()函数实现按需计算下一个数据,所以Iterator的计算是惰性的,只有在需要返回下一个数据时它才会计算。
  •  Iterator甚至可以表示一个无限大的数据流,例如全体自然数。而使用list是永远不可能存储全体自然数的。

迭代器小结

  •  凡是可作用于for循环的对象都是Iterable类型;
  •  凡是可作用于next()函数的对象都是Iterator类型,它们表示一个惰性计算的序列;
  •  集合数据类型如list、dict、str等是Iterable但不是Iterator,不过可以通过iter()函数获得一个Iterator对象。
  •  Python3的for循环本质上就是通过不断调用next()函数实现的,例如:
for x in [1, 2, 3, 4, 5]:
    pass
等价于

复制代码
# 首先获得Iterator对象:
iter_object  = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(iter_object)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

0

评论区