Python基础(四)——数据容器

Python
7.5k 词

数据容器入门

Python中的数据容器：

一个可以容纳多份数据的数据类型，容纳的每一份元素称之为1个元素，每个元素可以是任意类型的数据，如字符串、数字、布尔等。

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

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

分为5类，分别是：列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

数据容器：list（列表）

列表的定义

基本语法

1
2
3
4
5
6
7
8
9
# 字面量
[元素1,元素2,元素3,……]

# 定义变量
变量名称 = [元素1,元素2,元素3,……]

# 定义空列表
变量名称 = []
变量名称 = list()

注意：

  • 列表的每一个元素，称之为元素

  • 以 [] 作为标识

  • 列表内每个元素之间用逗号隔开

  • 列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

列表的下标索引

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

1
2
3
4
5
6
# 语法：列表[下标索引]

name_list = ['Sam','Jack','Mark']
print(name_list[0])		#结果：Sam
print(name_list[1])		#结果：Jack
print(name_list[2])		#结果：Mark

反向索引，从后往前的方向，从-1开始递减，如下：

1
2
3
4
5
6
# 语法：列表[下标索引]

name_list = ['Sam','Jack','Mark']
print(name_list[-1])		#结果：Mark
print(name_list[-2])		#结果：Jack
print(name_list[-3])		#结果：Sam

嵌套列表的下标索引，同上，写两层即可

1
# 语法 列表[下标][下标]

列表的常用操作

方法：在Python中，如果将函数定义为class（类）的成员，那么函数会称之为方法（写在类里的函数成为方法），使用“.”访问

列表的查询功能——index()

  • 查询某元素下标

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

    语法：列表.index(元素)

修改元素

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

    语法：列表[下标] = 值

    通过如上语法即可直接对指定位置的值进行重新赋值

  • 插入元素

    语法：列表.insert(下标,元素)

    在指定的下标位置，插入指定元素，该位置原来的元素和后续元素，依次向后移

  • 追加元素1

    语法：列表.append(元素)

    将元素追加到列表的尾部

  • 追加元素2

    语法：列表.extend(其他数据容器)

    将其他数据容器的内容取出，依次追加到列表尾部

  • 删除元素

    语法1：del 列表[下标]

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

    语法3：列表.remove(元素)

    方法pop()不仅可以删除元素，还会返回被删除的元素，remove()是删除某元素在列表的第一个匹配项

  • 清空列表

    语法：列表.clear()

    清空列表内容

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

    语法：列表.count(元素)

  • 统计列表中有多少元素

    语法：len(列表)

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

总结

功能 语法 描述
查询某元素下标 列表.index(元素) 查找指定元素在列表的下标，如果找不到，报错ValueError
修改元素值 列表[下标] = 值 直接对指定位置的值进行重新赋值
插入元素 列表.insert(下标,元素) 在指定的下标位置，插入指定元素，该位置原来的元素和后续元素，依次向后移
追加元素 列表.append(元素) 将元素追加到列表的尾部
追加元素 列表.extend(其他数据容器) 将其他数据容器的内容取出，依次追加到列表尾部
删除元素 del 列表[下标] 删除下标位置上的元素
删除元素 列表.pop(下标) 方法pop()不仅可以删除元素，还会返回被删除的元素
删除元素 列表.remove(元素) remove()是删除某元素在列表的第一个匹配项
清空列表 列表.clear() 清空列表内容
统计某元素数量 列表.count(元素)
统计列表元素 len(列表)

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
# 语法：列表[下标索引]

name_list = ['Sam','Jack','Mark']
print(name_list[0])		#结果：Sam
print(name_list[1])		#结果：Jack
print(name_list[2])		#结果：Mark

# 语法：列表[下标索引]

name_list = ['Sam','Jack','Mark']
print(name_list[-1])		#结果：Mark
print(name_list[-2])		#结果：Jack
print(name_list[-3])		#结果：Sam

# 1.索引元素 index()
index = name_list.index("Jack")
print(f"“Jack”在列表中的位置是{index}")

# 2.修改元素
name_list[2] = "Tom"
print(f"列表修改元素后，结果是：\t\t{name_list}")

# 3.插入元素 insert()
name_list.insert(2,"Mark")
print(f"列表插入元素后，结果是：\t\t{name_list}")

# 4.追加元素 append()
name_list.append("Peter")
print(f"列表追加元素后，结果是：\t\t{name_list}")

# 5.追加元素 extend()
name_list2 = [1,2,3]
name_list.extend(name_list2)
print(f"列表追加一个新列表后，结果是：\t{name_list}")

# 6.删除元素
del name_list[5]
print(f"列表删除元素后，结果是：\t\t{name_list}")

getWord = name_list.pop(5)
print(f"列表取出元素后，结果是：\t\t{name_list},取出的元素是：{getWord}")

name_list.remove(3)
print(f"列表删除元素后，结果是：\t\t{name_list}")

# 7.清空列表
name_list.clear()
print(f"清空列表后，结果是：\t\t\t{name_list}")

# 8.统计列表内某元素的数量
name_list = ['Sam','Jack','Mark','Sam','Sam','Sam']
count = name_list.count("Sam")
print(f"列表中Sam的数量是：\t\t\t{count}")

# 9.统计列表中有多少元素
count = len(name_list)
print(f"列表中元素的数量是：\t\t\t{count}")


"""
运行结果：
Sam
Jack
Mark
Mark
Jack
Sam
“Jack”在列表中的位置是1
列表修改元素后，结果是：		['Sam', 'Jack', 'Tom']
列表插入元素后，结果是：		['Sam', 'Jack', 'Mark', 'Tom']
列表追加元素后，结果是：		['Sam', 'Jack', 'Mark', 'Tom', 'Peter']
列表追加一个新列表后，结果是：	  ['Sam', 'Jack', 'Mark', 'Tom', 'Peter', 1, 2, 3]
列表删除元素后，结果是：		['Sam', 'Jack', 'Mark', 'Tom', 'Peter', 2, 3]
列表取出元素后，结果是：		['Sam', 'Jack', 'Mark', 'Tom', 'Peter', 3],取出的元素是：2
列表删除元素后，结果是：		['Sam', 'Jack', 'Mark', 'Tom', 'Peter']
清空列表后，结果是：			 []
列表中Sam的数量是：			  4
列表中元素的数量是：			 6

"""

特点

  • 可以容纳多个元素
  • 可以容纳不同类型的元素
  • 数据是有序储存（有下标序号）
  • 允许重复数据存在
  • 可以修改（增加或删除元素等）

列表的遍历

  1. 遍历：将容器的内容依次取出，并处理，称之为遍历
  2. for和while对比
    • for循环更简洁，while更灵活
    • for用于从容器内依次取出元素并处理，while可以用以任何需要循环的场景

数据容器：tuple（元组）

元组的定义

1
2
3
4
5
6
7
8
9
# 字面量
(元素1,元素2,元素3,……)

# 定义变量
变量名称 = (元素1,元素2,元素3,……)

# 定义空列表
变量名称 = ()
变量名称 = tuple()

注意：

  • 元组只有一个数据时，这个数后面要添加逗号
  • 元组也支持嵌套
  • 元组的下标索引与列表相同
  • 元组的内容时不可修改的，否则会报错，但如果在元组中嵌套列表，嵌套的列表是可以修改的
  • 多数特性和list一样，不同点在于不可修改

元组的相关操作

语法 作用
index() 查找某个数据，如果数据存在返回对于的下标，否则报错
count() 统计某个数据在当前元组出现的次数
len(元组) 统计元组内的元素个数

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# 定义元组
tup = ("Sam","Jack","Mark","Sam",["唱歌","篮球"])

# 统计元组长度
num = len(tup)
print(f"元组的长度是：\t{num}")

# 统计元组中，"Sam"出现的次数
num = tup.count("Sam")
print(f"”Sam“出现的次数：\t{num}")

# 索引"Mark"在元组中的位置
num = tup.index("Mark")
print(f"”Mark“所在的位置：{num}")

print(f"原元组的元素：\t{tup}")

# 删除元组中嵌套的列表元素
tup[4].pop(0)
print(f"删除元素后的元组：\t{tup}")

# 在元组嵌套的列表中添加元素
tup[4].append("coding")
print(f"添加元素后的元组：\t{tup}")

"""
运行结果：
元组的长度是：		 5
”Sam“出现的次数：	  2
”Mark“所在的位置：  2
原元组的元素：	     ('Sam', 'Jack', 'Mark', 'Sam', ['唱歌', '篮球'])
删除元素后的元组：	('Sam', 'Jack', 'Mark', 'Sam', ['篮球'])
添加元素后的元组：	('Sam', 'Jack', 'Mark', 'Sam', ['篮球', 'coding'])
"""

数据容器：str（字符串）

字符串介绍

  • 字符串是字符的容器
  • 一个字符串可以存放任意数量的字符
  • 支持下标索引
  • 允许重复字符串存在
  • 不可以修改
  • 字符串定义和格式化在Python基础（一）中有介绍

字符串的常用操作

语法 功能
字符串[下标] 同列表、元组
字符串.index() 同列表、元组
字符串.replace(字符串1,字符串2) 将字符串1内容替换为字符串2的内容
字符串.split(分隔符字符串) 按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
字符串.strip() 去掉前后空格
字符串.strip(字符串) 去掉前后指定的字符串
字符串.count(字符串) 统计某个数据在当前元组出现的次数
len(字符串) 统计元组内的元素个数

数据容器（序列）的切片

序列：内容连续、有序，可使用下标索引的一类数据容器，列表、元组、字符串均可以视为序列

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

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

  • 起始下标：从何处开始，可以留空，留空视作从头开始
  • 结束下标：何处结束（不含），可以留空，留空视作截到结尾
  • 步长：依次取元素的间隔
    • 不写默认是1
    • 步长1表示，一个个取元素，步长N表示每次跳过N-1个元素取
    • 步长为负数表示反向取（起始下标和结束下标也要反向标记）

注意：切片操作不会影响序列本身，而是得到一个新的序列

数据容器：set（集合）

集合的定义

1
2
3
4
5
6
7
8
# 定义集合字面量
{元素,元素,……,元素}

# 定义集合变量
变量名称 = {元素,元素,……,元素}

# 定义空集合
变量名称 = set()

集合的常用操作

方法 功能
集合.add(元素) 集合内添加一个元素
集合.remove(元素) 移除集合内指定的元素
集合.pop() 从集合中随机取出一个元素
集合.clear() 将集合清空
集合1.difference(集合2) 得到一个新集合，内含2个集合的差集，原有的2个集合内容不变
集合1.difference_uodate(集合2) 在集合1中，删除集合2中存在的元素集合1被修改，集合2不变
集合1.union(集合2) 得到1个新集合，内含2个集合的全部元素，原有的2个集合内容不变
len(集合) 得到一个整数。记录了集合的元素个数

集合的特点

  • 可以容纳多个元素
  • 可以容纳不同类型的数据（混装）
  • 数据时无序存储的（不支持下标索引）
  • 不允许重复数据存在
  • 可以修改
  • 支持for循环遍历，不可以使用while循环遍历（无法下标索引）

数据容器：dict（字典）

字典的定义

1
2
3
4
5
6
7
8
9
# 定义字典字面量
{key:value , key:value , key:value ,……, key:value}

# 定义字典变量
my_dict = {key:value , key:value , key:value ,……, key:value}

# 定义空字典
my_dict = {}
my_dict = dict()

字典的常用操作

语法 功能
字典[Key] 获取指定Key对应的Value值
字典[Key] = Value 添加或更新键值对
字典.pop(Key) 取出Key对应的Value并在字典内删除此Key的键值对
字典.clear() 请空字典
字典.keys() 获取字典的全部Key，可用for循环遍历字典
len(字典) 计算字典内的元素个数

字典的特点

  • 字典可以提供基于Key检索Value的场景实现，Key不可以重复（重复会覆盖）
  • 键值对的Key和Value可以是任意类型数据（Key不可以是字典）
  • 字典不可以下标索引，而是通过Key检索Value
  • 每一份数据都是KeyValue键值对
  • 支持for循环，不支持while循环
  • 可以修改

数据容器的总结对比

列表 元素 字符串 集合 字典
元素数量 支持多个 支持多个 支持多个 支持多个 支持多个
元素类型 任意 任意 仅字符 任意 Key：除字典外任意类型，Value：任意类型
下标索引 支持 支持 支持 不支持 不支持
重复元素 支持 支持 支持 不支持 不支持
可修改性 支持 不支持 不支持 支持 支持
数据有序 是 是 是 否 否
使用场景 可修改，可重复的一批数据记录场景 不可修改，可重复的一批数据记录场景 一串字符的记录场景 不可重复的数据记录场景 以Key检索Value的数据记录场景

数据容器的通用操作

功能 描述
通过for循环 遍历容器（字典是遍历Key）
max() 容器内最大元素
min() 容器内最小元素
len() 容器元素个数
list() 转换为列表
tuple() 转换为元组
str() 转换为字符串
set() 转换为集合
sorted(序列,[reverse=True]) 排序，reverse=True表示降序得到一个排好序的列表

字符串大小比较方式

字符串比较：从头到尾，一位位比较，其中一位大，后面就无需比较了

单个字符比较：通过ASCII码表，确定字符对应的码值数字来确定大小