首页Python

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

Python 数据容器可以分为 5 类：

  • 列表（list）
  • 元组（tuple）
  • 字符串（str）
  • 集合（set）
  • 字典（dict）
列表 元组 字符串 集合 字典
元素类型 任意 任意 字符 任意 key-value (key: 除字典外任意类型，value: 任意类型)
下标索引 支持 支持 支持 不支持 不支持
数据有序 是 是 是 否 否
重复元素 支持 支持 支持 不支持 不支持
可修改性 是 否 是 是 是

在 Python 中，有序是指其中的数据可以通过索引（即下标）进行访问

# 列表

# 列表的定义

# 字面量
[元素1, 元素2, ...]
# 定义变量
变量名 =  [元素1, 元素2, ...]
#定义空列表
变量名称 = []
变量名称 = list()
列表可以同时存储不同的数据类型，并且，列表支持嵌套


例如：


my_list = ["iteration", 1234, True]
nested_list = [[1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))
print(nested_list)
print(type(nested_list))
# 列表的方法


# 访问元素


可以通过列表的下标索引 idx 获取对应位置的数据


value = list_name[idx]
其中，列表的下标索引可以分为两种：


    

  • 正向索引（从左往右）：从 0 开始，依次递增
    • 

  • 反向索引（从右往左）：从 -1 开始，依次递减
    • 





要注意下标索引的取值范围，超出范围会报错




# 查找元素


查找元素 element 在列表 list_name 中的下标（元素在列表中的第一个匹配位置），如果找不到则报错 ValueError


list_name.index(element)
# 修改元素


修改下标为 idx 的元素的值


list_name[idx] = value
# 插入元素


在下标 idx 处插入元素 element


list_name.insert(idx, element)
# 追加元素


方式一


将元素 element 追加到列表 list_name 的尾部


list_name.append(element)
例如：


name_list = ["it", "its", "itself"]
name_list.append("itheima")
方式二


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


list_name.extend(Data)
例如：


mylist = [1, 3, 5]
temp_list = [2, 4, 6]
mylist.extend(temp_list)
# 删除指定位置元素


删除下标 idx 处的元素


del list_name[idx]
list_name.pop(idx)      # 该方式可以获取返回值（被删除的元素）
# 删除指定元素


删除指定元素值在列表中的第一个匹配项


list_name.remove(element)   # 删除元素 element 在列表中的第一个匹配项
# 清空列表


清空列表内容


list_name.clear()
# 统计指定元素数量


统计元素 element 在列表 list_name 中的数量


list_name.count(element)
# 其他


# 统计列表元素数量


统计整个列表中的元素总数量


len(list_name)
# 列表的 while 遍历


idx = 0
while idx < len(list_name):
    statement
    idx += 1
# 列表的 for 遍历


for i in range(0, len(list_name)):
    statement
# 元组


元组（tuple）：元组同列表一样，都是一种可以封装多个、不同类型的元素的容器；不同点在于，元素一旦定义完成，就不可以修改


# 元组的定义


定义元组：使用小括号包围数据，其中，每个数据之间用逗号隔开（数据可以是不同的数据类型）


# 定义元组字面量
(元素1, 元素2, ...)
# 定义元组变量
变量名称 = (元素1, 元素2, ...)
# 定义空元组
变量名称 = ()
变量名称 = tuple()
注意：如果元组只有一个数据，需要在这个数据后面添加逗号，否则不是元组类型


例如：


t4 = ("World", )
元组也支持嵌套


注意：


    

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

  • 如果元组内嵌套了 list 列表，则可以修改 list 列表的内容（修改、增加、删除元素，反转等）
    • 



例如：


mytuple = (1, 2, ["it", "20221124"])
mytuple[2][0] = "python"
# 元组的方法


# 访问元素


元组支持下标索引


element = tuple_name[idx]
# 查找元素


查找指定元素的第一个匹配项


tuple_name.index(element)
# 统计指定元素数量


tuple_name.count(element)
# 其他


# 统计元素数量


len(tuple_name)
# 元组的 while 遍历


idx = 0
while idx < len(tuple_name):
    statement
    idx += 1
# 元组的 for 遍历


for element in tuple_name:
    statement
# 字符串


字符串（str）：字符串是字符的容器，一个字符串可以存放任意数量的字符


字符串是一个 无法修改 的数据容器


# 字符串的定义


使用一对双引号包围一系列字符


str_name = "Here is the content of string"
# 字符串的方法


# 访问元素


字符串支持下标索引


    

  • 从前往后索引：下标从 0 开始
    • 

  • 从后往前索引：下标从 -1 开始
    • 



# 查找子串


查找子串 target_str 在字符串 str_name 中的下标索引值


str_name.index(target_str)
# 替换子串


将字符串 str_name 内的 str1 全部替换为 str2


str_name.replace(str1, str2)
注意，此方法并不是修改字符串本身（字符串是无法修改的），而是得到了一个新的字符串


# 分割子串


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


str_name.split(separator)
注意，此方法并不是修改字符串本身，而是得到了一个列表对象


例如：


my_str = "hello python itheima and itcast"
result = my_str.split(" ")  # 按照空格进行分割，得到一个列表
# 去除前后空格


strip () 方法删除开头和结尾的空白字符


str_name.strip()
例如：


my_str = "   itheima and itcast   "
new_my_str = my_str.strip()
# 去除前后指定字符串


通过给 strip () 方法传入参数，可以删除字符串开头和结尾处的指定字符串


str_name.strip(target_str)
需要注意，删除操作是按照单个字符进行的


例如：


my_str = "12itheima and itcast21"
new_my_str = my_str.strip("12")     # 传入的是 "12"，此时，"1" 和 "2" 都会移除，即，按照单个字符移除
# 统计指定字符串数量


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


str_name.count(target_str)
例如：


my_str = "itheima and itcast"
cnt = my_str.count('it')
# 其他


# 统计字符串长度


len(str_name)
# 字符串的 while 遍历


idx = 0
while idx < len(str_name)
    statement
    idx += 1
# 字符串的 for 遍历


for element in str_name:
    statement
# 序列


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


序列是字符串、元组、列表的统称


序列支持切片，即：从序列的指定位置开始，依次取出元素，到指定位置结束，得到一个新序列（该操作不会影响原序列，而是生成了一个新的序列）


sequence[start:end:step]
其中：


    

  • 起始下标 start 表示从何处开始，可以省略，省略时视为从头开始
    • 

  • 结束下标 end 表示何处结束（不截取结束下标对应元素），可以省略，省略时视为截取至序列末尾（截取最后一个元素）
    • 

  • 步长 step 表示依次取元素的间隔，步长可以为负数，表示反向取元素（注意，起始下标和结束下标也要反向标记）
    • 



# 集合


集合（set）：不支持元素重复（自带去重功能），并且内容无序


集合是无序的，不支持下标索引访问


集合是可以修改的


# 集合的定义


定义集合：使用大括号包围数据，其中，每个数据之间用逗号隔开


# 定义集合字面量
{元素1, 元素2, ...}
# 定义集合变量
变量名称 = {元素1, 元素2, ...}
# 定义空集合
变量名称 = set()
# 集合的方法


# 添加元素


将指定元素添加到集合内


set_name.add(element)
# 删除元素


将指定元素从集合内移除


set_name.remove(element)
# 随机取出元素


从集合中随机取出一个元素（集合本身被修改，元素被移除）


该操作可以具有返回值


element = set_name.pop()
# 清空集合


set_name.clear()
# 取两集合的差集


取出集合 1 与集合 2 的差集：元素在集合 1 中、但不在集合 2 中


该操作得到一个新集合，集合 1 和集合 2 保持不变


new_set = set1.difference(set2)
# 消除两集合的差集


消除集合 1 与集合 2 的差集：对比集合 1 和集合 2，在集合 1 内，删除与集合 2 相同的元素


该操作修改了集合 2，集合 2 保持不变


set1.difference_update(set2)
# 合并两集合


合并 2 个集合：将集合 1 与集合 2 组成新集合


该操作得到一个新集合，集合 1 与集合 2 保持不变


new_set = set1.union(set2)
# 其他


# 统计集合元素数量


len(set_name)
# 集合的遍历


集合不支持下标索引，不能使用 while 循环遍历


集合可以使用 for 循环遍历


for element in set_name
    statement
# 字典


字典（dict）：存储键值对（即，key-value 对），可以提供基于 key 检索 value 的场景实现


字典不支持重复的 key ，重复添加等同于覆盖原有数据


# 字典的定义


使用大括号 {} 包围元素，其中，每一个元素都是一个键值对（key: value），元素之间用逗号隔开


# 定义字典字面量
{key: value, key: value, ...}
# 定义字典变量
变量名称 = {key: value, key: value, ...}
# 定义空字典
变量名称 = {}
变量名称 = dict()
字典的 key 和 value 可以是任意数据类型（key 不可为字典）


因此可以将 字典 2 作为 字典 1 的 value ，实现字典的嵌套


例如：


score_dict = {
    "小红": {"语文": 77, "数学": 66, "英语": 33},
    "小明": {"语文": 88, "数学": 86, "英语": 55},
    "小花": {"语文": 99, "数学": 96, "英语": 66}
}
print(f"score_dict 的内容为：{score_dict}，类型为：{type(score_dict)}")
print(f"小红的语文成绩为：{score_dict['小红']['语文']}")
print(f"小明的数学成绩为：{score_dict['小明']['数学']}")
print(f"小花的英语成绩为：{score_dict['小花']['英语']}")
print()
# 字典的方法


# 访问元素


字典同集合一样，不支持下标索引。但是，字典可以通过 key 来获取对应的 value


value = dict_name[key]
# 添加 / 更新元素


新增元素 / 更新元素：如果 key 不存在，则新增元素；如果 key 存在，则更新元素（更新 value 值）


dict_name[key] = value
# 删除元素


将 key 所在键值对从字典中删除


该操作具有返回值，可以获取 key 所对应的 value


value = dict_name.pop(key)
# 清空字典


dict_name.clear()
# 获取 key 列表


获取全部的 key


keys = dict_name.keys()
例如：


my_dict = {"a": 0, "b": 1, "c": 2, "d": 3}
keys = my_dict.keys()
print(f"通过 keys 方法获取全部的 key ，结果为：{keys} ，其数据类型为：{type(keys)}")
# 其他


# 统计元素数量


统计字典的元素数量（一个键值对视为一个元素）


len(dict_name)
# 字典的遍历


方式 1：获取全部的 key ，从而实现遍历


keys = dict_name.keys()
for key in keys:
    statement
方式 2：直接对字典进行 for 循环遍历，每次循环都是直接得到 key


for key in dict_name:
    statement
# 数据容器的通用操作


# 统计元素数量


len(数据容器)
# 获取最大元素


max(数据容器)
# 获取最小元素


min(数据容器)
# 类型转换


# 转为列表


将给定容器转换为列表


    

  • 若原容器为字符串，则将字符串中的每个字符分别作为列表的一个元素
    • 

  • 若原容器为字典，则将字典的每个 key 分别作为列表的一个元素（value 被舍弃）
    • 



list(数据容器)
# 转为元组


将给定容器转换为元组


    

  • 若原容器为字符串，则将字符串中的每个字符分别作为元组的一个元素
    • 

  • 若原容器为字典，则将字典的每个 key 分别作为元组的一个元素（value 被舍弃）
    • 



tuple(数据容器)
# 转为字符串


将给定容器转换为字符串：整个容器（包括容器的组成括号）均被转换为字符串


str(数据容器)
例如：


mylist = [1,2,3,4]
mytuple = (1,2,3,4,5)
myset = {2,3,4,5}
mydict = {"a": 1, "b": 2}
str1 = str(mylist)      # '[1, 2, 3, 4]'
str2 = str(mytuple)     # '(1, 2, 3, 4, 5)'
str3 = str(myset)       # '{2, 3, 4, 5}'
str4 = str(mydict)      # "{'a': 1, 'b': 2}"
# 转为集合


将给定容器转换为集合


    

  • 若原容器为字典，则将字典的每个 key 分别作为集合的一个元素（value 被舍弃）
    • 



set(数据容器)


转换为集合后，原容器的数据有序性将不再保持




# 排序


将给定容器进行排序：


    

  • 排序的结果为列表对象（即，将给定容器的内容进行排序，并将结果放入列表中）
    • 



按升序排序（默认按照升序排序）：


sorted(容器)
按降序排序：


sorted(容器, reverse=True)
参考：