Python迭代和生成操作小结 - 简书
Python迭代和生成操作小结
最近在使用Python进行数据处理的过程中，使用for循环来进行迭代处理的次数比较多，于是萌发了要写一篇文章来总结python中迭代和生成操作，一方面加深对Python中这块知识的理解，另一方面也锻炼自己写技术类博文的能力，这篇文章算是一次尝试吧。
迭代的概念
维基百科中
的一个通用概念是：重复某个过程的行为，这个过程中的每次重复称为一次迭代。具体对应到Python编程中就是，对于一个可迭代对象，比如Python中的list、tuple、string、dictionary，set等，使用某种循环结构来遍历其中的元素，这种遍历就是迭代。
迭代的形式
python编程中可以使用while循环进行迭代。
while i & 100:
total = total + i
print(total)
在Python编程中，利用for循环进行迭代是比较常见的一种形式。Python使用for...in...的语法结构。这点和C、Java等语言利用下标进行迭代有点不一样。下面给出几个例子。
for i in range(2):
for s in "Max":
for key in {"Python":90, "java"：88， "C++":85}:
print(key)
除了上面的几种比较常见的迭代使用形式，for...in...循环中还有一些tricks。下面总结的是一些比较常见的，不一定全面。
当我们想在一次迭代中不仅返回迭代对象中的元素的值，同时还想返回该元素对应的下标，那么就可以使用enumerate()函数，该函数能在一次迭代中同时返回元素值和对应的下标。当想建立两个迭代对象元素之间的对应关系时，enumerate可以作为一种方法。
for i, item in enumerate(['Tom', 'Tony', 'Max']):
print("The index of {} is {}".format(item, i))
sub = ['Math', 'English']
score = [90, 88]
for i, item in enumerate(sub):
print("The subject {} got {}".format(item, score[i]))
zip是python的一个內建函数，接收一系列可迭代对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些元组组成的list列表。若传入的对象的长度不等，则返回的list与参数中长度最短的对象相同。
z1 = [1,2,3]
z2 = [4,5,6]
for i,j in zip(z1,z2):
print(i,j)
item()方法允许我们同时操作dictionary的key和value， 用起来也十分方便。
sc = {"Python":90, "java"：88， "C++":85}
for key, value in sc.item():
print(key)
print(value)
迭代器（iterator）
迭代器是访问集合中元素的一种方式，从集合中的第一个元素开始访问，直到所有的元素都被访问一遍后结束。迭代器不能回退，只能往前进行迭代。迭代器的一个优点是不需要事先准备好集合中的所有元素，仅仅在迭代至某个元素时才计算该元素。适合用于遍历一些大的文件或集合。同时迭代器提供了一个统一的访问集合的接口，只要是定义了iter()方法的对象，就可以使用迭代器进行访问。可以被next()方法调用并不断返回下一个值的对象称为迭代器，换句话说，迭代器对象具有next()方法。生成器就是迭代器对象，list、tuple、str等虽然是可迭代对象（Iterable），但不是迭代器（Iterator）。要把一个可迭代对象转换成迭代器，可以使用iter()函数。另外可以使用isinstance()函数来判断一个对象是可迭代对象还是迭代器对象。
对于迭代器的理解，可以把迭代器看成是一个数据流，迭代器对象被next()函数调用不断返回下一个数据，直到没有数据时抛出StopIteration错误。把这个数据流看做是一个有序序列，但却不能提前知道这个数据流到底有多长，而对于list、tuple等可迭代对象来说，对象的长度是可知的。这也是可迭代对象和迭代器的区别所在。
from collections import Iterator, Iterable
a = [1, 2, 3]
b = iter(a)
isinstance(a, Iterable)
isinstance(a, Iterator)
isinstance(b, Iterable)
isinstance(b, Iterator)
isinstance((x*x for x in range(3)), Iterator)
isinstance((x*x for x in range(3)), Iterable)
生成的意思是说通过某种规则产生一定的序列，在生成的过程中可能也会用到迭代操作。
列表生成式（list comprehension）
列表生成式是一种方便简洁的创建List的方式。创建一个List的一般思路可能是先创建一个空的List，然后再使用for循环进行迭代，将每次迭代生成的值通过append方法添加到List中去。
for i in range(6):
a.append(i)
如果使用列表生成式，代码则会相当简洁。
a = [i*2 for i in range(6)]
b = [a + b for a in range(3) for b in range(4)]
生成器（generator）
使用列表生成式的确可以生成一定规则的列表，但同时由于内存限制，列表容量是有限的。有时我们可能不想让一个列表占用太大的内存空间，我们希望在循环的过程中值是不断推算不断生成的，不必一次性创建完整的序列，从而节省内存空间。Python中就有这种一边循环一边计算的机制，这种机制叫生成器。关于生成器，还有一种定义说，带有yield的函数就被称为生成器。带有yield的函数不再是一个普通函数，python解释器会把它视为生成器。值得注意的是，生成器是可迭代对象，也是迭代器对象。
先讲一种简单的创建一个生成器的方法，就是直接把列表生成式的[]换成（）就创建了一个生成器。生成器具有next()方法，用于输出每次迭代值。
a = (x*x for x in range(4))
for i in a:
值得注意的是。使用next()方法，当迭代到最后一个元素，没有更多的元素时，生成器会抛出StopIteration错误。下面通过在函数中插入yield的方法来创建生成器。
def fab(m):
i, a, b = 0, 0, 1
while i & m:
a, b = b, a+b
yield把fab函数变成了一个生成器，每次循环执行到语句 yield b 时，fab函数就返回一个迭代值，下次迭代时，代码会从 yield b 语句的下一条语句继续执行，就好像是函数执行过程中被yield中断了数次，每次中断都会通过yield返回当前的迭代值。这个过程可以通过在代码中嵌入打印一些标记来进行可视化。
def foo():
print("begin")
for i in range(2):
print("before yield", i)
print("after yield", i)
print("end")
before yield 0
after yield 0
before yield 1
after yield 1
Traceback (most recent call last):
File "&stdin&", line 1, in &module&
StopIteration
可以使用for循环进行迭代的对象都是可迭代（Iterable）类型，可以调用next()方法的对象都是迭代器（Iterator）类型，生成器（generator）既是可迭代类型,也是迭代器类型。
you can learn anything
本文翻译自Functional Programming Howto 本文将介绍Python中函数式编程的特性。在对函数式编程的概念有了了解后，本文会介绍iterators和generators等语言特性，还有itertools和functools等相关的库。 函数式编程 本...
前言 这篇博客写了很久，其实写每一篇博客用的时间还是挺长的，不够这有利于自己的学习，也想分享一下。之前也说了创建了一个微信群，Python 学习讨论群，现在只有 40 个左右的小伙伴，如果有兴趣加入学习讨论的话，可以加我微信:androidwed,拉你进群。想看回之前的文章...
我们在学习web前端的路程起步时总是疑问，我们如何更好的遍历元素呢？迭代器和生成器是什么？今天为大家带上与精彩的ES6有关的遍历数据的一些方法和对迭代器和生成器的介绍。 一、for-of循环 （1）for循环的疑问 起初我们如何遍历数组中的元素呢？20年前JavaScrip...
转载自：深入讲解Python中的迭代器和生成器 在Python中，很多对象都是可以通过for语句来直接遍历的，例如list、string、dict等等，这些对象都可以被称为可迭代对象。至于说哪些对象是可以被迭代访问的，就要了解一下迭代器相关的知识了。 迭代器 一个对象存在迭...
http://python.jobbole.com/85231/ 关于专业技能写完项目接着写写一名3年工作经验的Java程序员应该具备的技能，这可能是Java程序员们比较关心的内容。我这里要说明一下，以下列举的内容不是都要会的东西—-但是如果你掌握得越多，最终能得到的评价、...
儿子今天18岁生日，我们一家三口在一起，热热闹闹的！
祝儿子生日快乐，今后的道路顺利而且精彩！愿儿子能进入心仪的大学！愿儿子慢慢成长为一正直、善良、勇敢，乐于开拓的男子汉！
今天一大早赶到公司陪老板开高层的生产会议，市场、技术、生产的老大们都来了。COO拿出来一张大表，各位同学，这是我们所有产品的成本优化后的单位利率。 我一眼扫去，一半的产品都在飘红。COO说，这个成本已经非常优化了，从生产到营销，连快递物流环节都考虑进去了，若是直接用实际成本...
⒈ 眼睛感染了么？ 没有。 昨晚没睡好么？ 不是？ 受委屈了么？ 没有。 那你为什么眼睛红红的？ 我 想你了 ⒉ 如果我告诉你我很喜欢一首歌 那么 这首歌里一定有一句歌词 是，给你的。 ⒊ 想知道你在做什么 想知道你在想什么 我就是这样 一个眼里只有你的自私鬼 ⒋ 美好的东...学习，坚持,注意健康
python 中迭代多个序列
一、多个序列迭代
有时候我们希望能够同时遍历多个序列，比如有序列a = [1, 2, 3, 4, 5], b = ['a', 'b', 'c', 'd', 'e']，我们如果要同时遍历的话，可以采用如下的方式：
&&& xpts = [1, 5, 4, 2, 10, 7]
&&& ypts = [101, 78, 37, 15, 62, 99]
&&& for x, y in zip(xpts, ypts):
print(x, y)
因为使用了zip()方法，我们将两个集合里的内容都同时取出来，按照tuple的方式一个个的组织起来。所以我们访问的时候也是通过一个个tuple的方式来读取。这里我们提供的两个list是长度一致的，如果不一致会怎么样呢？我们再来试试另外两个序列：
&&& a = [1, 2, 3, 4]
&&& b = ['a', 'b', 'c']
&&& for x, y in zip(a, b):
print(x, y)
从代码运行的结果来看，默认是遍历到短的那个序列结束。如果我们需要到那个长的序列结束呢？这里有另外一种办法：
Python代码
&&& from itertools import zip_longest
&&& for i in zip_longest(a, b):
这里引用了zip_longest方法，它可以将两个序列组合起来，不过对于短的那个序列，用None来补齐。
将几个序列串在一起
我们可以直接看如下的代码：
Python代码
&&& from itertools import chain
&&& a = [1, 2, 3, 4]
&&& b = ['a', 'b', 'c']
&&& for x in chain(a, b):
一个chain方法就解决了大部分问题了。和我们默认想到的方法比起来，chain方法效率更加高。因为我们最开始会考虑将两个或者多个序列连在一起，比如a + b，这样会创造一个新的序列出来，这样带来的成本开销明显偏大了。
将嵌套的序列变平
这是一个有意思的问题，因为一般来说当我们需要访问一个数组的时候，比如说a = [1, 2, [3, 4, [5, 6], 7, 8], 9, 10]，我们希望能够将他们所有的元素都输出，并使得他们看起来像就是一个一维数组那样，如a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]。我们默认的思路该怎么办呢？只怕一开始就是碰到一个元素的时候会判断它是否为数组，如果是的则递归的去输出它的元素。
Python里面有一个很强大的特性可以很好的实现这个方法：
Python代码
from collections import Iterable
def flatten(items, ignore_types=(str, bytes)):
for x in items:
if isinstance(x, Iterable) and not isinstance(x, ignore_types):
yield from flatten(x)
这种实现里面有一个额外的ignore_types，里面列举了一些类型我们可以不需要进一步的去遍历。比如说str，我们一般碰到一个字符串可以直接将他们作为一个整的对象输出而不是再对它们进一步拆分的遍历。最有意思的地方在yield from这个部分。yield from这个部分的意思是将后续的值作为它本身的一个subroutine。所以它们就会被当作一个拉平的数组。关于yield from这部分我们在后面的文章中会专门讲述。
按照这个方式，我们使用它们的代码如下：
Python代码
&&& from nested import flatten
&&& items = [1, 2, [3, 4, [5, 6], 7], 8]
&&& for x in flatten(items):
迭代多个有序排列数组
这个问题不太好用一句话描述，就是说假定我们有若干个已经排序的数组了。当我们希望能够去遍历这所有的序列，但是保证我们每次都取出他们中间最小的元素，保证所有输出还是一个严格排序的结果，我们该怎么办呢？实际上，这是一个多路归并排序的问题。在前面的一些文章里有过讨论，不过要做一个好的java实现我们可是费了一番功夫。这里有什么好的招呢？
Python代码
&&& import heapq
&&& a = [1, 4, 7, 10]
&&& b = [2, 5, 6, 11]
&&& for c in heapq.merge(a, b):
这里是归并两路的数据结果。在一些我们如果要归并多个文件的情况下，也可以这样来做。因为这里heapq.merge不是一次将所有的数据都装载到内存里，它只是每次取很小的一部分，像generator一样。所以对于大文件的合并用这种方式来做。呵呵，寥寥几行代码就解决了问题，不能不说，很好很强大啊。
Iterator的定义方法虽然看起来很简单，但是它的使用也可以非常的复杂和灵活。通过结合一些库的支持，我们可以实现非常强大的计算效果。当然，前提是我们需要知道去哪里找到这些库和知道这些用法。
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！Tomorrow is another day
Python——while和for循环
while 循环
一般格式：
while &test&:
&statements1&
else &test&:
&statements2&else为可选部分，当控制权离开循环而又没有碰到break语句时会执行。
&&& x = 'spam'
&&& while x :
print (x,end=' ')
spam pam am m 注意：这里使用end = ' '关键字参数，使所有输出都出现在同一行，之间用空格隔开
------------------------------------------------------------------------------------------------------------------------------------------------break、continue、pass和循环else
break:跳出最近所在的循环（跳过整个循环语句）
continue：跳到最近所在循环的开头处（来到循环的首行）
pass:什么事也不做，只是空占位语句
循环else块：只有当循环正常离开时才会执行（也就是没有碰到break语句）
------------------------------------------------------------------------------------------------------------------------------------------------
一般循环格式
加入break和continue后，while的一般循环格式变为：
while &test1&:
&statements1&
if &test2&:break
if &test3&:continue
&statements2&------------------------------------------------------------------------------------------------------------------------------------------------
pass语句是无运算的占位语句，当语法需要语句并且还没有任何使用的语句可写时，就可以使用它。它通常用于为复合语句编写一个空的主体。例如，如果想写个无限循环，每次迭代什么也不做，就写个pass
&&& while True :pass因为主体只是空语句，Python陷入了死循环，这个程序并没有什么用处。以后将会看到它更有意义的用处。例如，忽略try语句所捕获的异常，以及定义带属性的空类对象，而该类实现的对象行为就像其他语言的结构和记录。pass有时指的是“以后会填上”，只是暂时用于填充函数主体而已def func1():
def func2():
pass我们无法保持函数体为空而不产生语法错误，因此，可以使用pass来替代
【另外：在Python3.0以后，程序中可以使用三个点...来代替pass，这样似乎更加简洁明了】
------------------------------------------------------------------------------------------------------------------------------------------------
continue语句会立即跳到循环的顶端，即跳过本次循环，执行下一次循环
break 语句会立即离开循环
&&& while True:
name = input('Enter name:')
if name == 'stop':break
age = input('Enter age:')
print('Hello',name,'=&',int(age)**2)
Enter name:Gavin
Enter age:2
Hello Gavin =& 4
Enter name:Spam
Enter age:20
Hello Spam =& 400
Enter name:stop------------------------------------------------------------------------------------------------------------------------------------------------循环else
和循环else子句结合时，break语句通常可以忽略其他语言中所需要的搜索状态标志位。
例如，下列程序搜索大于1的因子，来决定正整数y是否为质数：
&&& def judge(y):
while x &1:
if y % x ==0:
print(y,'has factor',x)
print(y,'is prime')
&&& judge(8)
8 has factor 4
&&& judge(19)
19 is prime
&&& judge(119)
119 has factor 17除了设置标志位在循环结束时进行测试外，也可以在找到因子时插入break。这样一来，循环else分句可以视为只有当没有找到因子时才会执行。如果你没有碰到break，该数就是质数。
【注意，当第一次判断while循环条件就不满足时，也就是一次循环也没有进行时，还是会执行else子句的】
=================================================================================
一般用法：
for &target& in &object&:
&statements&
&statements&当python运行for循环时，会逐个将序列对象中的元素赋值给目标，然后为每个元素执行循环主体。
for循环也可以用break、continue和else子句
完整格式如下：
for &target&
in &object&:
&statements&
if &test&:break
if &test&:continue
&statements&------------------------------------------------------------------------------------------------------------------------------------------------基础应用：
&&& for x in ['spam','eggs','ham']:
print(x,end=
spam eggs ham
下面两个例子会计算列表得到所有元素的和与乘积。&&& s = 0
&&& for x in [1,2,3,4]:
#这里x这个变量依然是有值的
10&&& p = 1
&&& for x in [1,2,3,4]:
24在以后，还会知道Python有一些工具，可以自动对列表中的元素应用诸如‘+’和'*'类似的运算，但是使用for循环通常也一样简单------------------------------------------------------------------------------------------------------------------------------------------------其他数据类型
不止对于列表适用，for循环对任何序列都适用，for循环还可以应用于字符串和元组，这里就不举例了。
实际上，for循环甚至可以应用在一些根本不是序列的对象上，对于文件和字典也有效。------------------------------------------------------------------------------------------------------------------------------------------------
在for 循环中的元组赋值
&&& T = [(1,2),(3,4),(5,6)]
&&& for (a,b) in T:
print(a,b)
5 6&&& for x in T :
(5, 6)注意上述两个例子的区别。第一个例子可以看做元组解包的赋值运算
这种形式通常和我们将要介绍的zip调用一起使用，以实现并行遍历。在Python中，它通常还和SQL数据库一起使用，其中，查询结果表作为这里使用的列表这样的序列的序列而返回——外围的列表就是数据库表，嵌套的元组是表中的行，元组赋值和列对应
for 循环中的元组使得用items方法来遍历字典中的键和值变得很方便，而不必再遍历键并手动索引以获取值：
&&& D = {'a':1,'b':2,'c':3}
&&& for key in D:
print(key,'=&',D[key])
a =& 1&&& list(D.items())
[('b', 2), ('c', 3), ('a', 1)]
&&& for (key,value) in D.items():
print(key,'=&',value)
a =& 1注意for循环中的元组赋值并非一种特殊情况，这一点很重要；单词for之后的任何赋值目标在语法上都是有效的。尽管我们总是在for循环中手动地赋值以解包：&&& for both in T:
a,b = both
print(a,b)
5 6------------------------------------------------------------------------------------------------------------------------------------------------
Python3.0 在for循环中扩展的序列赋值
实际上，for循环中的循环变量真的可以是任何赋值目标，在这里，也可以使用Python3.0的扩展序列解包赋值语法，来提取序列中的序列的元素和部分。
------------------------------------------------------------------------------------------------------------------------------------------------
嵌套for循环
这段代码会在对象列表中搜索每个键，然后报告其搜索结果：
&&& items = ['aaa',111,(4,5),2.01]
&&& tests = [(4,5),3.14]
&&& for key in tests:
for item in items:
if key == item:
print(key,'was found')
print(key,'not found')
(4, 5) was found
3.14 not found=================================================================================编写循环的技巧
1.内置range函数返回一系列连续增加的整数，可作为for中的索引
2.内置zip函数返回并行元素的元组的列表，可用于在for中内遍历整个序列。------------------------------------------------------------------------------------------------------------------------------------------------
循环计数器：while和range
range函数是通用的工具，可用在各种环境中，虽然range常用在for循环中来产生索引，但也可以用在任何需要整数列表的地方。在Python3.0中，range是一个迭代器，会根据需要产生元素，因此，我们需要将其包含到一个list调用中以一次性显示其结果：
&&& list(range(5)),list(range(2,5)),list(range(0,10,2))
([0, 1, 2, 3, 4], [2, 3, 4], [0, 2, 4, 6, 8])一个参数时，range会产生从零算起的整数列表，但其中不包括该参数的值；
如果传进两个参数，第一个视为下边界。
第三个选用参数可以提供步进值，使用时，Python会对每个连续整数加上步进值（步进值默认为1）.
range也可以是非正数或非递增的：&&& list(range(-5,5))
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
&&& list(range(5,-5,-2))
[5, 3, 1, -1, -3]从内部实现上来看，for循环以这种方式使用时，会自动处理迭代的细节。如果你真的想要明确得掌控索引逻辑，可以用while循环来实现：&&& s = 'gavin'
&&& while i&len(s):
print(s[i],end = ' ')
g a v i n ------------------------------------------------------------------------------------------------------------------------------------------------非完备遍历：range和分片
一般情况下，在对序列进行遍历时，最好使用Python中的简单的for循环，不要使用while，并且不要在for循环中使用range调用，只将其视为最后的手段。
&&& for item in X:print(item)然而利用range进行索引的用处是，我们可以通过控制range来实现特殊的遍历，例如，在遍历的过程中跳过一些元素&&& S = 'abcdefghijklmn'
&&& for i in range(0,len(S),2):print(S[i],end = ' ')
a c e g i k m 在这里，我们通过所产生的range列表，访问了字符串S中每隔一个的元素，要使用每隔两个的元素，可以把range的第三个参数改为3，以此类推。
然而，这可能不是如今Python中最理想情况下实现的技术，如果你真想跳过序列中的元素，可以用前面介绍的扩展的第三个限制值形式的分片表达式，例如，要使用S中每隔一个的字符串，可以用步进值2来分片：&&& for item in S[::2]:print(item,end=' ')
a c e g i k m结果是相同的，但对我们来说更容易编写，对其他人来说，更容易阅读。------------------------------------------------------------------------------------------------------------------------------------------------
修改列表：range
可以使用range和for的组合的常见场合就是在循环中遍历列表时对其进行修改。例如，假设你因某种理由要为列表中的每个元素都加1，你可以通过简单的for循环来做，但结果可能不是你想要的：
&&& L = [1,2,3,4,5]
&&& for x in L:
[1, 2, 3, 4, 5]
6这样并不行，因为修改的是循环变量x，而不是列表L.
要真的在我们遍历列表时对其修改，我们需要使用索引，让我们可以在遍历时替每个位置赋一个一个已更新的值。range/len组合可以替我们产生所需要的索引。&&& L = [1,2,3,4,5]
&&& for i in range(len(L)):
[2, 3, 4, 5, 6]用while循环也可以做，只是运行比较慢。
[x+1 for x in L]这种形式的列表解析表达式也能做类似的工作，而且没有对最初的列表进行在原处的修改（我们可以把表达式的新列表对象赋值给L，但是这样不会更新原始列表的其他任何引用值）。因为这是循环的核心概念，我们将在以后对列表解析做一个完整的介绍。------------------------------------------------------------------------------------------------------------------------------------------------并行遍历：zip和map
内置zip函数可以让我们使用for循环来并行使用多个序列，在基本运算中，zip会取得一个或多个序列为参数，然后返回元组的列表，将这些序列中的并排的元素配成对
例如，假设我们要使用两个列表：
&&& A = [1,2,3,4]
&&& B = [11,22,33,44]要合并这些列表中的元素，我们可以使用zip来创建一个元组对的列表（和range一样，zip在Python3.0中也是一个可迭代对象，因此，我们必须将其包含在一个list调用中以便一次性显示所有结果）
&&& C = zip(A,B)
&zip object at 0x0405BE18&
&&& list(C)
[(1, 11), (2, 22), (3, 33), (4, 44)]这样的结果在其他环境下也有用，然而搭配for循环中，它就会支持并行迭代：&&& for (x,y) in zip(A,B):
print(x,y,'---',x+y)
1 11 --- 12
2 22 --- 24
3 33 --- 36
4 44 --- 48zip可以接受任何类型的序列（其实就是任何可迭代的对象，包括文件），并且可以有两个以上的参数。例如&&& T1,T2,T3 = (1,2,3),(4,5,6),(7,8,9)
&&& list(zip(T1,T2,T3))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]当参数长度不同时，zip会以最短序列的长度为准来截断所得到的元组：&&& S1 = 'abc'
&&& S2 = 'xyz123'
&&& list(zip(S1,S2))
[('a', 'x'), ('b', 'y'), ('c', 'z')]------------------------------------------------------------------------------------------------------------------------------------------------使用zip构造字典
前面介绍过，当键和值的集合必须在运行时计算时，这里所用的zip调用也可用于产生字典，并且非常方便。
假设有下列的键和值的列表：
&&& keys = ['spam','eggs','toast']
&&& vals=[1,2,3]将这些列表变成字典的一种做法就是将这些字符zip起来，并通过for循环并行步进处理：
&&& list(zip(keys,vals))
[('spam', 1), ('eggs', 2), ('toast', 3)]
&&& D2 = {}
&&& for (key,val) in zip(keys,vals):
D2[key] = val
{'toast': 3, 'spam': 1, 'eggs': 2}不过，在Python2.2和后续版本中，可以完全跳过for循环，直接把zip过的键/值列表传给内置的dict构造函数：&&& D3 = dict(zip(keys,vals))
{'toast': 3, 'spam': 1, 'eggs': 2}
------------------------------------------------------------------------------------------------------------------------------------------------
产生偏移和元素：enumerate
之前，我们讨论过通过range来产生字符串中元素的偏移值，而不是那些偏移处的元素，不过，在有些程序中，我们两者都需要：需要的元素以及这个元素的偏移值。
可以按照下面这个简单的例子做：
&&& S = 'spam'
&&& offset = 0
&&& for item in S:
print(item,'appears at offset',offset)
offset += 1
s appears at offset 0
p appears at offset 1
a appears at offset 2
m appears at offset 3不过内置函数enumerate可以为我们做这件事情：&&& S = 'spam'
&&& for (offset,item) in enumerate(S):
print(item,'appears at offset',offset)
s appears at offset 0
p appears at offset 1
a appears at offset 2
m appears at offset 3可以看到：&&& enumerate(S)
&enumerate object at 0x03602FA8&
&&& list(enumerate(S))
[(0, 's'), (1, 'p'), (2, 'a'), (3, 'm')]enumerate函数返回一个生成器对象：这种对象支持接下来要学习的迭代协议。简而言之，这个对象有一个__next__方法，由下一个内置函数调用它，并且在循环中每次迭代的时候它会返回一个（index,value）的元祖。我们可以在for循环中通过元组赋值将元组解包（很像是使用zip）
&&& E = enumerate(S)
&enumerate object at 0x03602F80&
&&& next(E)
&&& next(E)
&&& next(E)
(2, 'a')&&& [c*i for (i,c) in enumerate(S)]
['', 'p', 'aa', 'mmm']要像enumerate、zip和列表解析那样完全理解迭代的概念，需要继续学习。
扫码向博主提问
非学，无以致疑；非问，无以广识
擅长领域：
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！