In Python ist Integer (Ganzzahl) ein integrierter Datentyp, der zur Darstellung ganzzahliger Werte verwendet wird. Der Integer-Typ in Python kann Ganzzahlen beliebiger Größe darstellen, ohne die Wortlängenbeschränkung des Computers zu berücksichtigen. Dies liegt daran, dass Python die Anzahl der Bits in Ganzzahltypen automatisch nach Bedarf anpasst, sodass Ganzzahlen jeder Größe gespeichert werden können. Im Folgenden finden Sie einige Beispiele für Ganzzahlen:
x = 42 # 整数常量 y = -123 # 负整数常量 z = 0 # 零 #除法操作返回的结果可以是整数或浮点数，具体取决于操作数的类型和结果。如果除法的操作数都是整数，则结果为整数，如果有一个操作数是浮点数，则结果为浮点数。 x = 10 y = 3 print(x + y) # 输出结果为13 print(x / y) # 输出结果为3.3333333333333335 #在上面的示例中，我们定义了两个整数x和y，然后对它们进行了加法和除法操作，并打印了结果。注意，除法操作返回的结果是一个浮点数，而不是整数。如果要将结果转换为整数，可以使用`int()`函数进行转换。例如： x = 10 y = 3 result = int(x / y) print(result) # 输出结果为3
In Python können Sie zur Darstellung großer Zahlen direkt Ganzzahlen oder lange Ganzzahlen verwenden, ohne die wissenschaftliche Notation zu verwenden.
In Python 2.x ist die Größe der Ganzzahl begrenzt, der Maximalwert beträgt 2^31 - 1. Wenn Sie größere Ganzzahlen darstellen müssen, können Sie eine lange Ganzzahl verwenden. Lange Ganzzahlen unterliegen bei der Darstellung keiner Größenbeschränkung, da sie ihre Größe automatisch an die erforderliche Genauigkeit anpassen können. Sie können das Suffix „L“ verwenden, um ein Integer-Literal als Long-Literal zu kennzeichnen, zum Beispiel: 12345678901234567890L.
In Python 3.x unterliegen Ganzzahlen keinen Einschränkungen mehr hinsichtlich der Wertgröße und können extrem große Ganzzahlen direkt darstellen, ohne lange Ganzzahlen zu verwenden. In Python 3.x wurden lange Ganzzahlen in gewöhnliche Ganzzahlen integriert, sodass bei der Darstellung großer Zahlen kein zusätzliches Markup oder keine zusätzliche Syntax erforderlich ist.
Zum Beispiel kann in Python eine sehr große ganze Zahl wie folgt dargestellt werden:
x = 123456789012345678901234567890
Nullwert
In Python werden Nullwerte durch ein integriertes Objekt None dargestellt. Dieses Objekt ist etwas Besonderes und kann als Platzhalter beliebiger Art verwendet werden. Wenn einer Variablen kein Wert zugewiesen ist oder ein Funktionsrückgabewert einen Platzhalter erfordert, verwenden wir normalerweise None, um einen Nullwert darzustellen. Hier ist ein einfaches Beispiel, das zeigt, wie None verwendet wird:
x = None # 将变量x设置为None
y = 10 # 将变量y设置为一个整数值
z = None # 将变量z设置为None
if x is None:
print("x is None")
else:
print("x is not None")Im obigen Beispiel ändern wir zunächst die Variablen x und z auf „Set“. Keine. Dann verwenden wir den Operator is, um zu prüfen, ob die Variable x None ist. Da x tatsächlich None ist, ist die Bedingung if x is None wahr und "x is None" wird ausgegeben . Wenn die Variable x hingegen einen anderen Wert enthält (z. B. einen ganzzahligen Wert), gilt die Bedingung nicht. None 表示,这个对象是特殊的，可以用作任何类型的占位符。当变量未赋值或函数返回值需要一个占位符时，我们通常使用None来表示空值。以下是一个简单的示例，展示了如何使用None：
x = 3.14159 # 浮点数常量 y = -0.0001 # 负浮点数常量 z = 2.0e-6 # 科学计数法表示的浮点数（0.000002） #Python中的浮点数可以执行各种算术操作，如加法、减法、乘法和除法等。下面是一个简单的示例，计算三个浮点数之和： x = 0.1 y = 0.2 z = 0.3 print(x + y + z) # 输出结果为0.6000000000000001 #Python中的浮点数可以执行各种算术操作，如加法、减法、乘法和除法等。下面是一个简单的示例，计算三个浮点数之和： x = 0.1 y = 0.2 z = 0.3 print(x + y + z) # 输出结果为0.6000000000000001 #在上面的示例中，我们计算三个浮点数之和，并打印结果。然而，输出结果并不是期望的0.6，而是一个近似值0.6000000000000001。这是由于浮点数的近似性和舍入误差导致的。为了避免这种问题，我们可以使用`round()`函数对浮点数进行四舍五入，以便得到更精确的结果。例如： x = 0.1 y = 0.2 z = 0.3 result = round(x + y + z, 2) # 对浮点数进行四舍五入，并保留两位小数 print(result) # 输出结果为0.6
在上面的示例中，我们首先将变量x和z设置为None。然后，我们使用is运算符检查变量x是否为None。由于x确实是None，所以条件if x is None成立，打印出"x is None"。相反，如果变量x包含任何其他值（例如整数值），则该条件将不成立。
需要注意的是，None不同于空字符串或空列表。空字符串表示没有字符，而空列表表示没有元素。相比之下，None是一个对象，它表示没有值或空值。因此，在编写Python代码时，应该正确理解和使用None，以避免混淆和错误。
在Python中，浮点数是一种内置数据类型，用于表示实数。与整数类型不同的是，浮点数是近似值，而不是精确值。这是因为Python采用了双精度浮点数格式来表示浮点数，这种格式可以表示非常大和非常小的数字，但是由于近似性和舍入误差，会导致一些精度问题。因此，当使用浮点数时，需要注意舍入误差和精度问题。
在Python中，可以使用小数点来表示浮点数，也可以使用科学计数法。例如，下面是一些浮点数的示例：
#1. 与运算 #与运算（`and`）用于判断两个条件是否都为True。如果两个条件都为True，则返回True，否则返回False。以下是与运算的一些示例： x = 5 y = 10 result = x < 10 and y > 5 print(result) # 输出结果为True #在上面的示例中，我们使用与运算符`and`判断两个条件是否都为True，并打印了结果 #2. 或运算 #或运算（`or`）用于判断两个条件中是否有至少一个为True。如果两个条件都为False，则返回False，否则返回True。以下是或运算的一些示例： x = 5 y = 10 result = x < 10 or y < 5 print(result) # 输出结果为True #在上面的示例中，我们使用或运算符`or`判断两个条件中是否有至少一个为True，并打印了结果。 #3. 非运算 #非运算（`not`）用于对一个条件进行取反操作，如果条件为True，则返回False，如果条件为False，则返回True。以下是非运算的一些示例： x = 5 result = not x > 10 print(result) # 输出结果为True #在上面的示例中，我们使用非运算符`not`对一个条件进行取反操作，并打印了结果。 #总之，在Python中，逻辑运算符可以用于布尔类型的值（True或False），也可以用于其他类型的值。这些逻辑运算符包括与运算（`and`）、或运算（`or`）和非运算（`not`），可以用于各种逻辑操作中。
在上面的示例中，我们使用round()函数对浮点数进行四舍五入，并保留两位小数。然后，我们打印结果，得到期望的0.6。
Python中的逻辑运算符有三种：与运算（and）、或运算（or）和非运算（not）。这些逻辑运算符可以用于布尔类型的值（True或False），也可以用于其他类型的值。
用法如下：
#Python中的字符串可以用单引号、双引号或三引号来表示
str1 = 'Hello, world!' # 使用单引号
str2 = "Hello, world!" # 使用双引号
str3 = '''Hello,
world!''' # 使用三引号表示多行字符串
#字符串是不可变的，也就是说，一旦定义了一个字符串，就不能再修改它的值，只能重新定义一个新的字符串。
str1 = 'Hello, world!'
str1[0] = 'h' # 错误，字符串不可变
##Python中的字符串支持各种常见的操作，例如字符串连接、字符串切片、字符串查找、大小写转换等等。例如：
str1 = 'Hello, '
str2 = 'world!'
str3 = str1 + str2 # 字符串连接
print(str3) # 输出：Hello, world!
str4 = 'hello, world!'
print(str4[0:5]) # 输出：hello，字符串切片
print(str4.find('world')) # 输出：7，查找字符串中子串的位置
print(str4.upper()) # 输出：HELLO, WORLD!，将字符串转换为大写
#Python中的字符串非常灵活，可以通过各种操作来实现字符串的处理和转换。同时，Python也提供了丰富的字符串处理库，例如正则表达式库re，可以更加高效和方便地处理字符串。因为计算机是老外发明的，最初只能识别大小写英文字母、数字和一些符号，这些是通过 ASCII 编码实现的，如下图所示 B的编码是 66，1的 编码是 49；
随着计算机和互联网的发展，全球各个国家都要使用，ASCII 编码显然不足以表示中文等其他字符，这个过程中中国制定了 GB2312, 韩国制定了 Euc-kr 等自己的编码格式，为了防止冲突，后来诞生了 Unicode 字符集，它把所有的编码都统一起来，解决了编码冲突导致的乱码问题，后来又衍生出了更节约成本的 “可变长编码” UTF-8 编码。
我们梳理下 ASCII, Unicode, UTF-8 的区别：
ASCII、Unicode和 UTF-8
None von einer leeren Zeichenfolge oder einer leeren Liste unterscheidet. Eine leere Zeichenfolge bedeutet keine Zeichen und eine leere Liste bedeutet keine Elemente. Im Gegensatz dazu ist None ein Objekt, das keinen Wert oder einen Nullwert darstellt. Daher sollte beim Schreiben von Python-Code None richtig verstanden und verwendet werden, um Verwirrung und Fehler zu vermeiden. 🎜🎜Gleitkommazahlen🎜🎜In Python sind Gleitkommazahlen ein integrierter Datentyp, der zur Darstellung reeller Zahlen verwendet wird. Im Gegensatz zu Ganzzahltypen sind Gleitkommazahlen Näherungswerte und keine exakten Werte. Dies liegt daran, dass Python ein Gleitkommaformat mit doppelter Genauigkeit zur Darstellung von Gleitkommazahlen verwendet. Dieses Format kann sehr große und sehr kleine Zahlen darstellen, kann jedoch aufgrund von Näherungs- und Rundungsfehlern zu Präzisionsproblemen führen. Daher müssen Sie beim Arbeiten mit Gleitkommazahlen auf Rundungsfehler und Genauigkeitsprobleme achten. 🎜🎜In Python können Sie den Dezimalpunkt zur Darstellung von Gleitkommazahlen verwenden oder die wissenschaftliche Notation verwenden. Hier sind zum Beispiel einige Beispiele für Gleitkommazahlen: 🎜#1. 创建列表
#可以使用方括号 [] 或 list() 函数创建一个新的列表
my_list = [1, 2, 3, "hello"]
another_list = list(range(5))
#2. 访问列表元素
#可以使用索引来访问列表中的元素，索引从0开始。也可以使用负数索引从列表末尾开始倒数访问元素
print(my_list[0]) # 输出 1
print(my_list[-1]) # 输出 "hello"
#3. 切片操作
##可以使用切片操作访问列表的子序列，切片操作的语法为 start:end:step
print(my_list[1:3]) # 输出 [2, 3]
print(my_list[:2]) # 输出 [1, 2]
print(my_list[::2]) # 输出 [1, 3]
#4. 修改列表
#可以使用索引来修改列表中的元素，也可以使用切片操作修改多个元素
my_list[0] = "new value"
my_list[1:3] = [4, 5]
'''5. 列表方法
Python列表提供了许多有用的方法来操作列表，例如：
- `append()` 在列表末尾添加一个元素
- `extend()` 将一个列表的元素添加到另一个列表的末尾
- `insert()` 在指定索引处插入一个元素
- `remove()` 删除列表中第一个匹配的元素
- `pop()` 删除并返回指定索引处的元素
- `index()` 返回指定元素在列表中第一次出现的索引
- `count()` 返回指定元素在列表中出现的次数
- `sort()` 对列表进行排序
- `reverse()` 将列表反转
'''
my_list.append("new element")
my_list.extend([6, 7])
my_list.insert(1, "new element at index 1")
my_list.remove("hello")
popped_element = my_list.pop(2)
index_of_element = my_list.index("new element")
count_of_element = my_list.count(2)
my_list.sort()
my_list.reverse()
#6. 复制列表
##可以使用切片操作或者 `copy()` 方法来复制一个列表
my_list_copy = my_list[:]
my_list_copy = my_list.copy()
#7.获取列表长度
#可以使用 `len()` 函数获取一个列表的长度，即其中元素的个数
print(len(my_list)) # 输出 4round(), um eine Gleitkommazahl auf zwei Dezimalstellen zu runden. Dann drucken wir das Ergebnis aus und erhalten den erwarteten Wert von 0,6. 🎜🎜UND-, ODER-, NICHT-Operatoren🎜🎜Es gibt drei Arten von logischen Operatoren in Python: UND-Verknüpfung (und), ODER-Verknüpfung (oder) und NICHT-Verknüpfung ( nicht). Diese logischen Operatoren können für Werte vom booleschen Typ (True oder False) sowie für andere Wertetypen verwendet werden. 🎜🎜Die Verwendung ist wie folgt: 🎜#1. 创建： my_tuple = (1, 2, 3, "hello") another_tuple = tuple(range(5)) #2. 访问元组元素 #可以使用索引来访问元组中的元素，索引从0开始。也可以使用负数索引从元组末尾开始倒数访问元素。 print(my_tuple[0]) # 输出 1 print(my_tuple[-1]) # 输出 "hello" #3. 切片操作 #可以使用切片操作访问元组的子序列，切片操作的语法为 start:end:step。 print(my_tuple[1:3]) # 输出 (2, 3) print(my_tuple[:2]) # 输出 (1, 2) print(my_tuple[::2]) # 输出 (1, 3) #4. 复制元组 #由于元组是不可变的，所以不能像列表那样使用切片操作来复制一个元组。可以使用 `tuple()` 函数或者直接将一个元组赋值给另一个变量来复制一个元组，例如： my_tuple_copy = tuple(my_tuple) another_tuple = my_tuple #5. 元组解包 #元组可以使用比较运算符进行比较，比较的规则是从左到右依次比较元组中的每一个元素，直到发现不相等的元素或者所有元素都比较完毕 (1, 2) < (1, 3) # 返回 True (1, 2) == (2, 1) # 返回 False
ASCII implementiert Codierung, wie unten gezeigt. Der Code von B ist 66 und der Code von 1 ist 49. Mit der Entwicklung von Computern und Internet muss ihn jedes Land der Welt verwenden > Code reicht offensichtlich nicht aus, um andere Zeichen wie Chinesisch darzustellen. Während des Prozesses formulierte China GB2312 und Südkorea formulierte seine eigenen Codierungsformate wie Euc-kr Um Konflikte zu vermeiden, wurde später der Zeichensatz Unicode geboren, der alle Kodierungen vereinheitlichte und das Problem der durch Kodierungskonflikte verursachten verstümmelten Codes löste " UTF-8-Kodierung wurde abgeleitet. 🎜🎜Lassen Sie uns die Unterschiede zwischen ASCII, Unicode, UTF-8 klären: 🎜🎜ASCII, Unicode und < code>UTF-8 sind Zeichenkodierungsstandards zur Umwandlung von Zeichen in Binärzahlen für die Computerverarbeitung. Der Hauptunterschied zwischen ihnen besteht in der Kodierungsmethode und dem darstellbaren Zeichensatz. 🎜ASCII是一种最早的字符编码标准，它定义了 128 个字符，包括英文字母、数字和一些标点符号等基本符号。ASCII采用7位二进制编码表示字符，可以表示的字符范围是 0-127。
Unicode是一种用于表示字符集的标准，它定义了世界上几乎所有的字符集，包括中文、日文、韩文等各种语言的字符。Unicode使用32位二进制编码表示字符，可以表示的字符范围非常广泛，包括标点符号、表情符号、数学符号等等。
UTF-8 是 Unicode 的一种编码方式，它是一种可变长度编码方式，能够表示Unicode中的任何字符，包括中文、日文、韩文等各种语言的字符。UTF-8对于英文字母、数字和常用符号等ASCII字符只需1个字节编码，比较节省空间。在UTF-8编码中，使用1个字节表示0-127范围内的字符，2个字节表示 128-2047 范围内的字符，3个字节表示 2048-65535 范围内的字符，4个字节表示 65536-1114111 范围内的字符。
总的来说，ASCII是最基本的字符编码方式，Unicode扩展了字符集的范围，而UTF-8则是Unicode的一种编码方式，具有可变长度编码和兼容ASCII编码的优点，因此被广泛应用于互联网和计算机系统中。
了解了字符编码，我们再来看字符串，Python中，字符串是一个不可变的序列（Sequence），用于表示一段字符序列, 采用 Unicode 编码方式，因此可以表示世界上几乎所有的字符。
#Python中的字符串可以用单引号、双引号或三引号来表示
str1 = 'Hello, world!' # 使用单引号
str2 = "Hello, world!" # 使用双引号
str3 = '''Hello,
world!''' # 使用三引号表示多行字符串
#字符串是不可变的，也就是说，一旦定义了一个字符串，就不能再修改它的值，只能重新定义一个新的字符串。
str1 = 'Hello, world!'
str1[0] = 'h' # 错误，字符串不可变
##Python中的字符串支持各种常见的操作，例如字符串连接、字符串切片、字符串查找、大小写转换等等。例如：
str1 = 'Hello, '
str2 = 'world!'
str3 = str1 + str2 # 字符串连接
print(str3) # 输出：Hello, world!
str4 = 'hello, world!'
print(str4[0:5]) # 输出：hello，字符串切片
print(str4.find('world')) # 输出：7，查找字符串中子串的位置
print(str4.upper()) # 输出：HELLO, WORLD!，将字符串转换为大写
#Python中的字符串非常灵活，可以通过各种操作来实现字符串的处理和转换。同时，Python也提供了丰富的字符串处理库，例如正则表达式库re，可以更加高效和方便地处理字符串。python 中提供了 list 和 tuple 来表示有序集合，其区别是 list 可修改，tuple （元祖）一旦初始化就不能修改；
详细介绍如下：
在Python中，数组通常用列表（list）来表示。列表是一种有序的可变序列，它可以存储任意类型的元素。列表的索引从0开始，可以通过索引访问和修改元素。以下是一个示例：
#1. 创建列表
#可以使用方括号 [] 或 list() 函数创建一个新的列表
my_list = [1, 2, 3, "hello"]
another_list = list(range(5))
#2. 访问列表元素
#可以使用索引来访问列表中的元素，索引从0开始。也可以使用负数索引从列表末尾开始倒数访问元素
print(my_list[0]) # 输出 1
print(my_list[-1]) # 输出 "hello"
#3. 切片操作
##可以使用切片操作访问列表的子序列，切片操作的语法为 start:end:step
print(my_list[1:3]) # 输出 [2, 3]
print(my_list[:2]) # 输出 [1, 2]
print(my_list[::2]) # 输出 [1, 3]
#4. 修改列表
#可以使用索引来修改列表中的元素，也可以使用切片操作修改多个元素
my_list[0] = "new value"
my_list[1:3] = [4, 5]
'''5. 列表方法
Python列表提供了许多有用的方法来操作列表，例如：
- `append()` 在列表末尾添加一个元素
- `extend()` 将一个列表的元素添加到另一个列表的末尾
- `insert()` 在指定索引处插入一个元素
- `remove()` 删除列表中第一个匹配的元素
- `pop()` 删除并返回指定索引处的元素
- `index()` 返回指定元素在列表中第一次出现的索引
- `count()` 返回指定元素在列表中出现的次数
- `sort()` 对列表进行排序
- `reverse()` 将列表反转
'''
my_list.append("new element")
my_list.extend([6, 7])
my_list.insert(1, "new element at index 1")
my_list.remove("hello")
popped_element = my_list.pop(2)
index_of_element = my_list.index("new element")
count_of_element = my_list.count(2)
my_list.sort()
my_list.reverse()
#6. 复制列表
##可以使用切片操作或者 `copy()` 方法来复制一个列表
my_list_copy = my_list[:]
my_list_copy = my_list.copy()
#7.获取列表长度
#可以使用 `len()` 函数获取一个列表的长度，即其中元素的个数
print(len(my_list)) # 输出 4在Python中，元组（tuple）是一个不可变（immutable）的序列，类似于列表（list），不同之处在于元组的元素不能被修改，添加或删除。元组可以包含任何类型的对象，包括其他元组。
可以使用圆括号 () 或者 tuple() 函数来创建一个元组。
#1. 创建： my_tuple = (1, 2, 3, "hello") another_tuple = tuple(range(5)) #2. 访问元组元素 #可以使用索引来访问元组中的元素，索引从0开始。也可以使用负数索引从元组末尾开始倒数访问元素。 print(my_tuple[0]) # 输出 1 print(my_tuple[-1]) # 输出 "hello" #3. 切片操作 #可以使用切片操作访问元组的子序列，切片操作的语法为 start:end:step。 print(my_tuple[1:3]) # 输出 (2, 3) print(my_tuple[:2]) # 输出 (1, 2) print(my_tuple[::2]) # 输出 (1, 3) #4. 复制元组 #由于元组是不可变的，所以不能像列表那样使用切片操作来复制一个元组。可以使用 `tuple()` 函数或者直接将一个元组赋值给另一个变量来复制一个元组，例如： my_tuple_copy = tuple(my_tuple) another_tuple = my_tuple #5. 元组解包 #元组可以使用比较运算符进行比较，比较的规则是从左到右依次比较元组中的每一个元素，直到发现不相等的元素或者所有元素都比较完毕 (1, 2) < (1, 3) # 返回 True (1, 2) == (2, 1) # 返回 False
可以使用条件判断语句来根据某个条件来执行不同的代码，Python中的条件判断语句使用 if， elif， else 关键字
score = float(input("请输入分数："))
if score >= 90:
grade = "A"
elif score >= 80:
grade = "B"
elif score >= 70:
grade = "C"
elif score >= 60:
grade = "D"
else:
grade = "E"
print("你的等级是：", grade)除了 if 语句，Python还提供了一些其他的条件语句和表达式，如 while 循环和 for 循环，以及 and、or、not 等逻辑运算符。这些都是Python编程中非常基础的知识点，需要学习掌握。
python 有两种基本的循环方式， for in 和 while, 基本用法如下
#1. for in 循环示例：
my_list = [1, 2, 3, 4, 5]
for num in my_list:
print(num)
#2. while 循环示例
n = int(input("请输入一个整数："))
factorial = 1
while n > 0:
factorial *= n
n -= 1
print(factorial)除了 for 和 while 循环之外，Python 还提供了一些高级的循环控制语句，如 break、continue、else 等，这些语句能够使循环更加灵活。
for 循环怎么获取下标？
可以使用 enumerate() 函数来在 for 循环中同时获取元素和它的索引。enumerate() 函数返回一个枚举对象，其中每个元素都是一个元组，包含两个元素：索引和对应的元素值。
my_list = ["apple", "banana", "orange"]
for i, fruit in enumerate(my_list):
print(i, fruit)
# 0 apple
# 1 banana
# 2 orangePython 中的字典（dict）是一种无序、可变的数据类型，相当于其他语言中的 map, 用于存储键值对。
下面是一个简单的字典示例：
my_dict = {'apple': 3, 'banana': 2, 'orange': 4}
'''字典有许多常用的操作，包括：
1. 访问元素：可以通过键来访问字典中的值，例如 `my_dict['apple']` 将返回 3。
2. 修改元素：可以通过键来修改字典中的值，例如 `my_dict['banana'] = 5` 将把 `banana` 的值修改为 5。
3. 添加元素：可以使用赋值语句来添加新的键值对，例如 `my_dict['grape'] = 6` 将添加一个新的键值对 `grape: 6`。
4. 删除元素：可以使用 `del` 语句来删除键值对，例如 `del my_dict['orange']` 将删除键为 `orange` 的键值对。
5. 遍历元素：可以使用 `for` 循环来遍历字典中的键值对，例如：'''
for key, value in my_dict.items():
print(key, value)
#6. 获取键、值、键值对的列表：可以使用 `keys()`、`values()` 和 `items()` 方法来分别获取所有键、所有值和所有键值对的列表。例如:
keys = my_dict.keys()
values = my_dict.values()
items = my_dict.items()
#注意，`keys()`、`values()` 和 `items()` 方法返回的是视图对象，而不是列表。如果需要将其转换为列表，可以使用 `list()` 函数来转换。集合（set）是一种无序、可变的数据类型，用于存储一组唯一的对象，集合不允许重复元素，而且是无序的，即不支持通过索引来访问元素，集合可以用花括号 {} 或 set() 函数来创建。
#1.创建集合：
my_set = {1, 2, 3}
my_set = set([1, 2, 3])
#2.添加元素
my_set.add(4)
my_set.update([4, 5, 6])
#3.删除元素
my_set.remove(4)
my_set.discard(5)
my_set.pop()
#4.清空集合
my_set.clear()
#5.判断元素是否在集合中
if 1 in my_set:
print('1 is in the set')
#6.求交集、并集、差集
set1 = {1, 2, 3}
set2 = {2, 3, 4}
intersection = set1 & set2 # 求交集
union = set1 | set2 # 求并集
difference = set1 - set2 # 求差集
#7.遍历集合
for item in my_set:
print(item)Das obige ist der detaillierte Inhalt vonWas sind die grundlegenden Datentypen und die allgemeine Syntax in Python?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
