首页 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)

参考：

  • 黑马程序员
  • W3school
  • 菜鸟教程
阅读次数 次