python学习日记(迭代器、生成器)-乱七八糟

迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器：

 dir():

　　dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。

print(dir([]))
print(dir())

iterable,可迭代的。

只要是能够被for 循环的数据类型，就一定拥有__iter__方法。使用了此方法之后，就变成了迭代器。

可迭代对象含有iter()方法,但不一定含有next()方法，迭代器包含二者。__next__方法可以一个一个的获取值。

s = 's1'
x = s.__iter__()#iter方法创建的是迭代器
# x = iter(s)
print(x)
print(x.__next__())#next方法输出迭代器的下一个元素
print(next(x))

如果没有了下一个元素，会引发异常

可迭代对象：有__iter__方法、无__next__方法

迭代器：既有__iter__方法、也有__next__方法

s = '123'#可迭代对象
print('__iter__' in set(dir(s)))
print('__next__' in set(dir(s)))
s1 = s.__iter__()#迭代器
print('__iter__' in dir(s1))
print('__next__' in dir(s1))

附加：1、

from collections import Iterable
from collections import Iterator
print(isinstance([],Iterator))#sinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
print(isinstance([],Iterable))

　　2、

from collections import Iterable
from collections import Iterator
class A:
    def __iter__(self):pass
    def __next__(self):pass

a = A()
print(isinstance(a,Iterator))#sinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
print(isinstance(a,Iterable))

　　3、

from collections import Iterable
from collections import Iterator
class A:
    # def __iter__(self):pass
    def __next__(self):pass

a = A()
print(isinstance(a,Iterator))#sinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
print(isinstance(a,Iterable))

只有是可迭代对象才能用for；

当我们遇到一个变量，不确定是否能够for循环，可以判断其是否可迭代。

x = False
y = 123
z = (1,2,3)
print('__iter__' in dir(x))
print('__iter__' in dir(y))
print('__iter__' in dir(z))

附加1：

li = [1,2,3,4]
li1 = [1,2,3]

# print(li - li1)#列表与列表无法直接相减，转换成集合
print(set(li)-set(li1))
print(list(set(li)-set(li1)))

附加2：enumerate(枚举)

li = [1,2,3,4]
print(list(enumerate(li)))
print(tuple(enumerate(li)))

附加3：

import sys#引入sys模块
li = [1,2,3,4]
it = iter(li)#创建迭代器对象
for i in it:
    try:
        print(i)
    except StopIteration:#异常处理
        sys.exit()

迭代器的优点：

　　从容器类型中一个一个的取值，会把所有的值都取到；

　　节省内存空间

　　　　迭代器并不会在内存中占用一大块内存，而是随着循环，每次生成一个。（next）

生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

调用一个生成器函数，返回的是一个迭代器对象。

def generator():
    for i in range(2000000):
        i = 'happy day%s'%i
        yield i
x = generator()#返回的是一个迭代器
print(x)
print(x.__next__())
print(x.__next__())
print(x.__next__())

1、

def generator():
    for i in range(2000000):
        i = 'happy day%s'%i
        yield i
x = generator()#返回的是一个迭代器
s = 0
for i in range(200):
    if s < 2:
        print(x.__next__())
        s += 1
print('ooooooo',x.__next__())

2、

def generator():
    for i in range(2000000):
        i = 'happy day%s'%i
        yield i
x = generator()#返回的是一个迭代器
s1 = 0
for j in x:
    print(j)
    if s1 < 2:
        s1 += 1
    else:break#不break，就会一直print
print('ooooooo', x.__next__())

附加1：斐波那契数列

def f(num):
    n,a,b = 0,0,1
    while n < num:
        print(b,end=' ')
        a,b = b,a+b
        n += 1
f(5)

附加2：斐波那契数列

import sys
def fei(num):
    n,a,b = 0,0,1
    while True:
        if n >= num:
            return
        a,b = b,a+b
        n += 1
        yield b
x = fei(5)#返回的是一个迭代器
print(x)
while True:
    try:
        print(next(x),end='  ')
    except StopIteration:
        sys.exit()

监听文件输入：动态输入、动态监听

动态向文件中输入新内容，会输出新内容，并且你可以做筛选之类。

def sea(file):
    f = open(file,encoding='utf-8')
    while True:
        line = f.readline()
        if line.strip():#每次输入新内容的回车去掉,不然会有空行
           yield line.strip()#每次输入新内容的回车去掉,不然会有空行
g = sea('test')#创建的文件
for i in g:
    # if '你想查找的内容' in g:
        print(i)

pass