Python AI开发（python篇）学习笔记 – 第六章 – 容器类型

第六章：容器类型

此文章是作者学习ai的完整笔记，在现在ai快速发展的时期，鼓励大家一起学习python！！！

路线图: Python >> 算法 >> Linux(Rocky、Ubuntu) >> 爬虫与数据分析 >> 机器学习 >> 高等数学 >> 大模型 …

目录

6.1 什么是容器

1. 线性表(序列)

  • 优点
    • 管理方便
  • 缺点
    • 时间复杂度(O(n))

2. 哈希表(容器)

  • 优点
    • 便于查找、性能高、时间复杂度(O(1))
  • 缺点
    • 不方便管理

容器类型：字典与集合

6.2 字典 dict

1. 定义

由一系列无序的关键码记录（键值对）组成的可变散列容器

2. 解析

  • 这里的关键码记录描述的是一组键值对，它是由：
    键名 : 键值 这样的结构构成;
  • 不可索引 
    {'name' : '王玄', 'age' : 17}

3. 字典语法

  • 创建 
    # 方法一
dict = {}

# 方法二
dict = {
'键' : '值', 
'键' : '值', 
'键' : '值', 
'键' : '值', 
}

4. 字典对象的构造操作

  • dict()

    • 用法 
      # 赋值方式定义
dict(a = '1', b = '2', c = '3')

# 输出
{'a':1, 'b':2, 'c':3}

    Python 会将每一个关键字参数的参数名直接定为字符串类型，保证键名是可哈希对象；

  • 使用zip映射方式创建字典对象：

    # zip函数映射方式定义(列表1的各位一一对应'映射'列表2的各位)
dict(zip(['name', 'age', 'sex'], ['王玄', 17, '男']))

# 输出
{'name': '王玄', 'age': 17, 'sex': '男'}

  • 使用可迭代对象的方式创建字典对象：

    # 使用可迭代对象方式
dict([(1,'1'),(2,"2"),(4,'5')])
 
# 输出
{1: '1', 2: '2', 4: '5'}

5. 字典相关运算符

  • 字典成员运算符

    运算符 含义
    in 判断某关键码记录的键名是否存在于该字典对象，存在，返回True
    not in 判断某关键码记录的键名是否不存在于该字典对象，不存在，返回True

  • 使用方法

    # 定义字典
dicts = {'a':1, 'b':2, 'c':3}

# 判断键在不在dict字典中
if 'b' in dict:
print('在')
else:
print('不在') # 键在

# 判断值 2 是否存在
if 2 in dicts.values():
  print('值存在')
else:
  print('值不存在') # 输出：值存在

# 判断键值对 ('b', 2) 是否存在
if ('b', 2) in dicts.items():
  print('键值对存在')
else:
  print('键值对不存在') # 输出：键值对存在

6. 字典的键：取值与赋值

  • 取值
    • 语法：dict[key]
    • 作用： 从字典中某一组关键码记录中根据其键名获取该组关键码记录中存储的数据对象
    • 返回值： 该组关键码记录所存储的数据对象
    • 使用方法： 
      # 定义字典
dicts = {'a':1, 'b':2, 'c':3}

print(dict['c'])    # 输出 3
  • 赋值
    • 语法：dict[key] = value #key为一组关键码记录中的键名
    • 作用： 不存在该键名对应的关键码记录时：会创建一个新的关键码记录，该记录的键名为赋值时的键名，键值为赋值的键值，
      且会默认在散列表末尾添加
    • 使用方法： 
      # 定义字典
dicts1 = {'a':1, 'b':2, 'c':3}

# 将键'b'的值更改为'a'
d1[b] = 'a'
print(dicts1)    # 输出 {'a':1, 'b':'a', 'c':3}    

# 定义字典
dicts2 = {'a':1, 'b':2, 'c':3}    

# 将键'e'的值更改为5,为dicts中不存在的键值对，则在dicts末尾新增键值对
d1['e'] = 5
print(dicts2)    # 输出 {'a':1, 'b':'2', 'c':3, 'e':5}

7. 字典对象常用方法

  1. 函数
    • len()
      • 语法： results = len(dict)
      • 作用： 获取字典中键值对的个数
      • 返回值： 个数, int型
  2. 方法
    • .keys():

      • 语法： dict.keys()

      • 作用： 返回当前字典对象中所有键值对记录的键名

      • 返回值： 返回dict_keys()

      • 使用方法1

        # 示例1
dicts = {'a': 1, 'b': 2, 'c': 3}
print(dicts.keys())

# 去掉dicts, 
# 方式一：dicts前加*号
print(*dicts.keys())

# 方式二：将dicts转化为list
print(list(dicts.keys()))

      • 输出

         dict_keys(['a', 'b', 'c']) # 结果一
 a b c # 结果二
 ['a', 'b', 'c'] # 结果三
    • .values():

      • 语法： dict.values()

      • 作用： 返回当前字典对象中所有键值对记录的值

      • 返回值： 返回dict_values()

      • 使用方法1

        # 示例1
dicts = {'a': 1, 'b': 2, 'c': 3}
print(dicts.values())

# 去掉dicts, 
# 方式一：dicts前加*号
print(*dicts.values())

# 方式二：将dicts转化为list
print(list(dicts.values()))

      • 输出

        dict_values([1, 2, 3]) # 结果一
1 2 3 # 结果二
[1, 2, 3] # 结果三
    • .items():

      • 语法： dict.items()

      • 作用： 返回当前字典对象中所有键值对

      • 返回值： 返回dict_items()

      • 使用方法1

        # 示例1
dicts = {'a': 1, 'b': 2, 'c': 3}
print(dicts.items())

# 去掉dicts, 
# 方式一：dicts前加*号
print(*dicts.items())

# 方式二：将dicts转化为list
print(list(dicts.items()))

      • 输出

        dict_items([('a', 1), ('b', 2), ('c', 3)]) # 结果一
('a', 1) ('b', 2) ('c', 3) # 结果二
[('a', 1), ('b', 2), ('c', 3)] # 结果三

8. 字典的遍历

  • 方式一： 直接遍历字典对象中每一组键值对的键名

    • 语法

      for key in dict: # key为循环变量，直接取键名
  一次遍历的语句操作
  若取值：
  dict[key]
  若赋值：
  dict[key] = value
 
或：
 
for key in dict.keys():
  一次遍历的语句操作
  若取值：
  dict[key]
  若赋值：
  dict[key] = value

    • 作用： 通过遍历字典对象的键名实现遍历操作，循环变量
      key       拿到每一组键值对的键名， 输出键的值

    • 使用方法：

      # 定义字典
dicts = {'a': 1, 'b': 2, 'c': 3}

# 循环
for key in dicts:
    print(dicts[key])

# 输出每一个键对应的值
1
2
3
  • 方式二： 直接遍历字典对象中每一组键值对的值

    • 语法

      for value in dict.values():
    一次遍历的语句操作
    若取值：
    print(value)

    • 作用： 通过遍历字典对象键值对的值,返回键值对的值

    • 使用方法：

      # 定义字典
dicts = {'a': 1, 'b': 2, 'c': 3}

# 循环
for value in dicts.values():
    print(value)

# 输出每一个键值对对应的值
1
2
3
  • 方式三： 直接遍历字典对象中每一组键值对

    • 语法

      for value in dict.items():
    一次遍历的语句操作
    若取值：
    print(kvs)

    • 作用： 通过遍历字典对象键值对,返回键值对对象

    • 使用方法：

      # 定义字典
dicts = {'a': 1, 'b': 2, 'c': 3}

# 循环
for kvs in dicts.items():
    print(kvs)

# 输出每一个键值对对象
('a':1)
('b':2)
('c':3)
  • 方式四： 直接遍历字典对象中每一组键值对的键名和键值

    • 语法

        for key,value in dict.items():
      一次遍历的语句操作
      若取值：
       dict[key]
      若赋值：
      dict[key] = newValue

  for (key,value) in dict.items():
      一次遍历的语句操作
      若取值：
      dict[key] or value均可
      若赋值：
      dict[key] = newValue

    • 作用： 通过遍历字典对象键值对,返回键名和键值

    • 使用方法：

      # 定义字典
dicts = {'a': 1, 'b': 2, 'c': 3}

# 循环
for key, value in dicts.items():
    print(dicts[key])
    print(f'{key}:{value}')
    dicts[key] = 'abc'  # 每一个键对应的值都赋值为'abc

# 输出每一个键值对对象
1
a:1
2
b:2
3
c:3

9. json简介

  • 定义

    全称：
    JavaScript Object Notation ，是一种轻量级的数据交换格式。它基于 ECMAScript (欧洲计算机协会制定的js规
    范)的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据
    交换语言。 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

  • 理解

    json 是一种数据交换格式，其大量应用于应用的配置文件信息、WEB接口交互等实际的开发场景需求；
    以json格式的文件呈现；
    json本质上是一种特定格式的字符串，大部分情况下以参数的形式呈现，部分情况下（如应用于应用配置文件信息编写时）

  • 示例

    {
 "name": "southernbird",
 "age": 14,
 "gender": true,
 "height": 1.65,
 "grade": null,
 "skills": [
   "JavaScript",
   "Java",
   "Python",
   "Lisp"
 ]
}

    了解即可，后续会讲解json模块

6.3 集合与固定集合（set与frozenset）

1. 定义

  • 集合是一种可变类型对象；固定集合是一种不可变类型对象；

集合： 由一系列无序的、不重复的可哈希对象组成的可变散列容器；

固定集合： 由一系列无序的、不重复的可哈希对象组成的不可变散列容器；

如果定义集合时给定若干个重复的数据对象，其会自动进行去重处理；

2.集合的创建语法

  • 集合的创建：
    • 语法： set = {可哈希对象1,可哈希对象2,可哈希对象3,...}
    • 作用：
    • 注意： 空花括号 {} 创建的是空字典，而不是空集合。
    • 使用方法： 
      # 创建包含整数的集合
s1 = {1, 2, 3, 4}
print(s1)        # 输出：{1, 2, 3, 4}
print(type(s1))  # <class 'set'>

# 集合自动去重
s2 = {1, 2, 2, 3, 3}
print(s2)        # 输出：{1, 2, 3}

3. 集合的构造操作

  • 空集合的创建：
    • 语法： 集合对象 = set() 创建空集合
    • 语法： 集合对象 = set(可迭代对象) 创建非空集合
    • 作用：
    • 注意： 如果可迭代对象中存在重复元素，则会进行自动去重处理
    • 使用方法： 
      # 创建非空集合
l1 = set([1,1,1,2,3,2,1,2,1])   # 例如set(列表)为可迭代列表
print(l1)       # 输出：{1, 2, 3}

# 集合的构造操作
l2 = [1,1,1,2,3,2,1,2,1]
l3 = set(l2) # 转化为set类型
print(l3)       # 输出：{1, 2, 3}

4. 固定集合的创建语法

  • 固定集合的创建：
    • 语法： 集合对象 = frozenset() 创建一个空的固定集合对象
    • 语法： 集合对象 = frozenset(可迭代对象) 据传入的可迭代对象构造一个非空的固定集合对象
    • 作用： 创建一个空的固定集合对象
    • 注意： 如果可迭代对象中存在重复元素，则会进行自动去重处理
    • 使用方法： 
      # 创建包含字符串的集合
s = frozenset('1312413132312313123')
print(s)        # 输出：  frozenset({'2', '1', '4', '3'})
print(*s)       # 输出：  2 1 4 3 
print(list(s))  # 输出：  ['1', '3', '2', '4']

5. 集合相关运算符

  • 集合成员运算符

    运算符 含义
    in 判断某可哈希对象是否存在于该集合，存在，返回True
    not in 判断某可哈希对象是否不存在于该集合，不存在，返回True
    • 使用方法： 
      l1 = set([1,1,1,2,3,2,1,2,1])
if 2 in l1:
      print('在')
else:
      print('不在') # 输出：在

  • 集合数学运算符

    运算符 含义
    交集：& 返回再若干个集合中都存在的元素
    并集：| 返回若干个集合中所存在的所以元素，且自动去重后呈现
    补集：- 返回只属于其中某一个集合的元素
    异或集：^ 返回只在一个集合中出现过的元素
    超集：> 判断一个集合是否具有另一个集合的所有元素，如果是，则返回True
    子集：< 判断一个集合的所有元素是否全部存在于另一个集合，如果是，则返回True
    • 使用方法： 
      # 定义s1, s2集合
s1 = {1 ,2 ,3 , 4, 5}
s2 = {4, 5, 6, 7, 8}
s3 = {4, 5}

print(s1 & s2)  # s1, s2的交集
# 输出 {4, 5}

print(s1 | s2)  # s1, s2的并集
# 输出 {1, 2, 3, 4, 5, 6, 7, 8}

print(s1 - s2)  # s1, s2的补集：只属于s1但不属于s2的元素
# 输出 {1, 2, 3}
# 
print(s1 - s2)  # s1, s2的补集：只属于s2但不属于s1的元素
# 输出 {1, 2, 3}

print(s1 ^ s2)  # s1, s2的异或集
# 输出 {1, 2, 3, 6, 7, 8}

print(s1 > s3)  # 超集：判断s1是否是s3的超集，即s1中是否全部包含s3中的元素
# 输出 True

print(s3 < s1)  # 子集：判断s3是否是s1的子集，即s1中是否全部包含s3中的元素
# 输出 True

6. 集合相关比较符

  • 比较符

    运算符 含义
    集合相等：== 判断一个集合是否与另一个集合相等，且是无序判断，如果是，则返回True
    集合不相等：！= 判断一个集合是否与另一个集合不等，且是无序判断，如果是，则返回True
    • 使用方法： 
      s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7, 8}

print(s1 == s2)
# 输出 False

    集合set()也可以使用len()、max()、min()函数

7. 集合的遍历

  • 方法一： 使用for循环遍历
    • 语法： 
      for 循环变量 in 集合对象:
循环语句操作
若取值：
print(循环变量)

      集合无法实现单个元素取值，如果必须取值，只能通过遍历进行一次性全部取值；

    • 示例： 
      s1 = {1, 2, 3, 4, 5}

for i in s1:
    print(i)

# 输出
1
2
3
4
5
  • 方法二： 使用while循环遍历
    • 语法： 
      try:    # 尝试执行以下代码
    while True:
        item = 集合对象.pop()
except Exception as e:  # 如果报错将输出e
    print(e)
    • 示例： 
      s1 = {1, 2, 3, 4, 5}

try:    # 尝试执行以下代码
    while True:
        item = s1.pop()
except Exception as e:  # 如果报错将输出e
    print(e)

# 输出
1
2
3
4
5

      此种方式必须加 try 语句处理异常，因为集合的 .pop() 方法为随机从集合中删除一个元素，当删除全部元素后集
      合为 empty(空)，再循环会触发异常，故使用异常处理的方式来终止该循环；
      根据您提供的图片内容，整理为以下 Markdown 格式文档：

6.4 容器类型补充说明

一、类型对象常用函数与操作

1. 固定集合（frozenset）特性

  • 固定集合不支持任何对象修改操作。

2. 常用内置函数支持

类型 支持函数
字典 (dict) len()、max()、min()
集合 (set) 与 固定集合 (frozenset) len()、max()、min()

3. 类型对象遍历

  • 字典：支持灵活的遍历方式（如遍历键、值、键值对）。
  • 集合：支持 for 循环直接遍历集合数据对象。

4. 类型对象常用方法

  • 各自类型均有自己封装好的对象方法，详细用法见标准库源码。

二、容器类型总结

1. 底层原理实现

  • 字典类型：基于哈希表（散列表）实现。
  • 集合类型：也基于哈希表（散列表）实现。

2. 可变性与不可变性分类

可变类型容器 不可变类型容器
字典 (dict)、集合 (set) 固定集合 (frozenset)

3. 运算符支持情况

类型 支持的运算符
字典 仅支持成员运算符（in / not in）
集合 成员运算符、数学运算符（交并差）、比较运算符

4. 取值与赋值操作对比

字典类型
  • 支持按键取值及赋值：
    • 若键不存在 → 添加新键值对并完成赋值。
    • 若键存在 → 直接覆盖原有值。
集合类型
  • 不支持通过索引或键进行取值操作。
  • 若需取值，只能通过循环遍历一次性获取所有元素。
  • 支持数据对象添加操作（如 add() 方法）。
# python # 学习 # 人工智能 # 开发语言 # pycharm # 学习方法
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

cover

AtomGit 首发开源｜光轮智能发布全球首个十万小时级全模态人类行为开源数据集 EgoSuite-Open100K

avatar AtomGit开源社区
cover

CANN 开发者 Meetup 南京站圆满落幕：轻量开发专场，硬核技术面对面

avatar AtomGit开源社区
cover

AtomCode 全新上线万亿代码模型 LongCat-2.0。限时 7 天免费体验！

avatar AtomGit开源社区