组合数据类型

第3章组合数据类型2目录1.列表2.元组3.字典4.集合5.组合数据类型的高级特性31.列表Python内置的一种数据类型是列表(list)。list是一种最具灵活性的有序集合对象类型，可以随时添加和删除其中的元素。41.列表1.1创建列表

通常使用左右方括号（即：[和]）将数据元素包裹起来创建一个列表，如下所示。

>>>list1=[1,2,3,4,5]>>>list2=["a","b","c","d"]

其中列表list1中包含5个元素，分别是1、2、3、4、5，list1为列表名。这种创建列表的方式适用于对于列表中元素个数及其数值已知时。51.列表1.1创建列表

当遇到如将一个元组（参考3.2节）转换为列表时，则需要使用另外一种方法创建列表—调用list(tuple)函数，该函数返回一个包含tuple中所有元素的列表。

注：直接调用不带参的list()函数时，将返回一个空列表，即：[]。61.列表1.1创建列表

列表中的元素的数据类型可以各不相同，如int，string类型，甚至可以是一个列表类型，如在下例中[10,20]为一个list类型，它作为list3的一个元素存在于list3中。

>>>list3=['marry',2.0,5,[10,20]]>>>list3['marry',2.0,5,[10,20]]71.列表1.1创建列表

如图3-1所示，列表的下标是从0开始，list3列表的第一个元素是'marry'，用L[0]可以表示L的第一个元素，第二个元素是2.0，用L[1]表示，以此类推，第四个元素是一个列表，即[10,20]。图3-1元组索引位置81.列表1.2读取元素

元素下标表示该元素在list中的位置。注意list中元素下标是从0开始的，如第n个元素下标为n-1。但当读取元素传入的元素下标超出list集合的大小时将会报“元素下标超出范围”的错误。91.列表1.2读取元素

由于list2的长度为4，在取第5个元素时，list2中元素的最大下标为3<5，因此出现“listindexoutofrange”的错误。>>>list2=["a","b","c","d"]>>>list2[0]#访问列表的第一个元素'a'>>>list2[1]#访问列表的第二个元素'b'>>>list2[5]#超出列表元素下标，报错Traceback(mostrecentcalllast):File"<pyshell#46>",line1,in<module>list2[5]IndexError:listindexoutofrange101.列表1.2读取元素

除了正向取list中的元素外，也可以逆向去取，用元素下标-1表示最后一个元素，-2表示倒数第二个元素，同样注意不能超出元组个数的界限，例如：。>>>list2[-1]'d'>>>list2[-2]'c'>>>list2[-3]'b'>>>list2[-5]#超出列表元素下标，报错Traceback(mostrecentcalllast):File"<pyshell#50>",line1,in<module>list2[-5]IndexError:listindexoutofrange111.列表1.3遍历列表 遍历一个列表元素的最常见方式是使用for循环，常见的有以下两种方式。 第一种遍历方法隐藏了列表cheeses的长度，操作较为便利。>>>forcheeseincheeses: print(cheese)121.3遍历列表>>>foriinrange(len(numbers)): numbers[i]=numbers[i]*2 第二种遍历方法则使用len()函数计算出列表numbers的长度后进行遍历操作，其中range()函数返回的是从0到numbers长度的数值序列。1.列表131.4替换元素>>>numbers=[12,13]>>>numbers[1]=14>>>numbers[12,14]

和字符串不同的是，列表是可变的，可以在列表中指定下标的值对元素进行修改，例如： numbers[1]原先为13，当执行numbers[1]=14时，numbers[1]的值被修改为14。1.列表141.5增加元素>>>list=[1]>>>list=list+['a','b']>>>list[1,'a','b']*操作符重复一个列表多次：>>>[0]*5[0,0,0,0,0]>>>[4,5,6]*4[4,5,6,4,5,6,4,5,6,4,5,6]

方法一：使用“+”将一个新列表附加在原列表的尾部。例如：和字符串不同的是，列表是可变的，可以在列表中指定下标的值对元素进行修改，例如：1.列表151.列表1.5增加元素>>>list.append(True)>>>list[1,'a','b',True]

方法二：使用append()方法向列表的尾部添加一个新元素。例如：>>>list.extend(['c',5])>>>list[1,'a','b',True,'c',5]

方法三：使用extend()方法将一个列表添加在原列表的尾部。例如：161.列表1.5增加元素>>>list.insert(0,'x')>>>list['x',1,'a','b',True,'c',5]

方法四：使用insert()方法将一个元素插入到列表的指定位置。该方法有两个参数，第一个参数为插入位置，第二个参数为插入元素。例如：171.列表1.6检索元素

>>>list=['x','y','a','b',True,'x']>>>list.count('x')2

使用count()方法计算列表中某个元素出现的次数。>>>3inlistFalse>>>'x'inlistTrue

使用in运算符检查某个元素是否在列表中。181.列表1.6检索元素

使用index()方法返回某个元素在列表中的准确位置，若该元素不在列表中将会出错。值得注意的是，若使用该方法的元素在该列表中存在相同项，则返回显示最小index的位置，如list.index('x')，存在两个'x'，则只显示最小位置。>>>list.index('x')0191.列表1.7删除元素

方法一：使用del语句删除某个特定位置的元素。>>>list=['x','y','a','b',True,'x']>>>dellist[1]>>>list['x','a','b',True,'x']201.列表1.7删除元素

方法二：使用remove()方法删除某个特定值的元素。remove('x')从list中移除最左边出现的数据项x，如果找不到x就产生ValueError。>>>list=['x','y','a','b',True,'x']>>>list.remove('x')>>>list['y','a','b',True,'x']>>>list.remove('x')>>>list['y','a','b',True]>>>list.remove('x')Traceback(mostrecentcalllast):File"<pyshell#12>",line1,in<module>list.remove('x')ValueError:list.remove(x):xnotinlist211.列表1.7删除元素

方法三：使用pop()方法来弹出（删除）指定位置的元素，缺省参数时弹出最后一个元素。弹出空数组将会报错。>>>list=['x','y','a','b',True,'x']>>>list.pop()'x'>>>list['x','y','a','b',True]>>>list.pop(1)'y'>>>list['x','a','b',True]>>>list.pop(1)'a'221.列表1.7删除元素>>>list.pop(1)'b‘>>>list.pop(1)True>>>list.pop()'x'>>>list[]>>>list.pop()Traceback(mostrecentcalllast):File"<pyshell#54>",line1,in<module>list.pop()IndexError:popfromemptylist

接上一页PPT231.列表1.8字符串和列表的转化>>>s='Micheal'>>>t=list(s)>>>t['M','i','c','h','e','a','l']

字符串是字符的序列，而列表是值的序列，但字符的列表和字符串并不相同。若要将一个字符串转化为一个字符的列表，可以使用函数list。241.列表1.8字符串和列表的转化>>>s='youaresobeautiful'>>>t=s.split()>>>t['you','are','so','beautiful']

由于list是内置函数的名称，所以应当尽量避免使用它作为变量名称。list函数会将字符串拆成单个的字母。如果想要将字符串拆成单词，可以使用split方法。251.列表1.8字符串和列表的转化>>>u='www.studyP'>>>d=u.split()>>>d['www.studyP']

但是下面的例子却失败了，输出了整个列表。>>>u='www.studyP'>>>c=u.split('.')>>>c['www','studyPython','com','cn']

这时候就要用split接受一个可选的形参，作为分隔符，用于指定用哪个字符来分割单词。例如上面的例子可以用一个“.”作为分隔符，如下所示。261.列表1.8字符串和列表的转化

join是split的逆操作。它接收字符串列表，并拼接每个元素。join是字符串的方法，所以必须在分隔符上调用它，并传入列表作为实参。>>>t=['you','are','so','beautifil']>>>s=''.join(t)>>>s'youaresobeautifil'271.列表1.8列表的常用函数>>>list1=[123,'xyz']>>>list2=[123,'abc']>>>cmp(list1,list2)1>>>cmp(list2,list1)-1>>>list2=list1>>>cmp(list1,list2)0281.列表1.8列表的常用函数>>>len(list1)2291.列表1.8列表的常用函数max()和min()格式：max(列表)min(列表)。功能：返回列表中的最大或最小元素。>>>str_l=['abc','xyz','123']>>>num_l=[123,456,222]>>>max(str_l)'xyz'>>>min(str_l)'123'>>>max(num_l)456>>>min(num_l)123301.列表1.8列表的常用函数sorted()和resersed()格式：sorted(列表)reversed(列表)。功能：前者的功能是对列表进行排序，默认是按升序排序，还可在列表的后面增加一个reverse参数，其等于True则表示按降序排序；后者的功能是对列表进行逆序。>>>list=[1,4,3,6,9,0,2]>>>forxinreversed(list): printx,2096341>>>sorted(list)[0,1,2,3,4,6,9]>>>sorted(list,reverse=True)[9,6,4,3,2,1,0]311.列表1.8列表的常用函数sum()格式：sum(列表)。功能：对数值型列表的元素进行求和运算，对非数值型列表运算则出错。>>>sum(list)25>>>sum(str_l)Traceback(mostrecentcalllast):File"<pyshell#26>",line1,in<module>sum(str_l)TypeError:unsupportedoperandtype(s)for+:'int'and'str32目录2023/5/1721.列表2.元组3.字典4.集合5.组合数据类型的高级特性332.元组

元组（tuple）是值的一个序列。其中的值可以是任何类型，并且按照整数下标索引，与列表类似。但元组中的元素不能修改，列表中的元素可以修改。342.1元组与列表的区别

元组基本上都是不可改变的列表。元组几乎具有列表所有的特性，除开那些违反不变性的特征。也就是说，没有函数和方法可以改变元组。

不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。当后续介绍字典类型时，会发现字典的键必须是不可变的，因此元组可以用作字典的键，但列表不能。352.元组2.1元组与列表的区别

语法上，元组就是用逗号分隔的一列值，使用“=”将元组赋给变量。

>>>tuple1='a','1','boy'

虽然并不必需，但元组常常用括号括起来。

>>>tuple1=('a','1','boy') >>>tuple1 ('a','1','boy')362.元组2.1元组与列表的区别

新建元组的另一种形式是使用内置函数tuple。不带参数时，它会新建一个空元组。

>>>t=tuple() >>>t ()372.元组2.1元组与列表的区别

则定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义。因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。所以，只有一个元素的tuple定义时必须加一个逗号“,”来消除歧义，即： >>>t=(1,) >>>t (1,)

但是，要定义一个只有一个元素的tuple，例如：

>>>t=(1) >>>t 1382.元组2.1元组与列表的区别

其他序列（列表和字符串）的操作都可用于元组，除了那些会违反不变性的列表运算符。“+”和“*”运算符同样适用于元组。成员操作（in）和for循环同样适用于元组长度（len）、最大（max）和最小（min）同样适用于元组。

没有任何的操作能更改元组。例如append、extend、insert、remove、pop、reverse和sort不能用于元组。392.元组2.2元组的常用操作

由于元组和列表比较相似，使得对列表的很多操作如“+”、“*”等运算符以及长度（len）、最大（max）、最小（min）等运算都适用于元组。而那些如append、extend、insert、remove、pop、reverse和sort等能改变元素的操作都不能直接操作元组。

然而，当元组中存在列表元素项时，就可以使用上述如append等方法修改list中的元素，达到间接修改元组元素的目的。402.元组2.3元组的常用函数

元组的常用函数与列表类似，除了那些会违反不变性的函数。语

法描

述cmp(tuple1,tuple2)比较两个元组元素len(tuple)计算元组元素个数max(tuple)返回元组中元素最大值min(tuple)返回元组中元素最小值tuple(seq)将列表转换为元组41目录1.列表2.元组3.字典4.集合5.组合数据类型的高级特性423.字典

字典是一种集合，它不是序列。字典可以看成元素对构成的列表，其中一个元素是键，另一个元素是值。在搜索字典时，首先查找键，当查找到键后就可以直接获取该键对应的值，效率很高，是一种高效的查找方法。433.字典3.1创建字典

与列表、元组不同的是，字典是以“{”和“}”定义的，而且字典中每个元素包含两个部分，即键和值。下面给出了一些实例，展示了各种语法，这些语法产生的是相同的字典。443.字典3.1创建字典>>>d1=dict({"id":19,"name":"Marry","city":"chongqing"})>>>d2=dict(id=19,name="Marry",city="chongqing")>>>d3=dict([("id",19),("nmae","Marry"),("city","chongqing")])>>>d4=dict(zip(("id","name","city"),(19,"Marry","chongqing")))>>>d5={"id":19,"name":"Marry","city":"chongqing"}>>>d1{'name':'Marry','id':19,'city':'chongqing'}>>>d2{'name':'Marry','id':19,'city':'chongqing'}>>>d3{'name':'Marry','id':19,'city':'chongqing'}>>>d4{'name':'Marry','id':19,'city':'chongqing'}>>>d5{'name':'Marry','id':19,'city':'chongqing'}453.字典3.2查找与反向查找>>>d1['id']19>>>d1["name"]'Marry'>>>d1["chongqing"]Traceback(mostrecentcalllast):File"<pyshell#3>",line1,in<module>d1["chongqing"]KeyError:'chongqing'

字典定义好后，可以通过键来查找值，这个操作称为“查找”。463.字典3.2查找与反向查找>>>defreverse_lookup(d,v): forkind: ifd[k]==v: returnk raiseLookupError()

对于字典的操作通常是通过键来查找值，而能不能通过一个给定的值来确定其键呢？

由于字典是一对多的关系，即一个键可能对应多个值，若想根据一个值来确定其键时，只能通过暴力搜索的方法。下面给出一个简单的暴力搜索实例，该段代码接收一个值，并返回映射到该值的键：473.字典3.3遍历字典>>>forkeyind1.keys(): print(key,d1[key])

nameMarryid19cityChongqing

用循环语句来遍历字典中的每个元素的键和值，如下所示：483.字典3.4添加和修改字典>>>d1["name"]="jason">>>d1{'name':'jason','id':19,'city':'chongqing'}>>>d1["sex"]="female">>>d1{'sex':'female','name':'jason','id':19,'city':'chongqing'}

字典的大小和列表都是动态的，即不需要事先指定其容量大小，可以随时向字典中添加新的键—值对，或者修改现有键所关联的值。添加和修改的方法相同，都是使用“字典变量名[键名]=键值”的形式，主要区分在于字典中是否已存在该键—值对，若存在则为修改，否则为添加。例如：493.字典3.4添加和修改字典>>>d1["name"]="jason">>>d1{'name':'jason','id':19,'city':'chongqing'}>>>d1["sex"]="female">>>d1{'sex':'female','name':'jason','id':19,'city':'chongqing'}例如：d1=dict({"id":19,"name":"Marry","city":"chongqing"})，d1中已经存在name键—值对，所以第一个操作是“修改”。d1中原本不存在sex键—值对，所以第二个操作是“添加”。因为字典是无序的，类似于append在尾部添加键—值对的方法是没有任何意义的。503.字典3.5字典长度>>>len(d1)4

与列表、元组相同，可以用len()函数返回字典中键的数量，如下所示。513.字典3.6字典检索>>>"id"ind1True>>>"name"ind1True>>>"NO"ind1False

可以使用in运行符来测试某个特定的键是否在字典中。表达式kind（d为字典）查找的是键，而不是值。523.字典3.6字典检索>>>d1={'sex':'female','name':'jason','id':19,'city':'chongqing'}>>>vals=d1.values()>>>"jason"invalsTrue

查看一个值是不是出现在字典中，可以使用方法values，它返回该字典的所有值的一个集合，然后检索当前值是否在集合中即可，例如：533.字典3.7删除元素和字典可以使用del语句删除指定键的元素或整个字典；使用clear()方法来删除字典中所有元素；使用pop()方法删除并返回指定键的元素；popitem()弹出随机的项。543.字典3.8字典的常用函数copy()：返回一个具有相同键—值对的新字典，该新字典是原来字典的一个副本（这个方法实现的是浅拷贝）。fromkeys()：使用给定的键建立新的字典，每个默认对应的值为None。get()：get方法是一个更宽松的访问字典项的方法。一般来说，如果试图访问字典中不存在的项时会出错。items()：items方法将所有的字典项以列表的方式返回，这些列表项中的每一项都来自于(键,值)。553.字典3.8字典的常用函数keys()：将字典中的键以列表形式返回。setdefault()：能够获得与给定键相关联的值，除此之外，setdefault还能在字典中不含有给定键的情况下设定相应的键值。update()：利用一个字典项更新另一个字典，若有相同的键存在，则会进行覆盖。561.列表2.元组3.字典4.集合5.组合数据类型的高级特性目录574.集合

集合（set）是0个或多个对象引用的无序组合，这些对象所引用的对象都是可哈希运算的。集合是可变的，因此可以很容易地添加或移除数据项，但由于其中的项是无序的，因此，没有索引位置的概念。

在集合中，任何元素都没有重复，这是集合的一个非常重要的特点。 set和dict类似，是一组key的集合，但不存储value，且在set中没有重复的key。584.集合4.1创建集合

可以通过调用集合的构造函数来创建一个集合。和前文许多其他数据结构不同，创建集合没有快捷方式。因此，要创建集合，必须使用set构造函数。set构造函数至多有一个参数。如果没有参数，set会创建空集。如果有一个参数，那么参数必须是可迭代的，例如字符串或列表，可迭代对象的元素将生成集合的成员。594.集合4.1创建集合没有参数，set会创建空集。>>>nullSet=set()>>>nullSetset()提供一个str作为输入集合，创建一个set。>>>a_set=set('abcd')>>>a_set{'a','c','b','d'}提供一个list作为输入集合，创建一个set。>>>s=set([1,2,3])>>>s{1,2,3}重复元素在set中自动被过滤。>>>s=set([1,1,2,2,3,3])>>>s{1,2,3}604.集合4.2添加元素

通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果。例如：

>>>s.add(4) >>>s {1,2,3,4} >>>s.add(4) >>>s {1,2,3,4}614.集合4.3删除元素通过remove(key)方法可以删除元素。例如：discard(key)也可删除元素，不同的是，如果删除的元素不在集合中，remove会报错，discard不会报错。例如：clear()删除集合的所有元素（使它成为空集）。624.集合4.4典型的集合运算符len()：和所有集合类型一样，len函数可以确定集合中的元素数量。in：判断某元素是否在集合中。in运算符根据元素是否在集合中返回布尔值True或False。for：和所有集合类型一样，for语句能遍历集合中的元素。634.集合4.5典型的数学集合运算交集 >>>s1=set([1,2,3]) >>>s2=set([2,3,4]) >>>ersection(s2) {2,3} >>>s1&s2 {2,3}644.集合4.5典型的数学集合运算并集 >>>s1.union(s2) {1,2,3,4} >>>s1|s2 {1,2,3,4}654.集合4.5典型的数学集合运算差集 >>>s1.difference(s2) {1} >>>s2.difference(s1) {4} >>>s1-s2 {1} >>>s2-s1 {4}664.集合4.5典型的数学集合运算对称差 >>>s1.symmetric_difference(s2) {1,4} >>>s2.symmetric_difference(s1) {1,4}674.集合4.5典型的数学集合运算子集和超集>>>sSet=set([1,2,3])>>>bSet=set([1,2,3,4,5,6])>>>sSet.issubset(bSet)True>>>bSet.issubset(sSet)False>>>sSet.issuperset(bSet)False>>>bSet.issuperset(sSet)True>>>sSet.issubset(sSet)True>>>sSet.issuperset(sSet)True684.集合4.6集合的常用函数

前一小节集合的常用操作已经把集合的用法介绍得差不多了，这里就补充几个集合的常用函数，如表3-2所示。语

法描

述s.copy()返回一个新集合，它是集合s的浅拷贝s.update(t)用t中的元素修改s，即s现在包含s或t的成员ersection_update(t)s中的成员是共同属于s和t的元素s.symmetric_difference_update(t)s中的成员更新为那些包含在s或t中，但不是s和t共有的元素表3-2 集合的常用函数69目录1.列表2.元组3.字典4.集合5.组合数据类型的高级特性705.组合数据类型的高级特性5.1切片L[a:b]表示从索引a开始取，直到索引b为止，但不包括索引b。取前3个元素，用一行代码就可以完成切片。从索引1开始，取出2个元素：支持倒数切片。L[-1]取倒数第一个元素>>>L=['Michael','Sarah','Tracy','Bob','Jack']>>>L[0:3]['Michael','Sarah','Tracy']>>>L[1:3]['Sarah','Tracy']715.组合数据类型的高级特性5.1切片——简单应用>>>L=list(range(100))>>>L[0,1,2,3,…,99]>>>L[-10:][90,91,92,93,94,95,96,97,98,99]>>>L[:10][0,1,2,3,4,5,6,7,8,9]725.组合数据类型的高级特性5.1切片——简单应用前11~20个数：>>>L[10:20][10,11,12,13,14,15,16,17,18,19]>>>L[::5][0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95]前10个数，每两个取一个：>>>L[:10:2][0,2,4,6,8]所有数，每5个取一个：735.组合数据类型的高级特性5.1切片——tuple切片、字符串切片tuple也是一种list，唯一区别是tuple不可变。因此，tuple也可以用切片操作，只是操作的结果仍是tuple。>>>(0,1,2,3,4,5)[:3](0,1,2)>>>'ABCDEFG'[:3]'ABC'>>>'ABCDEFG'[::2]'ACEG'745.组合数据类型的高级特性5.2迭代——可迭代对象的迭代

列表这种数据类型有下标，但很多其他数据类型是没有下标的，但是，只要是可迭代对象，无论有无下标，都可以迭代。755.组合数据类型的高级特性5.2迭代——可迭代对象的迭代字典的迭代>>>d={'a':1,'b':2,'c':3}>>>forkeyind:print(key)

acb

由于字典是无序的，因此迭代出的结果顺序可能与上述结果不一样。

默认情况下，dict迭代的是key。如果要迭代value，可以用forvalueind.values()，如果要同时迭代key和value，可以用fork,vind.items()。765.组合数据类型的高级特性5.2迭代——可迭代对象的迭代集合的迭代>>>s=set([1,2,3,4])>>>s{1,2,3,4}>>>forxins: print(x)

1234775.组合数据类型的高级特性5.2迭代——可迭代对象的迭代>>>forchin'ABC':print(ch)

ABC

所以，当我们使用for循环时，只要作用于一个可迭代对象，for循环就可以正常运行，而我们不用太关心该对象究竟是list还是其他数据类型。字符串的迭代785.组合数据类型的高级特性>>>fromcollectionsimportIterable>>>isinstance('abc',Iterable #str是否可迭代True>>>isinstance([1,2,3],Iterable) #list是否可迭代True>>>isinstance(123,Iterable) #整数是否可迭代False

对于一个对象，通常是通过collections模块的Iterable类型判断该对象是否是一个可迭代的对象，如：5.2迭代——Iterable类型795.组合数据类型的高级特性5.2迭代——列表实现下标循环

如果要对list实现类似Java那样的下标循环，要怎么办呢？Python内置的enumerate函数可以把一个list变成索引—元素对，这样就可以在for循环中同时迭代索引和元素本身。>>>fori,valueinenumerate(['A','B','C']):print(i,value)

0A1B2C805.组合数据类型的高级特性5.3列表生成式——一层循环>>>list(range(1,11))[1,2,3,4,5,6,7,8,9,10]要生成list[1,2,3,4,5,6,7,8,9,10]，可以用list(range(1,11))：>>>L=[]>>>forxinrange(1,11):L.append(x*x)

>>>L[1,4,9,16,25,36,49,64,81,100]但如果要生成[1×1,2×2,3×3,…,10×10]，可使用下列语句。815.组合数据类型的高级特性5.3列表生成式——一层循环>>>[x*xforxinrange(1,11)][1,4,9,16,25,36,49,64,81,100]利用列表生成式可以用一行语句代替循环生成上面的list。>>>[x*xforxinrange(1,11)ifx%2==0][4,16,36,64,100]for循环后面还可以加上if判断，这样我们就可以筛选出仅偶数的平方。825.组合数据类型的高级特性5.3列表生成式——一层循环>>>L=['Hello','World','IBM','Apple']>>>[s.lower()forsinL]['hello','world','ibm','apple']另外，也可把一个list中所有的字符串变成小写：835.组合数据类型的高级特性5.3列表生成式——两层循环>>>[m+nformin'ABC'fornin'XYZ']['AX','AY','AZ','BX','BY','BZ','CX','CY','CZ']下面看一个两层循环的例子。

上例同时执行formin'ABC'循环和fornin'XYZ'循环，然后再执行m+n。845.组合数据类型的高级特性5.4生成器

通过列表生成式，我们可以直接创建一个列表。但由于计算机内存有限，当生成一个列表时，由于受到计算机内存容量的限制，我们需要使用合理的方法生成列表。例如，对于一个包含百万数目的列表，无法直接创建该列表。如果该列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？答案是肯定的，而这样做的好处是不必创建完整的list，可以节省大量的空间。

在Python中，这种一边循环一边计算的机制，称为生成器（generator）。

855.组合数据类型的高级特性5.4生成器——简单生成器要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator。>>>L=[x*xforxinrange(10)]>>>L[0,1,4,9,16,25,36,49,64,81]>>>g=(x*xforxinrange(10))>>>g<generatorobject<genexpr>at0x1022ef630>865.组合数据类型的高级特性5.4生成器——带yield语句的生成器

如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator。

这里最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而generator函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。875.组合数据类型的高级特性5.4生成器——递归生成器 >>>defflatten(nested): try: #不要迭代类似字符串的对象 try:nested+'' exceptTypeError:pass else:raiseTypeError forsublistinnested: forelementinflatten(sublist): yieldelement exceptTypeError: yieldnested如果要处理任意层的嵌套怎么办？每层