Python集合类型

第一章、集合

一、概述

集合是对象的容器，只能存储对象的引用

1、集合的概念及作用

        Python中的集合是一组对象的容器，用于存储、操作和传输数据。它们提供了各种不同类型的集合类，可以根据需求选择适当的集合实现。数组其实就是一个集合。集合实际上就是一个容器。可以来容纳其它类型的数据。

集合为什么说在开发中使用较多？

        集合是一个容器，是一个载体，可以一次容纳多个对象。在实际开发中，假设连接数据库，数据库当中有10条记录，那么假设把这10条记录查询出来，在Python程序中会将10条数据封装成10个Python对象，然后将10个Python对象放到某一个集合当中，将集合传到前端，然后遍历集合，将一个数据一个数据展现出来。

2、 集合存储的都是引用数据类型（实例对象的引用）

Python中一切皆对象，所有的数据全是对象，引用数据类型，没有基本数据类型

3、集合内存图示

 4、集合与数据结构

在Python中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中存储元素，等于将数据放到了不同的数据结构中。

为什么是数据结构？

数据存储的结构就是数据结构。不同的数据结构，数据存储方式不同。例如：

数组，二叉树，链表，哈希表...

以上这些都是常见的数据结构

• 你往集合c1中放数据，可能是放到数组上了。
• 你往集合c2中放数据，可能是放到二叉树上了
• ......
• 使用不同的集合等于使用了不同的数据结构

在Python集合这一章中，你需要掌握的不是精通数据结构，Python中已经将数据结构实现了，已经写好了这些常用的集合类，你只需要掌握怎么使用？什么情况下选择哪一种合适的集合去使用即可

1. 列表（List）：列表是 Python 中最常见的集合类型之一，它对应着动态数组的数据结构。列表是有序的，可以存储多种数据类型的元素。列表的长度可以随时改变，允许增，删，改，查和遍历元素

2. 元组（Tuple）：元组也对应着动态数组的数据结构，但与列表不同的是，元组创建后其内容不可修改，即是不可变的。元组通常用于存储一些不可变的数据，如坐标对、日期等，只允许查和遍历，不允许修改。

3. 集合（Set）：集合对应着哈希表或红黑树等数据结构，它用于存储一组不重复的元素，没有固定的顺序。集合可以执行集合操作，如并集、交集、差集等。

4. 字典（Dictionary）：字典对应着哈希表的数据结构，它存储键-值对，每个键对应一个值。字典是无序的，但是可以通过键来访问和修改值。字典用于存储关联性数据。

5. 不可变集合（frozenset）：不可变集合是不可修改的集合，对应着哈希表或红黑树等数据结构。它可以用作字典的键，因为字典的键必须是不可变的。

每种集合类型都有不同的性质和用途，您可以根据需求选择适合的集合类型和对应的数据结构来存储和处理数据

5、集合在builtins.py内置模块中

所有的集合类均在该模块中

二、集合分类

在 Python 中，并没有严格的 Collection 和 Map 接口的概念，这与 Java 中的 Collection 和 Map 接口有所不同。然而，Python 中的集合类型可以大致对应到这两个概念上。

1、单个方式存储元素

这可以理解为 Python 中的单一值集合，比如列表（list）、元组（tuple）、集合（set）等。这些集合类型可以存储一个或多个单一值，例如整数、字符串、浮点数等。

• 列表（list）：可以存储多种数据类型的有序集合，允许重复。
• 元组（tuple）：类似于列表，但是不可修改，可以用于存储不可变的数据。
• 集合（set）：存储一组不重复的元素，无序。

2、键值对方式存储元素

这可以理解为 Python 中的关联性集合，比如字典（dict）。字典是一种存储键-值对的集合，每个键对应一个值。

• 字典（dict）：存储键-值对的集合，可以根据键快速检索对应的值。

        虽然 Python 中没有严格的 Collection 和 Map 接口，但是这些集合类型在实际使用中与 Collection 和 Map 接口的概念相对应。

三、相关概念

1、有序

有序：有索引，按照一定顺序将元素存进去，取出元素还是该顺序，并不是排序

2、无序

无序，无索引，按照一定顺序将元素存进去，取出元素不一定还是该顺序

3、排序

放到该集合中的元素自动按照大小顺序进行排序

四、集合特点

1、list集合

• 有序
  • 存进去的元素的顺序和取出元素的顺序相同
• 可重复
  • 可以存入重复的元素
• 可索引
  • 集合中的元素有索引，从0开始，依次递增
• 容量不定
  • 具有动态大小调整的能力，可以在运行时添加和删除元素，使其具有一定的灵活性
• 类型不定
  • 可以容纳多种数据类型的元素，包括整数、浮点数、字符串、其他列表等。这使得 list 非常灵活，适用于存储各种类型的数据
• 可迭代
  • 可以进行遍历
• 可变性
  • list 是可变的，这意味着您可以在列表中添加、删除和修改元素。您可以使用各种方法来操作列表，增，删，改，查 等对元素进行操作。

2、tuple集合

• 有序
  • 存进去的元素的顺序和取出元素的顺序相同
• 可重复
  • 可以存入重复的元素
• 可索引
  • 集合中的元素有索引，从0开始，依次递增
• 容量固定
  • 一旦创建后，元组的容量是固定的，不能自动扩容
• 类型不定
  • tuple 可以容纳多种数据类型的元素，就像列表一样。这使得 tuple 适合存储不同类型的数据
• 可迭代
  • 可以进行遍历
• 不可变性
  • 一旦创建后，元组的内容就不能修改。这意味着您不能在元组中添加、删除或修改元素，只能查看元素和进行遍历

3、set集合

• 无序
  • 元素没有固定的顺序，存入元素的顺序和取出元素的顺序不同
• 不可重复
  • 元素是唯一的，不允许重复的元素。如果您试图向集合中添加已经存在的元素，集合不会发生变化。
• 无索引
  • 不能通过索引来访问集合中的元素，因为集合没有索引的概念。
• 容量不定
  • 具有动态大小调整的能力，这意味着您可以随时添加或删除元素，而集合会自动调整其内部存储以适应所需的容量。
• 类型不定
  • 元素类型是可以不固定的，也就是说，一个集合中可以同时包含不同类型的元素，如整数、字符串等。但是，通常情况下，一个特定的集合实例会包含相同类型的元素。
• 可迭代
  • 可以进行遍历
• 可变性
  • set 是可变的，您可以在运行时添加、删除和修改元素

4、dict集合

• key
  • 无序
  • 不可重复
  • 无索引
• value
  • 无序
  • 可重复
  • 无索引
• 整体
  • 容量不定
  • 类型不定
  • 可迭代
  • 可变性
  • 键值对有序，类似有java中的LinkedHashMap集合

第二章、list集合（单个方式存储元素）

一、概述

        在 Python 中，list 是一种有序的、可变的数据结构，它允许您存储多个元素，并可以随时进行添加、删除、修改等操作。list 是 Python 内置的一种数据类型，是常用的集合类型之一

二、创建list集合对象

1、直接使用方括号创建

使用方括号 [] 来直接创建一个列表，其中可以包含任何类型的元素。

多个数据间使用逗号隔开

my_list = [1, 2, 3, 'hello', True]

print(type([1])) #<class 'list'>
print(type([1,])) #<class 'list'>

2、使用列表推导式

使用列表推导式来根据某种规则生成一个列表。

numbers = [x for x in range(1, 6)]  # 生成包含1到5的数字列表

注意：

用for循环是给整体复制几次，用数字是给里面的内容复制几次

可变数据类型同时声明相同的值，内存地址不一样；不可变数据类型同时声明相同的值，内存地址一样。

使用列表推导式对list集合中的元素进行复制时，

• 对于可变元素，会创建新的对象，元素的内存地址变化
• 对于不可变元素，其本身就不会创建新的对象，内存地址不变

list1 = [[3] * 2 for i in range(3)]
print(list1) #[[3, 3], [3, 3], [3, 3]]
print(id(list1[0])) #2230041116872
print(id(list1[1])) #2230041116744
print(id(list1[2])) #2230041090888

list2 = [2 for i in range(3)]
print(list2) #[2, 2, 2]
print(id(list2[0])) #1744464672
print(id(list2[1])) #1744464672
print(id(list2[2])) #1744464672

3、通过内置的 list() 函数

使用 list() 函数将其他可迭代对象（如字符串、元组、集合等）转换为列表。

my_string = 'Python'
char_list = list(my_string)  # 将字符串转换为字符列表 ['P', 'y', 't', 'h', 'o', 'n']

my_list = list()  #创建一个空list集合

4、使用重复操作符 * 创建重复元素的列表

使用 * 操作符来创建包含重复元素的列表。

类型：def __mul__(self, n: SupportsIndex) -> list[_T]: ...

repeated_list = [0] * 5  # 创建包含5个0的列表 [0, 0, 0, 0, 0]

注意：

使用 * 运算符对list集合中的元素进行复制时，

• 对于可变元素，不会创建新的对象，元素的内存地址不变
• 对于不可变元素，其本身就不会创建新的对象，内存地址不变

l1 = [[1,2]] * 2
print(l1) #[[1, 2], [1, 2]]
print(id(l1[0])) #1779534600136
print(id(l1[1])) #1779534600136
l1[0][0] = 5
print(l1) #[[5, 2], [5, 2]]

l2 = [(1,2)] * 2
print(l2) #[(1, 2), (1, 2)]
print(id(l2[0])) #1779535446728
print(id(l2[1])) #1779535446728

5、使用 range() 函数创建连续数值的列表

使用 range() 函数生成连续的整数序列，然后通过 list() 函数将其转换为列表。

num_list = list(range(1, 6))  # 生成包含1到5的数字列表 [1, 2, 3, 4, 5]

6、通过其他方法生成的列表

某些内置函数也返回列表，例如 split() 函数用于字符串拆分。

my_string = 'apple orange banana'
fruit_list = my_string.split()  # 将字符串拆分为列表 ['apple', 'orange', 'banana']

三、集合遍历/迭代器

        Python中也有类似于Java中的集合对象的迭代器机制，不过Python的迭代器使用起来更加简洁和灵活。在Python中，使用迭代器的主要方式是通过使用iter()函数和next()函数，而不需要像Java中那样使用独立的迭代器对象和方法。

1、iter()函数： iter()函数来获取一个可迭代对象的迭代器

l = list()
l.append(1)
l.append(2)

it = l.__iter__()
print(it) #<list_iterator object at 0x00000283DA42A2B0>

2、next()函数： 使用next()函数可以从迭代器中获取下一个元素

print(it.__next__()) #1
print(it.__next__()) #2

3、StopIteration异常

与Java不同，Python中的迭代器没有hasNext()方法。当迭代器到达末尾时，会抛出StopIteration异常，表示迭代结束。

l = list()
l.append(1)
l.append(2)

it = l.__iter__()
print(it) #<list_iterator object at 0x00000283DA42A2B0>

print(it.__next__()) #1
print(it.__next__()) #2

print(it.__next__()) #StopIteration

总之，Python的迭代机制更加简单，您无需像在Java中那样手动管理迭代器对象和使用hasNext()方法。通过使用for循环或直接调用next()函数，您可以轻松地遍历集合对象中的元素。 

4、惰性迭代（Lazy Iteration）：

        迭代器是一种惰性的数据访问方式，也称为"延迟计算"。这意味着迭代器只在需要时生成下一个元素，而不是一次性把所有元素加载到内存中。这对于处理大量数据或无限数据流特别有用，因为它可以节省内存和计算资源。通过惰性迭代，你可以逐步处理数据，而不必一次性加载整个数据集。

5、多次迭代同一迭代器：

当你对一个迭代器进行多次迭代时，它会从上一次迭代停止的位置继续。这对于遍历数据集或生成序列的情况非常有用。每次迭代，迭代器都会生成下一个元素，然后保持状态，以便下次迭代时继续。

四、访问list集合中的元素

在Python中，可以使用索引和切片来访问list集合中的元素。索引用于访问单个元素，而切片用于访问一定范围内的元素子集。

若是索引访问，索引越界，会报出indexerror，若是切片时索引越界不会导致indexerror，只会返回空，什么都没有的

1、list集合元素索引

list索引：list集合中的每个元素都有一个与之关联的索引，索引从 0 开始，依次递增。负数索引表示从list集合末尾开始计数，-1 表示最后一个元素，-2表示倒数第二个元素，依次类推。

底层调用：__getitem__()方法

my_list = [10, 20, 30, 40, 50]
# 访问单个元素
first_element = my_list[0]  # 第一个元素，值为 10
third_element = my_list[2]  # 第三个元素，值为 30
last_element = my_list[-1]  # 最后一个元素，值为 50

2、list集合切片

底层调用：__getitem__()方法

my_list = [10, 20, 30, 40, 50]
# 访问元素子集
subset = my_list[1:4]      # 包含索引 1 到 3 的元素，值为 [20, 30, 40]
subset_from_start = my_list[:3]  # 从开始到索引 2 的元素，值为 [10, 20, 30]
subset_to_end = my_list[2:]  # 从索引 2 到结束的元素，值为 [30, 40, 50]

五、list集合的运算

1、+：表示列表进行拼接成一个新列表

底层调用：def __add__(self, x: list[_T]) -> list[_T]: ...

list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined_list = list1 + list2  # [1, 2, 3, 4, 5, 6]

2、*：对原列表里面的内容进行复制成一个新列表

底层调用：def __mul__(self, n: SupportsIndex) -> list[_T]: ...

list1 = [1, 2, 3]
repeated_list = list1 * 3  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

3、==：判断两个list集合中元素是否相等，相等返回True，不相等返回False

底层调用：def __eq__(self, o: object) -> bool: ...

list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = [4, 5, 6]
print(list1 == list2)  # True
print(list1 != list3)  # True

4、in和not in运算符

in：判断某个元素是否在list集合中，在为Ture，不在为False

not in：判断某个元素是否不在另一个list集合中，不在为Ture，在为False

底层调用：def __contains__(self, o: object) -> bool: ...

my_list = [1, 2, 3, 4, 5]
print(3 in my_list)  # True
print(6 not in my_list)  # True

六、list集合的常用操作

1、添加元素

1、append(element): 在列表末尾添加一个元素

类型：def append(self, __object: _T) -> None: ...

l = list()
l.append(1)
l.append(2)
print(l) #[1, 2]

2、extend(iterable): 在列表末尾添加一个可迭代对象的所有元素

类型：def extend(self, __iterable: Iterable[_T]) -> None: ...

l1 = [1,2,3,4]
l2 = [7,8,9]
l1.extend(l2)
print(l1) #[1, 2, 3, 4, 7, 8, 9]
print(l2) #[7, 8, 9]

3、insert(index, element): 在指定索引位置插入一个元素

向哪插入就写该位置的索引号，原来该位置元素统一往有挪动

类型：def insert(self, __index: SupportsIndex, __object: _T) -> None: ...

l = [1,2,3,4]
l.insert(1,88)
print(l) #[1, 88, 2, 3, 4]

2、删除元素

1、remove(element): 删除列表中第一个出现的指定元素。

移除列表中某个值的第一个匹配项

类型：def remove(self, __value: _T) -> None: ...

my_list = [1, 2, 3, 1, 5]
my_list.remove(1)
print(my_list) #[2, 3, 1, 5]

2、pop(index=-1): 删除并返回指定索引位置的元素，如果未提供索引，默认删除末尾元素

类型：def pop(self, __index: SupportsIndex = ...) -> _T: ...

l = [1,2,3,4]
#默认删除最后一个元素并返回
ele = l.pop()
print(ele) #4
#删除第一个元素并返回
ele = l.pop(0)
print(ele) #1

3、clear(): 清空列表中的所有元素

类型：def clear(self) -> None: ...

l = [1,2,3,4]
#清空列表中的元素
l.clear()
print(len(l)) #0

4、使用del 关键字删除指定元素

del  删除指定索引处的元素，del  list1[索引]

my_list = [1, 2, 3, 4, 5]
del my_list[0]
print(my_list) #[2, 3, 4, 5]

3、修改元素

my_list = [10, 20, 30, 40, 50]
index = my_list.index(30)
my_list[index] = 90
print(my_list) #[10, 20, 90, 40, 50]

1、实现原理

        在Python中，当你执行类似于 my_list[index] = 90 的操作时，底层实际上是在调用列表对象的特殊方法之一，即 __setitem__ 方法。这个方法允许你通过索引来设置列表中特定位置的元素值。

        具体来说，当你执行 my_list[index] = 90 这样的赋值操作时，Python会在 my_list 对象上查找名为 __setitem__ 的方法，并将 index 和新的值 90 作为参数传递给这个方法。这个方法会负责将列表中索引为 index 的元素设置为新的值 90。

示例代码如下，演示了底层如何调用 __setitem__ 方法：

class MyList:
    def __init__(self, data):
        self.data = data
    
    def __setitem__(self, index, value):
        self.data[index] = value

# 创建一个 MyList 实例
my_list = MyList([1, 2, 3, 4, 5])

# 调用底层的 __setitem__ 方法
my_list[2] = 90  # 相当于调用 my_list.__setitem__(2, 90)

print(my_list.data)  # 输出: [1, 2, 90, 4, 5]

注意，__setitem__ 是一种特殊的方法，用于自定义对象在被索引赋值时的行为。在内置的列表（list）类型中，__setitem__ 方法已经被实现，因此你可以直接在列表对象上使用索引赋值操作。

4、获取信息

1、index(element, start=0, end=len(list)): 返回指定元素第一次出现的索引，可指定搜索范围

类型：

def index(self, __value: _T, __start: SupportsIndex = ..., __stop: SupportsIndex = ...) -> int: ...

必须为列表中的元素

my_list = [10, 20, 30, 40, 50]
a = my_list.index(20)
print(a) #1

2、count(element): 返回指定元素在列表中出现的次数

类型：def count(self, __value: _T) -> int: ...

my_list = [10, 20, 30, 40, 50]
print(my_list.count(30)) #1

3、len(list)：返回元素的个数

底层调用：__len__()方法

my_list = [10, 20, 30, 40, 50]
print(len(my_list)) #5
#等同于
print(my_list.__len__()) #5

5、遍历list集合

1、for循环：类似于java中的foreach循环

#类似于java中的foreach循环
l = [1,2,3,4]
for i in l:
    print(i)

2、while循环：类似于java中的for循环

#类似于java中的for循环语法
#写法一
l = [1,2,3,4]
i = 0
while i < len(l):
    print(l[i])
    i += 1
print("=" * 30)

3、iterator迭代器

l = [1,2,3,4]
#获取迭代器对象
it = l.__iter__()
#死循环
while True:
    try:
        print(it.__next__())
    except StopIteration as e:
        break # 当迭代完成时，StopIteration 异常被抛出，退出循环

my_list = [1, 2, 3, 4, 5]
my_iterator = iter(my_list)

while True:
    try:
        item = next(my_iterator)
        print(item)
    except StopIteration:
        break  # 当迭代完成时，StopIteration 异常被抛出，退出循环

6、list集合排序

1、sort()：默认是从小到大升序排序

sort()不会修改内存地址，但是sorted()会修改内存地址

从小到大排列，依次为数字，大写字母A~Z，小写字母a~z，先按一个排，第一个相同则看第二个，依次类推

sort() 是 Python 列表（list）对象的一个方法，用于原地对列表进行排序。原地排序意味着列表本身会被修改，而不是返回一个新的排序列表。以下是对 sort() 函数的详细解释：

类型：

def sort(self: list[SupportsLessThanT], *, key: None = ..., reverse: bool = ...) -> None: ...

语法：

list.sort(key=None, reverse=False)

• key：可选参数，用于指定一个函数，该函数会在每个元素上调用，根据返回值进行排序。默认为 None，即直接对元素进行比较。
• reverse：可选参数，如果为 True，则会进行降序排序；如果为 False（默认），则进行升序排序。

示例：

my_list = [3, 1, 4, 1, 5, 9, 2, 6]

# 升序排序
my_list.sort()
print(my_list)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]

# 降序排序
my_list.sort(reverse=True)
print(my_list)  # 输出: [9, 6, 5, 4, 3, 2, 1, 1]

如果你想基于某些条件进行排序，你可以使用 key 参数来指定一个函数。这个函数将在每个元素上调用，并返回一个用于排序的键。例如，按字符串长度对列表进行排序：

words = ["apple", "banana", "cherry", "date", "fig"]
words.sort(key=len)
print(words)  # 输出: ['date', 'fig', 'apple', 'banana', 'cherry']

2、sorted()：默认是从小到大升序排序

类型：

def sorted(__iterable: Iterable[_T], *, key: Callable[[_T], SupportsLessThan], reverse: bool = ...) -> list[_T]: ...

需要注意的是，sort() 方法在原地修改列表，并不返回一个新的排序后的列表。如果你想要获得一个新的排序列表而不改变原列表，你可以使用 sorted() 函数：

original_list = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_list = sorted(original_list)
print(sorted_list)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]
print(original_list)  # 输出: [3, 1, 4, 1, 5, 9, 2, 6]（原列表不变）

总结：sort() 方法是对 Python 列表进行原地排序的方法，它可以根据默认或自定义的比较函数进行升序或降序排序。如果你想获得一个新的排序列表而不改变原列表，可以使用 sorted() 函数。

3、reverse()：反转列表中元素的顺序

语法：

list.reverse()

示例：

my_list = [1, 2, 3, 4, 5]

my_list.reverse()
print(my_list)  # 输出: [5, 4, 3, 2, 1]

reverse() 方法在原地修改列表，不返回一个新的列表。原列表的元素顺序会被改变，使得最后一个元素变为第一个，倒数第二个变为第二个，以此类推。

需要注意的是，reverse() 方法不是通过返回一个新的列表来实现反转，而是直接修改原列表。因此，在调用 reverse() 方法后，原列表的内容会发生改变。

如果你想获得一个新的反转后的列表而不改变原列表，可以使用切片操作：

original_list = [1, 2, 3, 4, 5]
reversed_list = original_list[::-1]
print(reversed_list)  # 输出: [5, 4, 3, 2, 1]
print(original_list)  # 输出: [1, 2, 3, 4, 5]（原列表不变）

总结：reverse() 方法用于反转列表中元素的顺序，它在原地修改列表，不返回新的列表。如果你希望获得一个新的反转后的列表，可以使用切片操作。

7、map函数在数组中的作用

map是python内置函数，会根据提供的函数对指定的序列做映射

语法：

map(function,iterable,...)

• 第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个集合
• 把函数依次作用在list中的每一个元素上，得到一个新的list并返回。注意，map不改变原list，而是返回一个新list

返回值：

返回一个可迭代对象

用法：

先声明一个函数，然后作为一个参数传入map函数中：

def square(x):
    return x ** 2
print(list(map(square, [1, 2, 3, 4, 5]))) #[1, 4, 9, 16, 25]

使用lambda函数：

square_iterator = map(lambda x: x ** 2,[1,2,3])

print(list(square_iterator)) #[1, 4, 9]

多个可迭代对象：

two_iterable_obj_ele_add = map(lambda x,y: x + y,[1,2,3],[4,5,6])

print(list(two_iterable_obj_ele_add)) #[5, 7, 9]

通过lambda函数使返回值是一个元组

a=map(lambda x,y : (x**y,x+y),[2,4,6],[3,2])
print(list(a)) #[(8, 5), (16, 6)]

一次输入两个数

a,b = map(int,input("请输入两个数，使用空格隔开").split())
print(a,b)

8、zip函数在数组中的作用

zip() 是 Python 内置的函数之一，它用于将多个可迭代对象（如列表、元组等）中的元素逐个配对组合，并返回一个生成器（迭代器）对象，生成的元素是一个个元组，每个元组包含来自不同可迭代对象的对应位置的元素。

语法：

zip(iterable1, iterable2, ...)

• iterable1, iterable2, ...：一个或多个可迭代对象，可以是列表、元组、字符串等。

示例

names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]

# 使用 zip() 将两个列表配对组合
zipped = zip(names, ages)
print(zipped) #<zip object at 0x000002471D5AAB08>
# 转换为列表以查看结果
zipped_list = list(zipped)
print(zipped_list)
# 输出: [('Alice', 25), ('Bob', 30), ('Charlie', 35)]

在这个示例中，zip() 函数将 names 列表和 ages 列表中的元素逐个配对组合，生成了一个包含元组的迭代器。每个元组包含了对应位置的姓名和年龄。

需要注意的是，zip() 函数的生成器只会生成到最短的可迭代对象结束位置，如果有不等长的可迭代对象，多余的元素将被忽略。

names = ["Alice", "Bob", "Charlie"]
ages = [25, 30]

zipped = zip(names, ages)
zipped_list = list(zipped)
print(zipped_list)
# 输出: [('Alice', 25), ('Bob', 30)]

如果你想要拆分配对的元组，可以使用解压操作（使用 * 运算符）：

zipped_list = [('Alice', 25), ('Bob', 30), ('Charlie', 35)]
unzipped_names, unzipped_ages = zip(*zipped_list)
print(unzipped_names)  # 输出: ('Alice', 'Bob', 'Charlie')
print(unzipped_ages)   # 输出: (25, 30, 35)

总结：zip() 函数用于将多个可迭代对象中的元素逐个配对组合，并生成一个包含元组的迭代器。这在同时遍历多个列表或元组时非常有用。

9、filter函数在数组中的作用

filter() 是 Python 内置的函数之一，用于从可迭代对象中筛选出满足指定条件的元素，并返回一个生成器（迭代器）对象。它会根据提供的函数对每个元素进行判断，只保留满足条件的元素。

语法：

filter(function, iterable)

• function：一个函数，用于对可迭代对象的每个元素进行判断。该函数返回 True 或 False，用于指示元素是否满足条件。
• iterable：一个可迭代对象，可以是列表、元组、集合等。

示例：

def is_even(x):
    return x % 2 == 0

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 使用 filter() 保留偶数
filtered = filter(is_even, numbers)

# 转换为列表以查看结果
filtered_list = list(filtered)
print(filtered_list)  # 输出: [2, 4, 6, 8]

在上述示例中，filter() 函数根据 is_even 函数的判断条件，保留了列表 numbers 中的偶数。

另一种常用的方法是使用匿名函数（lambda 函数）来定义判断条件，特别是当判断条件很简单时：

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 使用匿名函数保留奇数
filtered = filter(lambda x: x % 2 != 0, numbers)

filtered_list = list(filtered)
print(filtered_list)  # 输出: [1, 3, 5, 7, 9]

需要注意的是，filter() 函数返回的是一个生成器（迭代器），而不是一个列表。如果你需要查看结果，可以将它转换为列表。

总结：filter() 函数用于从可迭代对象中筛选出满足指定条件的元素，返回一个生成器对象。可以使用自定义的函数或匿名函数来定义筛选条件。

七、深拷贝与浅拷贝

深拷贝和浅拷贝详解

浅拷贝会共享可变对象，而深拷贝会创建完全独立的副本。

语法：

list集合对象 . copy()

list集合对象 [ : ]   #相当于复制，取切片[:]和[::]一样

1、可变对象在复制后会改变内存空间，但是不可变对象在复制后不会改变内存空间

s = "jzq"
s1 = s[:]
print(id(s)) #2910335181016
print(id(s1)) #2910335181016

l = [1,2,3,[4,5]]
l1 = l.copy()
print(id(l)) #2910337332616
print(id(l1)) #2910337332680

print(l is l1) #False
print(l == l1) #True

赋值后两个变量在同一块内存空间，而复制后两个变量在不同的内存地址。
==和is有什么区别？
== 只判断值是否相等，而is判断内存地址是否相等。
复制后只是==相等，而通过赋值是is相同

八、list类型转换（list(可迭代对象)  构造方法）

list构造方法中的实参必须是一个可迭代对象

1、将str类型转换为list类型

print(type("jzq"))  # <class 'str'>
print(type(list("jzq")))  # <class 'list'>

2、将tuple类型转换为list类型

print(type((1, 2, 3))) #<class 'tuple'>
print(type(list((1, 2, 3)))) #<class 'list'>

3、将set类型转换为list类型

print(type({1,2,3})) #<class 'set'>
print(type(list({1,2,3}))) #<class 'list'>

4、将dict类型转换为list类型

print(type({1: "one",2: "two"})) #<class 'dict'>
print(type(list({1: "one",2: "two"}))) #<class 'list'>
print(list({1: "one",2: "two"})) #[1, 2]

第三章、tuple集合（单个方式存储元素）

一、概述

        在 Python 中，元组（tuple）是一种有序、不可变的数据类型。与列表相似，元组可以容纳多个元素，但一旦创建，元组的内容是不可修改的。元组使用圆括号 () 表示，其中的元素可以是任何类型，并且可以是混合类型。

二、创建tuple集合对象

1、直接使用圆括号创建

你可以使用圆括号来创建一个元组，并在括号内用逗号 , 分隔元素。元组可以包含任何类型的元素，甚至可以包含其他元组。

empty_tuple = ()
single_element_tuple = (42,)  # 单个元素的元组需要在元素后面加逗号
mixed_tuple = ("apple", 42, True)
nested_tuple = (1, ("apple", "banana"), [3, 4])

2、使用元祖推导式

my_tuple = tuple(i for i in range(5))
print(my_tuple) #(0, 1, 2, 3, 4)

3、tuple特殊形式

print(type((1))) #<class 'int'>
print(type((1,))) #<class 'tuple'>

special_tuple = 1, "one"
print(type(special_tuple)) #<class 'tuple'>

三、访问tuple集合中的元素

1、tuple集合元素索引

你可以通过索引访问元组中的元素，索引从 0 开始。与列表类似，可以使用负数索引来从末尾开始索引。

my_tuple = ("apple", "banana", "cherry")
print(my_tuple[0])  # 输出: apple
print(my_tuple[-1])  # 输出: cherry

2、tuple集合切片

my_tuple = (1, 3, 4, 5, 6, 2, 3)
print(my_tuple[:3]) #(1, 3, 4)

四、遍历tuple集合

1、使用for循环遍历

my_tuple = (1, 3, False, 5, 6, "j", 3)
for i in my_tuple:
    print(i)
    """
    1
    3
    False
    5
    6
    j
    3
    """

2、使用迭代器遍历

my_tuple = (1, 3, False, 5, 6, "j", 3)
it = my_tuple.__iter__()
while True:
    try:
        print(it.__next__())
        """
        1
        3
        False
        5
        6
        j
        3
        """
    except StopIteration as e:
        break

五、tuple集合的运算

1、+：表示元祖进行拼接成一个新元祖

你可以使用 + 运算符将两个元组连接在一起，创建一个新的元组。

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
result = tuple1 + tuple2
print(result)  # 输出: (1, 2, 3, 4, 5, 6)

2、*：对原元祖里面的内容进行复制成一个新元祖

你可以使用 * 运算符将一个元组复制多次，创建一个新的元组。

tuple1 = (1, 2, 3)
result = tuple1 * 3
print(result)  # 输出: (1, 2, 3, 1, 2, 3, 1, 2, 3)

3、in和not in运算符

in：判断某个元素是否在tuple 集合中，在为Ture，不在为False

not in：判断某个元素是否不在tuple集合中，不在为Ture，在为False

底层调用：def __contains__(self, o: object) -> bool: ...

my_tuple = (1, 3, False, 5, 6, "j", 3)

# print(True not in my_tuple)
"""
my_tuple 包含多种类型的元素，包括整数、布尔值和字符串。
你使用了 True not in my_tuple 来检查 True 是否不在元组中，
即检查元组中是否没有 True。但是输出结果却是 False。

这是因为在 Python 中，布尔值 True 和整数 1 是等价的，
布尔值 False 和整数 0 也是等价的。当使用 in 运算符来检查一个值是否在元组中时，
会将 True 当作整数 1，将 False 当作整数 0 来比较。

所以，当你执行 True not in my_tuple 时，实际上是在检查整数 1 是否不在元组中，
而元组中确实包含了整数 1，所以结果为 False。

如果你想检查元组中是否没有布尔值 True（而不是整数 1），你可以使用以下方式
"""
print(not any(i is True for i in my_tuple)) #True
"""
这个代码片段使用了生成器表达式来检查元组中是否存在与布尔值 True 相等的元素。
使用 any() 函数来判断是否存在为 True 的值，然后使用 not 运算符来反转结果。
"""

print(6 in my_tuple) #True

六、tuple集合的常用操作

1、len和count方法

可以使用 len() 函数获取元组中元素的数量，使用 count() 方法获取特定元素在元组中的出现次数。

my_tuple = (10, 20, 30, 20, 40, 20, 50)
print(len(my_tuple))          # 输出: 7
print(my_tuple.count(20))     # 输出: 3

2、解包元组

可以将元组中的元素解包到多个变量中，用于同时获取多个元素的值。

my_tuple = (10, 20, 30)
a, b, c = my_tuple
print(a)  # 输出: 10
print(b)  # 输出: 20
print(c)  # 输出: 30

3、tuple集合中元素的最大值和最小值

my_tuple = (10, 20, 30)
#求最大值
print(max(my_tuple)) #30

#求最小值
print(min(my_tuple)) #10

第四章、set集合

一、概述

        在 Python 中，set 是一种无序、不重复元素的集合数据类型。它是 Python 的内置类型之一，用于存储一组独特的元素。set 类型在数学上类似于数学中的集合，不会包含重复的元素，并且不保持插入顺序。

二、创建set集合对象

1、使用花括号 {}

可以使用花括号 {} 来创建一个空的 set，或者使用花括号包含元素来创建非空的 set。

empty_set = set()
empty_set1 = {}
print(type(empty_set1)) #<class 'dict'>
fruits = {"apple", "banana", "orange"}
print(type(fruits)) #<class 'set'>

2、使用内置 set() 构造函数

可以使用 set() 构造函数来创建一个空的 set，或者将一个可迭代对象（如列表、元组）传递给构造函数来创建非空的 set。

empty_set = set()
numbers = set([1, 2, 3, 4])

3、使用集合推导式

类似于列表推导式，你可以使用集合推导式来创建 set，通过遍历某个可迭代对象并进行变换操作。

squares = {x * x for x in range(10)}
print(squares.__str__()) #{0, 1, 64, 4, 36, 9, 16, 49, 81, 25}

三、set集合的运算

Python 中的 set 集合支持一系列集合运算，如并集、交集、差集等。这些运算可以帮助你处理集合中的元素，以下是一些常见的集合运算示例：

1、并集（Union）：| 求两个set集合的并集

并集操作返回包含两个或多个集合中所有不重复元素的新集合。调用魔术方法：__or__

set1 = {1, 2, 3}
set2 = {3, 4, 5}

union_set = set1 | set2  # 使用 | 运算符取并集
# 或者使用 union() 方法
# union_set = set1.union(set2)

print(union_set)  # 输出: {1, 2, 3, 4, 5}

2、交集（Intersection）：& 求两个set集合的交集

交集操作返回包含两个或多个集合中共同元素的新集合。调用魔术方法：__and__

set1 = {1, 2, 3}
set2 = {3, 4, 5}

intersection_set = set1 & set2  # 使用 & 运算符取交集
# 或者使用 intersection() 方法
# intersection_set = set1.intersection(set2)

print(intersection_set)  # 输出: {3}

3、差集（Difference）：- 求两个set集合的差集

差集操作返回包含在第一个集合中但不在第二个集合中的元素的新集合。调用魔术方法：__sub__

set1 = {1, 2, 3}
set2 = {3, 4, 5}

difference_set = set1 - set2  # 使用 - 运算符取差集
# 或者使用 difference() 方法
# difference_set = set1.difference(set2)

print(difference_set)  # 输出: {1, 2}

print(set1 - set2) #{1, 2}
print(set2 - set1) #{4, 5}

4、对称差集（Symmetric Difference）：^ 求两个set集合的对称差集

对称差集操作返回包含在两个集合中但不同时出现在两个集合中的元素的新集合。调用魔术方法：__xor__

set1 = {1, 2, 3}
set2 = {3, 4, 5}

symmetric_difference_set = set1 ^ set2  # 使用 ^ 运算符取对称差集
# 或者使用 symmetric_difference() 方法
# symmetric_difference_set = set1.symmetric_difference(set2)

print(symmetric_difference_set)  # 输出: {1, 2, 4, 5}

5、in和not in运算符

in：判断某个元素是否在set 集合中，在为Ture，不在为False

not in：判断某个元素是否不在另一个set集合中，不在为Ture，在为False

底层调用：def __contains__(self, o: object) -> bool: ...

my_set = {1, 1, 4, 6, 3}
print(my_set) #{1, 3, 4, 6}
print(5 in my_set) #False
print(5 not in my_set) #True

四、set集合的常用操作

1、add(element): 向集合中添加一个元素，如果元素已存在，不会重复添加

类型：def add(self, element: _T) -> None: ...

fruits = {"apple", "banana", "cherry"}
fruits.add("orange")
print(fruits) #{'cherry', 'orange', 'apple', 'banana'}

2、remove(element): 从集合中移除指定的元素，如果元素不存在，会引发 KeyError

fruits.remove("apple")
print(fruits) #{'orange', 'banana', 'cherry'}

3、discard(element): 从集合中移除指定的元素，如果元素不存在，不会引发错误

fruits.discard("aa")
print(fruits) #{'banana', 'orange', 'cherry'}

4、clear(): 清空集合中的所有元素

fruits.clear()
print(fruits.__str__()) #set()

5、pop()  随机删除一个元素，并返回该删除的元素

类型：def pop(self) -> _T: ...

result = fruits.pop()
print(result) #banana

6、update() :集合合并

my_set = {1, 2, 3}
my_set.update({3, 4, 5})
print(my_set)  #{1, 2, 3, 4, 5}

五、遍历set集合

1、使用for循环

fruits = {"apple", "banana", "cherry"}

for fruit in fruits:
    print(fruit)

2、使用迭代器

fruits = {"apple", "banana", "cherry"}

iterator = iter(fruits)
while True:
    try:
        fruit = next(iterator)
        print(fruit)
    except StopIteration:
        break

六、set类型转换（set(可迭代对象) 构造方法）

1、将str类型转换为set类型

print(type("jzq")) #<class 'str'>
print(type(set("jzq"))) #<class 'set'>
print(set("jzq")) #{'j', 'q', 'z'}

2、将list类型转换为set类型

print(type([1,2,3])) #<class 'list'>
print(type(set([1,2,3]))) #<class 'set'>
print(set([1,2,3])) #{1, 2, 3}

3、将tuple类型转换为set类型

print(type((1,2,3,4))) #<class 'tuple'>
print(type(set((1,2,3,4)))) #<class 'set'>
print(set((1,2,3,4))) #{1, 2, 3, 4}

4、将dict类型转换为set类型

当你将字典转换为 set 时，实际上是转换了字典的键（keys）为 set

print(type({1: "one", 2: "two"})) #<class 'dict'>
print(type(set({1: "one", 2: "two"}))) #<class 'set'>
print(set({1: "one", 2: "two"})) #{1, 2}

第五章、dict集合

一、概述

        在Python中，字典（Dictionary）是一种无序的数据集合，用于存储键-值对。字典的键必须是唯一的，且不可变的（通常使用字符串或数字），而值可以是任何类型的数据。字典的创建使用花括号 {} 或者使用 dict() 构造函数。

1、dict集合中的键必须是不可变数据类型且唯一的

        在Python中，字典的键（key）不能存储可变数据类型（mutable data types）的主要原因是为了保证字典的可靠性和一致性。Python中的字典是基于哈希表（hash table）实现的，而哈希表的关键特点之一是其键必须是不可变的。这是因为哈希表使用键的哈希值来确定存储位置，如果键是可变的，那么在其生命周期内哈希值可能会发生变化，这将导致字典中的元素无法正常工作。

        Python中的字典（dict）内部使用哈希表（hash table）来实现，而字典的键是通过其哈希值来确定其存储位置的。

        Python中的哈希表（hash table）是一个数据结构，它将键映射到相应的值，并且可以高效地进行查找和访问。哈希表的核心思想是将键的哈希值作为索引，然后将值存储在与索引相关联的位置上。这使得查找键对应的值变得非常快速，几乎是常数时间复杂度。

        当你向字典中添加键值对时，Python会使用键的哈希值来计算存储位置，并将值存储在该位置上。当你想要查找一个特定的键时，Python会再次计算该键的哈希值，然后定位到相应的存储位置，以获取与之关联的值。

        由于哈希值在字典操作中起着重要作用，所以字典要求键是不可变的。不可变的键确保了哈希值的稳定性，因此键在字典中的位置不会随着时间而改变。这是保持字典数据一致性和可靠性的重要机制。

        因此，字典中的键实际上是通过其哈希值来确定存储位置的，而不是直接存储哈希值。哈希值用于确定键的存储位置，并且在查找键时也用于快速定位相应的值。

2、可哈希概念

        在Python中，"可哈希"（hashable）通常是指一个对象是否可以用作字典（dict）的键或集合（set）的元素。可哈希的对象具有以下特征：

1. 对象的哈希值不会随时间变化。即使在对象的生命周期中发生了变化，它的哈希值也应该保持不变。

2. 可以通过内置函数hash()计算对象的哈希值。

3. 对象具有相等性比较操作，即__eq__()方法，用于比较对象是否相等。

4. 如果两个对象是相等的（根据其__eq__()方法的定义），那么它们的哈希值也必须相等。

        在Python中，不可变的数据类型通常是可哈希的，例如整数、浮点数、字符串和元组。这是因为这些对象满足了上述条件。因此，你可以将它们用作字典的键或集合的元素。

然而，可变数据类型，例如列表（list），通常不可哈希。这是因为它们不满足第一个条件，即列表的内容可以随时间变化，导致哈希值变化。如果你尝试将不可哈希的对象用作字典的键，将会引发TypeError。

下面是一个示例：

my_dict = {}
my_list = [1, 2, 3]

# 尝试将不可哈希的列表用作字典的键，会引发 TypeError
my_dict[my_list] = "value"

上述代码会引发TypeError，因为my_list是一个不可哈希的对象。

        总之，字典中的键必须是可哈希的，而列表通常不是可哈希的，因此不能用作字典的键。这是为了确保字典的稳定性和一致性。如果需要使用可变对象作为键，可以考虑使用不可变对象的包装或使用其他数据结构来实现相应的需求。

3、dict集合不是可哈希的

二、创建dict集合对象

1、使用花括号 {}

最常见的方式是使用花括号来创建一个字典。你可以在花括号中指定键值对。

my_dict = {"name": "John", "age": 30, "city": "New York"}

空dict集合

my_dict = {}
print(type(my_dict)) #<class 'dict'>
print(my_dict) #{}

2、使用 dict() 构造函数

你可以使用 dict() 构造函数创建一个字典。你可以传递一个包含键值对的可迭代对象，比如元组的列表。

my_dict = dict([("name", "John"), ("age", 30), ("city", "New York")])
print(my_dict) #{'name': 'John', 'age': 30, 'city': 'New York'}

my_dict = dict(zip([1,2],["one","two"]))
print(my_dict) #{1: 'one', 2: 'two'}

 空dict集合

my_dict = dict()
print(type(my_dict)) #<class 'dict'>
print(my_dict) #{}

3、使用字典推导式

字典推导式允许你通过迭代来创建字典

my_dict = {key: value for key, value in [("name", "John"), ("age", 30), ("city", "New York")]}
print(my_dict) #{'name': 'John', 'age': 30, 'city': 'New York'}

4、通过键值对参数

你可以通过直接指定键值对参数来创建一个字典

my_dict = dict(name="John", age=30, city="New York")
print(my_dict) #{'name': 'John', 'age': 30, 'city': 'New York'}

5、使用fromkeys方法

dict集合的fromkeys()方法用于创建一个新的字典，其中指定的键都有相同的初始值。这个方法的语法如下：

dict.fromkeys(keys, value)

• keys：一个可迭代对象，表示要用作新字典的键的集合。
• value：可选参数，表示用作初始值的值。如果不提供这个参数，默认为None。

fromkeys()方法将返回一个新的字典，其中包含指定的键和初始值。如果未提供初始值，那么默认初始值为None。这在创建具有默认值的字典时非常有用。

下面是一个示例：

keys = ['a', 'b', 'c']
value = 0

new_dict = dict.fromkeys(keys, value)
print(new_dict) #{'a': 0, 'b': 0, 'c': 0}

        在上面的示例中，我们使用fromkeys()方法创建了一个新字典new_dict，其中的键来自于keys列表，并且每个键都被赋予了初始值0。

        需要注意的是，fromkeys()方法不会修改现有字典，而是创建一个新的字典。如果你想要在现有字典中添加新键并设置初始值，你可以使用普通的赋值语句，例如：my_dict['new_key'] = value。

三、访问dict集合中元素

1、使用方括号[]索引法：你可以通过将键放在方括号中来获取字典中的值。

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 使用键来访问值
name = my_dict['name']
age = my_dict['age']

print(name)  # 输出: Alice
print(age)   # 输出: 30

请注意，如果字典中不存在指定的键，使用方括号索引将引发KeyError异常。为了避免这种情况，你可以使用get()方法。

2、使用get()方法

get()方法允许你根据键获取值，如果键不存在，则返回一个默认值（默认是None）而不是引发异常。

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 使用get()方法来访问值
name = my_dict.get('name')
country = my_dict.get('country', 'Unknown')  # 如果键不存在，默认值为'Unknown'

print(name)     # 输出: Alice
print(country)  # 输出: Unknown

3、使用 setdefault() 方法

dict集合的setdefault()方法用于获取字典中指定键的值，如果键不存在，则设置该键的默认值，并返回该默认值。这个方法的语法如下：

dict集合对象.setdefault(key, default_value)

• key：要查找或设置的键。
• default_value：如果键不存在时要设置的默认值。

setdefault()方法的行为可以分为两种情况：

1. 键存在于字典中：如果键存在于字典中，则setdefault()方法返回该键对应的值，不会更改字典中的值。

2. 键不存在于字典中：如果键不存在于字典中，则setdefault()方法将该键添加到字典，并将其值设置为default_value，然后返回default_value。

以下是示例：

my_dict = {'name': 'Alice', 'age': 30}

# 情况1：键存在于字典中
name = my_dict.setdefault('name', 'Unknown')
print(name)  # 输出: Alice，因为'name'键已存在于字典中，所以返回对应的值

# 情况2：键不存在于字典中
country = my_dict.setdefault('country', 'Unknown')
print(country)  # 输出: Unknown，因为'country'键不存在于字典中，所以将其添加，并设置默认值

print(my_dict)
# 输出: {'name': 'Alice', 'age': 30, 'country': 'Unknown'}

        在上面的示例中，setdefault()方法的行为取决于键是否存在于字典中。如果键已存在，则返回对应的值；如果键不存在，则将其添加到字典并设置默认值，然后返回默认值。

setdefault()方法通常用于确保在访问字典的某个键时，即使该键不存在，也不会引发KeyError异常。

四、dict集合的常用操作

1、添加键值对

1、使用方括号[]进行添加

my_dict = {}
my_dict['name'] = 'Alice'
my_dict['age'] = 30
print(my_dict) #{'name': 'Alice', 'age': 30}

2、使用update()方法来添加多个键值对

my_dict = {}
my_dict.update({'name': 'Alice', 'age': 30})
print(my_dict) #{'name': 'Alice', 'age': 30}

3、使用setdefault()方法来添加键值对，如果键已存在则不修改

my_dict = {'name': 'Alice'}
my_dict.setdefault('age', 30)
print(my_dict) #{'name': 'Alice', 'age': 30}

2、删除键值对

1、使用del语句

my_dict = {'name': 'Alice', 'age': 30}
del my_dict['name']  # 删除'name'键值对
print(my_dict) #{'age': 30}

2、使用pop()方法，可以获取被删除的值

my_dict = {'name': 'Alice', 'age': 30}
removed_value = my_dict.pop('name')  # 删除'name'键值对并获取值
print(my_dict) #{'age': 30}
print(removed_value) #Alice

3、使用popitem()方法删除最后一个键值对

my_dict = {'name': 'Alice', 'age': 30}
removed_item = my_dict.popitem()  # 删除最后一个键值对
print(my_dict) #{'name': 'Alice'}
print(removed_item) #('age', 30)

4、使用clear()方法清空字典

my_dict = {'name': 'Alice', 'age': 30}
my_dict.clear()  # 清空字典，变成空字典{}
print(my_dict) #{}
print(len(my_dict)) #0

需要注意的是，如果试图删除一个不存在的键，使用del语句或pop()方法将引发KeyError异常。因此，在删除键之前，通常需要检查键是否存在，或使用pop()方法的默认值参数来避免异常。

3、修改键值对

1、使用方括号[ ]索引法：通过键来索引字典并分配一个新的值来修改键值对

my_dict = {'name': 'Alice', 'age': 30}
my_dict['name'] = 'Bob'  # 修改'name'键对应的值为'Bob'
print(my_dict) #{'name': 'Bob', 'age': 30}

2、使用update()方法

update()方法接受一个字典作为参数，将其键值对合并到现有字典中。如果键已存在，则将其值更新为新的值，如果键不存在，则添加新键值对

my_dict = {'name': 'Alice', 'age': 30}
my_dict.update({'name': 'Bob', 'city': 'New York'})  # 修改'name'键对应的值为'Bob'，并添加'city'键值对
print(my_dict) #{'name': 'Bob', 'age': 30, 'city': 'New York'}

3、使用setdefault()方法

setdefault()方法用于获取字典中指定键的值，如果键不存在，则设置该键的默认值，并返回该默认值。如果键已存在，则不修改它。

my_dict = {'name': 'Alice', 'age': 30}
my_dict.setdefault('name', 'Bob')  # 修改'name'键对应的值为'Bob'，但不会修改已存在的键值对
print(my_dict) #{'name': 'Alice', 'age': 30}

需要注意的是，字典的键是唯一的，因此如果要修改一个键的值，只需使用相同的键分配一个新的值。如果键不存在，则可以使用setdefault()方法添加新的键值对，或使用update()方法合并新的键值对。

4、遍历dict集合

1、遍历键（Keys）：默认为遍历所有的key

使用keys()方法来获取字典的所有键，然后使用for循环遍历这些键：

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
print(my_dict.keys()) #dict_keys(['name', 'age', 'city'])

for key in my_dict.keys():
    print(key)
    """
    name
    age
    city
    """

#默认为遍历所有的key
for key in my_dict:
    print(key)
    """
    name
    age
    city
    """

2、遍历值（Values）

使用values()方法来获取字典的所有值，然后使用for循环遍历这些值：

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
print(my_dict.values()) #dict_values(['Alice', 30, 'New York'])

for value in my_dict.values():
    print(value)
    """
    Alice
    30
    New York
    """

3、遍历键值对（Items）

使用items()方法来获取字典的所有键值对，然后使用for循环遍历这些键值对。每个键值对都表示为元组（键, 值）：

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
print(my_dict.items()) #dict_items([('name', 'Alice'), ('age', 30), ('city', 'New York')])

for item in my_dict.items():
    print(item)
    """
    ('name', 'Alice')
    ('age', 30)
    ('city', 'New York')
    """
    
for key, value in my_dict.items():
    print(f"{key}: {value}")
    """
    name: Alice
    age: 30
    city: New York
    """

5、其他操作

1、统计键值对数量：一个键值对数量为1

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
print(my_dict.__len__()) #3
print(len(my_dict)) #3

五、dict集合的运算

1、==：判断两个dict集合中的键值对是否相等，相等返回True，否则返回False，与键值对顺序无关

在 Python 中，== 运算符用于比较两个字典（dict）是否具有相同的键值对。它比较两个字典的内容是否相同，而不是比较它们是否是同一个对象。以下是 == 运算符的详细说明：

比较字典内容：== 运算符会比较两个字典的键值对是否相同。如果两个字典具有相同的键和相应的值，它们被认为是相等的。

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 2, 'a': 1}
result = dict1 == dict2  # 结果为 True，因为字典内容相同

顺序无关：字典的键值对比较是无序的，这意味着字典的键值对顺序不影响它们是否被视为相等。两个包含相同键值对的字典，即使键值对的顺序不同，也会被认为是相等的。

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 2, 'a': 1}
result = dict1 == dict2  # 结果为 True，因为字典内容相同，顺序不影响

值比较：== 运算符会逐一比较字典的键和对应的值。只有在键和值都相同时，两个字典才被认为是相等的。

dict1 = {'a': 1, 'b': 2}
dict2 = {'a': 1, 'b': 3}
result = dict1 == dict2  # 结果为 False，因为键 'b' 对应的值不同

        总之，== 运算符用于比较两个字典的内容是否相同，不关心它们的内存地址或顺序。如果两个字典具有相同的键和相应的值，则它们被认为是相等的。如果你想比较两个字典是否是同一个对象（具有相同的内存地址），可以使用 is 运算符。