数据容器是一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。Python 提供了四种主要的内置容器，列表、元组、集合、字典。

1.集合(set)

（1）集合的定义：不支持重复元素，内容无序(不支持下标索引)。

        # 定义空集合
        set = set()

# 集合
# 集合的定义
name_set = {"张三", "李四", "王五", "张三", "李四", "王五"}
# 不允许重复，内容无序
print(name_set)
print(type(name_set))

# 定义空集合
# 不能用 empty_set = {}
empty_set = set()
print(empty_set)
print(type(empty_set))

# 集合中存储元素的数据类型不受限制
user_set = {"张三", 18, 178.2, True}
print(user_set)
print(type(user_set))

（2）集合的常用操作

        1）查询

        统计集合元素数量
        语法：len(）

# 统计集合元素数量
name_set = {"张三", "李四", "王五", "张三", "李四", "王五"}
# 自动去重
count = len(name_set)
print(f"集合中的元素数量是：{count}")

        2）插入

        添加新元素
        语法：集合.add(元素)

# 插入
# 添加新元素
name_set = {"张三", "李四", "王五", "张三", "李四", "王五"}
name_set.add("曹仁")
print(f"添加元素后的集合为：{name_set}")
# 集合中已有元素"张三"，添加不进去(集合自动去重)
name_set.add("张三")
print(f"添加元素后的集合为：{name_set}")

         3）删除

        a.移除元素
        语法：集合.remove(元素)

# 删除
# 移除元素
name_set = {"张三", "李四", "王五", "张三", "李四", "王五"}
name_set.remove("王五")
print(f"移除元素后的集合为：{name_set}")

        b.从集合中随机取出元素,同时元素被移除
        语法：集合.pop()

# 从集合中随机取出元素同时元素被移除
name_set = {"张三", "李四", "王五", "张三", "李四", "王五"}
# 随机移除
element = name_set.pop()
print(f"移除元素后的集合为：{name_set}, 移除的元素为：{element}")

        c.清空集合
        语法：集合.clear()

# 清空集合
name_set = {"张三", "李四", "王五", "张三", "李四", "王五"}
name_set.clear()
print(f"清空后的集合为：{name_set}")

        4）修改（两个集合的相关操作）

        a.取出两个集合的差集(集合1有而集合2没有的)
        语法：集合1.difference(集合2) 集合1和集合2都不改变,得到新集合

# 取出两个集合的差集
num_set1 = {1, 2, 3}
num_set2 = {1, 2, 4}
# {3} num_set1有而num_set2没有的元素
new_set1 = num_set1.difference(num_set2)
print(f"集合1与集合2的差集是：{new_set1}")
# {4} num_set2有而num_set1没有的元素
new_set2 = num_set2.difference(num_set1)
print(f"集合2与集合1的差集是：{new_set2}")
print(f"取出差集后原有集合1的内容：{num_set1}")
print(f"取出差集后原有集合2的内容：{num_set2}")

        b.消除两个集合的差集
        语法：集合1.difference_update(集合2) 集合1被修改，集合2不改变

# 消除两个集合的差集
num_set1 = {1, 2, 3}
num_set2 = {1, 2, 4}
# 在num_set1内删除和num_set2相同的元素
num_set1.difference_update(num_set2)
print(f"消除差集后的集合1是：{num_set1}")
print(f"消除差集后的集合2是：{num_set2}")

        c.合并两个集合
        语法：集合1.union(集合2) 集合1和集合2都不改变,得到新集合

# 合并两个集合
num_set1 = {1, 2, 3}
num_set2 = {1, 2, 4}
new_set = num_set1.union(num_set2)
print(f"集合1和集合2合并后的集合为：{new_set}")
print(f"合并集合后原有集合1的内容：{num_set1}")
print(f"合并集合后原有集合2的内容：{num_set2}")

（3）集合的遍历

        不支持下标索引，不应用while循环，使用for循环

# 集合的遍历
# 不支持下标索引，不应用while循环
# for循环
name_set = {"张三", "李四", "王五", "张三", "李四", "王五"}
for element in name_set:
   print(element)

（4）集合的特点

  • 可以容纳多个元素

  • 可以容纳不同类型的元素

  • 数据是无序存储的(不支持下标索引)

  • 不允许重复数据存在

  • 可以修改

2.字典(dictionary)

（1）字典的定义：通过Key去找出对应的Value,存储的元素是一个个的键值对。

# 字典
# 字典的定义
name_dict = {"张三": 178, "李四": 169}
print(name_dict)
print(type(name_dict))

        注意：

  • 字典同集合一样，不可以使用下标索引，但字典可以通过Key值来取得对应的Value值

# 通过Key值来取得对应的Value值
name_dict = {"张三": 178, "李四": 169}
height = name_dict["张三"]
print(f"张三的身高是：{height}")

  • Key不可以重复，重复添加等同于覆盖原有数据

# 定义重复Key的字典 重复添加等同于覆盖原有数据
name_dict = {"张三": 178, "李四": 169, "张三": 180}
print(name_dict)
print(type(name_dict))

  • 字典的Key和Value可以是任意数据类型(Key不可为字典)

        # 定义空字典
        dict = {}
        dict = dict{}

# 定义空字典

# 方式一：
empty_dict = {}
print(empty_dict)
print(type(empty_dict))
# 方式二：
empty_dict = dict()
print(empty_dict)
print(type(empty_dict))

        # 字典的嵌套
        score_dict = dict{
            "张三": {
                "语文": 89,
                "数学": 90,
                "英语": 75
            }, "李四": {
                "语文": 87,
                "数学": 88,
                "英语": 80
            }, "王五": {
                "语文": 78,
                "数学": 92,
                "英语": 76
            }
        }

# 字典的嵌套
score_dict = {
        "张三": {
            "语文": 89,
            "数学": 90,
            "英语": 75
        }, "李四": {
            "语文": 87,
            "数学": 88,
            "英语": 80
        }, "王五": {
            "语文": 78,
            "数学": 92,
            "英语": 76
        }
    }
print(f"学生的分数信息是:{score_dict}")

# 从嵌套字典中获得数据
# 获取张三的数学成绩
score = score_dict["张三"]["数学"]
print(f"张三的数学成绩是：{score}")
# 获取王五的语文成绩
score = score_dict["王五"]["语文"]
print(f"王五的语文成绩是：{score}")

（2）字典的常用操作

        1）插入

        新增元素
        语法：字典[Key] = Value

# 字典的常用操作
# 插入 增加元素
name_dict = {"张三": 178, "李四": 169}
name_dict["王五"] = 192
print(f"增加元素后的字典为：{name_dict}")

        2）修改

        更新元素
        语法：字典[Key] = Value

# 修改 更新元素
name_dict = {"张三": 178, "李四": 169}
name_dict["张三"] = 188
print(f"更新元素后的字典为：{name_dict}")

        3）删除

        a.删除元素
        语法：字典.pop(Key) 获得指定Key的Value，同时字典被修改，指定Key的数据被删除

# 删除
# 删除元素
name_dict = {"张三": 178, "李四": 169}
height = name_dict.pop("李四")
print(f"删除元素后的字典为：{name_dict}, 删除的元素值为：{height}")

        b.清空字典
        语法：字典.clear()  字典被修改，元素被清空

# 清空字典
name_dict = {"张三": 178, "李四": 169}
name_dict.clear()
print(f"清空字典后的字典为：{name_dict}")

        4）查询

        a.获取全部的Key
        语法：字典.keys()

# 获取全部的Key
name_dict = {"张三": 178, "李四": 169}
keys = name_dict.keys()
print(f"字典中所有的Key值是：{keys}")

        b.统计字典的元素数量
        语法：len(字典)

# 统计字典的元素数量
name_dict = {"张三": 178, "李四": 169}
count = len(name_dict)
print(f"字典中的元素数量是：{count}")

（3）字典的遍历

        不支持下标索引，不应用while循环，使用for循环

# 字典的遍历
# 方式一：通过获取全部的key来完成
name_dict = {"张三": 178, "李四": 169}
for key in name_dict.keys():
    height = name_dict[key]
    print(f"字典中对应{key}的身高是{height}")

# 方式二：直接对字典进行for循环，每一次循环都是直接得到key
name_dict = {"张三": 178, "李四": 169}
for key in name_dict:
    height = name_dict[key]
    print(f"字典中对应{key}的身高是{height}")

（4）字典的特点

  • 可以容纳多个元素

  • 可以容纳不同类型的元素

  • 不支持下标索引

  • 每一份数据是KeyValue键值对

  • 可以通过Key获取到Value，Key不可重复(重复会覆盖)

  • 可以修改

3.数据容器的通用操作

（1）len 元素个数

（2）max 最大元素

（3）min 最小元素

# 数据容器的通用操作
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "12345"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

# len 元素个数
print(f"列表元素个数：{len(my_list)}")
print(f"元组元素个数：{len(my_tuple)}")
print(f"字符串元素个数：{len(my_str)}")
print(f"集合元素个数：{len(my_set)}")
print(f"字典元素个数：{len(my_dict)}")

# max 最大元素
print(f"列表最大元素：{max(my_list)}")
print(f"元组最大元素：{max(my_tuple)}")
print(f"字符串最大元素：{max(my_str)}")
print(f"集合最大元素：{max(my_set)}")
print(f"字典最大元素：{max(my_dict)}")

# max 最小元素
print(f"列表最小元素：{min(my_list)}")
print(f"元组最小元素：{min(my_tuple)}")
print(f"字符串最小元素：{min(my_str)}")
print(f"集合最小元素：{min(my_set)}")
print(f"字典最小元素：{min(my_dict)}")

（4）遍历操作：使用for循环或while循环

（5）转换功能

        1）list(容器):容器转列表
        2）tuple(容器):容器转元组
        3）str(容器):容器转字符串
        4）set(容器):容器转集合

# 容器的通用转换功能
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "12345"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

# list(容器):容器转列表
print(f"列表转列表的结果是：{list(my_list)}")
print(f"元组转列表的结果是：{list(my_tuple)}")
print(f"字符串转列表的结果是：{list(my_str)}")
print(f"集合转列表的结果是：{list(my_set)}")
print(f"字典转列表的结果是：{list(my_dict)}")

# tuple(容器):容器转元组
print(f"列表转元组的结果是：{tuple(my_list)}")
print(f"元组转元组的结果是：{tuple(my_tuple)}")
print(f"字符串转元组的结果是：{tuple(my_str)}")
print(f"集合转元组的结果是：{tuple(my_set)}")
print(f"字典转元组的结果是：{tuple(my_dict)}")

# str(容器):容器转字符串
# "[1, 2, 3, 4, 5]"
print(f"列表转字符串的结果是：{str(my_list)}")
# "(1, 2, 3, 4, 5)"
print(f"元组转字符串的结果是：{str(my_tuple)}")
print(f"字符串转字符串的结果是：{str(my_str)}")
# "{1, 2, 3, 4, 5}"
print(f"集合转字符串的结果是：{str(my_set)}")
# "{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}"
print(f"字典转字符串的结果是：{str(my_dict)}")

# set(容器):容器转集合
print(f"列表转集合的结果是：{set(my_list)}")
print(f"元组转集合的结果是：{set(my_tuple)}")
print(f"字符串转集合的结果是：{set(my_str)}")
print(f"集合转集合的结果是：{set(my_set)}")
print(f"字典转集表的结果是：{set(my_dict)}")

（6）排序功能 sorted(容器, [reverse=True]) 排序的结果是列表

# 排序功能
my_list = [1, 5, 3, 4, 2]
my_tuple = (1, 2, 5, 4, 3)
my_str = "31425"
my_set = {1, 4, 3, 2, 5}
my_dict = {"key2": 2, "key5": 5, "key3": 3, "key4": 4, "key1": 1}

print(f"列表的排序结果：{sorted(my_list)}")
print(f"元组的排序结果：{sorted(my_tuple)}")
print(f"字符串的排序结果：{sorted(my_str)}")
print(f"集合的排序结果：{sorted(my_set)}")
print(f"字典的排序结果：{sorted(my_dict)}")

print(f"列表的反向排序结果：{sorted(my_list, reverse=True)}")
print(f"元组的反向排序结果：{sorted(my_tuple, reverse=True)}")
print(f"字符串的反向排序结果：{sorted(my_str, reverse=True)}")
print(f"集合的反向排序结果：{sorted(my_set, reverse=True)}")
print(f"字典的反向排序结果：{sorted(my_dict, reverse=True)}")

4.补充：字符串的比较

字符串的比较：按位比较，一位位进行对比，只要有一位大，那么整体就大。

                         通过ASCII表，确定字符对应的码值数字来确定。

# 字符串的比较
print(f"'ab' > 'a': {'ab' > 'a'}")
print(f"'a' > 'A': {'a' > 'A'}")
print(f"'key2' > 'key1': {'key2' > 'key1'}")

5.总结

数据容器
序列类型非序列类型
列表元组字符串集合字典
元素数量支持多个支持多个支持多个支持多个支持多个
元素类型任意任意仅字符任意

Key：Value

Key：除字典外的任意类型

Value：任意类型

下标索引√√√××
重复元素√√√××
可修改性√××√√
数据有序√√√××
使用场景可修改、可重复的一批数据记录场景不可修改、可重复的一批数据记录场景一串字符的记录场景不可重复的数据记录场景以Key检索Value的数据记录场景

# python # 开发语言 # pycharm # 青少年编程 # windows
Logo
亚马逊云科技技术品牌专区

更多推荐

open-code-review Codex 插件教程：对话式调用评审技能指南

本文是一份面向新手的 **open-code-review Codex 插件教程**，教你在 Codex 中通过对话式方式调用 open-code-review 的 AI 代码评审技能。open-code-review 是阿里巴巴开源的 AI 代码评审工具，采用"确定性流水线 + LLM Agent"混合架构，内置多语言评审规则（NPE、线程安全、XSS、SQL 注入等），可在 Codex 里用一

avatar 亚马逊云科技技术品牌专区

OBS Studio 完整指南：免费开源录屏与直播软件从零上手

想做一场像模像样的直播，或者把屏幕内容录成教程视频，但一想到商用软件的订阅费就有些犹豫？其实你不需要花一分钱。OBS Studio 是一款免费开源的直播与录屏软件，支持 Windows、macOS 和 Linux，采集、混音、编码、推流、录制，一条流水线全包了。## 先搞清楚 OBS Studio 是什么OBS Studio 是一个"场景化"的采集合成工具：你把摄像头、窗口、浏览器、图片、

avatar 亚马逊云科技技术品牌专区

如何用MediaCrawler爬取小红书抖音数据？7大平台爬虫从安装到实战完整指南

MediaCrawler 是一个支持小红书、抖音、快手、B站、微博、百度贴吧、知乎的开源自媒体数据采集工具。它能按关键词、按帖子、按创作者主页三种方式抓取笔记/视频内容、评论甚至二级评论，并把结果存成 JSON、CSV、Excel 或数据库。适合做市场调研、竞品监控、内容选题的运营人员，以及想要现成爬虫框架而不想从零写 JS 逆向的开发者。## 从一次"手动抄数据"说起想象这个场景：你负责

avatar 亚马逊云科技技术品牌专区