【Python数据容器】一文学懂Python数据容器，超详细！

最新推荐文章于 2025-06-28 14:02:46 发布
最新推荐文章于 2025-06-28 14:02:46 发布
阅读量720 收藏 10
点赞数 17
CC 4.0 BY-SA版权
文章标签： python 开发语言 pycharm 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wwwvvvnnnmmm/article/details/147339905

文章目录

六、数据容器

00.注意

  1. 列表中的元素可以是 不同的数据类型 ，而数组中的元素是 同一数据类型 。
  2. 列表支持 反向索引 ，即( …, -3, -2, -1)。
  3. 元组若只有一个数据，则这个数据后面要添加逗号( , )，否则不是元组类型。
  4. 元组不支持修改，但元组内部list的内部元素可以修改。
  5. 字符串的strip方法去除字符串首尾指定字符串时，是按 字符 去除的，尽管传入参数是字符串。
  6. 数据容器的切片注意步长为负数时，表示反向取，起始下标和结束下标也要反向变化。

01.数据容器入门

数据容器： 一种可以存储多份数据的数据类型，数据容器中的每一个数据元素 可以是任意类型 的数据。

作用： 批量存储数据。

常见数据容器： 列表( list )、元组( tuple )、字符串( str )、集合( set )、字典( dict )。

02.列表

2.1 列表的定义

格式：

# 定义字面量
[元素1, 元素2, 元素3, 元素4, ...]

# 定义变量
变量名 = [元素1, 元素2, 元素3, 元素4, ...]

# 定义空列表 方式一
变量名 = []
# 定义空列表 方式二
变量名 = list()

注意：

  • 列表以[ ]作为标识。
  • 列表内元素之间用逗号( , )隔开。
  • 列表中的数据可以为不同的数据类型。注意和其它语言中数组的区别。
  • 支持嵌套。

演示：

# 1.列表中元素为同一类型
my_list = ["python", "java", "c++"]
print(my_list)  # ['python', 'java', 'c++']
print(type(my_list))  # <class 'list'>


# 2.列表中元素为不同类型
my_list = ["python", True, 678]
print(my_list)  # ['python', True, 678]
print(type(my_list))  # <class 'list'>


# 3.定义嵌套列表
my_list = [[1, 2, 3], ["python", "java", "c++"]]
print(my_list)  # [[1, 2, 3], ['python', 'java', 'c++']]
print(type(my_list))  # <class 'list'>

2.2 列表的下标索引

格式：

列表名称[下标索引]

注意：

  • 从前向后，下标索引从0开始，依次递增（0, 1, 2, …）。
  • 从后向前，反向索引，下标索引从-1开始，依次递减（…，-3，-2，-1）
  • 获取超出下标索引范围的数据会报错。

演示：

# 1.正向下标索引(0, 1, 2, ...)
name_list = ["Tom", "Lily", "Rose"]
print(name_list[0])  # Tom
print(name_list[1])  # Lily
print(name_list[2])  # Rose


# 2.反向下标索引(..., -3, -2, -1)
name_list = ["Tom", "Lily", "Rose"]
print(name_list[-1])  # Rose
print(name_list[-2])  # Lily
print(name_list[-3])  # Tom


# 3.嵌套列表索引
my_list = [[1, 2, 3], ["python", "java", "c++"]]
print(my_list[0][1])  # 2
print(my_list[1][2])  # c++

2.3 列表的常用操作

格式：

1.查找某元素的下标。					 列表名.index(元素)
2.修改特定位置的元素值。			    列表名[下标] = 值
3.在特定位置插入元素。			    列表名.insert(下标, 元素)
4.在列表尾部追加单个元素。			   列表名.append(元素)
5.在列表尾部追加一批元素。			   列表名.extend(其他数据容器)
6.删除特定位置元素。					 del 列表名[下标] 或 列表名.pop(下标)
7.根据指定内容删除遇到的第一个匹配项。   列表名.remove(元素)
8.清空列表。						    列表名.clear()
9.统计某元素的数量。					 列表名.count(元素)
10.列表长度。						len(列表名)

演示：

mylist = ["python", "java", "c++"]
# 1.查找某元素的下标，若找不到，报错ValueError
index = mylist.index("java")
print(index)  # 1
# index = mylist.index("hello")
# print(index)  # ValueError: 'hello' is not in list


# 2.修改特定位置元素值
mylist[0] = "php"
print(mylist)  # ['php', 'java', 'c++']


# 3.在特定位置插入元素
mylist.insert(1, "python")
print(mylist)  # ['php', 'python', 'java', 'c++']


# 4.在列表尾部追加单个元素
mylist.append("c#")
print(mylist)  # ['php', 'python', 'java', 'c++', 'c#']


# 5.在列表尾部追加一批元素
mylist2 = ["html", "css", "js"]
mylist.extend(mylist2)
print(mylist)  # ['php', 'python', 'java', 'c++', 'c#', 'html', 'css', 'js']


# 6.删除特定位置元素  两种方式
# 方式一
del mylist[2]
print(mylist)  # ['php', 'python', 'c++', 'c#', 'html', 'css', 'js']
# 方式二
element = mylist.pop(4)
print(mylist)  # ['php', 'python', 'c++', 'c#', 'css', 'js']
print(element)  # html


# 7.根据指定内容删除遇到的第一个匹配项
mylist = [2, 4, 6, 1, 4, 5]
mylist.remove(4)
print(mylist)  # [2, 6, 1, 4, 5]


# 8.清空列表
mylist.clear()
print(mylist)  # []


# 9.统计某元素的数量
mylist = [2, 4, 6, 1, 4, 5, 4]
num = mylist.count(4)
print(num)  # 3


# 10.列表长度
mylist = [2, 4, 6, 1, 3]
num = len(mylist)
print(num)  # 5

2.4 列表的遍历

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

while循环遍历：

mylist = ["python", "java", "c++"]

# while遍历
index = 0
while index < len(mylist):
    element = mylist[index]
    print(f"下标{index}对应的元素是：{element}")

    index += 1

for循环遍历：

mylist = ["python", "java", "c++"]

# for遍历
for element in mylist:
    print(f"元素是：{element}")

2.5 列表特点总结

  1. 可以容纳多个元素( 2**63 - 1)。
  2. 可以容纳不同类型的元素（混装）。
  3. 数据有序存储（有下标索引）。
  4. 允许数据重复。
  5. 可以修改。

03.元组

3.1 元组的定义

引言： 列表存储的数据可以修改，如果想要传递的信息不被修改，列表就不合适了，那怎么办？

解决： 元组和列表的最大不同点在于元组一旦定义完成，就不可修改。

格式：

# 定义字面量
(元素1, 元素2, 元素3, 元素4, ...)

# 定义变量
变量名 = (元素1, 元素2, 元素3, 元素4, ...)

# 定义空元组 方式一
变量名 = ()
# 定义空元组 方式二
变量名 = tuple()

注意：

  • 元组以( )作为标识。
  • 元组内元素之间用逗号( , )隔开。
  • 元组中的数据可以为不同的数据类型。
  • 元组若只有一个数据，则这个数据后面要添加逗号。否则不是元组类型。
  • 支持嵌套。

演示：

mytuple = ("python", True, 678)
print(mytuple)  # ('python', True, 678)
print(type(mytuple))  # <class 'tuple'>

# 元组若只有一个数据，则这个数据后面要添加逗号
mytuple2 = ("python",)

# 嵌套
mytuple3 = ((1, 2, 3), (4, 5))
print(mytuple3)  # ((1, 2, 3), (4, 5))
print(type(mytuple3))  # <class 'tuple'>

3.2 元组的下标索引

和列表list一模一样。有了前面的基础，这里直接上案例。

演示：

mytuple = (2, 4, 6, 1, 3)
num = mytuple[3]
print(num)  # 1

mytuple = ((1, 2, 3), (4, 5))
num = mytuple[1][1]
print(num)  # 5
num = mytuple[0][2]
print(num)  # 3

3.3 元组的常用操作

元组不可修改，故常用操作比较少。

格式：

1.查找某元素的下标。					 元组名.index(元素)
2.统计某元素的数量。					 元组名.count(元素)
3.元组长度。							len(元组名)

演示：

# 1.查找某元素的下标
mytuple = ("python", "java", "c++")
index = mytuple.index("java")
print(index)  # 1


# 2.统计某元素的数量
mytuple = ("python", "java", "c++", "java", "c++", "java")
num = mytuple.count("java")
print(num)  # 3


# 3.元组长度
mytuple = ("python", "java", "c++", "java", "c++", "java")
num = len(mytuple)
print(num)  # 6

3.4 元组的遍历

元组有下标索引，因此和列表的遍历一样。

while循环遍历：

mytuple = ("python", "java", "c++")

# while遍历
index = 0
while index < len(mytuple):
    element = mytuple[index]
    print(f"下标{index}对应的元素是：{element}")

    index += 1

for循环遍历：

mytuple = ("python", "java", "c++")

# for遍历
for element in mytuple:
    print(f"元素是：{element}")

3.5 元组数据的修改

普通的元组： 元组中元素不支持修改，否则报错。

t1 = (1, 2, 3)

t1[0] = 5  # 报错TypeError: 'tuple' object does not support item assignment

嵌套了列表的元组： 可以修改元组内list的内容。

t2 = (1, 2, True, ["python", "java", "c++"])

t2[3][0] = "php"
print(t2)  # (1, 2, True, ['php', 'java', 'c++'])

3.6 元组特点总结

  1. 可以容纳多个元素( 2**63 - 1)。
  2. 可以容纳不同类型的元素（混装）。
  3. 数据有序存储（有下标索引）。
  4. 允许数据重复。
  5. 不可以修改。注意内部list。

04.字符串

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

4.1 字符串的下标索引

索引：

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

演示：

my_str = "itheima and itcast"

# 从前向后，下标从0开始
value = my_str[2]
print(value)  # h

# 从后向前，下标从-1开始
value = my_str[-2]
print(value)  # s

4.2 字符串数据的修改

注意：

  • 同元组一样，字符串是一个无法修改的数据容器。
  • 所以修改特定位置字符、移除特定位置字符、追加字符等均无法完成。
  • 如果必须要做修改，只能得到一个新的字符串，老字符串无法修改。

演示：

my_str = "itheima and itcast"

my_str[2] = "a"  # 报错TypeError: 'str' object does not support item assignment

4.3 字符串的常用操作

格式：

1.查找某字符串的下标。					 字符串名.index(字符串)
2.字符串的替换。						   字符串名.replace(字符串1, 字符串2)
3.字符串的分割。						   字符串名.split(分隔符字符串)
4.字符串的规整操作。						  字符串名.strip() 或 字符串名.strip(字符串)
5.统计某字符串的出现次数。					字符串名.count(字符串)
6.字符串长度。							len(字符串名)

演示：

my_str = "itheima and itcast"
# 1.查找某字符串的下标    注意是该字符串中第一个字符的下标
index = my_str.index("and")
print(index)  # 8


# 2.字符串的替换  注意是将全部的字符串1替换为字符串2，得到的是一个新字符串
my_new_str = my_str.replace("it", "程序")
print(my_str)  # itheima and itcast
print(my_new_str)  # 程序heima and 程序cast


# 3.字符串的分割  注意是按指定分隔符字符串，将字符串分割成多个字符串，得到的是一个列表
my_str = "hello python itheima itcast"
my_list_str = my_str.split(" ")
print(my_str)  # hello python itheima itcast
print(my_list_str)  # ['hello', 'python', 'itheima', 'itcast']


# 4.字符串的规整操作  去除字符串前后空格  注意中间空格去不了
my_str1 = "   itheima and   itcast  "
new_my_str1 = my_str1.strip()
print(my_str1)  #    itheima and   itcast
print(new_my_str1)  # itheima and   itcast

# 4.字符串的规整操作  去除字符串前后指定字符串，注意虽然传入的是字符串，但实际按字符去除
# 该例子虽然传入"12"，但实际是只要满足"1"或"2"中的一个都会被去除
my_str2 = "12itheima and   itcast21"
new_my_str2 = my_str2.strip("12")
print(my_str2)  # 12itheima and   itcast21
print(new_my_str2)  # itheima and   itcast


# 5.统计某字符串的出现次数
my_str = "itheima itcast itjmu"
num = my_str.count("it")
print(num)  # 3


# 6.字符串长度
my_str = "itheima itcast itjmu"
num = len(my_str)
print(num)  # 20

4.4 字符串的遍历

同列表、元组一样。

while循环遍历：

my_str = "黑马程序员"
# while遍历
index = 0
while index < len(my_str):
    element = my_str[index]
    print(f"下标{index}对应的元素是：{element}")

    index += 1

for循环遍历：

my_str = "黑马程序员"
# for遍历
for element in my_str:
    print(f"元素是：{element}")

4.5 字符串特点总结

  1. 长度任意（取决于内存大小）。
  2. 不可以容纳不同类型的元素（不能混装），只能存字符串。
  3. 数据有序存储（有下标索引）。
  4. 允许字符串重复。
  5. 不可以修改。

4.6 字符串大小比较

比较原理： 比较ASCII码表值。

解释： 程序中每一个字符都会对应一个数字的码值，字符串大小比较就是逐位比较字符数字码值的大小。

字符串大小比较流程： 从左向右，一位一位进行比较，只要有一位大，那么该字符串整体就大。

演示：

print(f'"abd" > "abc"的结果是：{"abd" > "abc"}')  # "abd" > "abc"的结果是：True

print(f'"ab" > "a"的结果是：{"ab" > "a"}')  # "ab" > "a"的结果是：True

05.数据容器的切片

序列： 内容连续、有序、可使用下标索引的数据容器。比如列表、元组、字符串。

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

格式：

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

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

注意：

  • 起始下标表示从何处开始，可以不写，不写视作从头开始。
  • 结束下标表示到何处结束，但不含结束下标本身，可以不写，不写视作截取到结尾。
  • 步长表示依次取元素的间隔，默认为1，为1时可省略。步长1表示，一个个取元素，步长2表示，每次隔1个元素取。
  • 步长也可以为负数，表示反向取（注意，起始下标和结束下标也要反向标记）。

演示：

# 1.对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
new_my_list = my_list[1:4]  # 步长1，可省略
print(new_my_list)  # [1, 2, 3]


# 2.对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
new_my_tuple = my_tuple[:]  # 起始结束均可省略，但冒号保留，步长1，也可省略
print(new_my_tuple)  # (0, 1, 2, 3, 4, 5, 6)


# 3.对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
new_my_str = my_str[::2]  # 起始结束均可省略，但冒号保留
print(new_my_str)  # 0246


# 4.对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
new_my_str = my_str[::-1]  # 等同于序列反转
print(new_my_str)  # 76543210


# 5.对列表进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
new_my_list = my_list[3:1:-1]  # 注意步长为负数，表示反向取，故起始结束下标也要反着来
print(new_my_list)  # [3, 2]


# 6.对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
new_my_tuple = my_tuple[::-2]
print(new_my_tuple)  # (6, 4, 2, 0)

06.集合

6.1 集合的定义

引言： 列表、元组、字符串都支持重复元素且内容有序，那么有没有不支持重复元素的数据容器呢？

解决： 有的兄弟，有的，它就是集合，不支持重复元素且内容无序。

格式：

# 定义字面量
{元素1, 元素2, 元素3, 元素4, ...}

# 定义变量
变量名 = {元素1, 元素2, 元素3, 元素4, ...}

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

注意：

  • 集合中的元素不重复，不是说不允许向集合中添加已有元素，而是所有相同数据集合只保留一份。
  • 定义空集合不能用{ }，因为{ }被字典占用了。

演示：

# 定义集合     元素不重复且无序
my_set = {"传智教育", "黑马程序员", "Python", "传智教育", "黑马程序员", "Python", "传智教育", "黑马程序员"}
print(my_set)  # {'Python', '黑马程序员', '传智教育'}
print(type(my_set))  # <class 'set'>

# 定义空集合
empty_my_set = set()
print(empty_my_set)  # set()
print(type(empty_my_set))  # <class 'set'>

6.2 集合的常用操作

注意： 集合是无序的，故集合不支持下标索引，也不是序列，但集合允许修改。

格式：

1.添加新元素。					 集合名.add(元素)
2.移除元素。						  集合名.remove(元素)
3.随机取出一个元素。				   集合名.pop()
4.清空集合。						  集合名.clear()
5.取出2个集合的差集。			   集合1.difference(集合2)
6.消除2个集合的差集。			   集合1.difference_update(集合2)
7.2个集合合并为1个集合。			  集合1.union(集合2)
8.统计集合元素数量。				   len(集合名)

演示：

# 1.添加新元素
my_set = {'Python', '黑马程序员', '传智教育'}
my_set.add("itheima")
print(my_set)  # {'传智教育', 'itheima', 'Python', '黑马程序员'}


# 2.移除元素
my_set = {'Python', '黑马程序员', '传智教育'}
my_set.remove("黑马程序员")
print(my_set)  # {'传智教育', 'Python'}


# 3.随机取出一个元素     同时集合会移除该元素
my_set = {'Python', '黑马程序员', '传智教育'}
element = my_set.pop()
print(element)  # 传智教育
print(my_set)  # {'黑马程序员', 'Python'}


# 4.清空集合
my_set = {'Python', '黑马程序员', '传智教育'}
my_set.clear()
print(my_set)  # set()


# 5.取出2个集合的差集  集合1.difference(集合2)  即集合1独有的，返回一个新集合，集合1、2不变
set1 = {1, 2, 3}
set2 = {1, 5, 6}
my_set = set1.difference(set2)
print(my_set)  # {2, 3}
print(set1)  # {1, 2, 3}
print(set2)  # {1, 5, 6}


# 6.消除2个集合的差集。集合1.difference_update(集合2)  在集合1中，删除集合1、2共有的元素，集合1改变，2不变
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(set1)  # {2, 3}
print(set2)  # {1, 5, 6}


# 7.2个集合合并为1个集合    集合1.union(集合2)   得到新集合，集合1、2不变
set1 = {1, 2, 3}
set2 = {1, 5, 6}
my_set = set1.union(set2)
print(my_set)  # {1, 2, 3, 5, 6}
print(set1)  # {1, 2, 3}
print(set2)  # {1, 5, 6}


# 8.统计集合元素数量
my_set = {1, 3, 5, 7, 1, 3, 5, 7}
num = len(my_set)
print(num)  # 4

6.3 集合的遍历

集合没有下标索引，故不支持while循环遍历，仅支持for循环遍历。

for循环遍历：

# for遍历
my_set = {1, 3, 5, 7}

for element in my_set:
    print(f"元素是：{element}")

6.4 集合特点总结

  1. 可以容纳多个元素。
  2. 可以容纳不同类型的元素（混装）。
  3. 数据无序存储（没有下标索引）。
  4. 不允许数据重复。
  5. 可以修改。
  6. 不支持while循环遍历。

07.字典

7.1 字典的定义

引言： 列表、元组、字符串的下标索引都是 整数 ，能不能自定义下标索引的数据类型？

解决： 字典中的元素是key : value键值对，通过key来获取value，因此key的作用就相当于下标索引。其中key、value可以是任意数据类型(key不可以为字典)。

格式：

# 定义字面量
{key: value, key: value, key: value,  ...}

# 定义变量
变量名 = {key: value, key: value, key: value,  ...}

# 定义空字典  方式一
变量名 = {}
# 定义空字典  方式二
变量名 = dict()

注意：

  • key不可以重复。若定义重复key，虽然程序不会报错，但后面的数据会覆盖前面的数据。

演示：

# 定义字典
my_dict = {"薛之谦": 99, "林俊杰": 88, "周杰伦": 77}
print(my_dict)  # {'薛之谦': 99, '林俊杰': 88, '周杰伦': 77}
print(type(my_dict))  # <class 'dict'>


# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(my_dict2)  # {}
print(my_dict3)  # {}
print(type(my_dict2))  # <class 'dict'>
print(type(my_dict3))  # <class 'dict'>


# 重复key   覆盖
my_dict = {"薛之谦": 99, "林俊杰": 88, "薛之谦": 77}
print(my_dict)  # {'薛之谦': 77, '林俊杰': 88}

7.2 字典的索引

字典和集合一样，不可以使用下标索引。字典能使用的索引是key。

格式：

value = 字典名[key]

演示：

my_dict = {"薛之谦": 99, "林俊杰": 88, "周杰伦": 77}

score = my_dict["薛之谦"]
print(score)  # 99

7.3 字典的嵌套

key、value可以是任意数据类型(key不可以为字典)，故value可以为字典。

# 定义嵌套字典    注意数据容器中回车换行没影响，元素的分隔取决于逗号
stu_score_dict = {
    "薛之谦": {
        "语文": 77,  "数学": 66,  "英语": 33
    },
    "周杰伦": {
        "语文": 88,  "数学": 86,  "英语": 55
    },
    "林俊杰": {
        "语文": 99,  "数学": 96,  "英语": 66
    }
}
print(stu_score_dict)


# 从嵌套字典中获取信息
score = stu_score_dict["周杰伦"]["语文"]
print(score)  # 88

7.4 字典的常用操作

格式：

1.新增元素。				字典名[key] = value
2.更新元素。				字典名[key] = value
3.删除元素。				字典名.pop(key)
4.清空字典。				字典名.clear()
5.获取全部key。			字典名.keys()
6.统计字典内键值对数量。	len(字典名)

演示：

# 1.新增元素    注意key不存在 就是新增
my_dict = {"薛之谦": 99, "林俊杰": 88, "周杰伦": 77}
my_dict["张学友"] = 98
print(my_dict)  # {'薛之谦': 99, '林俊杰': 88, '周杰伦': 77, '张学友': 98}


# 2.更新元素    注意key存在 就是更新
my_dict = {"薛之谦": 99, "林俊杰": 88, "周杰伦": 77}
my_dict["周杰伦"] = 89
print(my_dict)  # {'薛之谦': 99, '林俊杰': 88, '周杰伦': 89}


# 3.删除元素     注意会获得value，同时字典中该键值对被删除
my_dict = {"薛之谦": 99, "林俊杰": 88, "周杰伦": 77}
score = my_dict.pop("林俊杰")
print(score)  # 88
print(my_dict)  # {'薛之谦': 99, '周杰伦': 77}


# 4.清空字典
my_dict = {"薛之谦": 99, "林俊杰": 88, "周杰伦": 77}
my_dict.clear()
print(my_dict)  # {}


# 5.获取全部key
my_dict = {"薛之谦": 99, "林俊杰": 88, "周杰伦": 77}
all_key = my_dict.keys()
print(all_key)  # dict_keys(['薛之谦', '林俊杰', '周杰伦'])


# 6.统计字典内键值对数量
my_dict = {"薛之谦": 99, "林俊杰": 88, "周杰伦": 77}
num = len(my_dict)
print(num)  # 3

7.5 字典的遍历

字典不支持下标索引，故不支持while循环遍历。话不多说，上案例。

演示：

# 字典的遍历
my_dict = {"薛之谦": 99, "林俊杰": 88, "周杰伦": 77}

# 方式一   直接遍历字典，每一次取出的就是key
for element in my_dict:
    print(f"element是：{element}，对应value是：{my_dict[element]}")


# 方式二   遍历keys()
all_key = my_dict.keys()
for key in all_key:
    print(f"字典的key是：{key}，value是：{my_dict[key]}")

7.6 字典特点总结

  1. 可以容纳多个元素 (键值对)。
  2. 可以容纳不同类型的元素（混装）。
  3. 不支持下标索引。
  4. key不可以重复 (重复会覆盖)。
  5. 可以修改。
  6. 不支持while循环遍历。

08.五类数据容器对比总结

列表元组字符串集合字典
是否支持下标索引是是是//
是否支持重复元素是是是//
是否可以修改是//是是
是否序列是是是//
是否有序是是是//

09.数据容器的通用操作

遍历、len(容器)，这些前面演示过了，这里不再赘述。

9.1 max(容器)

my_list = [1, 2, 3, 4, 5]
my_tuple = (6, 7, 8, 9, 10)
my_str = "abcdefg"
my_set = {11, 12, 13, 14, 15}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

# 最大元素
print(max(my_list))  # 5
print(max(my_tuple))  # 10
print(max(my_str))  # g
print(max(my_set))  # 15
print(max(my_dict))  # key5

9.2 min(容器)

my_list = [1, 2, 3, 4, 5]
my_tuple = (6, 7, 8, 9, 10)
my_str = "abcdefg"
my_set = {11, 12, 13, 14, 15}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

# 最小元素
print(min(my_list))  # 1
print(min(my_tuple))  # 6
print(min(my_str))  # a
print(min(my_set))  # 11
print(min(my_dict))  # key1

9.3 通用类型转换

格式：

list(容器)   			将给定容器转换为列表
tuple(容器)   		将给定容器转换为元组
str(容器)   			将给定容器转换为字符串
set(容器)   			将给定容器转换为集合

注意：

  • 除转换为字符串str( )外，其它转换都会丢失value。

演示：

my_list = [1, 2, 3, 4, 5]
my_tuple = (6, 7, 8, 9, 10)
my_str = "abcdefg"
my_set = {11, 12, 13, 14, 15}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

# 1.转换为列表
print(list(my_list))  # [1, 2, 3, 4, 5]
print(list(my_tuple))  # [6, 7, 8, 9, 10]
print(list(my_str))  # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list(my_set))  # [11, 12, 13, 14, 15]
print(list(my_dict))  # ['key1', 'key2', 'key3', 'key4', 'key5']


# 2.转换为元组
print(tuple(my_list))  # (1, 2, 3, 4, 5)
print(tuple(my_tuple))  # (6, 7, 8, 9, 10)
print(tuple(my_str))  # ('a', 'b', 'c', 'd', 'e', 'f', 'g')
print(tuple(my_set))  # (11, 12, 13, 14, 15)
print(tuple(my_dict))  # ('key1', 'key2', 'key3', 'key4', 'key5')


# 3.转换为字符串
print(str(my_list))  # [1, 2, 3, 4, 5]
print(str(my_tuple))  # (6, 7, 8, 9, 10)
print(str(my_str))  # abcdefg
print(str(my_set))  # {11, 12, 13, 14, 15}
print(str(my_dict))  # {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}


# 4.转换为集合
print(set(my_list))  # {1, 2, 3, 4, 5}
print(set(my_tuple))  # {6, 7, 8, 9, 10}
print(set(my_str))  # {'d', 'c', 'f', 'a', 'g', 'e', 'b'}
print(set(my_set))  # {11, 12, 13, 14, 15}
print(set(my_dict))  # {'key5', 'key4', 'key2', 'key3', 'key1'}

9.4 排序

格式：

# reverse默认为False，控制从小到大排序，True控制从大到小排序
sorted(容器, [reverse = True])

注意：

  • 排序结果变为列表。

演示：

my_list = [2, 1, 5, 4, 3]
print(sorted(my_list))  # [1, 2, 3, 4, 5]
print(sorted(my_list, reverse=True))  # [5, 4, 3, 2, 1]


my_tuple = (9, 8, 6, 7, 10)
print(sorted(my_tuple))  # [6, 7, 8, 9, 10]
print(sorted(my_tuple, reverse=True))  # [10, 9, 8, 7, 6]


my_str = "cabdgef"
print(sorted(my_str))  # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(sorted(my_str, reverse=True))  # ['g', 'f', 'e', 'd', 'c', 'b', 'a']


...
方知我
关注
知识笔记：Python数据容器(五)
11-29
内容概要：本文详细介绍了 Python 中五种主要的数据容器类型——列表、元组、字符串、集合与字典。对于每种数据容器，讲解了其基本格式、操作方法、特点及应用场景。其中包括创建数据容器的基本语法、常用操作方法...
Python复合数据类型（容器篇）
12-22
在python中使用容器来存储这样的数据。 1 list(列表) 列表是一种线性表，由大量的节点组成，每个节点都可以存储数据。 1.1列表的定义 a=list([n1,n2,n3,...,nn]) b=[1,2,3,4,5,64] 列表可以通过以上两种方式来定义...
python中的容器
LongHongYu908的博客
12-29 3519
python中的容器
Python-数据容器
m0_74416307的博客
07-05 607
用中括号[]括成，逗号隔开元素1,元素2,元素3,......用括号()括成，逗号隔开元素1,元素2,元素3,......注意：元组只有一个数据时，此数据后需添加逗号是字符的容器，可存放任意数量字符。内容连续，有序，支持下标索引的一类数据容器。如：列表，元组，字符串。
python数据容器
最新发布
qq_56805008的博客
06-28 906
1、从左向右下标索引从0开始依次增加2、从右向左下标索引从-1开始依次减少3、嵌套索引字符串是无法修改的不允许定义重复key的字典。
python---数据容器
简单点的博客
03-27 1063
python数据容器的定义
六、Python数据容器
zz3035786953的博客
03-05 904
六、Python数据容器
Python数据容器详解
ye_yumo的博客
12-19 1183
以方括号作为表示，用逗号隔开，元素之间可以是不同的数据类型，支持嵌套，后面两种都是定义空列表的方式例如定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型tuple2和tuple3都是空元组，tuple4是只含一个元素的元组，需要注意的是当元组只有一个数据时，这个数据之后需要添加逗号，否则就不是元组类型，而是他本身的类型在定义集合时哪怕e1和e2相同，他也会自动帮你去重字典的定义，同样使用{}，不过存储的元素是一个个的：键值对例如dict3 = {}
从零开始学习 Python 3 - Python 数据容器大揭秘 4：集合 - 高效处理去重数据
05-26
还在为数据去重而烦恼吗？ Python 集合，一键去重，高效处理，让你的代码更简洁、运行更快！
从零开始学习 Python 3 - Python 数据容器大揭秘 3：字典 - 数据存储的万能工具
05-26
还在为复杂数据的存储和查找而烦恼吗？ Python 字典，Key-Value 键值对，数据存储的万能工具，让你的代码更简洁、更高效！
从零开始重新学习 Python 3：列表、元组、字典？Python 数据容器大揭秘！
05-25
还在为数据存储而烦恼？Python 数据容器，帮你轻松解决数据管理难题！
Python基础语法，五大容器，函数-----------（阶段一）
泰勒今天想展开的博客
02-15 954
Python基础语法
第一阶段-第六章 Python的数据容器
无
07-13 966
该笔记是学习黑马程序员在b站上分享的视频而记录的。
【Python】Python中数据容器
X_H学Java的博客
04-14 1062
Python中的列表，元组，字典都是常用的类型，本文介绍了Python中的列表，元组，字典的操作
Python数据容器
m0_75011423的博客
04-15 1190
元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型集合，最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序可以容纳多个数据可以容纳不同类型的数据（混装）数据是无序存储的（不支持下标索引）不允许重复数据存在可以修改（增加或删除元素等）支持for循环使用{}存储原始，每一个元素是一个键值对每一个键值对包含Key和Value（用冒号分隔）键值对之间使用逗号分隔Key和Value可以是任意类型的数据（key不可为字典）
【Python基础】Python数据容器（列表）
Python、C++、HTML、Java
06-08 1960
在Python中列表的定义如下:列表是内置有序、可变序列,列表的所有元素放在一对中括号“[]”中,并使用逗号分隔开.本章我们来学习列表的定义及相关操作。
Python——数据容器
August_._的博客
12-01 2010
数据容器 列表 元组 字符串 序列 集合 字典
python学习-day2
alb3117149013的博客
07-25 915
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表等就不行print(mydic3[['Name']])#报错unhashable type: 'list'注: python 中有四种可变类型列表 list字典dict集合 set字节数组 bytearray。
Python--数据容器
太白_猿的博客
12-30 1184
python的数据容器（list、tuple、str、set、dict）
Python数据容器详解：列表、元组与字典操作
"Python数据容器入门教程，涵盖了列表、元组和字典的创建、访问、修改和删除等基础知识。" 在Python编程中，数据容器是存放和组织数据的重要工具，主要包括列表(List)、元组(Tuple)和字典(Dictionary)。这三种数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值