该博客详细介绍了Python中5类数据容器，包括列表、元组、字符串、集合和字典的定义、常用操作及特点。如列表的索引、修改，元组的不可修改特性，字符串的查找、替换，集合的去重与合并，字典的键值对操作等，还提及了序列切片和容器通用功能。
目录
数据容器分为5类：列表（list）、元组（tuple）、字符串（str）、集合（set）、
字典（dict）
一.列表
1.列表定义
# 字面量
[元素1，元素2，元素3，元素4，...]
# 定义变量
变量名称 = [元素1，元素2，元素3，元素4，...]
# 定义空列表
变量名称 = []
变量名称 = list()
2.元素类型
列表内的每一个数据称之为元素，元素可以是字符串类型、int类型、bool类型、list、tuple...等，如下：
my_list = ["123","asdf","fji123"]
my_list1 = ["123",456,True]
my_list2 = [[123,"asdf"],(1,2,"hello")]3.列表的常用操作
3.1 列表的索引
3.1.1 列表的下标索引（正向）
# 语法 列表[下标索引]
# 例子
my_list = ["hello","world"]
print(f"my_list[0]") # 结果"hello"
print(f"my_list[1]") # 结果"world"3.1.2 列表的下标索引（反向）
# 语法 列表[下标索引]
# 例子
my_list = ["hello","world"]
print(f"my_list[-1]") # 结果"world"
print(f"my_list[-2]") # 结果"hello"3.1.3 列表的嵌套索引
# 2层嵌套
my_list = [[1,2,3],["hello","world"]]
# 获取内层第一个list
print(f"my_list[0]") # 结果：[1,2,3]
# 获取内层第一个list的第一个元素
print(f"my_list[0][0]") # 结果：13.2 列表的查询
查找某元素的下标 功能：查找指定元素在列表的下标，如果找不到，报错ValueError
语法：列表.index(元素)
my_list = ["hello","world"]
print(my_list.index("hello")) # 结果 03.3 修改特定位置（索引）的元素值
语法：列表[下标] = 值
my_list = ["hello","world","123"]
my_list[0] = "abc"
my_list[-1] = "456"
print(my_list) # 结果 ['abc', 'world', '456']3.3 列表的修改功能（方法）
3.3.1 插入元素
语法：列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素
my_list = ["hello","world","123"]
my_list.insert(1,[5,6])
my_list.insert(0,"asd")
print(my_list) # 结果 ['asd', 'hello', [5, 6], 'world', '123']3.3.2 追加元素
语法：列表.append(元素)，将指定元素，追加到列表的尾部
my_list = ["hello","world","123"]
my_list.append(4)
my_list.append([5,6])
print(my_list) # 结果 ['hello', 'world', '123', 4, [5, 6]]3.3.3 追加元素2
语法：列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部
my_list = ["hello","world","123"]
my_list.extend("asd")
my_list.extend([4,5])
print(my_list) # 结果 ['hello', 'world', '123', 'a', 's', 'd', 4, 5]3.3.4 删除元素
语法1： del 列表[下标]
语法2：列表.pop(下标)
my_list = ["hello","world","123"]
del my_list[0]
print(my_list) # 结果 ['world', '123']
my_list.pop(0)
print(my_list) # 结果 ['123']3.3.5 删除某元素在列表中的第一个匹配项
语法：列表.remove(元素）
my_list = ["hello","123","world","123"]
my_list.remove("123")
print(my_list) # 结果 ['hello', 'world', '123']3.3.6 清空列表内容
语法：列表.clear()
my_list = ["hello","123","world","123"]
my_list.clear()
print(my_list) # 结果 []3.3.7 统计某元素在列表内的数量
语法：列表.count(元素)
my_list = ["hello","123","world","123"]
num = my_list.count("123")
print(num) # 结果 23.3.8 统计列表内有多少元素
语法：len(列表)
my_list = ["hello","123","world","123"]
num = len(my_list)
print(num) # 结果 43.3.9 列表方法的总览
| 编号 | 使用方式 | 作用 |
| 1 | 列表.append(元素) | 向列表中追加一个元素 |
| 2 | 列表.extend(容器) | 将数据容器的内容依次取出，追加到列表尾部 |
| 3 | 列表.insert(下标, 元素) | 在指定下标处，插入指定的元素 |
| 4 | del 列表[下标] | 删除列表指定下标元素 |
| 5 | 列表.pop(下标) | 删除列表指定下标元素 |
| 6 | 列表.remove(元素) | 从前向后，删除此元素第一个匹配项 |
| 7 | 列表.clear() | 清空列表 |
| 8 | 列表.count(元素) | 统计此元素在列表中出现的次数 |
| 9 | 列表.index(元素) | 查找指定元素在列表的下标 找不到报错ValueError |
| 10 | len(列表) | 统计容器内有多少元素 |
二.元组
1.元组定义
定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型
注意事项：
注意：元组只有一个数据，这个数据后面要添加逗号
2.元组的常用方法
| 编号 | 方法 | 作用 |
| 1 | index() | 查找某个数据，如果数据存在返回对应的下标，否则报错 |
| 2 | count() | 统计某个数据在当前元组出现的次数 |
| 3 | len(元组) | 统计元组内的元素个数 |
元组可以看成是一个不可修改其中元素的一个列表，如果元组中的元素是一个列表，那么可以修改列表中的元素，但是不可以用其他的元素或列表来替换当前的列表。
三.字符串
字符串是字符的容器，一个字符串可以存放任意数量的字符。
1. 字符串的下标（索引）
和其它容器如：列表、元组一样，字符串也可以通过下标进行访问。
从前向后，下标从0开始
从后向前，下标从-1开始
name = "hello world!"
print(name[0]) # 结果 h
print(name[-1]) # 结果 ！同元组一样，字符串是一个：无法修改的数据容器。
2. 字符串的常用操作
2.1 查找特定字符串的下标索引值
语法：字符串.index(字符串)
name = "hello world!"
pos = name.index("world")
print(pos) # 结果 62.2 字符串的替换
语法：字符串.replace(字符串1，字符串2）
功能：将字符串内的全部：字符串1，替换为字符串2
注意：不是修改字符串本身，而是得到了一个新字符串
str = "hello world! hello"
new_str = str.replace("he","1234")
print(str) # 结果 hello world! hello
print(new_str) # 结果 1234llo world! 1234llo
# 字符串.replace()方法还有一个参数为count，默认为-1，代表替换
# 出现的全部的字符，如果给了指定的count，则为替换从第一个开始出
# 现的count个字符串
str = "hello world! hello"
new_str = str.replace("he","1234",1)
print(str) # 结果 hello world! hello
print(new_str) # 结果 1234llo world! hello2.3 字符串的分割
语法：字符串.split(分隔符字符串）
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
注意：字符串本身不变，而是得到了一个列表对象
str = "hello world! I love you!"
new_list = str.split(' ')
print(new_list) # 结果 ['hello', 'world!', 'I', 'love', 'you!']
# 字符串.split()方法中最后一个参数为 'maxsplit',代表最大分割次数(从左边开始)。
# -1(默认值)表示没有限制。
str = "hello world! I love you!"
new_list1 = str.split(' ',2)
print(new_list1) # 结果 ['hello', 'world!', 'I love you!']2.4 字符串的规整操作（去前后空格）
语法：字符串.strip()
str = " hello world! I love you! "
print(str.strip()) # 结果 hello world! I love you!2.5 字符串的规整操作（去前后指定字符串）
语法：字符串.strip(字符串)
str = "123 hello world! I love you! 321"
print(str.strip("123")) # 结果 hello world! I love you!注意，传入的是“123” 其实就是：”1”和”2”，“3”都会移除，是按照单个字符。
2.6 统计字符串中某字符串的出现次数
语法：字符串.count(字符串)
str = " hello world! I love you! hello!"
print(str.count("hello")) # 结果 22.7 统计字符串的长度
语法：len(字符串)
str = " hello world! I love you! hello!"
print(len(str)) # 结果 323. 字符串的常用操作汇总
| 编号 | 操作 | 说明 |
| 1 | 字符串[下标] | 根据下标索引取出特定位置字符 |
| 2 | 字符串.index(字符串） | 查找给定字符的第一个匹配项的下标 |
| 3 | 字符串.replace(字符串1, 字符串2) | 将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的 |
| 4 | 字符串.split(字符串) | 按照给定字符串，对字符串进行分隔 不会修改原字符串，而是得到一个新的列表 |
| 5 | 字符串.strip() 字符串.strip(字符串) | 移除首尾的空格和换行符或指定字符串 |
| 6 | 字符串.count(字符串) | 统计字符串内某字符串的出现次数 |
| 7 | len(字符串) | 统计字符串的字符个数 |
四.序列的切片
序列支持切片，即：列表、元组、字符串，均支持进行切片操作
切片：从一个序列中，取出一个子序列
语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
起始下标表示从何处开始，可以留空，留空视作从头开始
结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
步长表示，依次取元素的间隔
步长1表示，一个个取元素
步长2表示，每次跳过1个元素取
步长N表示，每次跳过N-1个元素取
步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
注意，此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）
# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4] # 步长默认是1，所以可以省略不写
print(f"结果1:{result1}") # 结果 结果1:[1, 2, 3]
# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:] # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2:{result2}") # 结果 结果2:(0, 1, 2, 3, 4, 5, 6)
# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3:{result3}") # 结果 结果3:0246
# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1] # 等同于将序列反转了
print(f"结果4:{result4}") # 结果 结果4:76543210
# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"结果5:{result5}") # 结果 结果5:[3, 2]
# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6:{result6}") #结果 结果6:(6, 4, 2, 0)五.集合
集合，最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序
基本语法：
1.集合的常用操作
首先，因为集合是无序的，所以集合不支持：下标索引访问
1.1 添加新元素
语法：集合.add(元素)。将指定元素，添加到集合内
结果：集合本身被修改，添加了新元素
my_set = {"hello","world"}
my_set.add("python")
print(my_set) # 结果 {'hello', 'python', 'world'}1.2 移除元素
语法：集合.remove(元素)，将指定元素，从集合内移除
结果：集合本身被修改，移除了元素
my_set = {"hello","world","python"}
my_set.remove("python")
print(my_set) # 结果 {'hello','world'}1.3 从集合中随机取出元素
语法：集合.pop()，功能，从集合中随机取出一个元素
结果：会得到一个元素的结果。同时集合本身被修改，元素被移除
my_set = {"hello","world","python"}
tmp = my_set.pop()
print(my_set) # 结果 {'python', 'world'}
print(tmp) # 结果 hello1.4 清空集合
语法：集合.clear()，功能，清空集合
结果：集合本身被清空
my_set = {"hello","world","python"}
my_set.clear()
print(my_set) # 结果 set()1.5 取出2个集合的差集
语法：集合1.difference(集合2)，
功能：取出集合1和集合2的差集（集合1有而集合2没有的）
结果：得到一个新集合，集合1和集合2不变
1.6 消除2个集合的差集
语法：集合1.difference_update(集合2)
功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。
结果：集合1被修改，集合2不变
1.7 2个集合合并
语法：集合1.union(集合2)
功能：将集合1和集合2组合成新集合
结果：得到新集合，集合1和集合2不变
1.8 查看集合的元素数量
语法：len(集合)
功能：统计集合内有多少元素
结果：得到一个整数结果
1.9 for循环遍历
要注意：集合不支持下标索引，所以也就不支持使用while循环。
2.集合常用功能总结
| 编号 | 操作 | 说明 |
| 1 | 集合.add(元素) | 集合内添加一个元素 |
| 2 | 集合.remove(元素) | 移除集合内指定的元素 |
| 3 | 集合.pop() | 从集合中随机取出一个元素 |
| 4 | 集合.clear() | 将集合清空 |
| 5 | 集合1.difference(集合2) | 得到一个新集合，内含2个集合的差集 原有的2个集合内容不变 |
| 6 | 集合1.difference_update(集合2) | 在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变 |
| 7 | 集合1.union(集合2) | 得到1个新集合，内含2个集合的全部元素 原有的2个集合内容不变 |
| 8 | len(集合) | 得到一个整数，记录了集合的元素数量 |
六.字典
1. 字典的定义
同样使用{}，不过存储的元素是一个个的：键值对，如下语法：
注意：字典与集合都用 ‘{}’，定义空字典可以用 ‘={}’，但是集合不可以。
字典同集合一样，不可以使用下标索引，但是字典可以通过Key值来取得对应的Value。
2. 字典的嵌套
字典的Key和Value可以是任意数据类型（Key不可为字典）
例：
3. 嵌套字典的内容获取
4.字典的常用操作
4.1 新增元素
语法：字典[Key] = Value
结果：字典被修改，新增了元素
4.2 更新元素
语法：字典[Key] = Value
结果：字典被修改，元素被更新
注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值
4.3 删除元素
语法：字典.pop(Key)
结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除
4.4 清空字典
语法：字典.clear()
结果：字典被修改，元素被清空
4.5 获取全部的key
语法：字典.keys()
结果：得到字典中的全部Key
4.6 遍历字典
语法：for key in 字典.keys()
4.7 计算字典内的全部元素（键值对）数量
语法：len(字典)
结果：得到一个整数，表示字典内元素（键值对）的数量
5. 字典的常用操作总结
| 编号 | 操作 | 说明 |
| 1 | 字典[Key] | 获取指定Key对应的Value值 |
| 2 | 字典[Key] = Value | 添加或更新键值对 |
| 3 | 字典.pop(Key) | 取出Key对应的Value并在字典内删除此Key的键值对 |
| 4 | 字典.clear() | 清空字典 |
| 5 | 字典.keys() | 获取字典的全部Key，可用于for循环遍历字典 |
| 6 | len(字典) | 计算字典内的元素数量 |
七.容器通用功能总览
| 通用for循环 | 遍历容器（字典是遍历key） |
| max | 容器内最大元素 |
| min() | 容器内最小元素 |
| len() | 容器元素个数 |
| list() | 转换为列表 |
| tuple() | 转换为元组 |
| str() | 转换为字符串 |
| set() | 转换为集合 |
| sorted(序列, [reverse=True]) | 排序，reverse=True表示降序 得到一个排好序的列表 |
八.数据容器特点对比
| 列表 | 元组 | 字符串 | 集合 | 字典 | |
| 元素数量 | 支持多个 | 支持多个 | 支持多个 | 支持多个 | 支持多个 |
| 元素类型 | 任意 | 任意 | 仅字符 | 任意 | Key：Value Key：除字典外任意类型 Value：任意类型 |
| 下标索引 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 重复元素 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 可修改性 | 支持 | 不支持 | 不支持 | 支持 | 支持 |
| 数据有序 | 是 | 是 | 是 | 否 | 否 |
| 使用场景 | 可修改、可重复的一批数据记录场景 | 不可修改、可重复的一批数据记录场景 | 一串字符的记录场景 | 不可重复的数据记录场景 | 以Key检索Value的数据 记录场景 |
扫一扫
4621
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
