Python基础之列表，元组，字典，集合，推导式，迭代器

目录

• 1 列表
  • 1.1 定义
  • 1.2 访问列表中的值
  • 1.3 更新列表
  • 1.4 删除列表元素
  • 1.5 Python列表脚本操作符
  • 1.6 Python列表截取与拼接
  • 1.7 嵌套列表
  • 1.8 列表比较
• 2 元组
  • 2.1 定义
  • 2.2 创建空元组
  • 2.3 访问元组
  • 2.4 修改元组
  • 2.5 删除元组
  • 2.6 元组运算符
• 3 字典
  • 3.1 定义
  • 3.2 创建空字典
  • 3.3 访问字典里的值
  • 3.4 修改字典
  • 3.5 删除字典元素
  • 3.6 字典键的特性
  • 3.7 字典内置函数&方法
  • 3.8 字典优势
• 4 集合
  • 4.1 定义
  • 4.2 操作集合
    • 4.2.1 添加元素
    • 4.2.2 移除元素
    • 4.2.3 计算集合元素个数
    • 4.2.4 清空集合
    • 4.2.5 判断元素是否在集合中存在
• 5 推导式
  • 5.1 列表推导式
  • 5.2 字典推导式
  • 5.3 集合推导式
  • 5.4 元组推导式(生成器表达式)
• 6 迭代器与生成器
  • 6.1 迭代器定义
  • 6.2 创建一个迭代器
  • 6.3 StopIteration
  • 6.4 生成器

写这篇文章，是对于平常开发不是以Python为主，以便能快速复习Python基础知识而记录，以下文章都是基于python 3+

1 列表

1.1 定义

序列是Python 中最基本的数据结构
序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。
Python 有 6 个序列的内置类型，但最常见的是列表和元组
列表都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项 不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Test', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

1.2 访问列表中的值

列表索引从 0开始，第二个索引是 1，依此类推。
通过索引列表可以进行截取、组合等操作。

#!/usr/bin/python3
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )

结果：
red
green
blue

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推

#!/usr/bin/python3

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )

结果：
black
white
yellow

使用下标索引来访问列表中的值，同样也可以使用方括号 [] 的形式截取字符，如下所示：

#!/usr/bin/python3
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])

结果：
[10, 20, 30, 40]

使用负数索引值截取：

#!/usr/bin/python3 
list = ['Google', 'Test', "Zhihu", "Taobao", "Wiki"]
 # 读取第二位
print ("list[1]: ", list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print ("list[1:-2]: ", list[1:-2])

结果：

list[1]:  Test
list[1:-2]:  ['Test', 'Zhihu']

1.3 更新列表

可以对列表的数据项进行修改或更新，也可以使用 append() 方法来添加列表项，如下所示：

#!/usr/bin/python3
 
list = ['Google', 'Test', 1997, 2000]
 
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
 
list1 = ['Google', 'Test', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)

结果：
第三个元素为 :  1997
更新后的第三个元素为 :  2001
更新后的列表 :  ['Google', 'Test', 'Taobao', 'Baidu']

1.4 删除列表元素

可以使用 del 语句来删除列表的的元素，如下实例：

#!/usr/bin/python3
 
list = ['Google', 'Test', 1997, 2000]
 
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)

结果：
原始列表 :  ['Google', 'Test', 1997, 2000]
删除第三个元素 :  ['Google', 'Test', 2000]

1.5 Python列表脚本操作符

列表对+ 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ")	1 2 3	迭代

1.6 Python列表截取与拼接

Python的列表截取与字符串操作类型，如下所示：

L=['Google', 'Test', 'Taobao']

操作：

Python 表达式	结果	描述
L[2]	'Taobao'	读取第三个元素
L[-2]	'Test'	从右侧开始读取倒数第二个元素: count from the right
L[1:]	['Test', 'Taobao']	输出从第二个元素开始后的所有元素

>>>L=['Google', 'Test', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Test'
>>> L[1:]
['Test', 'Taobao']
>>>

列表还支持拼接操作：
>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>

1.7 嵌套列表

使用嵌套列表即在列表里创建其它列表，例如：

>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

1.8 列表比较

列表比较需要引入 operator 模块的 eq 方法

# 导入 operator 模块
import operator

a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))

结果
operator.eq(a,b):  False
operator.eq(c,b):  True

2 元组

2.1 定义

Python 的元组与列表类似，不同之处在于 元组的元素不能修改
注意：元组使用小括号 ( )，列表使用方括号 [ ]
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可

>>> tup1 = ('Google', 'Test', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d"   #  不需要括号也可以
>>> type(tup3)
<class 'tuple'>

2.2 创建空元组

创建空元组

tup1 = ()

元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。

2.3 访问元组

元组可以使用下标索引来访问元组中的值，如下实例:

#!/usr/bin/python3

tup1 = ('Google', 'Test', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

结果：
tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)

2.4 修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

#!/usr/bin/python3
 
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

结果：
(12, 34.56, 'abc', 'xyz')

2.5 删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

#!/usr/bin/python3
tup = ('Google', 'Test', 1997, 2000)
 
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)

以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

删除后的元组 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined

2.6 元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x, end=" ")	1 2 3	迭代

3 字典

3.1 定义

字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

注意：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict

键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

3.2 创建空字典

使用大括号 { } 创建空字典：

# 使用大括号 {} 来创建空字典
emptyDict = {}
# 打印字典
print(emptyDict)
# 查看字典的数量
print("Length:", len(emptyDict))
# 查看类型
print(type(emptyDict))

结果：
{}
Length: 0
<class 'dict'>

使用内建函数 dict() 创建字典：

emptyDict = dict()
# 打印字典
print(emptyDict)
# 查看字典的数量
print("Length:",len(emptyDict))
# 查看类型
print(type(emptyDict))

结果：
{}
Length: 0
<class 'dict'>

3.3 访问字典里的值

把相应的键放入到方括号中，如下实例:

#!/usr/bin/python3
tinydict = {'Name': 'Test', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])

结果：
tinydict['Name']:  Test
tinydict['Age']:  7

如果用字典里没有的键访问数据，会输出错误如下：

#!/usr/bin/python3
tinydict = {'Name': 'Test', 'Age': 7, 'Class': 'First'}
 print ("tinydict['Alice']: ", tinydict['Alice'])

结果：
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print ("tinydict['Alice']: ", tinydict['Alice'])
KeyError: 'Alice'

3.4 修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

#!/usr/bin/python3
tinydict = {'Name': 'Test', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "菜鸟教程"  # 添加信息
 
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])

结果：
tinydict['Age']:  8
tinydict['School']:  菜鸟教程

3.5 删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。
显式删除一个字典用del命令，如下实例：

#!/usr/bin/python3 
tinydict = {'Name': 'Test', 'Age': 7, 'Class': 'First'} 
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])

但这会引发一个异常，因为用执行 del 操作后字典不再存在：
Traceback (most recent call last):
  File "/test-test/test.py", line 9, in <module>
    print ("tinydict['Age']: ", tinydict['Age'])
NameError: name 'tinydict' is not defined

3.6 字典键的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行

• 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
• 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

#!/usr/bin/python3 
tinydict = {'Name': 'Test', 'Age': 7, 'Name': '小菜鸟'} 
print ("tinydict['Name']: ", tinydict['Name'])

结果：
tinydict['Name']:  小菜鸟

#!/usr/bin/python3
 
tinydict = {['Name']: 'Test', 'Age': 7}
 
print ("tinydict['Name']: ", tinydict['Name'])
以上实例输出结果：

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    tinydict = {['Name']: 'Test', 'Age': 7}
TypeError: unhashable type: 'list'

3.7 字典内置函数&方法

Python字典包含了以下内置函数：

• len(dict)：计算字典元素个数，即键的总数。
• str(dict)：输出字典，可以打印的字符串表示。
• type(variable)：返回输入的变量类型，如果变量是字典就返回字典类型

3.8 字典优势

为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字，无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。

dict就是第二种实现方式，给定一个名字，比如'Michael'，dict在内部就可以直接计算出Michael对应的存放成绩的“页码”，也就是95这个数字存放的内存地址，直接取出来，所以速度非常快。这种key-value存储方式，在放进去的时候，必须根据key算出value的存放位置，这样，取的时候才能根据key直接拿到value。

和list比较，dict有以下几个特点：

• 查找和插入的速度极快，不会随着key的增加而增加； 需要占用大量的内存，内存浪费多。 而list相反：
• 查找和插入的时间随着元素的增加而增加； 占用空间小，浪费内存很少。 所以，dict是用空间来换取时间的一种方法。
• dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。
• 这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。

4 集合

4.1 定义

集合（set）是一个无序的不重复元素序列。
可以使用 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为{ }是用来创建一个空字典。

创建格式：

parame = {value01,value02,...}
或者
set(value)

集合大致操作如下:

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

遍历元素：

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

4.2 操作集合

4.2.1 添加元素

语法格式如下：

s.add( x )

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

>>> thisset = set(("Google", "Test", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Test'}

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

s.update( x )

x 可以有多个，用逗号分开。

>>> thisset = set(("Google", "Test", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Test'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Test'}
>>>

4.2.2 移除元素

语法格式如下：

s.remove( x )

将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

>>> thisset = set(("Google", "Test", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Test'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>

此外还有一个方法也是移除集合中的元素，且 如果元素不存在，不会发生错误
格式如下所示：

s.discard( x )

>>> thisset = set(("Google", "Test", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Test'}

我们也可以设置随机删除集合中的一个元素，语法格式如下：

s.pop() 

thisset = set(("Google", "Test", "Taobao", "Facebook"))
x = thisset.pop()

print(x)
结果：

$ python3 test.py 
Test

多次执行测试结果都不一样。
set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

4.2.3 计算集合元素个数

语法格式如下：

len(s)

计算集合 s 元素个数。

>>> thisset = set(("Google", "Test", "Taobao"))
>>> len(thisset)
3

4.2.4 清空集合

语法格式如下：

s.clear()

清空集合 s

>>> thisset = set(("Google", "Test", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()

4.2.5 判断元素是否在集合中存在

语法格式如下：

x in s

判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

>>> thisset = set(("Google", "Test", "Taobao"))
>>> "Test" in thisset
True
>>> "Facebook" in thisset
False
>>>

5 推导式

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体

Python支持各种数据结构的推导式：

• 列表(list)推导式
• 字典(dict)推导式
• 集合(set)推导式
• 元组(tuple)推导式

5.1 列表推导式

列表推导式格式为：

[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]

或者

[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

各个元素说明：

• out_exp_res：列表生成元素表达式，可以是有返回值的函数。
• for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
• if condition：条件语句，可以过滤列表中不符合条件的值。

过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母：

>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
>>> new_names = [name.upper()for name in names if len(name)>3]
>>> print(new_names)
['ALICE', 'JERRY', 'WENDY', 'SMITH']

计算 30 以内可以被 3 整除的整数：

>>> multiples = [i for i in range(30) if i % 3 == 0]
>>> print(multiples)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

5.2 字典推导式

字典推导基本格式：

{ key_expr: value_expr for value in collection }

或

{ key_expr: value_expr for value in collection if condition }

使用字符串及其长度创建字典：

listdemo = ['Google','Test', 'Taobao']
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
>>> newdict = {key:len(key) for key in listdemo}
>>> newdict
{'Google': 6, 'Test': 4, 'Taobao': 6}

提供三个数字，以三个数字为键，三个数字的平方为值来创建字典：

>>> dic = {x: x**2 for x in (2, 4, 6)}
>>> dic
{2: 4, 4: 16, 6: 36}
>>> type(dic)
<class 'dict'>

5.3 集合推导式

集合推导式基本格式：

{ expression for item in Sequence }

或

{ expression for item in Sequence if conditional }

计算数字 1,2,3 的平方数：

>>> setnew = {i**2 for i in (1,2,3)}
>>> setnew
{1, 4, 9}

判断不是 abc 的字母并输出：

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}
>>> type(a)
<class 'set'>

5.4 元组推导式(生成器表达式)

元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

元组推导式基本格式：

(expression for item in Sequence )

或

(expression for item in Sequence if conditional )

元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。

例如，我们可以使用下面的代码生成一个包含数字 1~9 的元组：

>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50>  # 返回的是生成器对象

>>> tuple(a)       # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)

6 迭代器与生成器

6.1 迭代器定义

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

• 迭代器是一个可以记住遍历的位置的对象。
• 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。
• 迭代器只能往前不会后退。
• 迭代器有两个基本的方法：iter() 和 next()

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

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>>

迭代器对象可以使用常规for语句进行遍历：

#!/usr/bin/python3
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")

结果：
1 2 3 4

也可以使用 next() 函数：

#!/usr/bin/python3 
import sys         # 引入 sys 模块
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

结果如下：
1
2
3
4

6.2 创建一个迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__()

类都有一个构造函数，Python 的构造函数为 __init__(), 它会在对象初始化的时候执行

• __iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。
• __next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。

创建一个返回数字的迭代器，初始值为 1，逐步递增 1：

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    x = self.a
    self.a += 1
    return x
 
myclass = MyNumbers()
myiter = iter(myclass)
 
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

结果：
1
2
3
4
5

6.3 StopIteration

StopIteration异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

例如在 20 次迭代后停止执行：

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
 
myclass = MyNumbers()
myiter = iter(myclass)
 
for x in myiter:
  print(x)

6.4 生成器

在 Python 中，使用了 yield函数被称为生成器(generator)
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行

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

#!/usr/bin/python3
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 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

结果：
0 1 1 2 3 5 8 13 21 34 55