Python从入门到精通六：Python数据容器

数据容器入门

为什么学习数据容器

思考一个问题：如果我想要在程序中，记录5名学生的信息，如姓名。

如何做呢？

学习数据容器，就是为了批量存储或批量使用多份数据

Python中的数据容器：

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素

每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

数据容器根据特点的不同，如：

• 是否支持重复元素
• 是否可以修改
• 是否有序，等

分为5类，分别是：

列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

我们将一一学习它们

总结：

1、什么是数据容器？

一种可以存储多个元素的Python数据类型

2. Python有哪些数据容器？

list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)

它们各有特点，但都满足可容纳多个元素的特性。

数据容器：list(列表)

为什么需要列表

思考：有一个人的姓名(TOM)怎么在程序中存储？

答：字符串变量

思考：如果一个班级100位学生，每个人的姓名都要存储，应该如何书写程序？声明100个变量吗？

答：No，我们使用列表就可以了， 列表一次可以存储多个数据

列表（list）类型，是数据容器的一类，我们来详细学习它。

列表的定义

基本语法：

列表内的每一个数据，称之为元素

• 以 [] 作为标识
• 列表内每一个元素之间用, 逗号隔开

列表的定义方式：

案例演示：使用[]的方式定义列表

总结：

1. 列表的定义语法

[元素1, 元素2, 元素3, ......]

2. 什么是元素？

数据容器内的每一份数据，都称之为元素

3. 元素的类型有限制吗？

元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表

列表的下标索引

如何从列表中取出特定位置的数据呢？

我们可以使用：下标索引

如图，列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增

我们只需要按照下标索引，即可取得对应位置的元素。

列表的下标（索引） - 反向

或者，可以反向索引，也就是从后向前：从-1开始，依次递减（-1、-2、-3......）

如图，从后向前，下标索引为：-1、-2、-3，依次递减。

嵌套列表的下标（索引）

如果列表是嵌套的列表，同样支持下标索引

如图，下标就有2个层级了。

总结：

1. 列表的下标索引是什么？

列表的每一个元素，都有编号称之为下标索引

从前向后的方向，编号从0开始递增

从后向前的方向，编号从-1开始递减

2. 如何通过下标索引取出对应位置的元素呢？

列表[下标]，即可取出

3. 下标索引的注意事项：

要注意下标索引的取值范围，超出范围无法取出元素，并且会报错

列表的常用操作

列表的常用操作（方法）

列表除了可以：

• 定义
• 使用下标索引获取值

以外，列表也提供了一系列功能：

• 插入元素
• 删除元素
• 清空列表
• 修改元素
• 统计元素个数

等等功能，这些功能我们都称之为：列表的方法

列表的查询功能（方法）

回忆：函数是一个封装的代码单元，可以提供特定功能。

在Python中，如果将函数定义为class（类）的成员，那么函数会称之为：方法

方法和函数功能一样， 有传入参数，有返回值，只是方法的使用格式不同：

函数的使用：

方法的使用：

关于类和方法的定义，在面向对象章节我们学习，目前我们知道如何使用方法即可。

查找某元素的下标

     功能：查找指定元素在列表的下标，如果找不到，报错ValueError

     语法：列表.index(元素)

     index就是列表对象（变量）内置的方法（函数）

列表的修改功能（方法）

修改特定位置（索引）的元素值：

     语法：列表[下标] = 值

     可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）

 

插入元素：

     语法：列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素

追加元素：

     语法：列表.append(元素)，将指定元素，追加到列表的尾部

追加元素方式2：

     语法：列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部

删除元素：

     语法1： del 列表[下标]

     语法2：列表.pop(下标)

删除某元素在列表中的第一个匹配项

     语法：列表.remove(元素)

清空列表内容，语法：列表.clear()

统计某元素在列表内的数量

     语法：列表.count(元素)

列表的查询功能（方法）

统计列表内，有多少元素

     语法：len(列表)

     可以得到一个int数字，表示列表内的元素数量

列表的方法 - 总览

列表的方法 - 说明

功能方法非常多，同学们不需要硬记下来。

学习编程，不仅仅是Python语言本身，以后根据方向，会学习更多的框架技术。

除了经常用的，大多数是记忆不下来的。

我们要做的是，有一个模糊印象，知晓有这样的用法即可。

需要的时候，随时查阅资料即可。

列表的特点

经过上述对列表的学习，可以总结出列表有如下特点：

• 可以容纳多个元素（上限为2**63-1、9223372036854775807个）
• 可以容纳不同类型的元素（混装）
• 数据是有序存储的（有下标序号）
• 允许重复数据存在
• 可以修改（增加或删除元素等）
   

总结：

1. 列表的常见方法有:

2. 列表有哪些特点？

list（列表）的遍历

目标：

• 1. 掌握使用while循环，遍历列表的元素
• 2. 掌握使用for循环，遍历列表的元素

列表的遍历 - while循环

既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。

将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。

如何遍历列表的元素呢？

可以使用前面学过的while循环

如何在循环中取出列表的元素呢？

使用列表[下标]的方式取出

循环条件如何控制？

定义一个变量表示下标，从0开始

循环条件为 下标值 < 列表的元素数量

列表的遍历 - for循环

除了while循环外，Python中还有另外一种循环形式：for循环。

对比while，for循环更加适合对列表等数据容器进行遍历。

语法：

每一次循环将列表中的元素取出，赋值到变量i，供操作

表示，从容器内，依次取出元素并赋值到临时变量上。

在每一次的循环中，我们可以对临时变量（元素）进行处理。

while循环和for循环的对比

while循环和for循环，都是循环语句，但细节不同：

在循环控制上：

• while循环可以自定循环条件，并自行控制
• for循环不可以自定循环条件，只可以一个个从容器内取出数据

在无限循环上：

• while循环可以通过条件控制做到无限循环
• for循环理论上不可以，因为被遍历的容器容量不是无限的

在使用场景上：

• while循环适用于任何想要循环的场景
• for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

总结：

1. 什么是遍历？

将容器内的元素依次取出，并处理，称之为遍历操作

2. 如何遍历列表的元素？

可以使用while或for循环

3. for循环的语法：

4. for循环和while对比

• for循环更简单，while更灵活
• for用于从容器内依次取出元素并处理，while用以任何需要循环的场景
   

数据容器：tuple(元组)

元组的定义

为什么需要元组

思考：列表是可以修改的。

如果想要传递的信息，不被篡改，列表就不合适了。

元组同列表一样，都是可以封装多个、不同类型的元素在内。

但最大的不同点在于：

元组一旦定义完成，就不可修改

所以，当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了

定义元组

元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。

注意：元组只有一个数据，这个数据后面要添加逗号

元组也支持嵌套：

元组的相关操作

元组的相关操作 - 注意事项

不可以修改元组的内容，否则会直接报错

可以修改元组内的list的内容（修改元素、增加、删除、反转等）

不可以替换list为其它list或其它类型

元组的遍历

同列表一样，元组也可以被遍历。

可以使用while循环和for循环遍历它

元组的特点

经过上述对元组的学习，可以总结出列表有如下特点：

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是有序存储的（下标索引）
• 允许重复数据存在
• 不可以修改（增加或删除元素等）
• 支持for循环

多数特性和list一致，不同点在于不可修改的特性。

总结：

1. 元组的定义方式：

(元素, 元素, 元素, ......)

2. 元组的操作方法：

3. 元组的注意事项：

不可修改内容（可以修改内部list的内部元素）

4. 元组的特点：

• 和list基本相同（有序、任意数量元素、允许重复元素），唯一不同在于不可修改。
• 支持for循环
   

数据容器：str(字符串)

尽管字符串看起来并不像：列表、元组那样，一看就是存放了许多数据的容器。

但不可否认的是，字符串同样也是数据容器的一员。

字符串是字符的容器，一个字符串可以存放任意数量的字符。

如，字符串："itheima"

字符串的下标（索引）

和其它容器如：列表、元组一样，字符串也可以通过下标进行访问

• 从前向后，下标从0开始
• 从后向前，下标从-1开始

同元组一样，字符串是一个：无法修改的数据容器。

所以：

• 修改指定下标的字符    （如：字符串[0] = “a”）
• 移除特定下标的字符    （如：del 字符串[0]、字符串.remove()、字符串.pop()等）
• 追加字符等        （如：字符串.append()）

均无法完成。如果必须要做，只能得到一个新的字符串，旧的字符串是无法修改

字符串的常用操作

查找特定字符串的下标索引值

     语法：字符串.index(字符串)

字符串的替换

     语法：字符串.replace(字符串1，字符串2）

     功能：将字符串内的全部：字符串1，替换为字符串2

     注意：不是修改字符串本身，而是得到了一个新字符串哦

     可以看到，字符串name本身并没有发生变化

     而是得到了一个新字符串对象

字符串的分割

     语法：字符串.split(分隔符字符串）

     功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

     注意：字符串本身不变，而是得到了一个列表对象

     可以看到，字符串按照给定的 <空格>进行了分割，变成多个子字符串，并存入一个列表对象中。

字符串的规整操作（去前后空格）

     语法：字符串.strip()

字符串的规整操作（去前后指定字符串）

     语法：字符串.strip(字符串)

注意，传入的是“12” 其实就是：”1”和”2”都会移除，是按照单个字符。

统计字符串中某字符串的出现次数

     语法：字符串.count(字符串)

统计字符串的长度

     语法：len(字符串)

可以看出：

数字（1、2、3...）

字母（abcd、ABCD等）

符号（空格、!、@、#、$等）

中文

均算作1个字符

所以上述代码，结果20

字符串常用操作汇总

字符串的遍历

同列表、元组一样，字符串也支持while循环和for循环进行遍历

字符串的特点

作为数据容器，字符串有如下特点：

• 只可以存储字符串
• 长度任意（取决于内存大小）
• 支持下标索引
• 允许重复字符串存在
• 不可以修改（增加或删除元素等）
• 支持for循环

基本和列表、元组相同

不同与列表和元组的在于：字符串容器可以容纳的类型是单一的，只能是字符串类型。

不同于列表，相同于元组的在于：字符串不可修改

总结：

1. 字符串为什么被称之为数据容器呢？

字符串可以看做是字符的容器，支持下标索引等特性 

2. 字符串有哪些常用操作方法？

3. 字符串有哪些特点：

数据容器（序列）的切片

学习目标：

• 了解什么是序列
• 掌握序列的切片操作

序列

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

列表、元组、字符串，均可以可以视为序列。

如图，序列的典型特征就是：有序并可用下标索引，字符串、元组、列表均满足这个要求

序列的常用操作 - 切片

序列支持切片，即：列表、元组、字符串，均支持进行切片操作

切片：从一个序列中，取出一个子序列

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

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

1. 起始下标表示从何处开始，可以留空，留空视作从头开始
2. 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
3. 步长表示，依次取元素的间隔

• 步长1表示，一个个取元素
• 步长2表示，每次跳过1个元素取
• 步长N表示，每次跳过N-1个元素取
• 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

注意，此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）

序列的切片演示

my_list = [1, 2, 3, 4, 5]
new_list = my_list[1:4]	# 下标1开始，下标4（不含）结束，步长1
print(new_list)		# 结果：[2, 3, 4]

my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:]	# 从头开始，到最后结束，步长1
print(new_tuple)		# 结果：(1, 2, 3, 4, 5)

my_list = [1, 2, 3, 4, 5]
new_list = my_list[::2]		# 从头开始，到最后结束，步长2
print(new_list)		# 结果：[1, 3, 5]

my_str = "12345"
new_str = my_str[:4:2]	# 从头开始，到下标4（不含）结束，步长2
print(new_str)		# 结果："13"

my_str = "12345"
new_str = my_str[::-1]	# 从头（最后）开始，到尾结束，步长-1（倒序）
print(new_str)		# 结果："54321"

my_list = [1, 2, 3, 4, 5]
new_list = my_list[3:1:-1]	# 从下标3开始，到下标1（不含）结束，步长-1（倒序）
print(new_list)		# 结果：[4, 3]

my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:1:-2] 	# 从头（最后）开始，到下标1(不含)结束，步长-2（倒序）
print(new_tuple)		# 结果：(5, 3)

可以看到，这个操作对列表、元组、字符串是通用的

同时非常灵活，根据需求，起始位置，结束位置，步长（正反序）都是可以自行控制的

总结：

1. 什么是序列？

内容连续、有序，支持下标索引的一类数据容器

2. 哪些数据容器可以视为序列？

列表、元组、字符串

3. 序列如何做切片

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

• 起始可以省略，省略从头开始
• 结束可以省略，省略到尾结束
• 步长可以省略，省略步长为1（可以为负数，表示倒序执行）

数据容器：set(集合)

学习目标：

• 掌握集合的定义格式
• 掌握集合的特点
• 掌握集合的常见操作

为什么使用集合

我们目前接触到了列表、元组、字符串三个数据容器了。基本满足大多数的使用场景。

为何又需要学习新的集合类型呢？

通过特性来分析：

• 列表可修改、支持重复元素且有序
• 元组、字符串不可修改、支持重复元素且有序

同学们，有没有看出一些局限？

局限就在于：它们都支持重复元素。

如果场景需要对内容做去重处理，列表、元组、字符串就不方便了。

而集合，最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序

集合的定义

基本语法：

和列表、元组、字符串等定义基本相同：

• 列表使用：[]
• 元组使用：()
• 字符串使用：""
• 集合使用：{}
   

集合的常用操作 - 修改

首先，因为集合是无序的，所以集合不支持：下标索引访问

但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。

• 添加新元素

     语法：集合.add(元素)。将指定元素，添加到集合内

     结果：集合本身被修改，添加了新元素

• 移除元素

     语法：集合.remove(元素)，将指定元素，从集合内移除

     结果：集合本身被修改，移除了元素

• 从集合中随机取出元素

     语法：集合.pop()，功能，从集合中随机取出一个元素

     结果：会得到一个元素的结果。同时集合本身被修改，元素被移除

• 清空集合

     语法：集合.clear()，功能，清空集合

     结果：集合本身被清空

• 取出2个集合的差集

     语法：集合1.difference(集合2)，功能：取出集合1和集合2的差集（集合1有而集合2没有的）

     结果：得到一个新集合，集合1和集合2不变

• 消除2个集合的差集

     语法：集合1.difference_update(集合2)

     功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。

     结果：集合1被修改，集合2不变

• 2个集合合并

     语法：集合1.union(集合2)

     功能：将集合1和集合2组合成新集合

     结果：得到新集合，集合1和集合2不变

集合的常用操作 - 集合长度

查看集合的元素数量

     语法：len(集合)

     功能：统计集合内有多少元素

     结果：得到一个整数结果

 

集合的常用操作 - for循环遍历

集合同样支持使用for循环遍历

要注意：集合不支持下标索引，所以也就不支持使用while循环。

集合常用功能总结

集合的特点

经过上述对集合的学习，可以总结出集合有如下特点：

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是无序存储的（不支持下标索引）
• 不允许重复数据存在
• 可以修改（增加或删除元素等）
• 支持for循环

总结：

1.集合有哪些特点

集合内不允许重复元素（去重）

集合内元素是无序的（不支持下标索引）

2. 集合的定义方式：

{元素, 元素, ......, 元素}

3. 集合的常用操作

4. 如何遍历集合元素

可以使用for循环进行变量

不可以使用while循环，因为不支持下标索引

5. 集合的特点

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

字典的定义

为什么使用字典

生活中的字典：

通过【字】

就能找到对应的【含义】

所以，我们可以认为，生活中的字典就是记录的一堆：

【字】：【含义】

【字】：【含义】

......

【字】：【含义】

为什么需要字典

Python中字典和生活中字典十分相像：

字典的定义

字典的定义，同样使用{}，不过存储的元素是一个个的：键值对，如下语法：

• 使用{}存储原始，每一个元素是一个键值对
• 每一个键值对包含Key和Value（用冒号分隔）
• 键值对之间使用逗号分隔
• Key和Value可以是任意类型的数据（key不可为字典）
• Key不可重复，重复会对原有数据覆盖

                                                                                 
前文中提到的，记录学生成绩，可以使用如下定义：

前文中记录学生成绩的需求，可以如下记录：

字典数据的获取

字典同集合一样，不可以使用下标索引

但是字典可以通过Key值来取得对应的Value

字典的嵌套

字典的Key和Value可以是任意数据类型（Key不可为字典）

那么，就表明，字典是可以嵌套的

需求如下：记录学生各科的考试信息

代码：

优化一下可读性，可以写成：

嵌套字典的内容获取

嵌套字典的内容获取，如下所示：

总结：

1. 为什么使用字典

字典可以提供基于Key检索Value的场景实现

就像查字典一样

2. 字典的定义语法

3.  字典的注意事项

• 键值对的Key和Value可以是任意类型（Key不可为字典）
• 字典内Key不允许重复，重复添加等同于覆盖原有数据
• 字典不可用下标索引，而是通过Key检索Value

字典的常用操作

学习目标：

• 掌握字典的常用操作
• 掌握字典的特点
   

字典的常用操作

• 新增元素

    语法：字典[Key] = Value，结果：字典被修改，新增了元素

• 更新元素

    语法：字典[Key] = Value，结果：字典被修改，元素被更新

    注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值

• 删除元素

    语法：字典.pop(Key)，结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除

• 清空字典

    语法：字典.clear()，结果：字典被修改，元素被清空

• 获取全部的key

    语法：字典.keys()，结果：得到字典中的全部Key

• 遍历字典

    语法：for key in 字典.keys()

注意：字典不支持下标索引，所以同样不可以用while循环遍历

运行结果

• 计算字典内的全部元素（键值对）数量

    语法：len(字典)

    结果：得到一个整数，表示字典内元素（键值对）的数量

字典的常用操作总结

字典的特点

经过上述对字典的学习，可以总结出字典有如下特点：

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是KeyValue键值对
• 可以通过Key获取到Value，Key不可重复（重复会覆盖）
• 不支持下标索引
• 可以修改（增加或删除更新元素等）
• 支持for循环，不支持while循环

总结：

1. 字典的常用操作

2. 操作注意

新增和更新元素的语法一致，如果Key不存在即新增，如果Key存在即更新（Key不可重复）

3. 字典的特点

数据容器对比总结

数据容器分类

数据容器可以从以下视角进行简单的分类：

• 是否支持下标索引

1. 支持：列表、元组、字符串 - 序列类型
2. 不支持：集合、字典 - 非序列类型

• 是否支持重复元素：

1. 支持：列表、元组、字符串 - 序列类型
2. 不支持：集合、字典 - 非序列类型

• 是否可以修改

1. 支持：列表、集合、字典
2. 不支持：元组、字符串
    

数据容器特点对比

总结：

基于各类数据容器的特点，它们的应用场景如下：

• 列表：一批数据，可修改、可重复的存储场景
• 元组：一批数据，不可修改、可重复的存储场景
• 字符串：一串字符串的存储场景
• 集合：一批数据，去重存储场景
• 字典：一批数据，可用Key检索Value的存储场景
   

数据容器的通用操作

数据容器的通用操作 - 遍历

数据容器尽管各自有各自的特点，但是它们也有通用的一些操作。

首先，在遍历上：

• 5类数据容器都支持for循环遍历
• 列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）

尽管遍历的形式各有不同，但是，它们都支持遍历操作。

数据容器的通用统计功能

除了遍历这个共性外，数据容器可以通用非常多的功能方法

同学们可能会疑惑，字符串如何确定大小？

我们下一个小节为同学们解惑。

容器的通用转换功能

除了下标索引这个共性外，还可以通用类型转换

容器通用排序功能

通用排序功能

sorted(容器, [reverse=True])

将给定容器进行排序

注意，排序后都会得到列表（list）对象。

容器通用功能总览

字符串大小比较

ASCII码表

在程序中，字符串所用的所有字符如：

• 大小写英文单词
• 数字
• 特殊符号(!、\、|、@、#、空格等）

都有其对应的ASCII码表值

每一个字符都能对应上一个：数字的码值

字符串进行比较就是基于数字的码值大小进行比较的。

字符串比较

字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大。

 

总结：

1. 字符串如何比较

从头到尾，一位位进行比较，其中一位大，后面就无需比较了。

2. 单个字符之间如何确定大小？

通过ASCII码表，确定字符对应的码值数字来确定大小