迭代器
1.说明是迭代器（iter）
迭代器就是容器型数据类型，只能通过类型转换和生成器来获得迭代器对象

迭代器存储数据的特点：同时可以保存多个数据，没有办法直接查看，而是需要先将数据从迭代器中取出来，取出来后不能再放进去

所有的容器都可以转换成迭代器
iter1 = iter([1,2,3,4])
print(iter1)

iter2 = iter('abc')
print(iter2)

iter3 = iter({'a':1})
print(iter3)
2. 获取迭代器中的元素
无论通过什么样的方式，只要将迭代器中的某个元素拿到了，那么这个元素在迭代器中就不存在了
list1 = list(iter1)
print(list1)
list2 = list(iter1)
print(list2)
1) 遍历
iter5 = iter('hello')
for i in iter5:
    print(f'x:{i}')
2) 获取单个元素
next - 获取迭代器中的一个元素（当前最前面的那个元素）

迭代器对象.next（）- 获取迭代器中的一个元素（当前最前面的元素）
iter6 = iter('hello')
print(next(iter6))
print(next(iter6))
print(next(iter6))
print(next(iter6))
print(next(iter6))

迭代器
1、什么是迭代器
​	  迭代器指的是迭代取值的工具，迭代是一个重复的过程，每次重复都是基于上一次的结果而继续的，单纯的重复并不是迭代
2、迭代器应用场景
​    迭代器是用来迭代取值的工具，优点在于能够不依赖与索引进行循环取值
3、迭代器的使用
可迭代对象
# 凡是内置有__iter__方法的都称之为可迭代对象
# 调用可迭代对象下的__iter__方法会将其转换成迭代器对象
# 常见的可迭代对象包括：列表、字符串、元组、集合、字典、文件

迭代器方法遍历字典
#!/usr/bin/env python3
# -*- coding:utf-8 -*-


dic = {
	'a': 1,
	'b': 2,
	'c': 3
}
dic_iter = dic.__iter__()

while True:
	try:
		print(dic_iter.__next__())
	except StopIteration:
		break


迭代器与for循环的工作原理
for循环工作原理：
1. 调用对象下的__iter__()方法得到一个迭代器对象
2. 调用迭代器对象下的__next__()方法拿到一个返回值,然后赋值
3. 循环往复步骤2，直到抛出异常StopIteration，捕捉异常然后结束循环


即for循环是上部分代码实现的功能的简化

迭代器优缺点
**优点：**1、可以遍历无索引数据	2、节省内存(同一时间内存中只有调用时的值)
**缺点：**1、无法如索引取值一样精准定位取值	2、生命周期短(取完即销毁)
生成器（yield）
1、什么是生成器
​	生成器是自定义的迭代器，本质就是生成器
​	在函数内一旦存在yield关键字，调用函数并不会执行函数体代码，会返回一个生成器对象
2、生成器应用场景
​	将函数挂起，适用于大多数并发编程中
3、生成器案例
基础生成器案例
#!/usr/bin/env python3
# -*- coding:utf-8 -*-


def my_range(begin, end, step=1):
	print('start...')
	while begin < end:
		yield begin
		begin += step
	print('over...')


gen = my_range(1, 10)
for i in my_range(1, 10):
	print(i)



生成器用法一
通过yield挂起函数为函数内部变量传值
#!/usr/bin/env python3
# -*- coding:utf-8 -*-


# 生成器用法一： 通过yield挂起函数为函数内部变量传值
def shopping(name):
	print('{}去商场扫货啦！'.format(name))
	while True:
		good = yield
		print('{}把{}买下来啦！'.format(name, good))


fan = shopping('小范')    # 获取生成器对象
fan.send(None)      # 初始化，将函数挂起，yield开始等待接受值
fan.send('耐克球鞋')    # 传入值给yield 再通过yield赋值给good
fan.send('旺仔牛奶')    # 传入值给yield 再通过yield赋值给good


生成器用法二： 通过yield挂起函数并返回值
#!/usr/bin/env python3
# -*- coding:utf-8 -*-

def shopping(name):
	good_list = []
	print('{}去商场扫货啦！'.format(name))
	while True:
		good = yield good_list
		print('{}把{}买下来啦！'.format(name, good))
		good_list.append(good)


fan = shopping('小范')  # 获取生成器对象
res = fan.send(None)  # 初始化，将函数挂起，yield开始等待接受值
print('现在购物车里有:{}'.format(res))
res = fan.send('耐克球鞋')  # 传入值给yield 再通过yield赋值给good 最后通过res接受yield的返回值
print('现在购物车里有:{}'.format(res))
res = fan.send('旺仔牛奶')  # 传入值给yield 再通过yield赋值给good 最后通过res接受yield的返回值
print('现在购物车里有:{}'.format(res))

迭代器
  什么是迭代器
  迭代器是访问可迭代对象的工具
  迭代器是指iter(obj)函数返回的对象(实例)
  迭代器可以用next(it)函数获取可迭代对象的数据
迭代器函数iter和next
iter(iterable)从可迭代对象中返回一个迭代器
Iterable，必须能提供一个可迭代对象
next(Iterator)从迭代器中获取下一个记录，如果无法获取下一条记录则触发stopiterator异常
说明
1.迭代器只能往前取值，不会后退
2.用iter函数可以返回一个可迭代对象的迭代器
实例
>>> l=[1,2,3,45,6,7,9]
>>> i=iter(l)
>>> next(i)
1
>>> next(i)
2
>>> next(i)
3
>>> next(i)
45
>>> next(i)
6
>>> next(i)
7
>>> next(i)
9
>>> next(i)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> 


迭代器的用途
  用迭代器可以依次访问可迭代对象的数据
  l=[1,2,34,5]
  for i in l :
  	print(x)
>>> l=[1,2,34,5]
>>> it=iter(l)
>>> while True:
	try:
		
		x=next(it)
		print(x)
	except StopIteration:
		break

	
1
2
34
5
s={'唐僧','悟空','八戒','沙僧'}
it=iter(s)
while True:
    try:
        print(next(it))
    except StopIteration:
        break

生成器
什么是生成器
生成器是能够动态提供数据的对象，生成器对象也是可迭代对象
生成器有两种
1生成器函数
2生成器表达式
生成器函数的定义
含有yield语句的函数是生成器，此函数被调用将返回一个生成器对象
yield  翻译为产生(或生成)
yield 语句
语法 yield

说明：
    yield 用于def 函数中目的是将此函数作用生成器函数使用yield
    用来生成数据，供迭代器和next(it)函数使用
把生成器变成迭代器
def gen():
    for i in range(20):
        print('qqqq')
        yield i

gen1=gen()

it=iter(gen1)

while True:
    try:
        print(next(it))
    except StopIteration:
        break


def gen():
    for i in range(20):
        print('qqqq',i)
        yield gen()
for i in gen():
    print(i)
    qqqq 0
<generator object gen at 0x7fc294b04f10>
qqqq 1
<generator object gen at 0x7fc294b04f68>
qqqq 2
<generator object gen at 0x7fc294b04f10>
qqqq 3
<generator object gen at 0x7fc294b04f68>
qqqq 4
<generator object gen at 0x7fc294b04f10>
qqqq 5
<generator object gen at 0x7fc294b04f68>
qqqq 6
<generator object gen at 0x7fc294b04f10>
qqqq 7
<generator object gen at 0x7fc294b04f68>
qqqq 8
<generator object gen at 0x7fc294b04f10>
qqqq 9
<generator object gen at 0x7fc294b04f68>
qqqq 10
<generator object gen at 0x7fc294b04f10>
qqqq 11
<generator object gen at 0x7fc294b04f68>
qqqq 12
<generator object gen at 0x7fc294b04f10>
qqqq 13
<generator object gen at 0x7fc294b04f68>
qqqq 14
<generator object gen at 0x7fc294b04f10>
qqqq 15
<generator object gen at 0x7fc294b04f68>
qqqq 16
<generator object gen at 0x7fc294b04f10>
qqqq 17
<generator object gen at 0x7fc294b04f68>
qqqq 18
<generator object gen at 0x7fc294b04f10>
qqqq 19
<generator object gen at 0x7fc294b04f68>
0
1
2
3
4
5
6
7
8
9
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99]
生成器函数的说明
生成器函数的调用将返回一个生成器对象
生成器对象是一个可迭代对象
通常用来动态生成数据
生成器函数调用return 会触发一个StopIteration异常
def myrange(start,stop,step=1):
    while start<stop-1:
        start+=step
        yield start
for x in myrange(0,30,2):
    print(x)
l=[x**2 for x in myrange(0,30)]
print(l)
2
4
6
8
10
12
14
16
18
20
22
24
26
28
30
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841]
def jiecheng(n):
    for i in range(1,n+1):
        x=1
        for j in range(1,i+1) :
            x*=j
        yield x
l=list(jiecheng(5))
print(l)

生成器表达式
语法
（表达式 for i in 可迭代对象 [if 真值表达式]）
作用：
用推导式创建一个新生成器
说明
if 可以省略

>>> gen=(x**2 for x in range(1,5) )
>>> it=iter(gen)
>>> print(next(it))
1
>>> print(next(it))
4
>>> print(next(it))
9
>>> print(next(it))
16
>>> print(next(it))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> 
# def pingfangjianyi(n):
#     i=1
    
#     while  i<n:
#         s=0
#         s=i**2+1
#         i+=1
#         yield s
# for i in pingfangjianyi(10):
#     print(i)

def pingfangjianyi():
    l=[2,3,5,7]
    for j in l :
        s=0
        s=j**2+1
   
        yield s
for i in pingfangjianyi():
    print(i)





l=[2,3,5,7]
l1=(x**2+1 for x in l )
print(list(l1))
l2=[i**2+1 for i in l]
print(l2)



生成器表达式和列表推导式的区别
就是生成器只能迭代一次
且现用现生成
而列表生成静态数据
l=[2,3,5,7]
l1=(x**2+1 for x in l )
l[1]=8
print(list(l1))


l=[2,3,5,7]
l2=[i**2+1 for i in l]
l[1]=8
print(l2)


[5, 65, 26, 50]
[5, 10, 26, 50]


迭代工具函数
作用是生成一个个性化的可迭代对象
函数 zip(iter1[,iter2[......]])
返回一个zip对象此对象用于生成元组，
该元组的每个数据来源于参数中的可迭代对象当最小的可迭代对象向不在提供数据
时迭代结束
enumerate(iterable[,start])
生成带索引的枚举对象
返回对象为索引值(index-value)
默认索引从零开始
也可以用start
指定
enumerate(sequence, start=0)


def hanshu():
    l=[]
    while True:
        x=input('亲输入')



        if x=='':
            break
        l.append(x)

    for s in enumerate(l,1):
        print('第%s行：'%s[0],s[1])
hanshu()

Python迭代器及自定义迭代器

一、可迭代对象

在Python中，对list、tuple、str等类型的数据可以使用for...in...的循环语法，从其中依次拿到数据进行使用，我们把这样的过程称为遍历，也叫迭代。

在Python的基本数据类型中，列表、元组、字符串、字典都是可迭代的，而整数、浮点数、布尔数都是不可迭代的。

list_a = [1, 2, 3]
for a in list_a:
    print(a, end=' ')

tuple_b = ('a', 'b', 'c')
for b in tuple_b:
    print(b, end=' ')

str_c = 'AKQJ'
for c in str_c:
    print(c, end=' ')

dict_d = {'BJ': '北京', 'SH': '上海', 'GZ': '广州', 'SZ': '深圳'}
for d in dict_d:
    print(d, end=' ')

运行结果：

1 2 3 a b c A K Q J BJ SH GZ SZ 

在Python中，把可以通过for...in...这类语句迭代，读取一条数据供我们使用的对象称之为可迭代对象（Iterable）。列表、元组、字符串、字典都是可迭代对象。

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

from collections.abc import Iterable

print(isinstance(list_a, Iterable))

运行结果：

True

二、可迭代对象的本质

对可迭代对象进行迭代使用的过程，每迭代一次（即在for...in...中每循环一次）都会返回对象中的下一条数据，一直向后读取数据直到迭代了所有数据后结束。

在这个过程中，我们需要知道每次访问到了第几条数据，以便下一次迭代返回的是下一条数据，不会跳过或者重复返回数据。Python帮我们实现了这个功能，这个功能就是迭代器(Iterator)。

可迭代对象的本质就是提供一个迭代器帮助我们对其进行迭代遍历使用。那Python是怎么实现这些功能的呢？

在Python中，可迭代对象通过__iter__方法向我们提供一个迭代器，在迭代一个可迭代对象的时候，实际上就是先获取该对象提供的一个迭代器，然后通过这个迭代器来依次获取对象中的每一个数据。

可迭代对象是一个具备了__iter__方法的对象，通过__iter__方法获取可迭代对象的迭代器。

 三、iter()函数与next()函数

列表、元组、字符串、字典等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器。然后我们可以对获取到的迭代器不断使用next()函数来获取下一条数据。

list_b = ['ppp', 'yyy', 'ttt', 'hhh', 'ooo', 'nnn']
iterator_b = iter(list_b)
print(next(iterator_b))
print(next(iterator_b))
print(next(iterator_b))
print(next(iterator_b))
print(next(iterator_b))
print(next(iterator_b))

运行结果：

ppp
yyy
ttt
hhh
ooo
nnn

iter(iterable)函数是把可迭代对象的迭代器取出来，内部是调用可迭代对象的__iter__方法，来取得迭代器的。

next(iterator)函数是通过迭代器取得下一个位置的值，内部是调用迭代器对象的__next__方法，来取得下一个位置的值。

当我们已经迭代完最后一个数据之后，再次调用next()函数会抛出StopIteration的异常，来告诉我们所有数据都已迭代完成，不用再执行next()函数了。

for item in Iterable 循环的本质就是先通过iter()函数获取可迭代对象Iterable的迭代器，然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration的异常后循环结束。

四、迭代器Iterator

通过上面的分析，我们已经知道，迭代器用来帮助我们记录每次迭代访问到的位置，当我们对迭代器使用next()函数的时候，迭代器会向我们返回它所记录位置的下一个位置的数据。

在使用next()函数的时候，调用的是迭代器对象的__next__方法。所以，我们要想构造一个迭代器，就要实现它的__next__方法。

同时，python要求迭代器本身也是可迭代的，所以我们还要为迭代器实现__iter__方法，而__iter__方法要返回一个迭代器，迭代器自身正是一个迭代器，所以迭代器的__iter__方法返回自身即可。

也就是说，一个实现了__iter__方法和__next__方法的对象，就是迭代器，迭代器自身也是一个可迭代对象。

五、自定义迭代器

迭代器最核心的功能就是可以通过next()函数的调用来返回下一个数据值。

如果每次返回的数据值不是在一个已有的数据集合中，而是通过程序按照一定的规律计算生成的，那就不用再依赖一个已有的数据集合，也就是说不用再将所有要迭代的数据都一次性缓存下来，这样可以节省大量的存储（内存）空间。

class FeiboIterator(object):
    """斐波那契数列迭代器"""

    def __init__(self, n):
        # 斐波那数列值的个数
        self.n = n
        # 记录当前遍历的下标
        self.index = 0
        # 斐波那数列前面的两个值
        self.num1 = 0
        self.num2 = 1

    def __next__(self):
        """被next()函数调用来获取下一个数"""
        if self.index < self.n:
            num = self.num1
            self.num1, self.num2 = self.num2, self.num1 + self.num2
            self.index += 1
            return num
        else:
            raise StopIteration

    def __iter__(self):
        """迭代器的__iter__返回自身即可"""
        return self


if __name__ == '__main__':
    fb = FeiboIterator(20)
    for num in fb:
        print(num, end=' ')


运行结果：

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

上面的代码中，我们自定义一个类，里面实现了__next__和__iter__方法，__next__方法中每次返回的值是我们通过计算得到的结果，所以可以一直使用next()方法。

当我们通过for...in...循环来遍历迭代斐波那契数列中的前n个数时，会在第n+1次调用next()时抛出StopIteration异常，然后结束for循环，这与Python迭代器的功能是一样的。

所以，我们已经实现了自定义迭代器。