查看: 3645|回复: 0

【Python从入门到精通】（六）Python内置的数据类型-列表（list）和元组（tuple）,...

字体大小: 正常放大

杨利霞

5273 主题	82 听众	17万积分

TA的每日心情

	开心 2021-8-11 17:59

签到天数: 17 天

[LV.4]偶尔看看III

网络挑战赛参赛者

自我介绍: 本人女，毕业于内蒙古科技大学，担任文职专业，毕业专业英语。

群组: 2018美赛大象算法课程

群组: 2018美赛护航培训课程

群组: 2019年数学中国站长建

群组: 2019年数据分析师课程

群组: 2018年大象老师国赛优

电梯直达

1^#

发表于 2021-6-28 11:55 |只看该作者 |倒序浏览

|招呼Ta 关注Ta

【Python从入门到精通】（六）Python内置的数据类型-列表（list）和元组（tuple）,九浅一深，十个章节，不信你用不到

文章目录
一浅: 列表（list）的介绍
二浅：列表的操作
三浅：向列表中新增元素
四浅：修改列表中的元素
五浅：删除列表中的元素
六浅：列表中元素的查找以及访问
访问列表中的元素
查找某个元素在列表中出现的位置 index()
七浅：列表使用技巧及注意事项
Python新增元素中各个方法的区别
八浅：元组（tuple）的介绍
元组的创建方式
九浅：元组和列表的区别
小结
一深：列表和元组的底层实现
总结
一浅: 列表（list）的介绍
列表作为Python序列类型中的一种，其也是用于存储多个元素的一块内存空间，这些元素按照一定的顺序排列。其数据结构是：

[element1, element2, element3, ..., elementn]
1
element1~elementn表示列表中的元素，元素的数据格式没有限制，只要是Python支持的数据格式都可以往里面方。同时因为列表支持自动扩容，所以它可变序列，即可以动态的修改列表，即可以修改，新增，删除列表元素。看个爽图吧！

二浅：列表的操作
首先介绍的是对列表的操作：包括列表的创建，列表的删除等！其中创建一个列表的方式有两种：
第一种方式：
通过[]包裹列表中的元素，每个元素之间通过逗号,分割。元素类型不限并且同一列表中的每个元素的类型可以不相同，但是不建议这样做，因为如果每个元素的数据类型都不同的话则非常不方便对列表进行遍历解析。所以建议一个列表只存同一种类型的元素。

list=[element1, element2, element3, ..., elementn]
1
例如：test_list = ['测试', 2, ['码农飞哥', '小伟'], (12, 23)]
PS: 空列表的定义是list=[]
第二种方式：
通过list(iterable)函数来创建列表，list函数是Python内置的函数。该函数传入的参数必须是可迭代的序列，比如字符串，列表，元组等等，如果iterable传入为空，则会创建一个空的列表。iterable不能只传一个数字。

classmates1 = list('码农飞哥')
print(classmates1)
1
2
生成的列表是：['码', '农', '飞', '哥']

三浅：向列表中新增元素
向列表中新增元素的方法有四种，分别是：
第一种: 使用**+运算符将多个列表**连接起来。相当于在第一个列表的末尾添加上另一个列表。其语法格式是listname1+listname2

name_list = ['码农飞哥', '小伟', '小小伟']
name_list2 = ['python', 'java']
print(name_list + name_list2)
1
2
3
输出结果是：['码农飞哥', '小伟', '小小伟', 'python', 'java']，可以看出将name_list2中的每个元素都添加到了name_list的末尾。
第二种：使用append()方法添加元素
append()方法用于向列表末尾添加元素，其语法格式是:listname.append(p_object)其中listname表示要添加元素的列表，p_object表示要添加到列表末尾的元素，可以是字符串，数字，也可以是一个序列。举个栗子：

name_list.append('Adam')
print(name_list)
name_list.append(['test', 'test1'])
print(name_list)
1
2
3
4
运行结果是：

['码农飞哥', '小伟', '小小伟', 'Adam']
['码农飞哥', '小伟', '小小伟', 'Adam', ['test', 'test1']]
1
2
可以看出待添加的元素都成功的添加到了原列表的末尾处。并且当添加的元素是一个序列时，则会将该序列当成一个整体。
第三种：使用extend()方法
extend()方法跟append()方法的用法相同，同样是向列表末尾添加元素。元素的类型只需要Python支持的数据类型即可。不过与append()方法不同的是，当添加的元素是序列时，extend()方法不会将列表当成一个整体，而是将每个元素添加到列表末尾。还是上面的那个例子：

name_list = ['码农飞哥', '小伟', '小小伟']
name_list.extend('Adam')
print(name_list)
name_list.extend(['test', 'test1'])
print(name_list)
1
2
3
4
5
运行结果是：

['码农飞哥', '小伟', '小小伟', 'A', 'd', 'a', 'm']
['码农飞哥', '小伟', '小小伟', 'A', 'd', 'a', 'm', 'test', 'test1']
1
2
从结果看出，当添加字符串时会将字符串中的每个字符作为一个元素添加到列表的末尾处，当添加的列表时会将列表中的每个元素添加到末尾处。
第四种：使用insert()方法
前面介绍的几种插入方法，都只能向列表的末尾处插入元素，如果想在列表指定位置插入元素则无能为力。insert()方法正式用于处理这种问题而来的。其语法结构是listname.insert(index, p_object) 其中index表示指定位置的索引值，insert()会将p_object插入到listname列表第index个元素的位置。与append()方法相同的是，如果待添加的元素的是序列，则insert()会将该序列当成一个整体插入到列表的指定位置处。举个栗子：

name_list = ['码农飞哥', '小伟', '小小伟']
name_list.insert(1, 'Jack')
print(name_list)
name_list.insert(2, ['test', 'test1'])
print(name_list)
1
2
3
4
5
运行结果是：

['码农飞哥', 'Jack', '小伟', '小小伟']
['码农飞哥', 'Jack', ['test', 'test1'], '小伟', '小小伟']
1
2
四浅：修改列表中的元素
说完了列表中元素新增的方法，接着让我们来看看修改列表中的元素相关的方法。修改列表元素的方法有两种：
第一种：修改单个元素：
修改单个元素的方法就是对某个索引上的元素进行重新赋值。其语法结构是：listname[index]=newValue，就是将列表listname中索引值为index位置上的元素替换成newValue。
举个栗子：

name_list = ['码农飞哥', '小伟', '小小伟']
name_list[1] = 'Sarah'
print(name_list)
1
2
3
运行结果：['码农飞哥', 'Sarah', '小小伟'] 从结果可以看出索引为1处的元素值被成功修改成了Sarch。
第二种：通过切片语法修改一组元素
通过切片语法可以修改一组元素，其语法结构是:listname[start:end:step]，其中，listname表示列表名称，start表示起始位置，end表示结束位置（不包括），step表示步长，如果不指定步长，Python就不要求新赋值的元素个数与原来的元素个数相同，这意味着，该操作可以为列表添加元素，也可以为列表删除元素。举个栗子：

name_list = ['码农飞哥', '小伟', '小小伟']
name_list[0:1] = ['飞哥', '牛逼']
print(name_list)
1
2
3
运行结果是：['飞哥', '牛逼', '小伟', '小小伟'] ，从结果可以看出将原列表中索引为0处的元素值已经被替换为飞哥,并且插入了牛逼这个元素。

五浅：删除列表中的元素
删除列表中元素的方法共有四种。
第一种：根据索引值删除元素的del关键字
根据索引值删除元素的del关键字有两种形式，一种是删除单个元素，del listname[index]，一种是根据切片删除多个元素del listname[start : end]，其中，listname表示列表名称，start表示起始索引，end表示结束索引，del会删除从索引start到end之间的元素，但是不包括end位置的元素。还是举个栗子：

name_list = ['码农飞哥', '小伟', '小小伟', '超人']
name_list2 = name_list
print('原始的name_list={0}'.format(name_list))
print('原始的name_list2={0}'.format(name_list2))
# 删除索引0到2之间的元素，即删除索引0和索引1两个位置的元素
del name_list[0:2]
print('使用del删除元素后name_list={0}'.format(name_list))
print('使用del删除元素后name_list2={0}'.format(name_list2))
del name_list
print('使用del删除列表后name_list2={0}'.format(name_list2))

1
2
3
4
5
6
7
8
9
10
11
运行结果是：

原始的name_list=['码农飞哥', '小伟', '小小伟', '超人']
原始的name_list2=['码农飞哥', '小伟', '小小伟', '超人']
使用del删除元素后name_list=['小小伟', '超人']
使用del删除元素后name_list2=['小小伟', '超人']
使用del删除列表后name_list2=['小小伟', '超人']
1
2
3
4
5
可以看出用del删除列表元素时是真实的删除了内存数据的，但是用del删除列表时，则只是删除了变量，name_list2所指向的内存数据还是存在的。
第二种：根据索引值删除元素的pop()方法
根据索引值删除元素的pop()方法的语法结构是：listname.pop(index)，其中，listname表示列表名称，index表示索引值，如果不写index参数，默认会删除列表中最后一个元素，类似于数据结构中的出栈操作。举个例子：

name_list = ['码农飞哥', '小伟', '小小伟', '超人']
# 删除list末尾的元素
name_list.pop()
print(name_list)
# 删除指定位置的元素，用pop(i)方法，其中i是索引位置
name_list.pop(1)
print(name_list)
1
2
3
4
5
6
7
运行结果是：

['码农飞哥', '小伟', '小小伟']
['码农飞哥', '小小伟']
1
2
第三种：根据元素值进行删除的remove()方法
根据元素值进行删除的remove()方法,其语法结构是:listname.remove(object)，其中listname表示列表的名称，object表示待删除的元素名称。需要注意的是：如果元素在列表中不存在则会报ValueError的错误。举个栗子：

name_list = ['码农飞哥', '小伟', '小小伟', '超人']
name_list.remove('小小伟')
print(name_list)
1
2
3
运行结果是：['码农飞哥', '小伟', '超人']。
第四种：删除列表中的所有元素clear()方法
通过clear()方法可以删除掉列表中的所有元素，其语法结构是：listname.clear()，其中listname表示列表的名称。还是举个栗子吧：

name_list = ['码农飞哥', '小伟', '小小伟', '超人']
name_list.clear()
print(name_list)
1
2
3
运行结果是：[]，可以看出列表中元素被全部清空了。

六浅：列表中元素的查找以及访问
说完了第五浅列表元素的删除，略感疲惫。接着进行第六浅吧！看看列表中元素的查找以及访问。看完这个之后，列表相关的内容也就告一段落了。

访问列表中的元素
访问列表中的元素有两种方式，分别是通过索引定位访问单个元素，通过切片访问多个元素。
第一种：通过索引定位访问单个元素，其语法结构是：listname[index] ,其中listname表示列表的名字，index表示要查找元素的索引值。
第二种：通过切片的方式访问多个元素，其语法结构是：listname[start:end:step]。其中，listname表示列表的名字，start表示开始索引，end表示结束索引（不包括end位置），step表示步长。同样是举个栗子：

list = ['码农飞哥', '小伟', '小小伟',123]
print(list[0])  # 输出列表的第一个元素
print(list[1:3])  # 输出第二个至第三个元素
print(list[2:])  # 输出从第三个开始至列表末尾的所有元素
1
2
3
4
运行结果是：

码农飞哥
['小伟', '小小伟']
['小小伟', 123]
1
2
3
查找某个元素在列表中出现的位置 index()
indext()方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素在列表中不存在，则会报ValueError错误。其语法结构是：listname.index(object, start, end) 其中listname表示列表的名字，object表示要查找的元素，start表示起始索引，end表示结束索引（不包括）。

name_list = ['码农飞哥', '小伟', '小小伟', '超人']
print(name_list.index('小伟', 0, 2))
1
2
运行结果是：1

七浅：列表使用技巧及注意事项
此处留一个空白，欢迎小伙伴留言告诉我，先看个图放松下吧！！

图片看完之后是不是感觉好多了，那就让我们接着来学习吧。

Python新增元素中各个方法的区别
前面介绍了使用+运算符，使用append方法，使用extend方法都可以新增元素，那么他们到底有啥区别呢？还是举例说明吧;

name_list = ['码农飞哥', '小伟', '小小伟', '超人']
name_list2 = ['牛魔王']
name_list3 = name_list + name_list2
print("原始的name_list的值={0}；内存地址={1}".format(name_list, id(name_list)))
print("使用+运算符后name_list3的值={0}；内存地址={1}".format(name_list3, id(name_list3)))
print("使用+运算符后name_list的值{0}；内存地址={1}".format(name_list, id(name_list)))
name_list4 = name_list.append('牛魔王')
print('使用append方法后name_list4的值={0}；内存地址={1}'.format(name_list4, id(name_list4)))
print("使用append方法后name_list的值{0}；内存地址={1}".format(name_list, id(name_list)))
name_list5 = name_list.extend('牛魔王')
print('使用extend方法后name_list5的值={0}；内存地址={1}'.format(name_list4, id(name_list4)))
print("使用extend方法后name_list的值{0}；内存地址={1}".format(name_list, id(name_list)))

1
2
3
4
5
6
7
8
9
10
11
12
13
运行结果是：

原始的name_list的值=['码农飞哥', '小伟', '小小伟', '超人']；内存地址=2069467533448
使用+运算符后name_list3的值=['码农飞哥', '小伟', '小小伟', '超人', '牛魔王']；内存地址=2069467533896
使用+运算符后name_list的值['码农飞哥', '小伟', '小小伟', '超人']；内存地址=2069467533448
使用append方法后name_list4的值=None；内存地址=2012521616
使用append方法后name_list的值['码农飞哥', '小伟', '小小伟', '超人', '牛魔王']；内存地址=2069467533448
使用extend方法后name_list5的值=None；内存地址=2012521616
使用extend方法后name_list的值['码农飞哥', '小伟', '小小伟', '超人', '牛魔王', '牛', '魔', '王']；内存地址=2069467533448
1
2
3
4
5
6
7
从运行结果可以看出如下几点：

使用+运算符是创建一个新的列表，新列表的地址与原列表的地址不相同，并且原始列表的内容不会改变。
append方法和extend方法都是修改原始列表的内容，并且都没有返回值，所以两者都不能使用链式表达式。
当待添加的元素是列表时,append方法会将列表当成一个整体，而extend不会。
八浅：元组（tuple）的介绍
说完了列表，接着让我们来看看另外一个重要的序列–元组（tuple），和列表类似，元组也是由一系列按特定书序排序的元素组成，与列表最重要的区别是，元组属于不可变序列，即元组一旦被创建，它的元素就不可更改了。

元组的创建方式
第一种：使用()直接创建
使用()创建元组的语法结构是tuplename=(element1,element2,....,elementn),其中tuplename表示元组的变量名，element1~elementn表示元组中的元素。小括号不是必须的，只要将元素用逗号分隔，Python就会将其视为元组。还是举个栗子：

#创建元组
tuple_name = ('码农飞哥', '小伟', '小小伟', '超人')
print(tuple_name)
#去掉小括号创建元组
tuple2 = '码农飞哥', '小伟', '小小伟', '超人'
print(type(tuple2))
1
2
3
4
5
6
运行结果是：

('码农飞哥', '小伟', '小小伟', '超人')
<class 'tuple'>
1
2
第二种：使用tuple()函数创建
与列表类似的，我们可以通过tuple(iterable)函数来创建元组，如果iterable传入为空，则创建一个空的元组，iterable 参数必须是可迭代的序列，比如字符串，列表，元组等。同样的iterable不能传入一个数字。举个栗子：

name_list = ['码农飞哥', '小伟', '小小伟', '超人']
print(tuple(name_list))
print(tuple('码农飞哥'))
1
2
3
运行结果是：

('码农飞哥', '小伟', '小小伟', '超人')
('码', '农', '飞', '哥')
1
2
由于元组是不可变序列，所以没有修改元素相关的方法，只能对元组中的元素进行查看。查看元素的方式也与列表类似，共两种方式：
第一种：通过索引（index）访问元组中的元素，其语法结构是tuplename[index]
第二种：通过切片的方式访问，其语法结构是：tuplename[start:end:step]
相关参数的描述在此不再赘述了。依然是举例说明：

tuple_name = ('码农飞哥', '小伟', '小小伟', '超人')
# 获取索引为1的元素值
print(tuple_name[1])
#获取索引为1到索引为2之间的元素值，不包括索引2本身
print(tuple_name[0:2])
1
2
3
4
5
运行结果是：

小伟
('码农飞哥', '小伟')
1
2
元组中的元素不能修改，不过可以通过 + 来生成一个新的元组。

九浅：元组和列表的区别
说完了前面八浅之后，也有点累了。接着说下元组和列表的区别吧。为啥Python要另外设置元组这样一个数据结构呢？元组的功能列表不是都可以满足么？所以，这一浅主要是介绍元组的优点，存在即合理，哈哈哈哈。
区别：

元素是否可以修改？
列表中的元素可以修改，而元组中的元素不能修改。如果强行修改元组中的元素，你会得到如下错误：
TypeError: 'tuple' object does not support item assignment
1
存储同样数据所占空间
下面展示初始化一个空列表和一个空元组所占的字节数
>>> listdemo = []
>>> listdemo.__sizeof__()
40
>>> tupleDemo = ()
>>> tupleDemo.__sizeof__()
24
1
2
3
4
5
6
可以看出元组比列表少占用16个字节，这是因为列表是动态的，它需要存储指针来指向对应的元素（占用8个字节），另外，由于列表中的元素可变，所以需要额外存储已经分配的长度大小（占用8个字节）。但是对于元组，情况就不同了，元组长度的大小固定，其存储元素不可变，所以存储空间也是固定的。总体来说，元组的存储性能要由于列表，存储同样数据所占用空间更小。
3. 初始化同样数据所需时间
大家想一想初始化同样数据的元组和列表，哪个的速度更快呢？是元组还是列表呢？相信大部分人都会选择元组，那么元组到底快多少呢？下面就用一个例子说明一下：同样是初始化元素为1,2,3,4两个序列。

(python-demo)  root$ python3 -m timeit 'x=(1,2,3,4)'
10000000 loops, best of 3: 0.029 usec per loop
(python-demo)  root$ python3 -m timeit 'x=[1,2,3,4]'
10000000 loops, best of 3: 0.165 usec per loop

1
2
3
4
5
初始化元组花了0.029秒，初始化话列表花了0.165 秒，所以，可以得出的结论是初始化一个相同元素的列表和元组分别所需的时间，元组的初始化速度要比列表快5倍多。

小结
元组有如下优点：元组比列表的访问和处理速度更快，存储相同内容所需空间更小。

一深：列表和元组的底层实现
九浅已经完成了，最后就来一次更深入的交流吧。知其然更要知其所以然。话不多说，下面就直接从源码层面来看看列表和元组的底层实现。
首先来分析列表（list），它的具体结构如下所示：

typedef struct {
PyObject_VAR_HEAD
/* Vector of pointers to list elements.  list[0] is ob_item[0], etc. */
PyObject **ob_item;

/* ob_item contains space for 'allocated' elements.  The number
   * currently in use is ob_size.
   * Invariants:
   *    0 <= ob_size <= allocated
   *    len(list) == ob_size
   *    ob_item == NULL implies ob_size == allocated == 0
   * list.sort() temporarily sets allocated to -1 to detect mutations.
   *
   * Items must normally not be NULL, except during construction when
   * the list is not yet visible outside the function that builds it.
   */
Py_ssize_t allocated;
} PyListObject;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
PS：列表实现的源码文件是 listobject.h 和 listobject.c。
list 本质上是一个长度可变的连续数组。其中ob_item是一个指针列表，里面的每个指针都指向列表中的元素，而allocated则用于存储该列表目前被分配的空间大小。
需要注意的是，allocated和列表的实际空间大小不同，列表实际空间大小是指len(list)返回的结果，即上面注释中的ob_size,表示该列表实际存储了多少个元素，而实际情况是，为了优化存储结构，避免每次增加元素都要重新分配内存，列表预分配的空间allocated往往大于ob_size。他们的关系是0 <= ob_size <= allocated。
接下来在分析元组，如下所示为Python3.7 tuple元组的具体结构:

typedef struct {
PyObject_VAR_HEAD
PyObject *ob_item[1];

/* ob_item contains space for 'ob_size' elements.
   * Items must normally not be NULL, except during construction when
   * the tuple is not yet visible outside the function that builds it.
   */
} PyTupleObject;
1
2
3
4
5
6
7
8
9
PS: 元组（tuple）实现的源码文件是 tupleobject.h 和 tupleobject.c。
tuple和list相似，本质也是一个数组，但是空间大小固定。不同于一般数组，Python 的 tuple 做了许多优化，来提升在程序中的效率。

总结
本文详细介绍了Python内置数据类型中的列表（list）和元组（tuple）。特别是列表，它的新增元素和删除元素的方法很多，各种方法之间还有许多不同，需要在使用时特别注意。对于不涉及修改元素操作的场景，优先使用元组。因为它的性能更好，所占空间更少。

为了更好帮助更多的小伙伴对Python从入门到精通，我从CSDN官方那边搞来了一套《Python全栈知识图谱》，尺寸 870mm x 560mm，展开后有一张办公桌大小，也可以折叠成一本书的尺寸，有兴趣的小伙伴可以了解一下。
————————————————
版权声明：本文为CSDN博主「码农飞哥」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u014534808/article/details/118161703

zan