Python语言教程之Python序列doc.docx

Python语言教程之Python序列doc.docx

《Python语言教程之Python序列doc.docx》由会员分享，可在线阅读，更多相关《Python语言教程之Python序列doc.docx（9页珍藏版）》请在冰豆网上搜索。

Python语言教程之Python序列doc

Python语言教程之Python序列

Python语言教程Python序列主要内容列表元组字典概述序列是Python中常用的数据存储方法，是按一定的数据顺序排列的。

　　Python中常用的序列结构包括列表、元组、字典、字符串等。

　　List、tuple、string和其他序列都支持双向索引。

第一个元素索引是第二个元素索引，依此类推。

最后一个元素索引是倒数第二个元素索引，依此类推。

　　列表创建和删除列表元素添加列表元素删除列表元素访问和计数成员资格判断切片操作列表排序常用内置函数列表序列操作列表是内置变量序列在Python中是元素的有序集合列表每个数据称为元素列表所有元素都放在一对括号中并用逗号分隔列表中的数据类型可以不同也可以是整数、实数、基本类型作为字符串，偶数列表、elements、dictionary、collections和其他自定义类型的对象是示例:

，，，#CrunchyFrog###RambLade###LarkToox##Spam#，，，#File##File#，方法描述列表追加（x）将元素x添加到列表列表末尾扩展（L）将列表L中的所有元素添加到列表末尾插入（索引，x）在列表的指定位置添加元素xlistremove（x）删除第一个公式元素列表弹出（索引）删除并返回列表对象指定位置的元素列表清除（）删除列表中的所有元素，但保留列表对象此方法在Python中没有列表索引（x）返回值为x的第一个元素的下标列表计数（x）返回列表中指定元素x的出现次数listreverse（）将列表元素放入反向列表排序（）将列表元素放入反向列表复制（）返回列表对象的浅拷贝。

该方法在Python中没有列表。

创建一个空列表使用list（）函数将元组、范围对象、字符串或其他类型的迭代对象类型的数据转换成一个列表。

　　例如:

list=list（（，，）#括号表示元组列表，，，list（范围（，#该范围返回，，，list（#helloworld#）#h#，e#，l#，l#，o##，#w#，o#，r#，l#，#d#x=list（）#createemptylistxlistcreateanddelete内置函数range（）语法为range（开始、停止、步进）第一个参数表示起始值（默认值）第二个参数表示结束值结果不包含该值第三个参数表示步长（默认值）函数返回Pidonx中的rangeiterated对象和包含Pidonx中的几个整数的列表。

　　列表（范围（）），，，，，列表（范围（，，），，，列表派生*（本课程不要求）是一种生成满足特定要求的列表的方法。

　　列表创建和删除删除命令删除整个列表。

如果列表对象指向的值不再有其他对象指向Python，则该值将同时被删除。

　　列表=#A###B##MpilGrim##Z##示例#DelalistalistTraceback（MostRecentCallLast）:

FilePyShell#，Line，InmoduleListNameError:

名称#A列表#未定义列表元素添加（）运算符将元素添加到列表中。

　　实际上并不是向列表中添加元素，而是创建一个新列表来将元素从原始列表中复制到新列表的内存空间中，这又涉及到复制大量的元素。

此操作速度较慢，不建议在添加大量元素时使用。

　　AList=，，alistalist，，，blist，，，additionoflistelements（）append（）方法修改原始列表时，在列表末尾添加元素的速度更快，例如:

aListappend（）#将列表设置为，，，AList，，，comparisonandappend（）两种方法之间的速度差分别生成，，，:

importtimeresult=start=time（）#time模块的time（）函数返回当前时间foriirange（）:

result=resultprint（len（result），#，#，time（）start）result=start=time（）foriirange（）:

resultpend（I）print（len（result），#，#，time（）start）printout:

，，，oflistelementsPython在修改对象的值时使用基于值的自动内存管理方法，它并不真正直接修改变量值，而是将变量指向新值。

　　示例:

A=打印（id（a））#函数id（a）获取A的内存地址A=打印（ID（A））B=打印（id（b））打印结果:

示例:

A=，，，PRINT（ID（A））A=，PRINT（ID（A））B=，，print（id（b））打印结果:

每次执行相同的列表元素时，红色地址不会增加相同的列表元素对于可变序列类型，如列表、设置、字典，情况稍微复杂。

　　以列表为例:

列表包含对元素值的引用，而不是直接包含元素值。

　　当通过下标或通过变量序列对象本身提供的方法添加、来修改序列中元素的值时，删除和修改元素时，内存中列表的起始地址不变，只有值发生变化的元素的地址发生变化。

　　添加列表元素（）使用列表对象的extend（）方法将另一个迭代对象的所有元素添加到列表对象的末尾，而不改变其内存头地址。

　　Aextend（，，）#将a设置为，，a，，，，，id（a）aextend（，，，，，，aextend（（））a，，，，id（a）listelementaddition（）使用list对象的insert（）方法将元素添加到列表的指定位置。

　　ainsert（，，，，，，，，，，insert（）方法涉及插入位置之后所有元素的移动，这将影响处理速度。

尝试添加列表末尾的元素。

例如，使用append（）比较append与Insert:

importtimedefinessert（）:

#define函数Insert（）a=foriirange（）:

aInsert，I）Defappend（）:

a=foriirange（）:

aAppend（I）start=time（）foriirange（）:

Insert（）print（#Insert:

#，time（）start）start=time（）foriirange（）:

Append（）print（#Append:

#，time（）start）操作的结果如下:

Insert:

Append:

list元素的添加（）。

使用乘法扩展列表对象将列表乘以整数以生成新列表。

新列表是原始列表中元素的重复。

　　Alist=，，blist=alistid（alist）id（blist）alist=alist*alist，，，，，blist，，id（alist）id（blist）注意:

当使用*运算符重复包含列表的列表并创建新列表时，它不会创建元素的副本，而是创建对现有对象的引用。

　　因此，当修改其中一个值时，相应的引用也将被修改:

x=none**xnone、none、none、none、none、nonex=x、none、none、none、none=、*x=x、、、、deletionoflistelements（）使用del命令删除列表中指定位置的元素。

　　del命令也可以直接删除整个列表。

　　列表=，，，，delalistalist，，，delalistalistraceback（mostrecetalllast）:

filepyshell#，第行，inmodulelistnamerror:

name#alist#未定义列表元素删除（）使用列表的pop（）方法删除并返回指定位置（默认为最后一个）的元素。

如果给定的索引超出列表范围，将引发异常。

　　列表末尾的操作速度比列表末尾的操作速度快，非列表末尾的操作速度比列表末尾的操作速度慢，删除列表元素（）使用列表对象的remove（）方法删除第一个指定的元素，如果列表中没有要删除的元素，将引发异常。

　　list=，，，，，alistremove（）list，，，q:

如何删除列表中的所有代码？

列表元素访问和计数使用下标直接访问列表元素。

如果下标不存在，则抛出异常。

列表#读取列表=#计算列表、、、、、列表回溯（mostrencetcalllast）:

filepyshell#，第行，InModulealistindexer:

ListIndexOofRange列表元素访问和计数使用列表对象的索引方法获取指定元素第一次出现的索引。

如果没有指定的元素，将引发异常列表。

AListindex（）AListindex（）Traceback（mostrencetcalllast）:

Filepyshell#，line，Inmodulealiistindex（）valueerror:

isnotlist元素计数方法访问和计数列表对象计数指定元素在列表中出现的次数alist=，，，，，，，alistcount（）alistcount（）alistcount（）alistcount（）成员判断如果需要判断列表中是否存在指定值，可以使用in关键字判断列表中是否存在值，并将结果返回为True或False。

　　切片操作切片是Python序列中最重要的操作之一。

它适用于列表、元组、字符串、范围对象和其他类型。

　　切片是使用数字起始位置:

数字结束（但不包括）位置:

数字切片步长（默认）来完成的，以在步长被忽略时忽略最后一个冒号。

　　使用切片可以:

截取列表的任何部分以获得新列表。

　　修改、添加、删除列表中的一些元素切片操作返回一个新列表。

　　由于下标越界，切片操作不会引发异常，但会在列表末尾截断或返回一个空列表。

　　切片操作anlist=，，，，，，，anlist:

:

，，，，，，，anlist:

:

，，，，，anlist:

:

，，，，anlist:

，，，，anlist:

:

，，anlist:

:

，，，，，anlist:

:

#超出范围，，，，，，，，列表:

切片操作切片原位修改列表内容列表=，，alislen（列表）:

alislen（列表）:

=列表，，，a列表:

=，，a列表，，，a列表:

=alistalist=列表（范围（））a切片操作切片返回列表元素列表的浅层副本，，，Blist=anlist#深度复制同一内存地址中的两个数据列表#将其他列表中的一个一起更改为Blist，Blist=anlist，anlist==blittruelistisblistrueid（anlist）id（Blist）#addresssamenlist=，，BList=aList:

:

#浅层副本不同地址列表==bList#list元素相同truealistBlist（aList）==id（Blist）#addressdifferentFasBlist=Blist，，，aLiST，，列表==，，，，，ImportrandomRandom（A列表）#随机排序序列的所有元素列表，，，，，，，，，alistsort（）anlist，，，，，，alistsort（反向=真）anlist，，，，，Alistsort（反向=真）anlist，，，，Alistsort（键=lambdax:

len（str（x）））#lambdax:

len（str（x））是一个匿名函数anlist，以x作为传入参数，，，，，，，#按字符串长度排序表使用已排序的内置函数对列表进行排序，并返回新列表A列表、、、、已排序（A列表）、、、、、、已排序（A列表，反向=真）、、、、、、使用列表对象的反向方法就地反向元素列表=，，，，，，，，，，AListreverse（）列表、，，，，，列表排序使用内置函数反向方法以反向顺序排列列表元素，并返回迭代对象列表=，，，，，，，新迭代=反向（列表）新迭代列表反向操作对象列表对象列表（新迭代）、，，，，，，，，foriinnewit:

print

（1）#（没有遍历输出迭代对象，需要重新创建迭代对象）newiteration=reversed（一个列表）foriinnewit:

print

（1）序列操作中常用的内置函数使用Pythonx中的关系运算符来比较值或序列大小。

您还可以使用对象的le（）及其相关方法。

　　A=，b=，（ab）（ab）ale（b）truegat（b）falsea=，b=，，abtrueabfalse（ab）==true（ab）==true普通内置函数len（list）用于序列运算:

返回列表中的元素数量也适用于tuple、dictionary、string等。

　　最大（列表）、最小（列表）:

返回列表中最大或最小的元素也适用于元组、范围。

　　求和（列表）:

对数字列表的元素求和，对非数字列表出错。

这同样适用于元组、范围。

　　通用内置函数zip（列表，列表，）:

将多个列表对应的位置元素组合成元组，以返回包含这些元组的列表。

　　A=，，b=，，c=zip（a，b）czipobjetactxac=list（c）c（，，（），（），（））常用于序列操作的内置枚举函数:

枚举列表元素返回枚举对象，其中每个元素都是包含下标和值的元组。

　　该函数对tuple、字符串也有效。

　　C=（，），（，），（，）forIteminenumerate（c）:

Print（Item）（，（）（（）（（）（，（）（）（（）（（）（）（，（））计算机编程:

尝试输入一组数字，找出余数被除而余数被除的所有数字。

　　p主题列表lst=，，，，，，请分别使用列表方法sort（）和内置函数sort（）元组按升序、降序对列表进行排序，以创建和删除元组和列表差异序列解包元组，列表相似但属于不可变序列元组。

一旦创建，它的元素不能被任何方法修改。

　　元组的定义方式与列表相同，但是所有元素都在一对括号（和）中定义，而不是在方括号中定义。

　　元组创建和删除使用=将元组分配给变量当只有一个元素时，元组必须有一个，元组（#A#）元组=（#A##B##MPILGRIM##Z##示例#）元组（#A##B##MPILGRIM##Z##示例#）a=aa=，#，不能小于a（，）x=（）#emptytuplex（）tuple创建和删除使用tuple函数将其他序列转换为tupleprint（#abcdefg#）（#a##b##c##d##e##f##g#）anlist=，，，，，tuple（anlist）（，，）s=tuple（）#emptytuples（）使用del删除元组不能删除tuple元素元组和列表之间的差异。

一旦定义，元组中的数据就不能改变。

　　没有append（）、extend（）和insert（）等方法，就无法将元组添加到元组中。

如果没有remove（）或pop（）方法，就不能对元组元素进行元组删除操作。

不能从元组中移除元素。

　　元组比列表快。

不需要更改的元组写保护数据将使代码更加安全。

　　有些元组可以用作字典键（尤其是包含不可变数据的元组，如string、值和其他元组）。

　　列表永远不能用作字典键，因为列表不是不可变的。

　　内置元组（）函数接受列表参数并返回包含相同元素的元组，而列表（）函数接受元组参数并返回列表。

　　序列解包可以使用序列解包函数来分配v元组=（false，#exp#）（x，y，z）=v元组#元组来分配元组。

序列解包对于列表和字典同样有效。

a=、b、c、d=as={lsquoarsquo:

，lsquobrsquo:

，lsquocrsquo:

}#lsquoarquo:

以lsquoarquo为键，依此类推。

　　默认情况下，b、c、d=s#为相应的元素分配键；否则，svalueb#a#c#d#b#序列解包键=#A##b##c##d#值=，，，fork，vinzip（键，值）:

打印（k，v）执行:

ABCDanlist=，，，，blist=，，clist=，，DLIST=列表（zip（列表，blist，Clist））ForIndex，Valueinnumerate（DLIST）:

打印（索引，:

#，值）执行:

:

（，，）:

（，，）字典创建和删除字典元素读取

　　{rsquodeskrsquo，rsquobook}定义字典时，每个元素的键和值用冒号分隔，元素用逗号分隔，所有元素都放在一对大括号{and}中。

　　字典中的每个元素都由两部分组成:

键和值。

向字典中添加键时，必须向键中添加一个值。

　　字典中的关键字可以是任何不可变的数据，例如整数、实数、复数、字符串、元组等。

　　字典中的键不允许重复。

　　Globals（）返回包含当前范围内所有全局变量和值的字典区域设置（）。

locals（）返回包含当前范围内所有局部变量和值的字典。

Use=将字典分配给变量ADICT={#server#:

#dbdivintopythorg###database#:

#MySQl#:

#ADICT{#database#:

#MySQl###server#:

#dbdivintopythorg#}x={}#空字典x{}字典创建和删除字典使用现有数据创建字典:

keys=#a###b##c##d#values=，，，Dictionary=dictionary（zip（keys，values））print（dictionary）{#a#:

，#c#:

，#b#:

:

。

#d#:

}x=dictionary（）#emptydictionaryx{}使用dictionary基于给定的键、值创建字典d=dictionary（name=#dong#，age=）d{#age#:

）。

#name#:

#Dong#}字典创建和删除使用给定内容作为键值的字典创建空白ADICT=DiCtFromKeys（#NAME##AGE##SEX#）ADICT{#AGE#:

NONE，#NAME#:

NONE，#sex#:

None}使用del删除整个字典deladidictraceback（mostrencetcalllast）:

filepyshell#，行，INMODULEADITCNAMEERROR:

NAME#ADICT#未定义字典元素读取关键字作为下标字典元素如果关键字不存在则可以读取异常ADICT={#NAME#:

#DONG###SEX#:

#MANAL##age#:

}ADICT#NAME##DONG#ADICT#tel#traceback（mostrencetcalllast）:

filepyshell#，第行，INMODULEADITCT#tel#Keyerror:

#tel#字典元素读取使用字典对象的get方法来获取与指定关键字对应的值，并且可以在下列情况下返回指定的值

　　print（ADisctGet（#address#））Noneprint（ADisctGet（#address##SDIBT#））SDibtADisctLSquoscore\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u\u列表字典对象的key（）方法返回字典的键。

listdictionary对象的values（）方法返回字典ADICT的值列表={#NAME#:

#DONG###SEX#:

#MANAL##age#:

}ForItemInAdictitems（）:

print（item）（#age#）（#NAME###DONG#）（#SEX##MANAL#）forkey，valueinaDictitems（）:

print（key，Value）字典元素的添加和删除:

print（key）agenamesexualkey（）dictkey（#age##NAME##SEX#）adictvalues（）dictvalues（#DONG）如果不存在，则意味着添加一个key、值对。

　　aDict#age#=aDict{#age#:

，#name#:

#Dong#，#sex#:

#male#}ADict#address#=#SDIBT#ADict{#age#:

，#address#:

#SDIBT#，#name#:

#Dong#，字典元素的添加、修改和删除#sex#:

#male#}使用字典对象的更新方法将另一个字典的键、值对添加到当前字典对象。

如果原始字典具有相同的关键字，请修改相应的值ADICT={#AGE#:

，#score#:

，#NAME#:

#DONG#，#SEX#:

#MANAL#}ADICTITEMS（）（#AGE#），（#score#，），（#NAME#，#DONG#，#SEX##MANAL#）ADICtUpdate（{#AGE#:

，#a#:

#a#，#b#:

#b#}）aDict{#a#:

#a#，#SCORE#:

，，#NAME#:

#DONG#sex#:

#mal#:

#deladice#AGE#aDict{#sex#:

#mal###name#:

#dong###score#:

，}使用字典对象的clear（）方法删除字典中的所有元素aDictclear（）aDict{}使用字典对象的pop（）方法删除并返回指定的关键元素ADICT={#AGE#:

，#SCORE#:

，#NAME#:

#DONG#，#SEX#:

#MANAL#}ADICTPOP（#AGE#）ADICT{#SEX#:

#MANAL###NAME#:

#DONG###SCORE#:

，}使用字典对象的popitem方法随机删除并返回一个元素ADICTPITEM（）（#SEX###MANAL#）ADICT{#NAME#:

#DONG##SCORE#:

，}*字典应用程序案例下面的代码首先生成一个包含随机字符的字符串，然后计算每个字符出现的次数。

　　*importstringimportrandomx=stringasciilettersstringdigitstringpunctuationx#abcdefghijklmnopqrstuvwxyz！

#$#（）*，:

=`{|}~#y=randomchoice（x）foriirange（）#randomchoice（）方法返回一个随机项z=##join（y）d=dict（）forchinz:

dch=dget（ch），*dictionary应用程序案例也可以使用collections模块的defaultdict类来实现此函数。

　　*importstringimportrandomx=stringg