[Python知识库]Python入门学习（五）

什么是容器

生活中，容器指的是可以容纳物品的收纳器，在程序中，容器是一种可以把多个元素放在一起的数据结构，容器中的元素可以逐个地迭代获取，可以用in, not in等关键字判断某个元素是否包含在容器中。

在Python中，包括列表(list)、元组(tuple)、字典(dict)、集合(set)等，他们都可以放入多个元素，因此都可以算作是容器，这些容器是Python编程中非常重要的数据结构，接下来重点学习这些数据结构。

List

??????定义

????????List列表是一种有序的容器，放入list中的元素，将会按照一定顺序排列。使用中括号[]把需要放在容器里的元素括起来，就定义了一个列表，是不是很简单。接下来举个例子：

比如列出同学们的姓名：

????????stuNames = ['张三'，'李四'，'王五'，'赵六']

列出同学们的学号：

????????stuNos = [21001,21002,21003,21004,21005]

以上举例可以看出，list列表中可以放入数字和字符串，除了这些还可以放任意类型的数据，这也是Python语言决定的，因为Python是动态语言。

test = [21001,'张三',21002,'李四']

????????

Python按顺序访问list

上述也说了，列表是有序的，因此我们可以按顺序访问列表中的元素，回顾一下，前面的文章中说到，字符串是使用循环来访问字符串中的每一个字符的，在这里List访问是一样，通过循环访问list列表中每一个元素。

test = [21001,'张三',21002,'李四']

for item in test：

? ? ? ? print(item)

学习到这里，事实上可以看出字符串也可以看作是一种特殊的列表，它只能按顺序存放多个字符，通过for循环访问列表每一个元素的方式，我们称为迭代。
而对于一个空的列表，使用for循环访问，将不会打印任何东西。

test = []
for item in test:
    print(item)

Python按索引访问list

????????由于列表list是一个有序的容器，所以在list里面，每一个元素都有一个唯一的位置，我们称之为索引(index)，这和字符串是类似的，因此我们也可以通过位置的方式获取list中的元素，我们通过中括号[]来按位置访问对应的元素。

注意，这里要注意区分，列表的定义也是通过中括号[]来定义的，但这和通过索引访问列表里面的元素并不冲突

test = [21001,'张三',21002,'李四']

print(test[0])
print(test[1])
print(test[2])
print(test[3])

索引是从0开始的，所以这里我们只能获取到索引3，指向的是==>’李四‘，如果获取索引4，会引起Python运行的错误，提示索引访问超出范围。

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

因此，我们在使用索引的方式访问列表时，一定要特别注意不要越界。
同时，列表和字符串一样，也支持切片，通过切片的方式，获取到列表的子列表。

test = [21001,'张三',21002,'李四']
sub_test = test[0:2]
print(sub_test)

这里需要注意一下，如果我们越界切片的话，不会出现Python运行错误，但是按照这样的下标去切片，获取不到任何元素。

test = [21001,'张三',21002,'李四']
sub_test = test[6:10]
print(sub_test)

Python倒序访问list

????????Python的列表，除了支持正向顺序索引获取列表中的每一个元素以外，也支持倒序访问list中的每一个元素。

test = [21001,'张三',21002,'李四']

对于test列表，'李四'的名字排在最后，也就是我们所说的倒数第一个，在Python中，可以使用-1来表示最后一个元素。

test = [21001,'张三',21002,'李四']
print(test[-1]) # ==> '李四'

同样的道理：

print(test[-2]) # ==> 21002
print(test[-3]) # ==> '张三'

注意，如果我们使用-5的话，因为不存在倒数第五个，因此这也是一种越界，同样会报错。

test = [21001,'张三',21002,'李四']
print(test[-5]) 

# 列表下标越界
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Python向list添加新的元素

第一个方法：append(）方法，注意：该方法是将元素添加到list的尾部。

例：

names = ['张三','李四','王五']
names.append('赵六')
print(names) # ==> ['张三','李四','王五','赵六']

第二个方法：insert()方法，注意：将某元素插入到指定的位置之后原来的位置上的元素，都将自动往后移动一位。

names = ['张三','李四','王五']
names.insert(2,'赵六')
print(names) # ==> ['张三','李四','赵六','王五']

Python从list删除元素

第一种方式：使用pop()方法，默认删除列表的最后一个元素， 并返回。

names = ['张三','李四','王五']
name = names.pop()
print(name) # ==> 王五
print(names) # ==> ['张三','李四']

第二种方式：使用pop(带参数)方法，接收一个参数，指定需要删除的元素的位置。

names = ['张三','李四','王五']
name = names.pop(1)
print(name) # ==> 李四
print(names) # ==> ['张三','王五']

Python替换list中的元素

????????对于列表，除了可以向列表添加元素，删除列表元素以外，列表已有的元素，也是可以修改的，通过索引指定位置，并赋值新的元素，即可替换列表中原有的元素。

例：

names = ['张三','李四','王五']
names[1] = '赵六'
print(names) # ==> ['张三','赵六','王五']

也可以使用倒叙索引来完成同样的功能。

names = ['张三','李四','王五']
names[-2] = '赵六'
print(names) # ==> ['张三','赵六','王五']

?注意，如果替换一个不存在的下标，则同样会引起Python运行错误。
?

names = ['张三','李四','王五']
names[10] = '赵六'

# 不存在下标索引异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range

Python二维list

????????有时候，一维list并不能满足所有的要求（上述所有list均为一维list），这个时候需要二维list甚至更高维的list。
比如：
????????zhangsan最近的三次成绩分别是[100, 89, 95]
????????lisi最近的三次成绩分别是[73, 68, 84]
? ? ? ? wangwu最近的三次成绩分别是[88, 72, 77]
????????如果需要用一个列表存放三个同学的成绩，则需要这样：

zhangsan_scores = [100, 89, 95]
lisi_scores = [73, 68, 84]
wangwu_scores = [88, 72, 77]
all_scores = [zhangsan_scores , lisi_scores , wangwu_scores ]
print(all_scores) # ==> [[100, 89, 95],[73, 68, 84], [88, 72, 77]]

这个时候得到的就是一个二维list，对于二维list，列表里面的每一个元素仍然是一个列表。这个时候，如果需要从二维list all_scores获取lisi最近第三次考试的成绩，可以这样写：

zhangsan_scores = [100, 89, 95]
lisi_scores = [73, 68, 84]
wangwu_scores = [88, 72, 77]
all_scores = [zhangsan_scores , lisi_scores , wangwu_scores ]
score = all_scores[1][2]
print(all_scores) # ==> 84

Tuple

????????元组(tuple)和list一样，也是一个有序容器，在元组中，同样可以包含0个或者多个元素，并且也支持索引访问、切片等操作。

定义元组的方式是使用小括号（）将元组内的元素扣起来。

TNames = ('张三','李四','王五','赵六')
# 通过下标的方式访问元素
print(TNames[0]) # 张三
print(TNames[2]) # 王五
# 切片
print(TNames[1:3]) # ==> ('李四','王五')

元组数据类型可以把不是元组的容器转换为元组，比如将列表转换成元组。

TNames = ['张三','李四','王五','赵六']
print(TNames) # ==>['张三','李四','王五','赵六']
T = tuple(TNames)
print(T) # ==> ('张三','李四','王五','赵六')

同样的，对于列表数据类型，也可以把元组转换成列表。

TNames = ('张三','李四','王五','赵六')
print(TNames) # ==>('张三','李四','王五','赵六')
T = LIST(TNames)
print(T) # ==> ['张三','李四','王五','赵六']

但是，tuple和list不一样的是，tuple是固定不变的，一旦变成tuple，tuple中的每一个元素都不可被改变，同时也不能再往tuple中添加数据，而list是可以的。

TNames = ('张三','李四','王五','赵六')
# 替换元素
TNames[1] = '小七'
# 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

请注意，元组(tuple)的这个特性是非常重要的，在运行上tuple的性能是list的数倍。

访问tuple元素的其他方法

????????由于tuple一旦定义之后便不可修改，所以在实际编程中，tuple经常用于存放固定不变的数据。
????????因此在使用上，tuple提供了便捷的方法可以访问tuple中的数据。

count方法

count()方法用来统计tuple中某个元素出现的次数。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(1)) # ==> 3
print(T.count(5)) # ==> 1

对于不存在的元素，count方法不会报错，而是返回0，这是合理的，因为元组里面有0个不存在的元素。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(10)) # ==> 0

index()方法

index()方法可以返回指定元素的下标，当一个元素多次重复出现时，则返回第一次出现的下标位置。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
T.index(9) # ==> 10
T.index(5) # ==> 8
T.index(1) # ==> 0 # 多次出现，返回第一次出现的位置

注意，index()方法和count()方法不一样，当指定的元素不存在时，使用index()方法Python会报错。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
T.index(100)
# 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple

Python创建单个元素的tuple

tuple和list一样，可以包含 0 个、1个和任意多个元素。
包含多个元素的 tuple，前面我们已经创建过了。

包含 0 个元素的 tuple，也就是空tuple，直接用()表示：

T = ()
print(T) # ==> ()

接着，我们创建包含一个元素的tuple。

T = (1)
print(T) # ==> 1

这和我们期望的输出有些差异，为什么包含一个元素的元组打印出来之后没有小括号，而是只有一个数字1呢？
回顾一下前面数字的四则运算。

result = 3 * 4 - 2
print(result) # ==> 10
# 改变优先级，先运算减法
result = 3 * (4 - 2)
print(result) # ==> 6

可以看到，改变优先级我们是通过()来实现的，这和元组的定义有冲突，这就解释了前面只有一个元素的元组，为什么打印出来却得到一个数字的结果了。
因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果(1)被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。
因此，要定义只有一个元素的tuple，需要在元素后面添加一个逗号,。

T = (1, )
print(T) # ==> (1, )

而对于多个元素的tuple，则加和不加这个逗号，效果是一样的。

>>> T = (1, 2, 3,)
>>> print(T) # ==> (1, 2, 3)

Python的可变tuple

????????对于tuple，它和list一个最大的不同点就是tuple是不可变的，tuple里面的元素，也是不可替换的。但是这针对的是仅包含基础数据类型（数字类型、布尔类型、字符串类型）的数据，对于组合数据类型，则不受这个约束。

T = (2, 'CH', [6, 7，8])

这里T有三个元素，第一个元素是数字类型，第二个元素是字符串类型，第三个元素是列表类型的，我们尝试修改第三个元素的数据。

T = (2, 'CH', [6, 7，8])
M = T[2]
print(M) # ==> [6,7,8]
#尝试替换M中的元素
M[1] = 40
print(M) # ==> [6,40,8]
print(T) # ==> (2,'CH',[6,40,8])

这个时候，我们发现，元组T中的第三个元素已经成功被改变了，这就有悖前面的定义，元组是不可改变的。

这种情况是为什么呢？

答案：这是因为虽然tuple中的list元素改变了，但是tuple本身指向的list仍然是同一个list，list本身并没有改变，改变的只是list里面的一个元素，这是tuple所约束不到的范围。

?简单画了个图，帮助大家理解，如图中的蓝色区域，可以当作元组T的管控范围，但是元组内的三个元素，的类型没有改变，我们只是改变了元组内第三个元素内的值，第三个元素是列表类型，列表内的数据，是由列表来管控的，红色部分就是列表的管控范围。 说到这里大家应该能理解了吧。

还有种情况，如下：

T = (2, 'CH', [6, 7，8])
M = [6,40,8]
#尝试替换T中的元素list
T[2] = M
# 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

?如果我们直接替换list，这也是不行的；即便是替换的相同的类型，那也不可以的。

好了，到这里，我们对于元组的了解就先到这里。

哎呀妈呀，这文章有点长，不过都是基础中的基础，硬货中的硬货，通往大神路上的必经之路！！！！！！！！！

?

我们来总结一下本文章内容，我们学到了List列表容器，以及列表相关功能；Tuple元组容器，以及元组的相关特性。大家在私下可以练习一下，熟能生巧哦！！!

作者：筱白爱学习！