Python의 기본 데이터 유형과 일반적인 구문은 무엇입니까?

Integer

Python에서 정수(integer)는 정수 값을 나타내는 데 사용되는 내장 데이터 유형입니다. Python의 정수 유형은 컴퓨터 단어 길이 제한을 고려하지 않고 모든 크기의 정수를 나타낼 수 있습니다. 이는 Python이 필요에 따라 정수 유형의 비트 수를 자동으로 조정하여 모든 크기의 정수를 저장할 수 있기 때문입니다. 다음은 정수의 몇 가지 예입니다.

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

파이썬에서는 큰 수를 표현하기 위해 과학적 표기법을 사용하지 않고 정수나 긴 정수를 직접 사용할 수 있습니다.

Python 2.x에서는 정수의 크기가 제한되어 있으며 최대값은 2^31 - 1입니다. 더 큰 정수를 표현해야 하는 경우 긴 정수를 사용할 수 있습니다. 긴 정수는 필요한 정밀도에 맞게 크기를 자동으로 조정할 수 있으므로 표현 시 크기 제한이 없습니다. "L" 접미사를 사용하여 정수 리터럴을 long으로 표시할 수 있습니다(예: 12345678901234567890L).

Python 3.x에서는 정수에 더 이상 값 크기 제한이 없으며 긴 정수를 사용하지 않고도 매우 큰 정수를 직접 나타낼 수 있습니다. Python 3.x에서는 긴 정수가 일반 정수에 통합되었으므로 큰 숫자를 나타낼 때 추가 마크업이나 구문이 필요하지 않습니다.

예를 들어 Python에서는 매우 큰 정수를 다음과 같이 표현할 수 있습니다.

x = 123456789012345678901234567890

null value

Python에서 null 값에 관해서는 값 없음 또는 null을 나타내는 데 사용되는 자리 표시자로 생각할 수 있습니다. 값.

Python에서 null 값은 내장 개체 None으로 표시됩니다. 이 개체는 특별하며 모든 유형의 자리 표시자로 사용할 수 있습니다. 변수에 값이 할당되지 않았거나 함수 반환 값에 자리 표시자가 필요한 경우 일반적으로 None을 사용하여 null 값을 나타냅니다. 다음은 None을 사용하는 방법을 보여주는 간단한 예입니다.

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")

위 예에서는 먼저 변수 x 및 z를 다음으로 변경합니다. 없음. 그런 다음 is 연산자를 사용하여 변수 x가 None인지 확인합니다. x는 실제로 None이므로 if x is None 조건이 true이고 "x is None"이 인쇄됩니다. . 반대로 x 변수에 다른 값(예: 정수 값)이 포함되어 있으면 조건이 유지되지 않습니다. 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은 빈 문자열이나 빈 목록과 다르다는 점에 유의하세요. 빈 문자열은 문자가 없음을 의미하고, 빈 목록은 요소가 없음을 의미합니다. 반면, None은 값이 없거나 null 값을 나타내는 개체입니다. 따라서 Python 코드를 작성할 때 혼란과 오류를 피하기 위해 None을 이해하고 올바르게 사용해야 합니다. 🎜🎜부동 소수점 숫자🎜🎜Python에서 부동 소수점 숫자는 실수를 나타내는 데 사용되는 내장 데이터 유형입니다. 정수 유형과 달리 부동 소수점 숫자는 정확한 값이 아닌 근사치입니다. 이는 Python이 부동 소수점 숫자를 표현하기 위해 배정밀도 부동 소수점 형식을 사용하기 때문입니다. 이 형식은 매우 큰 숫자와 매우 작은 숫자를 나타낼 수 있지만 근사치 및 반올림 오류로 인해 일부 정밀도 문제가 발생할 수 있습니다. 따라서 부동 소수점 숫자로 작업할 때는 반올림 오류와 정밀도 문제를 알고 있어야 합니다. 🎜🎜Python에서는 소수점을 사용하여 부동 소수점 숫자를 나타내거나 과학적 표기법을 사용할 수 있습니다. 예를 들어, 다음은 부동 소수점 숫자의 몇 가지 예입니다. 🎜

#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

🎜 위의 예에서는 round() 함수를 사용하여 부동 소수점 숫자를 소수점 두 자리로 반올림했습니다. 그런 다음 결과를 인쇄하고 예상되는 0.6을 얻습니다. 🎜🎜AND, OR, NOT, 연산자🎜🎜Python에는 세 가지 논리 연산자가 있습니다: AND 연산(and), OR 연산(or) 및 NOT 연산( 아닙니다). 이러한 논리 연산자는 부울 유형 값(True 또는 False)뿐만 아니라 다른 유형의 값에도 사용할 수 있습니다. 🎜🎜사용법은 다음과 같습니다. 🎜

#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를 통해 구현되었습니다. 인코딩은 아래와 같습니다. 표시된 B의 코드는 66이고, 1의 코드는 49입니다. 🎜🎜컴퓨터와 인터넷의 발달로 인해 세계 모든 국가에서는 ASCII)를 사용해야 합니다. > 코드는 중국어 등 다른 문자를 표현하기에는 확실히 부족합니다. 이 과정에서 중국은 GB2312를 공식화했고, 한국은 Euc-kr와 같은 자체 인코딩 형식을 공식화했습니다. 충돌을 방지하기 위해 나중에 모든 인코딩을 통합하고 인코딩 충돌로 인해 발생하는 잘못된 코드 문제를 해결한 유니코드 문자 집합이 탄생했습니다. " UTF-8 인코딩이 파생되었습니다. 🎜🎜ASCII, Unicode, UTF-8: 🎜🎜ASCII, Unicode 및 Unicode 간의 차이점을 정리하겠습니다. UTF-8은 컴퓨터 처리를 위해 문자를 이진수로 변환하기 위한 문자 인코딩 표준입니다. 이들의 주요 차이점은 인코딩 방법과 표현 가능한 문자 집합입니다. 🎜

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，可以更加高效和方便地处理字符串。

列表（list）, 元祖（tuple）

python 中提供了 list 和 tuple 来表示有序集合，其区别是 list 可修改，tuple （元祖）一旦初始化就不能修改；

详细介绍如下：

list

在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

tuple

在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 orange

字典 (dict)

Python 中的字典（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）是一种无序、可变的数据类型，用于存储一组唯一的对象，集合不允许重复元素，而且是无序的，即不支持通过索引来访问元素，集合可以用花括号 {} 或 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)

위 내용은 Python의 기본 데이터 유형과 일반적인 구문은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!