python 可迭代对象 迭代器 生成器,python生成器和迭代器

　　本文介绍了Python中迭代器和生成器的用法，通过示例代码非常详细。对大家的学习或者工作都有一定的参考价值，有需要的朋友可以参考一下。

一、迭代器（foreach）

1、可迭代的对象

　　所有内置__iter__方法的对象都称为可迭代对象。

　　Python内置的str、list、tuple、dict、set、file都是可迭代的对象。

　　x=1。__iter__ # SyntaxError:无效语法

　　#以下是所有可以迭代的对象

　　name=nick 。__iter__

　　print(type(name)) # 方法包装

2、迭代器对象

　　执行iterable对象的_ _ iterator _ _方法，返回值是iterator对象。

　　只有字符串和列表依赖于索引，其他可迭代对象不能依赖于索引，只能使用迭代器对象。

　　有一个内置的__iter__方法，执行这个方法会得到迭代器本身。内置__next__方法，执行时将在迭代器对象中获取一个值。你好

　　iter_s=s.__iter__()

　　print(type(iterator _ s))# str _ iterator iterator _ s是一个迭代器对象

　　而True:

　　尝试：

　　print(iter_s.__next__())

　　StopIteration:除外

　　破裂

　　#你好

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

　　你好

　　创建一个迭代器对象

　　Print(type(iter_s)) # iter_s是迭代器对象

　　而True:

　　尝试：

　　Print(next(iter_s)) #输出迭代器的下一个元素

　　StopIteration:除外

　　破裂

　　#你好

4、for迭代器循环

　　使用正则for语句可以直接遍历迭代对象。

　　for循环称为迭代器循环，in后面必须跟一个iterable对象。

　　#str

　　name=尼克

　　对于名称：中的x

　　打印(x)

　　#列表

　　对于x in [None，3，4.5， foo ，lambda: moo ，object，object()]:

　　打印(“{0} ({1})”。格式(x，类型(x)))

　　#字典

　　d={

　　1: 好吃，

　　2: 最好，

　　3芽 : 邪，

　　4: 相当好

　　}

　　对于d:中的sKey

　　打印(“{0}是{1}”。格式(sKey，d[sKey]))

　　#文件

　　f=打开( 32.txt ， r ，编码=utf-8 )

　　对于f:中的x

　　打印(x)

　　f.close()

5、实现迭代器(__next__和__iter__)

　　将类用作迭代器需要在类中实现两个方法__iter__()和__next__()。

　　__iter__()方法返回一个特殊的迭代器对象，该对象实现__next__()方法，并通过StopIteration异常来标识迭代的完成。__next__()方法返回下一个迭代器对象。StopIteration异常用于标识迭代的完成，防止无限循环的发生。在__next__()方法中，我们可以将StopIteration异常设置为在完成指定数量的循环以结束迭代后触发。创建一个返回数字的迭代器，初始值为1，逐渐递增1，迭代20次后停止执行：

　　类别MyNumbers:

　　def __iter__(self):

　　self.a=1

　　回归自我

　　def __next__(self):

　　如果self.a=20:

　　x=自我

　　self.a=1

　　 return x

　　 else:

　　 raise StopIteration

　　myclass = MyNumbers()

　　myiter = iter(myclass)

　　for x in myiter:

　　 print(x)

1、模拟range

class Range:
　　 def __init__(self, n, stop, step):
　　 self.n = n
　　 self.stop = stop
　　 self.step = step
　　 def __next__(self):
　　 if self.n >= self.stop:
　　 raise StopIteration
　　 x = self.n
　　 self.n += self.step
　　 return x
　　 def __iter__(self):
　　 return self
　　for i in Range(1, 7, 3):
　　 print(i)
　　#1
　　#4

2、斐波那契数列

class Fib:
　　 def __init__(self):
　　 self._a = 0
　　 self._b = 1
　　 def __iter__(self):
　　 return self
　　 def __next__(self):
　　 self._a, self._b = self._b, self._a + self._b
　　 return self._a
　　f1 = Fib()
　　for i in f1:
　　 if i > 100:
　　 break
　　 print(%s % i, end=)
　　# 1 1 2 3 5 8 13 21 34 55 89

二、生成器

1、yield

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

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

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

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

　　yield后面可以加多个数值（可以是任意类型），但返回的值是元组类型的。

• 提供一种自定义迭代器的方式
• yield可以暂停住函数，并提供当前的返回值

import sys
　　def fibonacci(n): # 函数 - 斐波那契
　　 a, b, counter = 0, 1, 0
　　 while True:
　　 if counter > n:
　　 return
　　 yield a
　　 a, b = b, a + b
　　 counter += 1
　　f = fibonacci(10) #f 是一个生成器
　　print(type(f)) # generator>
　　while True:
　　 try:
　　 print(next(f), end=" ")
　　 except StopIteration:
　　 sys.exit()

　　yield和return:

• 相同点：两者都是在函数内部使用，都可以返回值，并且返回值没有类型和个数的限制
• 不同点：return只能返回一次值；yield可以返回多次值

2、自定义range()方法

def my_range(start, stop, step=1):
　　 while start < stop:
　　 yield start
　　 start += 1
　　g = my_range(0, 3)
　　print(f"list(g): {list(g)}")

　　复杂版本：

def range(*args, **kwargs):
　　 if not kwargs:
　　 if len(args) == 1:
　　 count = 0
　　 while count < args[0]:
　　 yield count
　　 count += 1
　　 if len(args) == 2:
　　 start, stop = args
　　 while start < stop:
　　 yield start
　　 start += 1
　　 if len(args) == 3:
　　 start, stop, step = args
　　 while start < stop:
　　 yield start
　　 start += step
　　 else:
　　 step = 1
　　 if len(args) == 1:
　　 start = args[0]
　　 if len(args) == 2:
　　 start, stop = args
　　 for k, v in kwargs.items():
　　 if k not in [start, step, stop]:
　　 raise (参数名错误)
　　 if k == start:
　　 start = v
　　 elif k == stop:
　　 stop = v
　　 elif k == step:
　　 step = v
　　 while start < stop:
　　 yield start
　　 start += step
　　for i in range(3):
　　 print(i) # 0,1,2
　　for i in range(99, 101):
　　 print(i) # 99,100
　　for i in range(1, 10, 3):
　　 print(i) # 1,4,7
　　for i in range(1, step=2, stop=5):
　　 print(i) # 1,3
　　for i in range(1, 10, step=2):
　　 print(i) # 1,3,5,7,9

3、生成器表达式(i.for .in)

　　把列表推导式的[]换成()就是生成器表达式 。

　　优点：比起列表推导式，可以省内存，一次只产生一个值在内存中

t = (i for i in range(10))
　　print(t) # <generator object at 0x00000000026907B0>
　　print(next(t)) # 0
　　print(next(t)) # 1

　　举例：

with open(32.txt, r, encoding=utf8) as f:
　　 nums = [len(line) for line in f] # 列表推导式相当于直接给你一筐蛋
　　print(max(nums)) # 2
　　with open(32.txt, r, encoding=utf8) as f:
　　 nums = (len(line) for line in f) # 生成器表达式相当于给你一只老母鸡。
　　print(max(nums)) # ValueError: I/O operation on closed file.

　　到此这篇关于Python迭代器与生成器的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持盛行IT软件开发工作室。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。