Python数据容器（1）--列表与元组

数据容器

在Python中，数据容器是指能够存储多个数据项（可以是不同类型的数据）的数据结构。Python提供了多种内置的数据容器类型，每种类型都有其特定的用途和特性。Python中最常用的数据容器有：List列表、Tuple元组、Dictionary字典、Set集合。

本篇我们来介绍其中的List列表和Tuple元组。

List列表

在Python中，列表（List）是一种非常基础且强大的数据结构，用于存储一系列有序的项目（也称为元素）。列表可以包含不同类型的元素，比如整数、浮点数、字符串、甚至是其他列表（嵌套列表）。

列表是有序的、可变的。有序意味着list列表可以索引、切片；而可变意味着list列表可以增、删、改、查操作，但是不稳定、不够安全。

列表形式

列表是放在方括号[]中来创建的，其中可以包含不同类型的元素，列表中的元素用","隔开，比如：

list = [1,2,5.2,3.9,'a','cs',True,False,[1,2]]

可以在其中再存放一个列表

有序

索引

之前我们了解过字符串的索引index方法使用，我们来尝试用同样的方法对列表索引试试：

list = [1,2,5.2,3.9,'a','cs',True,False,[1,2]]

print(list.index(3.9))  #索引列表中元素3.9的位置
print(list.index('cs'))

---------------------------
输出结果：
3
5

 由此可知，列表的索引方法和字符串的相同，且列表的位置编号也是从左到右由0开始。

切片

同样的，我们也尝试使用字符串切片方法试试列表的切片：

list = [1,2,5.2,3.9,'a','cs',True,False,[1,2]]

print(list[2])       #切出第二个位置的元素
print(list[5])
print(list[::-1])    #将列表反方向输出

----------------------------
输出结果：
5.2
cs
[[1, 2], False, True, 'cs', 'a', 3.9, 5.2, 2, 1]

切片也同字符串方法一样。

但是我们学习了列表，对于列表内的元素还是列表的列表怎么切片呢？比如：

b = [[1, 2],
     [3, 4]]     #两个列表以矩阵方式存放，b可以表示二维矩阵

对b进行切片：

b = [[1, 2],    #[1, 2]的位置为0，[3, 4]位置为1
     [3, 4]] 

print(b[1][0])    #表示切片：位置为1的元素中存放在第0个位置的元素

如果一个列表存放在另一个列表中，那么该列表的索引位置以整个列表为一个单位。

注意

另外，注意索引越界问题，如果索引的位置超过了列表位置的长度，就会产生越界。我们可以通过：

list = [1,2,5.2,3.9,'a','cs',True,False,[1,2]]
print(len(list))

---------------------------
输出结果：
9

来查看列表的长度，列表的位置范围为0~len(list) - 1. 

可变

列表可变也就意味着我们可以对它进行增加、删除、查找、更改操作。

增加

字符串有字符串的方法，列表同样有列表的方法：

append追加

list_1 = [1,2,5.2,3.9,'a','cs',True,[1,2]]

#增加
list_1.append(False)    #append()括号内输入添加的元素
print(list_1)
list_1.append([3,4])
print(list_1)

----------------
输出结果：
[1, 2, 5.2, 3.9, 'a', 'cs', True, [1, 2], False]
[1, 2, 5.2, 3.9, 'a', 'cs', True, [1, 2], False, [3, 4]]

将元素追加在列表的末尾。

extend()追加

把可迭代（iterable）的对象一个一个追加进列表。那么，可迭代是什么？哪些是可迭代的呢？

可迭代对象（Iterable）:是指那些可以被迭代遍历的对象，即可以通过一个循环（如for循环）一次返回其成员的对象。 包括但不限于：列表、元组、字符串、字典、集合、布尔类型等等。

那么extend怎么使用呐？输出返回方式和append相同吗？

list_1 = [1,2,5.2,3.9,'a','cs',True,[1,2]]

list_1.extend([5,6])
print(list_1)

--------------------------------
输出结果：
[1, 2, 5.2, 3.9, 'a', 'cs', True, [1, 2], 5, 6]

我们发现我们原本要追加进去的元素[5,6]被分开成一个一个追加进列表。这就是extend不一样的地方，一个一个追加。

删除

列表如何将不需要的元素去除呢？

pop()弹出

list_1 = [1,2,5.2,3.9,'a','cs',True,[1,2]]
# 删除操作
# pop 弹出操作
list_1.pop()    #括号内空字符弹出最后一个元素
print(list_1)
list_1.pop(4)   #括号内输入的是目标元素的索引位置
print(list_1)

输出结果：

[1, 2, 5.2, 3.9, 'a', 'cs', True]
[1, 2, 5.2, 3.9, 'cs', True]

pop()括号内空字符弹出最后一个元素，输入位置则弹出该位置的元素’

remove()移除

remove（）移除的是值，即括号内输入的是列表内的元素，比如：

list_1 = [1,2,5.2,3.9,'a','cs',True,[1,2]]
# remove 移除的是值
list_1.remove(5.2)
print(list_1)
list_1.remove(1)
print(list_1)
-------------------------
输出结果：
[1, 2, 3.9, 'a', 'cs', True, [1, 2]]
[2, 3.9, 'a', 'cs', True, [1, 2]]

值得一提的是：基于上方代码的基础上，假设我们再次移除一个"1",会怎么样呢？

list_1.remove(1)
print(list_1)

输出结果：

[2, 3.9, 'a', 'cs', [1, 2]]

我们发现：元素True被移除了，之前提过，Python中True = 1。故，True被当作1移除了。

查找

index索引查找

有序索引中已经介绍咯，该方法不再细说啦。

count()计数

count(x)返回列表中元素x出现的次数。

list_1 = [1,2,5.2,3.9,'a','cs',True,[1,2]]
print(list_1.count(1))

---------------------
输出结果：
2        #True也算哦

更改

reverse()反转

list_1 = [1,2,5.2,3.9,'a','cs',True,[1,2]]
#改
#reverse 列表的反转

list_1.reverse()	#将列表数据逆着逐一排序
print(list_1)

------------------------------
输出结果：
[[1, 2], True, 'cs', 'a', 3.9, 5.2, 2, 1]

sort()排序

sort()括号内输入reverse=bool（布尔值）

介绍：reverse=True这个参数的含义是指定排序的顺序应该是降序的（即从大到小）。
# 相反，如果reverse参数被省略或者设置为False（默认值），则排序顺序是升序的（即从小到大）。

list_1 = [1,2,5.2,3.9,'a','cs',True,[1,2]]
# sort 排序
c = [5, 6, 7, 8, 3, 4]
c.sort(reverse=True)
#reverse=True这个参数的含义是指定排序的顺序应该是降序的（即从大到小）。
# 相反，如果reverse参数被省略或者设置为False（默认值），则排序顺序是升序的（即从小到大）。
print(c)

-------------------
输出结果：
[8, 7, 6, 5, 4, 3]

Tuple元组

 Tuple（元组）是Python中一种内置的数据结构，用于存储一系列不可变的项目（元素）。与列表（List）不同，元组一旦创建就不能被修改（即它是不可变的）。这意味着你不能增加、删除或更改元组中的元素。

元组有序但不可变，意味着稳定、安全。（可查找）

元组形式

元组是放在圆括号()中来创建de，其中可以包含不同类型的元素，元组中的元素用","隔开，比如：

tuple_a = (1, 2, 3, 4,'e123', "daqwe", [1, 2])

一元组

元组中的元素只有一个时，我们该怎么表示呢？直接在小括号内存放一个？我们来试试看：

tuple_b = ("a")
print(tuple_b,type(tuple_b))

输出tuple_b的类型：

a <class 'str'>

我们发现输出类型是字符串，并不是元组 ，正确的表示方法是这样的：

tuple_1 = ("a",)    #正确方法，加,意味定义元组
print(tuple_1, type(tuple_1))

------------------
输出结果：
('a',) <class 'tuple'>

 一元组的表示要在元素后加个","。

有序

查找

有序代表我们可以通过index索引和count计数

tuple_a = (1, 2, 3, 4,  'e123', "daqwe", [1, 2])

print(tuple_a.index(1))  #索引元组中"1"所在的位置
print(tuple_a.count(3))  #计数元组中有多少个"3"

------------
输出结果：
0
1

不可变

元组不可变不能进行增加、删除或更改元组中的元素的操作。我们不妨来试试，就往元组中增加一个元素：尝试通过切片赋值：

tuple_a = (1, 2, 3, 4, 5, 6, 'e123', "daqwe", [1, 2])

tuple_a[4] = 10     #通过切片赋值
print(tuple_a)

输出结果：

    tuple_a[4] = 10
TypeError: 'tuple' object does not support item assignment

>>>当我们尝试修改元组（tuple）中的元素时，出现报错
意味着元组（tuple）是一种不可变的数据结构，一旦创建，其内部元素就不能被更改。

所以，元组不可进行增加、删除和更改元组中元素的操作。

 

总结

列表：放在方括号[]中来创建，有序且可变，可以索引、切片，可进行增加、删除、查找和更改元组中元素的操作。

元组：放在圆括号()中来创建，有序但不可变，可以进行索引和查找操作，不可进行增加、删除和更改元组中元素的操作。