1.5 数据容器

数据容器入门

一个数据容器可以容纳多份数据，就比如我们原本想拿五个变量去储存五个人的名字，但是现在只需要一个数据容器，就可以实现一个变量储存五个名字，这也就是我们学习数据容器的原因。

所以说：数据容器就是一种可以容纳多份数据的数据类型，容纳的每一份数据叫做元素，每一个元素也都可以是任意类型的，比如字符串，布尔型，整型等等。

然后根据数据当中的各个特性：

1. 是否支持重复的元素。
2. 是否可以修改。
3. 是否有序。

这三个主要问题大致可以分成以下五类，我们下面进行相关的介绍：
列表 元组 字符串 集合 字典

数据容器：list(列表)

列表的定义

基本的语法：
第一种：定义字面值

[元素1，元素2，元素3······]

第二种：定义变量

name_list = [元素1，元素2，元素3······]

第三种：定义空列表

name_list = []
name_list = list()

基本的操作就是上面的这些，需要注意的是，列表需要使用中括号[]进行标识，然后元素与元素之间，通过逗号进行分隔开。

而且值得注意的是，列表当中是可以储存不同类型的数据的，比如

my_list = [“hello world”,666,Ture]
my_list2 = [[1,2,3],[1,3,2]]

这个也是正确的，没有要求列表内部的类型必须一致这种说法，并且也支持嵌套使用。

列表的下标索引

其实就是每一个列表当中的每一个元素，都有着一个数字用来表明：自己在这个列表当中占的是第几个元素，但是值得注意的是，是从0开始的，就比如[1,2,3,4]当中1是第0个元素，2是第1个元素，掌握了这一点，我们就可以轻松简单的调用列表。

使用的格式

my_list[number]

样例示范：

name_list = ['hello',' ','world']
print(name_list[0],end='')
print(name_list[1],end='')
print(name_list[2],end='')

输出结果：

而相同的，我们还有反向读取的操作，实际上也就是把最后一个列表数标记为-1，往前变为-2，-3，所以操作也有：

样例：

name_list = ['hello',' ','world']
print(name_list[-3],end='')
print(name_list[-2],end='')
print(name_list[-1],end='')

输出结果：

最后还有就是面对嵌套的列表我们该怎么进行使用呢?

也很简单，就好比如二维数组之类的:

name_list = ['hello',' ','world']
print(name_list[-3][0],end='')
print(name_list[-3][1],end='')
print(name_list[-3][2],end='')

输出结果：

需要注意的是：使用下标索引的时候，切记不要超出下标的范围。比如总共就3个元素，你访问3，就是超出范围了。

列表的常用操作

列表的方法：就代表着列表的功能操作，也就是我们所要讲解的东西。

查询指定元素的下标

语法：

列表.index(元素)

返回的值是所指定元素的下标，如果找不到，将报错ValueError。

样例：

name_list = ['hello',' ','world']
print(f"world的下标索引是{name_list.index('world')}")

输出结果：

如果加入没有的元素：
代码：

name_list = ['hello',' ','world']
print(f"world的下标索引是{name_list.index('world')}")
print(f"不存在的数据的下标索引是{name_list.index('adwad')}")

输出结果：

修改指定下标的值

实际上也很简单：
语法：

my_list[number] = 指定的值

样例：（比如说我们要把第一个元素" “修改成"空格”）

name_list = ['hello',' ','world']
name_list[1] ='空格'
print(name_list)

输出结果：

插入元素

语法：

列表.insert(下标,元素)# 所产生的后果就是insert后续的元素自然往后推。

样例：

name_list = ['hello',' ','world']
name_list.insert(1,'空格')
print(name_list)

输出结果：

追加一个元素（尾部添加）

语法：

列表.append(元素)# 实际上就是把该元素放到列表的尾部

样例：

name_list = ['hello',' ','world']
name_list.append('空格')
print(name_list)

输出结果：

追加多个元素（尾部添加）

语法：

列表.extend(列表)# 实际上就是把传入的列表当中的数据一个个取出，然后逐个添加到该列表的尾部。

样例：

name_list = ['hello',' ','world']
name_list2 = ['hello',' ','world']
name_list.extend(name_list2)
print(name_list)

输出结果：

相同的你也可以直接写字面值列表放在extend的括号内。

删除指定元素（下标）

有两种方式：
语法1：

del 列表[下标]

样例：

name_list = ['hello',' ','world']
del name_list[1]
print(name_list)

输出结果：

语法2：

列表.pop(指定的下标)

样例：

name_list = ['hello',' ','world']
name_list.pop(1)
print(name_list)

输出结果：

值得注意的是：pop这个函数的功能是将对应位置的列表元素取出来，返回出去，所以他是有一个返回值的，可以拿一个变量去接住。

删除指定元素（内容）

语法：

列表.remove(元素)
# 实际上只能删除指定内容的元素中的第一个，比如说一个列表[1,2,3,4,1,1]我们要删除1这个元素,使用这种方法只能删除第一个所找到的1，也就是删除后的列表是[2,3,4,1,1]

样例：

name_list = [1,2,3,4,1,1]
name_list.remove(1)
print(name_list)

输出结果：

清空元素列表

语法：

列表.clear()

样例：

name_list = [1,2,3,4,1,1]
name_list.clear()
print(name_list)

输出结果：

统计元素在列表中出现的次数

语法：

列表.count(元素)

样例：

name_list = [1,2,3,4,1,1]
num = name_list.count(1)
print(num)

输出结果：

统计列表当中的元素个数

语法：

len(列表)

样例：

name_list = [1,2,3,4,1,1]
num = len(name_list)
print(num)

输出结果:

总结

所以说，对于列表：

1. 列表几乎可以容纳无限多个元素
2. 列表可以容纳不同类型
3. 数据是有序存储的（有下标）
4. 允许重复数据的存在
5. 可以修改删除插入

以及对于上述函数的总结：

函数	功能
列表.append(元素)	尾部追加一个元素
列表.extend(列表)	尾部追加一个列表（多个元素）
列表.insert(下标，元素)	在指定下标的地方，插入指定的元素
del 列表[下标]	删除指定下标的元素
列表.pop(下标)	删除指定下标的元素（返回值为该元素）
列表.remove(元素)	删除指定内容的元素（第一个）
列表.clear()	清空列表
列表.count(元素)	统计这个元素在列表中出现的次数
列表.index(元素)	查询该元素出现的下标（第一个）
len(列表)	返回列表当中元素的数量

list(列表)的遍历

while循环遍历

语法：

index = 0
while index<len(列表) :
列表[index] 的操作；
······
index+=1

样例：

my_list = ['hello',' ','world']
index = 0
while index<len(my_list) :
    print(my_list[index],end='')
    index+=1

输出结果：

for循环遍历

语法：

for i in 数据容器 :
对变量的处理

样例：

my_list = ['hello',' ','world']
for i in my_list :
    print(i,end='')

输出结果:

关于while循环和for循环的差别

1. 首先在循环控制上：

   while循环可以自定义控制条件，自行控制循环停止结束。
   for循环则不行，但是一般都是搭配着容器进行使用。

2. 在无限循环上：

   while循环可以通过控制条件达到无限循环。
   for循环则不行，因为容器内部的值不是无限大的。

3. 在使用场景上面：

   while循环适用于任何想要使用循环的地方。
   for循环遍历容器，或者遍历次数固定的地方。

数据容器：tuple(元组)

元组和列表一样，都是可以封装多个不同类型的元素，但是他和列表最大的差别就是，元组一旦定义成功，就无法进行修改内部的值。

元组的定义格式

基本的语法：
第一种：定义字面值

(元素1，元素2，元素3······)

第二种：定义变量

name_tuple = (元素1，元素2，元素3······)

第三种：定义空元组

name_tuple = ()
name_tuple = tuple()

基本的操作就是上面的这些，需要注意的是，元组需要使用小括号()进行标识，然后元素与元素之间，通过逗号进行分隔开。

最重要的是，如果你建立的元组只含有一个元素，那你应该(元素1，)，需要加上一个单独的 逗号，不然就不是一个元组了。

而且值得注意的是，元组当中是可以储存不同类型的数据的，比如

my_tuple = (“hello world”,666,Ture)
my_tuple2 = ((1,2,3),(1,3,2))

这个也是正确的，没有要求列表内部的类型必须一致这种说法，并且也支持嵌套使用。

元组的常见操作

首先元组也满足类似于列表的下标取出操作，可以说是一模一样，所以这里也不赘述了。

以下是列出元组常见的操作：

函数	功能
元组.index(元素)	查询该元素出现的下标（第一个）
元组.count(元素)	统计这个元素在列表中出现的次数
len(元组)	返回元组当中元素的数量

元组的遍历

while循环遍历元组

与列表的方法也是一致的。

语法：

index = 0
while index<len(元组) :
元组[index] 的操作；
······
index+=1

for循环遍历元组

与列表也是一致的。

语法：

for i in 数据容器 :
对变量的处理

元组的注意事项及总结

注意事项：

1. 元组只读，不能修改内部的数据。
2. 但是如果是元组内部储存着一个列表，那么列表就是可以修改的了。

样例：

my_tuple=(1,2,3,[5,6,7])
print(my_tuple)
my_tuple[3][1]=1
print(my_tuple)

输出结果：

总结：

1. 元组可以容纳多个数据。
2. 元组可以容纳多种类型的数据
3. 元组储存数据是有序的（有下标索引）
4. 允许重复数据的存在
5. 不可以修改元组，包括增加减少修改内部的元素。
6. 支持for循环。

这里最后给一段代码，看看大家是否可以理解：

my_tuple=('小明',11,['football','music'])
print(my_tuple.index(11))
print(my_tuple[0])
my_tuple[2].pop(0)
print(my_tuple)
my_tuple[2].insert(0,'cooding')
print(my_tuple)

数据容器：str(字符串)

字符串储存的是字符元素的容器，相同的也可以这么理解他也有第0位，第1位，第2位这种概念，毕竟他本身也是一个容器，关于怎么定义，相信大家熟悉的不能再熟悉了，这边就不再赘述。

字符串的常见操作

字符串的下标索引

关于第一点，他也存在下标索引，也是相同的，这里也不再赘述。而通过相关函数的运算，我们也能知道，字符串也是属于一个不能修改的数据容器，与tuple相同。

查找指定元素的下标索引值

语法：

字符串.index(元素)

返回的值是所指定元素的下标，如果找不到，将报错ValueError。

样例：

my_string='hello and world'
print(my_string.index('and'))

输出结果：

可以看出的是，字符串当中我们可以搜索的是子串，但返回的是字串的第一个元素所占整个字符串当中的第几位。

字符串的替换

尽管字符串不能直接进行修改，但是字符串内部自定义了一种内置的函数，就是替换函数：

语法：

字符串.replace(字符串1，字符串2)

作用是将原本字符串当中的全部子串1全部替换成字符串2，但注意这并不是修改字符串，而是得到了一个新的字符串。

样例：

my_string='hello and world'
new_string = my_string.replace(' and ',' ')
print(my_string)
print(new_string)

输出结果：

字符串的分割

语法：

字符串.split(分隔符字符串)

功能是：按照指定的分隔符字符串，将字符串划分为多个字符串，并将其存储到列表对象当中。注意点是，字符串本身不变，但是多了一个列表储存子字符串。

样例：

my_string='hello and world'
new_list = my_string.split(" ")
print(my_string)
print(new_list)

输出结果：

字符串的规整操作

语法：

字符串.strip(element)

1. 如果不传入element，就是为空的话，得到的是去掉字符串最前面的空格和最后面的空格的一个新的字符串。

2. 如果传入element，甚至多个元素，传入的是去掉前后的指定元素的字符串，注意假设传入的是12，那么内部的前面和后面的1和2都会被删除，实际上是被认为是两个字符串，1 和 2。

样例：

my_string=' 12hello and world21 '
new1_string =my_string.strip()
new2_string =my_string.strip('1 2')
new3_string =my_string.strip('12')
print(my_string)
print(new1_string)
print(new2_string)
print(new3_string)

输出结果：

可以看出的是，函数的执行过程实际上是把该字符串的首位和末位与element内部的子串进行比较，出现相同的就删除，知道有不存在的，然后停止下来，后续的操作也就不再运行了。

统计字符串当中子串出现的次数

其实也和列表的一样，不过就是可以统计的是子串，也可以是字符，如果是子串，过程就是拿该条子串不断平移去对比。这里也不赘述了。

语法：

字符串.count(子串)

统计字符串的长度

也很好理解就是len(字符串)。不赘述了。

for while循环

不赘述，之前使用过很多次了，也和list完全一样，不过元素是字符，切记。

总结以及注意事项

函数	功能
字符串[下标]	根据索引取出特定位置的字符
字符串.replace(字符串1，字符串2)	将字符串内的全部字符串1替换为字符串2
字符串.split(字符串)	按照给定的字符串，对字符串进行分割，不会修改原本的字符串，而是得到一个新的列表，作为分隔符的字符串不会出现在列表里
字符串.split(element)	如果element没有内容代表取出首尾的空格，如果有内容代表取出首尾出现的相关的字符
字符串.count(字符子串)	统计这个字符子串在字符串中出现的次数
字符串.index(字符串)	查询该字符串出现的下标（第一个）
len(字符串)	返回字符串当中字符的数量

注意事项：

1. 字符串只能存储字符串。
2. 长度任意。
3. 存在下标索引（有顺序的序列）。
4. 允许重复字符。
5. 不可以修改
6. 支持for循环。

最后给一段代码，大家分析以下是什么意思

my_string = "itmma itamm bomam"
print(my_string.count('it'))
new_string = my_string.replace(" ",'|')
print(new_string)
new_list = new_string.split('|')
print(new_list)

数据容器(序列)的切片

序列是指：内容连续，有序，可以使用下标索引的一系列数据容器。

所以说前面学的列表 元组 字符串都是序列。

序列有一个常用的操作，也就是切片。切片就是指：从一个序列中取出一个子序列的过程。

语法：

序列[起始下标:结束下标:步长]

1. 起始下标标记着从哪里开始切片，也可以留空，留空代表着从头开始。
2. 结束下标（不包含）表示到哪里结束，留空代表着到结尾结束。
3. 步长代表依次取元素的间隔，如果为负数，代表着反向取数，但是有一个要求就是，起始下标和结束下标也一样要反向标记。步长不写代表为1.
4. 此操作结束后，并不会影响序列本身，会得到一个新的序列。

样例：

my_list = [1,2,3,4,5,6,7,8,9]
new_list = my_list[::2]
print(new_list)
my_tuple = (1,2,3,4,5,6,7,8,9)
new_tuple =my_tuple[0:5:2]
print(new_tuple)
my_string = "123456789"
new_string = my_string[7:0:-3]
print(new_string)

输出结果：

数据容器：set(集合)

集合的内容是不重复的，无序的。也会自动去重，在输出时，是乱序的。

集合的定义

基本的语法：
第一种：定义字面值

{元素1，元素2，元素3······}

第二种：定义变量

name_set = {元素1，元素2，元素3······}

第三种：定义空集合

name_set = set()

切记没有直接{}的这个空集合，因为这个是空字典。

值得注意的是使用的是{}大括号。

集合的常见操作

下标索引不存在

由于集合是乱序的，所以下标索引不存在。

添加新元素

语法：

集合.add(元素)

样例：

my_set = {1,2,3}
print(my_set)
my_set.add(4)
print(my_set)
my_set.add(2)
print(my_set)

输出结果：

由此可以看出，当添加的元素，集合内部已经有了，那么就不会再次出现。

删除元素

语法：

集合.remove(元素)

样例：

my_set = {1,2,3}
print(my_set)
my_set.remove(2)
print(my_set)

输出结果：

随机取一个元素

语法：

集合.pop()

样例：

my_set = {1,2,3}
print(my_set)
number = my_set.pop()
print(my_set)
print(number)

输出结果：

和列表相同的pop函数也会有返回值，返回的是取出的那个数。

清空集合

语法：

集合.clear()

这就不赘述了。

取两个集合的差集

语法：

集合1.difference(集合2)

功能是取出集合1中有的但是集合2中没有的元素，组成一个新的集合，集合1和集合2不变。

样例：

my1_set = {1,2,3}
my2_set = {2,3,4}
new_set = my1_set.difference(my2_set)
print(new_set)

输出结果：

删除差集

语法：

集合1.difference_updata(集合2)

功能是在集合1内，删除和集合2相同的元素。结果就是集合1发生改变，集合2不改变。

实际上就是省略了一个新的容器的产生，不然效用其实等效于前者函数。

样例：

my1_set = {1,2,3}
my2_set = {2,3,4}
my1_set.difference_update(my2_set)
print(my1_set)

输出结果：

两个集合的合并

语法：

集合1.union(集合2)

功能是将集合1和集合2的元素合并，去重后的元素返回给一个新的集合。结果是：得到一个新的集合，集合1 集合2不发生改变。

样例：

my1_set = {1,2,3}
my2_set = {2,3,4}
new_set = my1_set.union(my2_set)
print(new_set)

输出结果：

统计集合当中的元素的数量

语法：

len(集合)

集合的遍历

由于集合不存在下标索引，索引就不存在while循环，所以说，只能使用for进行遍历迭代。

my_set = {1,2,3}
for i in my_set :
    print(i,end=' ')

运算结果：

总结以及特点

总结操作：

函数	功能
集合.add(元素)	集合内添加一个元素
集合.pop()	随机取出集合的一个元素（返回值为该元素）
集合.remove(元素)	删除指定内容的元素
集合.clear()	清空集合
len(集合)	返回集合当中元素的数量
集合1.difference(集合2)	得到一个新集合，内部是集合1与集合2的差值
集合1.difference_updata(集合2)	在集合1中，删除集合2的元素，集合2保持不变
集合1.union(集合2)	得到一个新的集合，内含集合1和集合2的所有元素

集合的特点：

1. 可以容纳多个数据。
2. 可以容纳不同类型的数据。
3. 数据是无序存储的。（没有下标索引）
4. 不允许重复存在。
5. 可以修改（增加删减元素）
6. 支持for循环，不支持while循环。

数据容器：dict(字典 、映射）

我们可以通过相关的key去取得对应的value（比较类似于哈希表的结构），这样子的东西我们称作字典。

字典的定义

基本的语法：
第一种：定义字面值

{key1:value1，key2:value2，key3:value3······}

第二种：定义变量

name_dict = {key1:value1，key2:value2，key3:value3······}

第三种：定义空字典

name_dict = dict()
name_dict = {}

字典的定义同样使用大括号{}，但是存储的元素是key:value这样子的键值对。

相同的字典和集合一样，也是不允许重复定义的，如果重复定义，结果相当于是后面定义的对于前面定义的的覆盖操作。

字典定义的嵌套操作

对于key和value来说可以是任何数据类型，但是key不能是字典，相反的value可以是类型。也就有：

举个小例子进行说明：

my_dict = {"张三":{"语文":11,"数学":22},"李四":{"语文":33,"数学":44},"王五":{"语文":55,"数学":66}}
print(my_dict["张三"]["语文"]) # 关于怎么调用先不用了解,了解完下面的知识再回来看，就会有收获的

输出结果：

字典的常用操作

字典使用key获取相应的value

由于字典同集合一样，也不允许使用下标操作。

语法：

字典[key]

样例：

my_dict = {"张三":1,"李四":2,"王五":3}
print(my_dict["张三"])

输出结果：

新增元素

语法：

字典[key] =value

实际上就是直接外部直接定义一个：

样例：

my_dict = {"张三":{"语文":11,"数学":22},"李四":{"语文":33,"数学":44},"王五":{"语文":55,"数学":66}}
my_dict["赵四"] = {"语文":77,"数学":88}
print(my_dict)

输出结果（不全）：

修改元素

实际上就是覆盖，上文也有讲述，这里不赘述。

语法：

字典[key] =value

删除元素

语法：

字典.pop(key) # 同样的pop也会返回一个对应key的value值，看你需不需要承接。

样例：

my_dict = {"张三":{"语文":11,"数学":22},"李四":{"语文":33,"数学":44},"王五":{"语文":55,"数学":66}}
my_dict.pop("张三")
print(my_dict)

输出结果：

清空元素

语法：

字典.clear()

清空字典内所有的元素。这就不介绍了，不赘述。

获取全部的key

语法：

字典.keys() # 返回得到字典中所有的key，可不要理解成返回key的列表。

样例：

my_dict = {"张三":{"语文":11,"数学":22},"李四":{"语文":33,"数学":44},"王五":{"语文":55,"数学":66}}
my_dict_key = my_dict.keys()
print(my_dict_key)

输出结果：

遍历字典

可以通过for循环遍历key从而遍历字典。

语法：

for key in key或者字典 :
字典[key]# 相当于调用了

样例：

my_dict = {"张三":{"语文":11,"数学":22},"李四":{"语文":33,"数学":44},"王五":{"语文":55,"数学":66}}
my_dict_key = my_dict.keys()
for key in my_dict_key : # 这里in后面也可以直接接上my_dict
    print(f"字典中的key是{key}")
    print(f"字典中的value是{my_dict[key]}")

输出结果：

字典的大小

语法：

len(字典)

不赘述。

总结及注意事项

注意事项：

1. 字典内key值不允许重复，重复添加等效于覆盖。
2. key和value可以是任意类型（key不允许是字典）。
3. 字典也没有下标检索，支持for循环，不支持while循环。
4. 每一份数据都是键值对。
5. 可以容纳多组数据。
6. 可以容纳不同种类型的数据。
7. 可以修改元素。

操作总结：

操作	说明
字典[key]	获取指定key对应的value
字典[key]=value	添加或者更新键值对
字典.pop(key)	从字典中取出key对应的value值
字典.clear()	清空字典
字典.keys()	获取字典中全部的key，可用于for循环遍历字典，但是for循环也可以直接接上字典名字，相当于也是直接取key
len(字典)	计算字典中的元素的数量

数据容器的通用操作

五类容器都支持for循环的遍历，而对于while循环，集合和字典不支持while循环。

还有一些共通的函数：
比如：

1. len(容器)：统计该容器的大小。
2. max(容器)：统计该容器中最大的元素。（对于字典，比较大小的对象是key，而不是value）
3. min(容器)：统计该容器中最小的元素。（对于字典，比较大小的对象是key，而不是value）
4. str(容器)：将容器转换为字符串类型。（任何类型转换成字符串，都是直接加双引号，其他原封不动。）
5. list(容器)：将容器转换为列表类型。（对于字符串转列表实际上是每个字符作为一个元素，转成列表。而字典转列表，是把每个key作为元素，转成列表，value就舍弃了。）
6. tuple(容器)：将容器转换为元组类型。（对于字符串转列表实际上是每个字符作为一个元素，转成元组。而字典转列表，是把每个key作为元素，转成元组，value就舍弃了。）
7. set(容器)：将容器转换为集合类型。（对于字符串转列表实际上是每个字符作为一个元素，去重后，转成集合。而字典转列表，是把每个key作为元素，转成集合，value就舍弃了。）
8. 容器的通用排序功能sorted(容器，[reverse=True]),（默认不写即升序，如果想降序，就在该位置写上 reverse=True ）排序出来的结果是生成一个列表对象。

而关于字符的比较实际上就是比较其在ASCII的码值，也很简单，这里不赘述。

结语

应用场景简介：

1. 列表：一批数据，可修改 、可重复的存储场景。
2. 元组： 一批数据，不可修改 、可重复的存储场景。
3. 字符串：一串字符串。
4. 集合：一批数据，去重的存储场景。
5. 字典：一批数据，用key检索value的存储场景。