python内置的序列数据类型包括_python内置数据类型：列表

列表和字典

列表和字典这两个对象类型都是其他对象的集合。这两种类型几乎是Python所有脚本的主要工作组件。这两种类型都相当灵活&＃xff1a;它们都可以在原处进行修改&＃xff0c;也可以按需求增长或缩短&＃xff0c;而且可以包含任何种类的对象或者被嵌套。借助这些类型&＃xff0c;可以在脚本中创建并处理任意的复杂的信息结构。

列表

列表是Python中最具灵活性的有序集合对象类型。与字符串不同的是&＃xff0c;列表可以包含任何种类的对象&＃xff1a;数字、字符串甚至其他列表。同样&＃xff0c;与字符串不同&＃xff0c;列表是可变对象&＃xff0c;支持在原处修改的操作&＃xff0c; 可以通过指定的偏移值和分片、列表方法调用、删除语句等方法来实现。

Python中的列表可以完成大多数集合体数据结构的工作&＃xff0c;

python列表属性

任意对象的有序集合

从功能上看&＃xff0c;列表就是收集其他对象的地方&＃xff0c;可以把它们看做组。同时列表所包含的每一项都保持了从左到右的位置顺序(也就是说&＃xff0c;它们是序列)。

通过偏移读取

可以通过的偏移对列表对象进行索引&＃xff0c;从而读取对象的某一部分内容。由于列表的毎一项都是有序的&＃xff0c;那么可以执行如分片和合并之类的任务。

可变长度、异构以及任意嵌套

列表可以实现的增长或者缩短(长度可变)&＃xff0c;并且可以包含任何类型的对象(异构)。因为列表能够包含其他复杂的对象&＃xff0c;又能够支持任意的嵌套&＃xff0c;所以可以创建列表的子列表的子列表.....

属于可变序列的分类

就类型分类而言&＃xff0c;列表支持在原处的修改(它们是可变的),也可以使用所有针对字符串序列的操作&＃xff0c;例如&＃xff0c;索引、分片以及合并这样的序列操作在列表与字符串中的工作方式是相同的。唯一的区别是&＃xff1a;当应用于字符串上的合并和分片这样的操作应用于列表时&＃xff0c;是返回新的列表对象。然而列表是可变的&＃xff0c;因此列表也支持字符串不支持的其他操作(例如&＃xff0c;删除和索引赋值操作&＃xff0c;切片赋值操作&＃xff0c;它们都是在原处修改列表)。

对象引用数组

Python列表包含了零个或多个其他对象的引用&＃xff0c;从Python的列表中读取一个项的速度与索引一个C语言数组差不多。实际上&＃xff0c;在标准Python解释器内部&＃xff0c;列表就是C数组而不是链接结构。(每当用到引用时&＃xff0c;Python总是会将这个引用指向一个对象&＃xff0c;所以程序只需处理对象的操作。当把一个对象赋给一个数据结构元素或变量名时&＃xff0c;Python总是会存储对象的引用&＃xff0c;而不是对象的一个拷贝(除非明确要求保存拷贝))

列表常量和操作

可以査阅Python的标准库手册&＃xff0c;或者运行help(list)或dir(list)査看list方法的完整列表清单&＃xff0c;也可以传入一个真正的列表&＃xff0c;或者列表数据类型的名称——list这个单单词获取

列表常量与操作

序列操作

1.len(list)&＃xff1a;列表元素个数

2.max(list)&＃xff1a;返回列表元素最大值

3.min(list)&＃xff1a;返回列表元素最小值

4.list(tuple)&＃xff1a;将元组转换为列表

5.list(str):将字符串转换成列表

列表内置方法

6.l1 &＃61; [] &＃xff1a;创建一个空列表

7.l3 &＃61; [1,&＃39;b&＃39;]&＃xff1a;列表异构

8.l4 &＃61; [[1,2],[&＃39;a&＃39;,&＃39;b&＃39;]]&＃xff1a;列表嵌套

9.l2[1:3] &＃61; [] &＃xff1a;把指定的切片定义为空

10.del(list[])&＃xff1a;删除列表中的某元素或切片 #del list[]

11.list.append()&＃xff1b;在列表末尾添加新的对象(只能添加一个元素)&＃xff1b;也可将另一个序列(列表、元组)当成一个元素附加至当前列表的末尾(用于实现列表嵌套)

12.list.extend()&＃xff1b;在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)

13.list.count()&＃xff1a;用于统计指定值在列表中出现的次数

14.list.index()&＃xff1a;查找列表中指定值第一次出现的位置

15.list.insert(index,object)&＃xff1a;在指定索引(偏移)位置之前插入一个对象

16.list.pop():弹出列表中某一个指定索引中的元素&＃xff1b;并且返回该元素的值&＃xff0c;默认弹出最后一个索引中的元素

17.list. remove()&＃xff1a;删除指定值第一次出现的位置

18.list.reverse()&＃xff1a;在原处直接进行逆序

19.list.sort()&＃xff1a;原处排序(升序)

20.list.clear()&＃xff1a;清空列表&＃xff0c;成为一个空列表

20&＃xff0e;列表相加:

l1 &＃43; l2 :合并两个列表&＃xff0c;返回一个新的列表&＃xff0c;不会修改原列表

21&＃xff0e;列表相称操作:

list * N: 把list中的元素重复N次&＃xff0c;返还一个新列表&＃xff0c;

22&＃xff0e;列表in操作

in&＃xff1a;成员关系判断字符&＃xff1b;#在指定的容器中是否出现了指定的元素(存在为True&＃xff0c;不存在为False)

用法&＃xff1a;

object in container

列表not in操作

not in&＃xff1a;成员关系判断字符&＃xff1b;#在指定的容器中是否出现了指定的元素(存在为False&＃xff0c;不存在为True)

用法&＃xff1a;

object not in container

23&＃xff0e;列表复制方式

方法1&＃xff1a;l1 &＃61; [1,2,3]&＃xff1b;l2 &＃61; l1[:] ; 定义l2等于l1中的所有元素

方法2&＃xff1a;导入模块copy 使用copy.deepcopy方法&＃xff1b;深度复制一个指定的内存对象

import copy

l2 &＃61; copy.deepcopy(l1)

基本列表操作

由于列表是序列&＃xff0c;它支持与字符串很多相同的操作&＃xff0c;例如&＃xff1a;“&＃43;” 表示合并&＃xff0c;“*”表示重复&＃xff0c;这两个操作的结果都是创建了一个新的列表

>>> [1, 2, 3] &＃43; [4, 5, 6]

[1, 2, 3, 4, 5, 6]

>>> [&＃39;Ni!&＃39;] * 4

[&＃39;Ni!&＃39;, &＃39;Ni!&＃39;, &＃39;Ni!&＃39;, &＃39;Ni!&＃39;]

列表的“&＃43;”操作和字符串中的一样&＃xff0c;但是“&＃43;”两边必须是相同类型的序列对象&＃xff0c;否则运行时会出现类型错误。

例如&＃xff0c;不能将列表和字符串“&＃43;”合并到一 起&＃xff0c;除非先把列表转换为字符串(使用诸如反引号、str或者%格式这样的工具)&＃xff0c;或者是把字符串转换为列表(列表内置函数能完成这一转换)

>>> [1, 2] &＃43; "34" #错误提示如下

Traceback (most recent call last):

File "", line 1, in

TypeError: can only concatenate list (not "str") to list

>>> str([1,2]) &＃43; "34" #将列表通过内置函数str()转换为字符串&＃xff0c;在与字符串“34”合并

&＃39;[1, 2]34&＃39;

>>> [1,2]&＃43;list("34") #将字符串“34”通过内置函数list()转换为字符串&＃xff0c;在与列表[1,2]合并

[1, 2, &＃39;3&＃39;, &＃39;4&＃39;]

列表迭代和解析

字符串使用的所有序列操作都一样适用与列表&＃xff0c;包括迭代工具

>>> for x in [1,2,3]:

... print(x, end&＃61;&＃39; &＃39;)

...

1 2 3

>>> 3 in [1, 2, 3]

True

for循环从左到右遍历序列中的每一项&＃xff0c;对每一项执行一条语句或多条语句&＃xff0c;列表解析是通过对序列中的每一项应用一个表达式&＃xff0c;来构建一个新的列表的方式&＃xff0c;它与for相关

>>> res &＃61; [ c * 4 for c in &＃39;SPAM&＃39;]

>>> res

[&＃39;SSSS&＃39;, &＃39;PPPP&＃39;, &＃39;AAAA&＃39;, &＃39;MMMM&＃39;]

这个表达式功能上等同于手动构建一个结果的列表的一个for循环

>>> res &＃61; []

>>> for c in &＃39;SPAM&＃39;:

... res.append(c * 4)

...

>>> res

[&＃39;SSSS&＃39;, &＃39;PPPP&＃39;, &＃39;AAAA&＃39;, &＃39;MMMM&＃39;]

内置函数map也做类似的工作&＃xff0c;但它是对序列中的每一项应用一个函数并把结果收集到一个新的列表中

>>> list(map(abs, [-1, -2, 0, 1, 2]))

[1, 2, 0, 1, 2]

索引、分片和矩阵

由于字符串和列表都是序列&＃xff0c;对于列表而言&＃xff0c;索引和分片与字符串的操作基本相同&＃xff0c;对列表进行索引的结果就是指定偏移处的对象(无论对象是什么类型)并返回一个新的列表&＃xff0c;而对列表进行分片也是返回一个新的列表

>>> L &＃61; [&＃39;spam&＃39;, &＃39;Spam&＃39;, &＃39;SPAM!&＃39;]

>>> L[2] #索引

&＃39;SPAM!&＃39;

>>> L[-2] #负索引

&＃39;Spam&＃39;

>>> L[1:] #切片&＃xff0c; 结果是返回一个新的列表

[&＃39;Spam&＃39;, &＃39;SPAM!&＃39;]

由于可以在列表中嵌套列表(和其他对象类型)&＃xff0c;有时需要将几次索引操作连在一起使用来深入到数据结构中去&＃xff0c;最简单的方法之一是将列表表示为矩阵(多维数组)&＃xff0c;在python中相当于嵌套了子列表的列表&＃xff0c;这里是一个基于列表的 3x3 的二维数组

>>> matrix &＃61; [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

使用一次索引&＃xff0c;会得到一个嵌套的子列表&＃xff0c;如果使用两次索引才能得到某一子列表中的其中一项

>>> matrix[1]

[4, 5, 6]

>>> matrix[1][1]

5

>>> matrix[2][0]

7

>>> matrix[2][-1]

9

原处修改列表

列表是可变的&＃xff0c;支持原处改变列表对象的操作&＃xff0c;但是&＃xff0c;如果在原处修改一个对象时&＃xff0c;可能会影响到一个以上指向它的引用

>>> L &＃61; [&＃39;spam&＃39;, &＃39;Spam&＃39;, &＃39;SPAM!&＃39;]

>>> L[1] &＃61; &＃39;eggs&＃39; #将列表L中偏移为1的元素值修改为&＃39;eggs&＃39;

>>> L

[&＃39;spam&＃39;, &＃39;eggs&＃39;, &＃39;SPAM!&＃39;]

>>> L[0:2] &＃61; [&＃39;eat&＃39;, &＃39;mote&＃39;] #分片赋值

>>> L

[&＃39;eat&＃39;, &＃39;mote&＃39;, &＃39;SPAM!&＃39;]

索引和分片的赋值都是在原处修改&＃xff0c;而不是生成一个新的列表对象

列表分片赋值&＃xff0c;可以分成两步理解&＃xff1a;

1, 删除&＃xff0c;删除等号左边指定的分片

2, 插入&＃xff0c;将等号右边的对象中插入到左边分片被删除的位置

这样有助于理解为什么插入元素的数目不需要于删除的数目相匹配&＃xff0c;例如&＃xff0c;已知一个列表L的值为[1,2,3],陚值操作L[1:2] &＃61; [4,5]会把L修改成列表 [1,4,5,3]。Python会先删除2 (单项分片)&＃xff0c;然后在删除2的地方插入4和5。这也解释了为什么L[l:2] &＃61; []实际上是刪除操作——Python刪除分片(偏移为1的项)之后什么也不插入。

分片陚值是一次性替换整个片段。因为被賦值的序列长度不一定要与陚值的分片的长度相匹配&＃xff0c;所以分片陚值能够用来替换、增长、 缩短主列表。在实践当中这是不常见的操作

列表方法调用

列表方法调用很多是原处修改主体列表的

>>> L

[&＃39;eat&＃39;, &＃39;mote&＃39;, &＃39;SPAM!&＃39;]

>>> L.append(&＃39;please&＃39;)

>>> L

[&＃39;eat&＃39;, &＃39;mote&＃39;, &＃39;SPAM!&＃39;, &＃39;please&＃39;]

>>> L.sort()

>>> L

[&＃39;SPAM!&＃39;, &＃39;eat&＃39;, &＃39;mote&＃39;, &＃39;please&＃39;]

方法是附属于特定对象的函数(方法实际上是引用函数的属性)方法提供特定类型的工具&＃xff0c; 例如列表的方法只能适用于列表

append方法&＃xff1a;是简单的将一个单项(对象引用)追加至列表末端&＃xff0c;与合并“&＃43;”不同的是&＃xff0c;append允许传入单一个对象而不是列表(如果传入的是一个列表或元组&＃xff0c;也会把列表看着是一个元素来追加至当前列表末端)&＃xff0c;L.append(x)与L&＃43;[x]的结果类似&＃xff0c;不同的是&＃xff0c;L.append(x)是直接原处修改L&＃xff0c; L&＃43;[x]会生成新的列表

sort方法&＃xff1a;对列表进行原处排序&＃xff0c;sort是使用python标准的比较校验作为默认值&＃xff0c;以递增的顺序进行排序(升序)

改变sort方法的排序行为&＃xff1a;可以通过传入关键字参数来修改排序行为&＃xff0c;这里是指按名称的函数调用中特殊的“name&＃61;value”语法&＃xff0c;常常用来给定配置选项&＃xff0c;在排序中&＃xff0c;key参数给出了一个单个参数的函数&＃xff0c;它返回在排序中使用的值&＃xff0c;reverse参数允许排序是按照降序而不是升序进行

>>> L &＃61; [&＃39;abc&＃39;, &＃39;ABD&＃39;, &＃39;aBe&＃39;]

>>> L.sort()

>>> L

[&＃39;ABD&＃39;, &＃39;aBe&＃39;, &＃39;abc&＃39;]

>>> L &＃61; [&＃39;abc&＃39;, &＃39;ABD&＃39;, &＃39;aBe&＃39;]

>>> L.sort(key&＃61;str.lower)

>>> L

[&＃39;abc&＃39;, &＃39;ABD&＃39;, &＃39;aBe&＃39;]

>>> L &＃61; [&＃39;abc&＃39;, &＃39;ABD&＃39;, &＃39;aBe&＃39;]

>>> L.sort(key&＃61;str.lower, reverse&＃61;True) #其结果等效于&＃xff1a;L.sort() , L.reverse()

>>> L

[&＃39;aBe&＃39;, &＃39;ABD&＃39;, &＃39;abc&＃39;]

注意啦&＃xff01;

在Python 2.6中不同类型的对象是可进行比较的(例如&＃xff0c;字符串和列表)---- python在不间类型之中都定义了一个固定的顺序&＃xff0c;也就是说&＃xff0c;次序是根据的类型名称而定的。例如&＃xff0c;所有整数都小于所有字符串&＃xff0c;因为”int"比”str"小。比较运算时绝不会自动转换类型&＃xff0c;除非是在比较数值类型对象。

在Python 3.0中&＃xff0c;不同类型的比较不再依赖于固定的跨类型之间的排序&＃xff0c;而是引发一个异常。因为排序是在内部进行比较&＃xff0c;这意味着[1, 2,&＃39;spam&＃39;].sort()在Python 2.X中是能行得通的&＃xff0c;但是在Python 3.0中则会发生异常。Python 3.0也不再支持&＃xff1a;传入一个任意的比较函数来进行排序以实现不同的顺序。解决方法是使用key&＃61;func关键字参数在排序时编码值的转换&＃xff0c;并且使用reverse&＃61;True关键字参数把排序顺序改为降序。这些都是过去比较函数的典型用法。

append和“&＃43;”合并不同&＃xff0c;append不会创建一个新的对象&＃xff0c;执行效率很高&＃xff0c;也可以使用分片运算模拟append的效果&＃xff0c;L[len(L):] &＃61; [x]就与L.append(x)一样&＃xff0c;而L[:0]&＃61;[x]就好像在列表前段附加一样&＃xff0c;两者都会删除空分片&＃xff0c;并插入X&＃xff0c;快速地在适当之处修改L&＃xff0c;就像append一样

append和sort都是原处修改列表对象&＃xff0c;两者返回的值皆为None(而结果并没有返回列表)。如果编辑类似L&＃61;L.append(X)的语句&＃xff0c;将不会得到L 修改后的值(实际上&＃xff0c;将会失去整个列表的引用)&＃xff0c;当使用append和sort之类的属性时&＃xff0c; 对象的修改有点像副作用&＃xff0c;所以没有理由再重新赋值。

内置函数sorted()

排序也在最新的Python版本中可以作为内置函数sorted()使用了&＃xff0c;它可以排序任何集合(序列)(不只是列表) 并且针对结果返回一个新的列表(而不是原处修改)

>>> L &＃61; [&＃39;abc&＃39;, &＃39;ABC&＃39;, &＃39;aBc&＃39;]

>>> sorted(L, key&＃61;str.lower, reverse&＃61;True)

[&＃39;abc&＃39;, &＃39;ABC&＃39;, &＃39;aBc&＃39;]

>>> sorted([x.lower() for x in L], reverse&＃61;True)#等效于&＃xff1a;sorted((x.lower() for x in L), reverse&＃61;True)

[&＃39;abc&＃39;, &＃39;abc&＃39;, &＃39;abc&＃39;]

sorted([x.lower() for x in L], reverse&＃61;True) -- 我们可以用一个列表解析在排序之前转换为小写&＃xff0c;但是结果不包含最初的列表的值&＃xff0c;因为这是用key参数来实现的。后者在排序中临时应用&＃xff0c;而不会改变排序的值。内置函数sorted有时候比sort方法更有用。(内置函数sorted()&＃xff1a;会创建一个新的对象&＃xff0c;不会修改原对象)

内置函数reverse()

与字符串相同&＃xff0c;列表有其他方法可执行特定的操作。例如&＃xff0c;reverse可原地反转列表&＃xff0c;extend和pop方法分别能够在末端插入多个元素、刪除一个元素。也有一个 reversed内置函数&＃xff0c;像sorted—样地工作&＃xff0c;但是&＃xff0c;它必须包装在一个list调用中&＃xff0c;因为它是一个迭代器

>>> L &＃61; [1, 2]

>>> L.extend([3,4,5])

>>> L

[1, 2, 3, 4, 5]

>>> L.pop()

5

>>> L

[1, 2, 3, 4]

>>> L.reverse()

>>> L

[4, 3, 2, 1]

>>> list(reversed(L))

[1, 2, 3, 4]

在某些类型的应用程序中&＃xff0c;会把列表的pop和append方法连用&＃xff0c;来实现快速的后进先出&＃xff0c;(LIFO, last-in-first-out)堆栈结构&＃xff0c;列表的末端作为堆栈的顶端&＃xff1a;

>>> L &＃61; []

>>> L.append(1)

>>> L.append(2)

>>> L

[1, 2]

>>> L.pop()

2

>>> L

[1]

pop方法也能接受某一个即将删除并返回的元素的偏移(默认值为最后一个元素)&＃xff0c;偏移是可选的&＃xff0c;其他的列表方法可以通过值删除(remove)某元素&＃xff0c;在偏移处之前插入(insert)某元素&＃xff0c;查找某元素的偏移(index)等

>>> L &＃61; [&＃39;spam&＃39;,&＃39;eggs&＃39;,&＃39;ham&＃39;]

>>> L.index(&＃39;eggs&＃39;)

1

>>> L.insert(1, &＃39;toast&＃39;)

>>> L

[&＃39;spam&＃39;, &＃39;toast&＃39;, &＃39;eggs&＃39;, &＃39;ham&＃39;]

>>> L.remove(&＃39;eggs&＃39;)

>>> L

[&＃39;spam&＃39;, &＃39;toast&＃39;, &＃39;ham&＃39;]

>>> L.pop(1)

&＃39;toast&＃39;

>>> L

[&＃39;spam&＃39;, &＃39;ham&＃39;]

其他常用的列表操作

由于列表是可变的支持原处修改&＃xff0c;可以使用del语句在原处删除某项或某片段(del语句或者是del()函数)

>>> L &＃61; [&＃39;SPAM!&＃39;,&＃39;eat&＃39;, &＃39;mote&＃39;, &＃39;please&＃39;]

>>> del L[0]

>>> L

[&＃39;eat&＃39;, &＃39;mote&＃39;, &＃39;please&＃39;]

>>> del L[1:]

>>> L

[&＃39;eat&＃39;]

>>> L &＃61; [&＃39;SPAM!&＃39;,&＃39;eat&＃39;, &＃39;mote&＃39;, &＃39;please&＃39;]

>>> del(L[0])

>>> L

[&＃39;eat&＃39;, &＃39;mote&＃39;, &＃39;please&＃39;]

>>> del(L[1:])

>>> L

[&＃39;eat&＃39;]

分片赋值式删除外加插入操作&＃xff0c;也可以通过将空列表赋值给分片&＃xff0c;来删除列表片段(L[i:j]&＃61;[]),python 会删除左侧的分片&＃xff0c;然后什么也不插入&＃xff0c;另一方面&＃xff0c;将空列表赋值给一个索引只会在指定的位置存储空列表的引用&＃xff0c;而不是删除

>>> L &＃61; [&＃39;Already&＃39;, &＃39;got&＃39;, &＃39;one&＃39;]

>>> L[1:] &＃61; []

>>> L

[&＃39;Already&＃39;]

>>> L[0] &＃61; []

>>> L

[[]]