大家好，Python 是一种强大而灵活的编程语言，被广泛用于各种领域，包括软件开发、数据分析、科学计算等。在 Python 中，变量、注释和数据类型是构建代码的基础，对于理解和掌握这些概念是至关重要的。本文将深入探讨 Python 中的变量、注释以及常见的数据类型，帮助大家更好地理解和运用它们。

一、变量

        Python中的变量是用于存储数据值的标识符。它们可以用来表示数字、字符串、列表、元组、字典等各种类型的数据。在Python中，变量不需要显式声明或指定数据类型；它们的类型是根据分配给它们的值自动推断的。

1、变量赋值

将数据放入变量的过程叫做赋值，Python中使用等号“=”作为赋值运算符，格式如下：

name = value

name 表示变量名称；value 表示值，也就是要存储的数据。

例如，下面的语句将整数 10 赋值给变量 number：

number = 10

        变量是标识符的一种，名字不能随便起，要遵守 Python 标识符命名规范，还要避免和 Python 内置函数以及 Python 保留字重名。

标识符命名规则：

• 标识符是由字母（A~Z 和 a~z）、下划线和数字组成，但第一个字符不能是数字。
• 标识符不能和 Python 中的保留字相同。
• Python中的标识符中，不能包含空格、@、% 以及 \$…… 等特殊字符

例如，以下变量的命名都是合法的：

UserId
name
student123
user_id
_name

以下变量的命名不合法：

123student   # 不能以数字开头
try          # try是保留字，不能作为标识符
$name        # 不能包含特殊字符

        标识符中的字母是严格区分大小写的，两个同样的单词，如果大小写格式不一样，代表的意义也是完全不同的。
例如：

number = 3
Number = 3
NUMBER = 3

这三个变量之间，是完全独立、毫无关系的。

保留字：

由于 Python 是严格区分大小写的，所以，if 是保留字，但 IF 就不是保留字。

        变量的值不是一成不变的，它可以随时被修改，只要重新赋值即可；另外也不用关心数据的类型，可以将不同类型的数据赋值给同一个变量。
例如：

number = 10    # 将整数10赋值给变量number
number = 50    # 将整数50赋值给变量number
number = 100   # 将整数100赋值给变量number

age = 10.5        # 将小数10.5赋值给变量age
age = 66          # 将整数66赋值给变量age
age = "我是张三"   # 将字符串赋值给变量age

变量只能容纳一个值，变量的值一旦被修改，之前的值就被覆盖了，不复存在了，再也找不回了。

除了赋值单个数据，也可以将表达式的运行结果赋值给变量。
例如：

number = 150 + 20          # 将加法的结果赋值给变量
number = 25 * 30 % 7       # 将余数赋值给变量
string = "我是" + "张三"    # 将字符串拼接的结果赋值给变量

2、变量的使用

使用 Python 变量时，需要知道变量的名字，代码的任何地方都能使用变量。

        在强类型的编程语言中，定义变量时要指明变量的类型，而且赋值的数据也必须是相同类型的，例如：C、C++、Java等。

和强类型语言相对应的是弱类型语言，例如：Python、JavaScript 等一般都是弱类型编程语言。

弱类型语言特点：

• 变量无须声明就可以直接赋值，对一个不存在的变量赋值就相当于定义了一个新变量。
• 变量的数据类型可以随时改变，比如：同一个变量可以一会儿被赋值为整数，一会儿被赋值为字符串。

        但是，弱类型并不代表没有类型，弱类型是说在写代码时不用刻意关注类型，但是在编程语言的内部仍然是有类型的。

可以使用 type() 内置函数查询某个变量的类型，例如：

二、注释

注释用来提示或解释某些代码的作用或者功能，可以出现在代码中的任何位置。
在调试程序的过程中，注释还可以用来临时移除暂时无用的代码。
注释的最大作用是提高程序的可读性。

Python 支持两种类型的注释，单行注释和多行注释。

1、单行注释

Python 使用井号“#”作为单行注释的符号，语法格式为：

# 注释内容

        从井号“#”开始，直到这行结束为止的所有内容都是注释。Python 解释器遇到“#”时，会忽略后面的整行内容。

解释多行代码的功能时，一般将注释放在代码的上一行，例如：

# 使用print输出字符串
print("张三")
print("Hello World")

# 使用print输出数字
print(100)
print(10 + 100 * 2)
print((10 + 100) * 2 )

解释单行代码的功能时一般将注释放在代码的右侧，例如：

print("Hello World")  # 输出Hello World
print(5 + 10)  # 输出5加10的结果
print(100)  # 输出整数100

2、多行注释

Python 使用三个连续的单引号'''或者三个连续的双引号"""注释多行内容，具体格式如下：

"""
使用三个双引号分别作为注释的开头和结尾
可以一次性注释多行内容
这里面的内容全部是注释内容
"""

或者使用三个单引号

'''
使用三个双引号分别作为注释的开头和结尾
可以一次性注释多行内容
这里面的内容全部是注释内容
'''

多行注释一般用来为 Python 文件、模块、类或者函数做出功能解释。

3、通过注释用来调试程序

给代码添加说明是注释的基本作用，除此以外还有另外一个实用的功能，就是用来调试程序。

        如果觉得某段代码可能有问题，可以先把这段代码注释起来，让 Python 解释器忽略这段代码，然后再运行。如果程序可以正常执行，则可以说明错误就是由这段代码引起的；反之，如果依然出现相同的错误，则可以说明错误不是由这段代码引起的。

在调试程序的过程中使用注释可以缩小错误所在的范围，提高调试程序的效率。

三、数据类型

        Python中有许多内置的数据类型，每种数据类型都有其特定的用途和功能。以下是一些常见的Python数据类型的简要介绍：

• 整数（int）：用于表示整数值，如-5、0、100等。
• 浮点数（float）：用于表示有小数点的数值，如3.14、-0.001等。
• 字符串（str）：用于表示文本数据，由单引号（'）或双引号（"）括起来，如"hello"、'Python'等。
• 列表（list）：用于存储一系列有序的元素，可以包含任意类型的数据，用方括号（[]）括起来，如[1, 2, 3]、['apple', 'banana', 'orange']等。
• 元组（tuple）：类似于列表，但是元组是不可变的，用圆括号（()）括起来，如(1, 2, 3)、('a', 'b', 'c')等。
• 字典（dict）：用于存储键-值对（key-value pairs），每个键都与一个值相关联，用花括号（{}）括起来，如{'name': 'Alice', 'age': 30}等。
• 集合（set）：用于存储无序且不重复的元素，用花括号（{}）括起来，如{1, 2, 3}、{'apple', 'banana', 'orange'}等。
• 布尔值（bool）：用于表示真（True）或假（False）的值，常用于条件判断和逻辑运算。
• None类型：表示空值或缺失值的数据类型，常用于初始化变量或函数返回值。

        Python还支持许多其他数据类型，如复数（complex）、字节串（bytes）等，但上述数据类型是最常用和最基本的数据类型。通过合理地使用这些数据类型，可以在Python中处理各种类型的数据，并编写出简洁、高效的代码。

1、整数（int）

整数就是没有小数部分的数字，整数包括正整数、0 和负整数。

        有些强类型的编程语言会提供多种整数类型，每种类型的长度都不同，能容纳的整数的大小也不同，编程时要根据实际数字的大小选用不同的类型。

例如：C语言提供了 short、int、long、long long 四种类型的整数，它们的长度依次递增。

        Python 的整数不分类型，它只有一种类型的整数。Python 整数的取值范围是无限的，不管多大或者多小的数字。

当所用数值超过计算机自身的计算能力时，Python 会自动转用高精度计算（例如：大数计算）。

        number_2 是一个极大的数字，number_3 是一个很小的数字，Python 都能正确输出，不会发生溢出。不管对于多大或者多小的整数，Python 只用一种类型存储，就是 int。

        为了提高数字的的可读性，在 Python3 中 允许使用下划线“_”作为数字（包括整数和小数）的分隔符。通常每隔三个数字添加一个下划线，类似于英文数字中的逗号。下划线不会影响数字本身的值。

2、浮点数（float）

        Python 只有一种浮点数类型，就是 float。对比强类型编程语言，C语言有两种浮点数类型，分别是 float 和 double，float 的小数范围比较小，double 的小数范围比较大。

从运行结果看出，Python 的float类型能支持极小和极大的浮点数。

3、布尔值（bool）

        Python 中的布尔类型（bool）来表示真（对）或假（错），比如5 > 3，这个是正确的，在程序世界里称之为真（对），Python 中使用 True 来代表；

再比如4 > 20，这个是错误的，在程序世界里称之为假（错），Python 中使用 False 来代表。

布尔类型可以当做整数来对待， True 相当于整数 1，False 相当于整数 0。

例如：

        布尔类型就是用于代表某个事情的真（对）或假（错），如果这个事情是正确的，用 True（或 1）代表；如果这个事情是错误的，用 False（或 0）代表。
例如：

4、字符串（str）

字符串的定义

Python 中的字符串必须由双引号" "或者单引号' '包围，具体格式为：

"我是一个字符串"
'我是一个字符串'

Python 字符串中的双引号和单引号没有任何区别，但是不能混用。
Python 字符串的内容可以包含全世界的所有文字、字母、标点、特殊符号。

字符串的换行，需要在行尾添加反斜杠“\”，例如：

name = '我叫张三，我想换\
        行，哎呦，我换\
        行了'

Python 长字符串由三个双引号"""或者三个单引号'''包围，语法格式如下：

"""这是一个长字符串"""
'''这是一个长字符串'''

如果长字符串没有赋值给任何变量，那么这个长字符串就相当于一段注释。

        当程序中有大段文本内容需要定义成字符串时，优先推荐使用长字符串形式，因为这种形式可以在字符串中放置任何内容，包括单引号和双引号。

字符串的拼接

Python 中拼接字符串可以直接将两个字符串紧挨着写在一起，格式为：

name = "张三" "李四"

name表示拼接以后的字符串变量名，张三 和 李四 是要拼接的字符串内容。

如果是字符串变量拼接，需要使用 “+” 来拼接，格式为：

name = name1 + name2

字符串和数字的拼接

        Python 不允许直接拼接数字和字符串，必须先将数字转换成字符串。可以使用 str() 函数将数字转换为字符串。格式为：

str(obj)

obj 表示要转换的对象，可以是数字、列表、元组、字典等多种类型的数据。

例如：

获取字符串长度

        Python 中，要想知道一个字符串有多少个字符（获得字符串的长度），可以使用 len() 内置函数。
len() 函数的基本语法格式为：

len(string)

其中 string 就是要进行长度统计的字符串。
例如：

格式化字符串

使用以%开头的占位符对各种类型的数据进行格式化输出

占位符会被后面表达式（变量、常量、数字、字符串、加减乘除等各种形式）的值代替。

例如：

        在 print() 函数中，由引号包围的是格式化字符串，它相当于一个字符串模板，可以放置一些占位符。上述字符串中包含一个%d占位符，当执行时会被后面的 age 变量的值所替代。

中间的红色的“%”是分隔符，前面是格式化字符串，后面是要输出的变量或表达式。

        格式化字符串中也可以包含多个占位符，同时也需要提供多个变量或者表达式，用来替换对应的占位符；多个变量或者表达式必须使用小括号( )括起来。
例如：

有几个占位符，后面就需要跟着几个变量或者表达式。

截取字符串

        字符串是由多个字符构成的，字符之间是有顺序的，这个顺序号就称为索引。Python 中通过索引来操作字符串中的单个或者多个字符，比如：获取指定索引处的字符，返回指定字符的索引值等。

知道字符串名字以后，在方括号“[ ]”中使用索引即可访问对应的字符，具体的语法格式为：

strname[index]

strname 表示字符串名字，index 表示索引值。

Python 允许从字符串的两端使用索引：

• 当以字符串的左端为起点时，索引从 0 开始计数；字符串的第一个字符的索引为 0，第二个字符的索引为 1，第三个字符串的索引为 2 。
• 当以字符串的右端为起点时，索引从 -1 开始计数；字符串的倒数第一个字符的索引为 -1，倒数第二个字符的索引为 -2，倒数第三个字符的索引为 -3 。

例如：

        使用“[ ]”除了可以获取单个字符外，也可以指定一个范围来获取多个字符，也就是一个子串或者片段，具体格式为：

strname[start : end]

对各个部分的说明：

• strname：要截取的字符串名字
• start：表示要截取的第一个字符所在的索引（截取时包含该字符）。如果不指定，默认为 0；
• end：表示要截取的最后一个字符所在的索引（截取时不包含该字符）。如果不指定，默认为字符串的长度；

例如：

统计字符串出现的次数

        count() 方法用于查询指定字符串在另一字符串中出现的次数，如果查询的字符串不存在，则返回 0，否则返回出现的次数。

分割字符串

        split() 方法可以实现将一个字符串按照指定的分隔符切分成多个子串，这些子串会被保存到列表中（不包含分隔符），作为方法的返回值返回回来。

5、列表（list）

定义一个列表

        列表是最常用的Python数据类型，列表中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。

name_list = ['张三', '李四', '王五']

列表的数据项不需要具有相同的类型。

list1 = [10, 55.01, '张三', {'key':'value'}, True, [1, 2, 3]]

        以上列表中包含了6种数据类型，分别是：整数（int）、浮点数（float）、字符串（str）、字典（dict）、布尔值（bool）、列表（list）

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。

获取列表中的值

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。

通过索引列表可以进行截取、组合等操作。

以上列表中索引对应的值为：

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

以上列表中索引对应的值为：

使用下标索引来访问列表中的值，同样也可以使用方括号 [] 的形式截取列表，如下所示：

使用负数索引值截取：

更新列表

可以对列表的数据项进行修改或更新，也可以使用 append() 方法来添加列表项。

通过索引位置修改列表中的值：

append()方法可以在列表的末尾追加对象：

insert()方法可以将对象插入列表：

pop()方法可以移除列表中的一个元素（默认最后一个元素），并且返回该元素的值：

remove()方法可以移除列表中某个值的第一个匹配项：

也可以使用del来删除列表中的元素：

index()方法可以从列表中找出某个值第一个匹配项的索引位置：

除此之外还有另外一些操作列表的方法：

• sort()：对列表进行排序
• reverse()：反向列表中的元素
• max():返回列表中元素的最大值
• min():返回列表中元素的最小值
• list():转换成列表

列表操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

如下所示：

6、字典（dict）

        字典可存储任意类型对象。字典的每个键值 key:value 对用冒号 : 分割，每个键值对之间用逗号,分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

        在字典中，键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

获取字典中的值

把相应的键放入到方括号中，如下实例:

如果用字典里没有的键查询字典，会出现如下错误：

修改字典

向字典添加新元素的方法是增加新的键值对，修改或删除已有键值对，如下实例:

字典中键的特性

不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：

字典中常用函数

get()可以返回字典中指定键的值：

update(dict_name)可以将字典dict_name的键值对更新到dict里：

keys()可以返回字典中所有的键：

values()可以返回字典中所有的值：

pop()可以删除字典 key（键）所对应的值：

key in dict可以判断某个键是否存在于字典中：

7、元组（tuple）

        在Python中，元组（tuple）是一种有序、不可变的数据类型。这意味着一旦创建了元组，就无法修改它的内容。元组用于存储一组元素，可以包含任意类型的数据，包括整数、浮点数、字符串、列表、元组等。元组的每个元素都有一个索引，从0开始递增。

创建元组

最简单的方式是直接将元素放入圆括号中，用逗号 , 分隔每个元素，例如：：

my_tuple = (1, 2, 3, 'a', 'b', 'c')

        还可以使用 tuple() 函数来创建元组。tuple() 函数接受一个可迭代对象作为参数，并将其转换为元组。可迭代对象可以是列表、字符串、元组等，例如：

my_list = [1, 2, 3]
my_tuple = tuple(my_list)

要创建一个空元组，只需使用空的圆括号即可，例如：

empty_tuple = ()

        创建包含单个元素的元组时，需要注意，由于逗号 , 是用于表示元组的，而不是圆括号 ()。如果只有一个元素且没有逗号，则会被认为是该元素的类型，而不是元组。因此，如果要创建只有一个元素的元组，需要在元素后面加上一个逗号，例如：

single_tuple = (1,)  # 注意逗号

没有逗号的话，Python 会将 (1) 视为一个整数，而不是元组。

访问元组元素

访问元组元素是通过索引来完成的，索引是从0开始的整数，用于标识元素在元组中的位置。

        正向索引是从左到右的索引方式，从0开始递增。你可以使用正向索引来访问元组中的元素。例如，如果有一个元组 my_tuple：

my_tuple = (1, 2, 3, 'a', 'b', 'c')

 可以通过索引来访问元组中的元素，例如：

        负向索引是从右到左的索引方式，从-1开始递减。你也可以使用负向索引来访问元组中的元素。例如，继续使用上面的元组 my_tuple：

负索引可以方便地从元组的末尾开始访问元素。

切片操作

        除了单个索引外，还可以使用切片操作来访问元组中的子集。切片操作允许你获取元组中的一部分元素。语法为 tuple[start:stop:step]，其中 start 表示起始索引，stop 表示结束索引（不包含该索引），step 表示步长。例如：

切片操作可以方便地获取元组中的子集，可以指定起始索引、结束索引和步长来满足不同的需求。

注意事项：

• 如果使用的索引超出了元组的范围，将会引发 IndexError 错误。
• 元组是不可变的数据结构，因此不能修改元组中的元素。只能通过索引来访问元素，而不能通过索引来修改元素的值。

不可变性

        元组的不可变性是指一旦创建了元组，就无法修改其内容。换句话说，元组中的元素不能被更改、删除或添加。这种不可变性使得元组具有以下特点：

创建后无法修改元素

一旦创建了元组，其中的元素就不能被修改。例如，如果有一个元组：

my_tuple = (1, 2, 3, 'a', 'b', 'c')

则无法通过索引或其他方式修改元组中的任何元素。尝试修改元组中的元素会导致错误。

稳定性和可靠性

        元组的不可变性使得它们在需要保持数据稳定性和可靠性的场景中非常有用。例如，在函数返回多个值时，如果返回的是元组，调用函数的代码可以信任返回的数据不会在函数外部被修改。

线程安全性

        由于元组的不可变性，它们在多线程环境中是线程安全的。多个线程可以同时访问和使用元组，而不必担心数据被修改的风险。

适用于字典的键

        由于元组是不可变的，因此可以作为字典的键使用。字典中的键必须是不可变的数据类型，因此元组常常用作复杂键的容器。

元组解包

        元组解包是一种 Python 中的特性，允许你将元组中的元素解包（unpack）到多个变量中。这使得你可以方便地一次性将元组中的多个值分配给多个变量，而无需一个一个地提取。

        元组解包的基本语法是将元组的名称放在赋值语句的左边，并使用相同数量的变量来接收元组中的元素。例如：

my_tuple = (1, 2, 3)
a, b, c = my_tuple

        这将把元组 (1, 2, 3) 中的第一个元素赋给变量 a，第二个元素赋给变量 b，第三个元素赋给变量 c。

下面是一个更完整的示例，演示了如何使用元组解包： 

忽略某些元素

在元组解包时，如果对某些元素不感兴趣，可以使用下划线 _ 来表示忽略。例如：

x, _, z = (1, 2, 3)

这将把元组中的第一个和第三个元素分别赋给变量 x 和 z，而第二个元素则被忽略。

使用 * 符号

        如果想要将元组中的一部分元素赋给一个变量，并将其余元素赋给另一个变量，可以使用 * 符号。例如：

first, *rest = (1, 2, 3, 4, 5)

这将把元组中的第一个元素赋给变量 first，并将其余元素打包成一个列表赋给变量 rest。

8、集合（set）

        在Python中，集合（Set）是一种无序、可变的数据类型，用于存储唯一的元素。集合中的元素不重复，且没有固定的顺序。Python中的集合是基于哈希表实现的，因此集合操作的时间复杂度通常为 O(1)。

创建集合

        在Python中，可以使用两种方法来创建集合：使用花括号 {} 或使用 set() 函数。下面分别介绍这两种方法的具体使用：

使用花括号 {} 创建集合

可以使用花括号 {} 来创建一个集合，其中包含一组元素，元素之间用逗号 , 分隔。例如：

my_set = {1, 2, 3, 4, 5}

        如果想要创建一个空集合，必须使用 set() 函数，因为 {} 创建的是一个空字典，而不是一个空集合。例如：

empty_set = set()

使用 set() 函数创建集合

        除了使用花括号 {} 外，还可以使用 set() 函数来创建集合。set() 函数接受一个可迭代对象（如列表、元组、字符串等）作为参数，并将其转换为集合。例如：

my_list = [1, 2, 3, 4, 5]
my_set = set(my_list)

这将创建一个包含列表 my_list 中唯一元素的集合。

注意事项：

• 集合中的元素必须是不可变的（immutable），因此你不能在集合中包含列表、字典等可变对象。但是，你可以包含元组，因为元组是不可变的。
• 集合中的元素必须是唯一的，重复的元素会被忽略。
• 集合是无序的，因此你无法依赖索引来访问集合中的元素。

添加和删除元素

        在 Python 中，可以使用不同的方法向集合中添加和删除元素。下面是添加和删除元素的详细介绍：

add() 方法

使用 add() 方法向集合中添加一个元素。如果元素已经存在于集合中，则不会重复添加。

my_set = {1, 2, 3}
my_set.add(4)  # 添加元素 4

update() 方法

使用 update() 方法向集合中添加多个元素，可以传入一个可迭代对象，如列表、元组等。

my_set = {1, 2, 3}
my_set.update([4, 5, 6])  # 添加元素 4、5、6

remove() 方法

使用 remove() 方法从集合中删除指定的元素，如果元素不存在，则会引发 KeyError 错误。

my_set = {1, 2, 3}
my_set.remove(3)  # 删除元素 3

discard() 方法

使用 discard() 方法从集合中删除指定的元素，如果元素不存在，不会引发错误。

my_set = {1, 2, 3}
my_set.discard(3)  # 删除元素 3

pop() 方法

使用 pop() 方法从集合中删除并返回任意一个元素。由于集合是无序的，无法确定删除的是哪个元素。

my_set = {1, 2, 3}
x = my_set.pop()  # 删除并返回任意一个元素

clear() 方法

使用 clear() 方法清空集合，将集合中的所有元素删除。

my_set = {1, 2, 3}
my_set.clear()  # 清空集合

        以上是向集合中添加和删除元素的几种常见方法。添加元素时，可以使用 add() 方法添加单个元素，或者使用 update() 方法添加多个元素。删除元素时，可以使用 remove()、discard() 或 pop() 方法删除指定元素，或者使用 clear() 方法清空集合。

集合操作

        在 Python 中，集合支持多种操作，包括并集、交集、差集、对称差集等。下面详细介绍这些集合操作的使用方法：

并集（Union）

        并集操作将两个集合中的所有元素合并成一个新的集合。可以使用 union() 方法或 | 运算符执行并集操作。

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

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

交集（Intersection）

        交集操作返回两个集合中都包含的元素。可以使用 intersection() 方法或 & 运算符执行交集操作。

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

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

 

差集（Difference）

        差集操作返回属于第一个集合但不属于第二个集合的元素。可以使用 difference() 方法或 - 运算符执行差集操作。

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

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

对称差集（Symmetric Difference）

        对称差集操作返回两个集合中的非公共元素。可以使用 symmetric_difference() 方法或 ^ 运算符执行对称差集操作。

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

symmetric_difference_set = set1.symmetric_difference(set2)  # 使用 symmetric_difference() 方法
# 或者
symmetric_difference_set = set1 ^ set2  # 使用 ^ 运算符

子集和超集检查

        可以使用 issubset() 和 issuperset() 方法来检查一个集合是否为另一个集合的子集或超集。

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

is_subset = set2.issubset(set1)  # 检查 set2 是否为 set1 的子集
is_superset = set1.issuperset(set2)  # 检查 set1 是否为 set2 的超集

集合相等性比较

可以使用 == 和 != 运算符来比较两个集合是否相等或不相等。

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

is_equal = set1 == set2  # 检查两个集合是否相等
is_not_equal = set1 != set2  # 检查两个集合是否不相等

不可变集合

        在 Python 中，集合是可变的数据类型，这意味着你可以向集合中添加或删除元素。但是，Python 中也有一种不可变的集合类型，称为 frozenset（冻结集合）。下面详细介绍集合的不可变性以及如何创建和使用不可变集合：

创建不可变集合

        可以使用 frozenset() 函数来创建不可变集合，这个函数接受一个可迭代对象作为参数，并返回一个不可变的集合。例如：

my_frozenset = frozenset([1, 2, 3, 4, 5])

不可变集合的特点：

• 不可变性：不可变集合中的元素不可修改、删除或添加。任何试图修改不可变集合的操作都会引发错误。

• 元素唯一性：不可变集合中的元素必须是唯一的。与普通集合类似，不可变集合中的重复元素会被忽略。

• 无序性：不可变集合是无序的，因此不能通过索引来访问元素。与普通集合一样，不可变集合中的元素顺序是不确定的。

下面是一个示例，演示如何创建和使用不可变集合：

my_frozenset = frozenset([1, 2, 3, 4, 5])

# 尝试修改不可变集合会引发错误
# my_frozenset.add(6)  # 这行代码会引发 AttributeError 错误

# 尝试删除元素会引发错误
# my_frozenset.remove(3)  # 这行代码会引发 AttributeError 错误

# 不可变集合支持集合操作
another_frozenset = frozenset([4, 5, 6, 7, 8])
union_set = my_frozenset | another_frozenset  # 计算并集
intersection_set = my_frozenset & another_frozenset  # 计算交集

        不可变集合适用于需要稳定性和不变性的场景。它们可以用作字典的键，也可以在需要存储静态数据的情况下使用。由于不可变集合不可修改，因此它们在并发编程中更安全，不会引发竞态条件。

        不可变集合是一种不可修改的集合类型，适用于需要稳定性和不变性的场景。通过使用 frozenset() 函数创建不可变集合，可以确保集合的内容不会被修改。