在 Python 程序设计中，数据类型是构建一切程序逻辑的基础。无论是进行数值计算、文本处理，还是构建复杂的数据结构，本质上都是对不同类型数据的存储、操作与转换。合理理解和使用数据类型，不仅能够提升代码的可读性与可维护性，还直接关系到程序的执行效率与健壮性。同时，Python 作为一门动态类型语言，其数据类型机制具有灵活性强、表达能力高的特点，但也对开发者提出了更高的规范性要求。因此，系统掌握 Python 数据类型及其相关操作，是深入学习编程语言与提升开发能力的关键前提。
基于此，本章将围绕 Python 中的常用数据类型展开，介绍其基本概念、使用方式及典型操作，帮助读者建立清晰的数据类型认知体系，为后续章节的学习打下坚实基础。
1. Python 数据类型简介
在学习 Python 数据类型之前，需要首先掌握语言的一些基本语法规则。这些规则直接影响代码的编写方式与程序的执行结果，是理解数据类型及其操作的前提。
① 大小写敏感性。
Python 是一门区分大小写的编程语言。在标识符命名中，不同大小写会被视为不同的名称。例如，变量名 age 与 Age 会被解释为两个彼此独立的变量，因此在使用过程中必须保持命名的一致性，避免因大小写混用而引发错误。
② 代码块的标识方式。
Python 采用缩进来划分代码块结构，而不是像其他多数编程语言那样通过分号（;）作为语句结束标志，或使用花括号（{}）来界定代码块范围。这种基于缩进的语法设计，使代码结构更加清晰直观，但也对缩进规范提出了更高要求。
③ 缩进规范。
在 Python 中，缩进可以使用制表符（Tab）或空格来实现。按照通行规范，1 个制表符通常等价于 4 个空格。需要注意的是，在同一代码块中必须保持缩进方式的一致性，不能混用 Tab 与空格，否则会引发 IndentationError: unindent does not match any outer indentation level（缩进不匹配错误），从而导致程序无法正常运行。
2. Python 常用数据类型概述
在 Python 中，数据类型（Data Type） 是变量存储数据的形式，它决定了变量在内存中的表现方式以及可进行的操作类型。Python 是一种动态类型语言，变量在定义时无需显式声明类型，解释器会根据赋值内容自动推断。表 2-1 列出了 Python 中常见的数据类型。
图2-1 Python 中常见的数据类型
名称 | 类型 | 描述 | 是否引用复制 |
整数 | int
| 整数类型，如 -5、0、16 | 否 |
浮点数 | float
| 带小数点的数值，如 10.25、0.04、3.14159 | 否 |
字符串 | str
| 有序的字符序列，如 "Aloha" | 否 |
布尔值 | bool
| 表示逻辑真 True 或假 False | 否 |
列表 | list
| 有序的数据序列，如 [12, "Hello", True] | 是 |
字典 | dict
| 无序的键值对集合，如 {"name": "Wilson"} | 是 |
元组 | tup
| 有序且不可变的对象序列，如 (10, "100", "Hello") | 是 |
集合 | set
| 无序且不重复的元素集合，如 {"a", "b"} | 是 |
从上表可以看出，Python 的数据类型既包括基础类型（如 int、float、str、bool），也包括容器类型（如 list、dict、tuple、set）。其中，基础类型变量在赋值或传参时会复制数值本身（Copy by Value），而容器类型变量则会引用同一内存地址（Copy by Reference）。这意味着对容器对象的修改会影响到所有引用它的变量。
例如：
# 基础类型：值复制a = 10b = ab = 20print(a) # 输出 10，不受影响# 容器类型：引用复制x = [1, 2, 3]y = xy.append(4)print(x) # 输出 [1, 2, 3, 4]，原列表被修改
上例中，int 类型变量 a 和 b 是独立的内存副本；而 list 类型变量 x 和 y 实际上指向同一个列表对象，因此当 y 发生修改时，x 也随之改变。
Python 的这种数据类型设计既提供了灵活性，也要求开发者在编写程序时关注可变与不可变对象的差异，以避免在函数传参或数据共享时出现意外的逻辑错误。
3. 数字类型（Number）
数字是 Python 中最常用的数据类型之一，主要分为两种：整数（int）和浮点数（float）。
- 整数
- 浮点数用于表示带有小数点的数值，如
3.14、0.5、-2.75。
Python 支持丰富的数值运算，包括：
- 加法（
+） - 减法（
-） - 乘法（
*） - 除法（
/） - 取余（
%） - 幂运算（
**）
示例代码如下：
a = 10b = 3print(a + b) # 加法：13print(a - b) # 减法：7print(a * b) # 乘法：30print(a / b) # 除法：3.333...print(a % b) # 取余：1print(a ** b) # 幂运算：1000
通过这些基本的算术运算，Python 可以方便地完成从日常计算到复杂数学建模等多种任务。
4. 函数（Function）
如果你是编程初学者，不妨先从“函数”这个概念开始。在 Python 中，函数（Function）就像数学中的函数一样，用来接收输入并产生输出。回想一下数学课上的例子：
在这个公式中，f 是函数名，x 是输入（参数），而 3x + 6 的结果就是输出。每次给出一个输入值 x，就会得到唯一的输出结果。
同样的道理，在 Python 中，函数也具有类似的结构。一个函数可以接收输入参数，也可以没有输入参数；它可以返回一个输出值，也可以不返回值。函数的作用就是把一段可以重复使用的逻辑封装起来，方便在程序中多次调用。
例如：
def add(x, y): return x + yresult = add(3, 5)print(result) # 输出 8
在上面的代码中：
通过定义函数，我们可以让代码更加简洁、清晰、易于维护，也能避免重复编写相同的逻辑。
5. 数字的内置方法（Built-in Functions for Numbers）
除了基本的算术运算，Python 还提供了许多针对数字的内置方法，可以帮助我们更高效地进行数值处理和类型转换。以下是一些常见的方法介绍：
abs(x)：返回数字 x 的绝对值。示例：abs(-5) 的结果是 5。pow(x, y)：返回 x 的 y 次幂，相当于 x ** y。示例：pow(2, 3) 的结果是 8。max(a, b, c, …)：返回给定参数中的最大值。示例：max(3, 8, 5) 的结果是 8。min(a, b, c, …)：返回给定参数中的最小值。示例：min(3, 8, 5) 的结果是 3。round(x, n)：将数字 x 四舍五入到保留 n 位小数。示例：round(3.14159, 2) 的结果是 3.14。
此外，Python 还提供了三个常用的类型转换函数：
示例：
num = -4.7print(abs(num)) # 输出 4.7print(pow(2, 5)) # 输出 32print(max(10, 20, 5)) # 输出 20print(round(3.14159, 2)) # 输出 3.14print(str(100)) # 输出 "100"print(int(3.6)) # 输出 3print(float("2.5")) # 输出 2.5
这些内置方法使数字的处理更加灵活，既能方便地进行数学计算，也能完成不同类型之间的转换，为后续编程打下坚实的基础。
6. 数学模块（Math Module）
在 Python 中，除了内置的数值运算和函数外，还有许多功能更强大的数学方法需要借助 数学模块（math） 才能使用。
所谓模块（Module），可以理解为一个功能集合，它将一组相关的函数、常量和类组织在一起，方便我们在程序中直接调用。关于模块的详细用法，将在后续章节中深入介绍。这里先重点了解数学模块中一些常用的常量和方法。
① 常用常量：
② 常用方法：
math.floor(x)math.ceil(x)math.sqrt(x)
示例代码如下：
import mathprint(math.e) # 输出 2.718281828459045print(math.pi) # 输出 3.141592653589793num = 9.8print(math.floor(num)) # 输出 9（向下取整）print(math.ceil(num)) # 输出 10（向上取整）print(math.sqrt(16)) # 输出 4.0（平方根）
通过 math 模块，Python 能够轻松处理更复杂的数学计算，如三角函数、对数运算、幂运算等。这些方法在科学计算、图形绘制、数据分析等领域都非常实用。
7. 变量与赋值（Variable and Assignment）
变量（Variable）是所有编程语言中的核心概念之一。可以把变量理解为一个“容器”，用来存储各种数据。在 Python 中，通过赋值符号=将数据存入变量。
需要特别注意的是：
Python 中的 = 与数学中的“等号”概念并不相同！在数学中，= 表示左右两边的值相等；而在 Python 中，= 表示的是赋值操作，即“将右侧的值放入左侧的变量中”。
例如：
执行后，变量 x 的结果为 6。这是因为第二行代码表示“取出当前的 x 值（即 5），加上 1，再把结果存回变量 x 中”。
Python 还提供了一种更简洁的写法，称为语法糖（Syntax Sugar），可以把 x = x + 1 简化为：
这两种写法效果完全相同，只是后者更加简洁高效。类似的还有：
这种复合赋值运算符在实际编程中非常常见，既能让代码更短，也能提升可读性。
8. 字符串（String）
字符串（String） 是由一系列字符组成的有序序列，例如 "Hello" 或 'Python'。在程序中，字符串常用于表示文字内容、用户输入、文件路径等信息。
① 字符串的基本特征。
字符串是有序的，这意味着我们可以通过索引（indexing）和切片（slicing）来访问其中的字符。
需要注意的是，Python 的索引是从 0 开始的，也就是说，第一个字符的索引为 0，第二个为 1，以此类推。
示例：
text = "Hello"print(text[0]) # 输出 H（索引访问）print(text[1:4]) # 输出 ell（切片访问，从索引1到3）
② 引号的使用规则。
在 Python 中，单引号 ' ' 和双引号 " " 作用完全相同，都可以用来定义字符串。例如，以下两种写法都是合法且等价的：
msg1 = 'Python is fun'msg2 = "Python is fun"
选择哪种引号主要取决于代码风格或字符串内容的需要，例如当字符串中包含单引号时，可以使用双引号来包裹：
sentence = "It's a sunny day"
通过这些规则，我们可以灵活地创建和操作字符串，从而实现更丰富的文本处理功能。
9. 字符串拼接（String Concatenation）
在 Python 中，字符串可以通过多种方式组合和连接，从而构建出更复杂的文本信息。下面介绍几种常见的字符串拼接与换行方法。
① 使用换行符 \n。
换行符 \n 用于在字符串中创建新的一行。当 Python 解释器遇到 \n 时，会将其后的内容输出到下一行。
示例：
输出结果为：
这在格式化输出或打印多行文本时非常实用。
② 使用加号 + 进行拼接。
如果在两个字符串之间使用加号 +，Python 会将它们拼接成一个新的字符串。
示例：
greeting = "Hello"name = "Alice"message = greeting + " " + nameprint(message)
输出结果为：
③ 字符串与数字的拼接。
需要注意的是，在 Python 中字符串和数字不能直接拼接。以下代码会报错：
age = 18print("I am " + age + " years old") # 错误
正确的做法是先将数字转换为字符串：
age = 18print("I am " + str(age) + " years old") # 正确
④ 字符串的不可变性（Immutable）。
Python 中的字符串是不可变的（immutable），也就是说，一旦字符串被创建，其内容就无法被直接修改。当我们进行拼接操作时，其实是生成了一个新的字符串对象，而不是在原字符串上修改内容。
示例：
text = "Hello"text += " World"print(text) # 实际上创建了一个新的字符串 "Hello World"
理解这一特性对于编写高效的 Python 程序非常重要，尤其是在处理大量字符串拼接的场景中，应优先考虑使用 join() 或格式化字符串（如 f-string）来提升性能。
10. Python 内置字符串方法
在掌握字符串的基本概念与常见操作之后，进一步了解 Python 提供的内置字符串方法，对于提升字符串处理效率具有重要意义。Python 为字符串类型内置了丰富的方法，用于完成长度计算、大小写转换、查找替换、格式化输出等常见操作。这些方法不仅语法简洁，而且功能强大，是日常开发中处理文本数据的核心工具。接下来将对常用的字符串方法进行逐一介绍。
①len()。
作用： 返回字符串的长度（字符个数）。
text = "Hello World"print(len(text)) # 输出 11
注意：空格、符号也会计入长度。
② int()。
作用： 将字符串（或数字）转换为整数类型。
num_str = "123"print(int(num_str)) # 输出 123（整数）
⚠️ 如果字符串中包含非数字字符，会报错：ValueError。
③ float()。
作用： 将字符串（或数字）转换为浮点数类型。
num_str = "3.14"print(float(num_str)) # 输出 3.14
④ str()。
作用： 将任意数据类型转换为字符串。
age = 18print("I am " + str(age) + " years old.") # 输出：I am 18 years old.
在字符串拼接时常用此方法。
⑥ upper()。
作用： 将字符串中的所有字母转换为大写。
text = "hello"print(text.upper()) # 输出 HELLO
⑦ lower()。
作用： 将字符串中的所有字母转换为小写。
text = "hello"print(text.upper()) # 输出 HELLO
⑧ isupper()。
作用： 判断字符串是否全为大写字母，返回布尔值（True / False）。
text1 = "HELLO"text2 = "Hello"print(text1.isupper()) # 输出 Trueprint(text2.isupper()) # 输出 False
⑨ index()。
作用： 返回指定字符（或子字符串）在字符串中第一次出现的位置索引。
text = "Python Programming"print(text.index("P")) # 输出 0print(text.index("gram")) # 输出 10
⚠️ 如果未找到匹配项，会抛出 ValueError 异常。
⑪replace(old, new[, count])。
用途：返回一个新字符串，将原字符串中出现的 old 子串全部（或最多 count 次）替换为 new。
参数：
返回值：替换后的新字符串（原字符串不变）。
示例：
s = "apple banana apple"t = s.replace("apple", "pear")# t -> "pear banana pear"
注意：若 old 未找到，返回原字符串的副本（或相同字符串）。替换不会改变原字符串（字符串不可变）。
⑫ split(sep=None, maxsplit=-1)。
用途：将字符串按指定分隔符拆分，返回字符串列表。
参数：
sep：分隔符，默认 None 表示以任意空白字符（空格、制表符、换行等）为分隔，且连续的空白视为一个分隔符。若指定为 ''（空字符串）会引发 ValueError。maxsplit：可选，表示最多拆分多少次，剩余部分作为最后一个元素；默认 -1 表示不限制。
返回值：字符串列表。
示例：
s = "a b c\n d"print(s.split()) # ['a', 'b', 'c', 'd']print("one,two,three".split(",")) # ['one', 'two', 'three']print("a b c d".split(" ", 2)) # ['a', 'b', 'c d']
注意点：
- 当
sep=None 时，前后多余的空白不会产生空字符串元素；但当显式指定 sep=" " 时，连续的空格会产生空元素。
⑬ list(s)。
用途：将字符串 s 的每个字符逐个转换为列表元素，返回字符列表。
返回值：由字符串中每个字符组成的列表（每个元素为长度为 1 的字符串）。
示例：
s = "hello"print(list(s)) # ['h', 'e', 'l', 'l', 'o']
常见用法：用于需要按字符操作或将字符串转换为可变序列（列表）以便修改。
⑭format(args, kwargs)。
用途：格式化字符串，将位置参数或命名参数插入到模板字符串中。返回格式化后的新字符串。
占位与参数：
- 使用大括号
{} 作为占位符，内部可以写索引或名称，如 {0}, {name}。 - 支持格式说明符：
{:.2f}、{:>10} 等，用于控制小数位、对齐、填充等。
示例：
# 位置参数"{} + {} = {}".format(1, 2, 3) # "1 + 2 = 3"# 索引与命名参数"{0} {1} {0}".format("A", "B") # "A B A""Name: {name}, Age: {age}".format(name="Alice", age=30)# "Name: Alice, Age: 30"# 格式控制"Pi ≈ {:.3f}".format(3.1415926) # "Pi ≈ 3.142"
补充：Python 3.6 之后常用 f-string（格式化字符串字面量）：
name = "Bob"f"Hello, {name}" # 推荐、直观且性能较好
f-string 与 str.format() 功能相似但语法更简洁；在本章中将同时介绍两者及各自适用场景。
⑮ count(sub[, start[, end]])。
用途：返回子串 sub 在字符串中出现的次数，可选地在 start 到 end 范围内计数（半开区间 [start, end)）。
返回值：出现次数（整数）。
示例：
s = "ababa"print(s.count("a")) # 3print(s.count("aba")) # 1print(s.count("a", 1, 4)) # 1 （在索引 1 到 3 范围内）
注意：count 是非重叠匹配计数（但对于单字符或不重叠的子串，行为直观）。在需要判断某子串是否存在并频次多少时非常方便。
⑯ find(sub[, start[, end]])。
用途：返回子串 sub 第一次出现的位置索引（从 start 开始到 end 结束），若未找到则返回 -1。
返回值：首次出现的索引或 -1。
示例：
s = "hello world"print(s.find("o")) # 4print(s.find("z")) # -1
与 index() 的区别：index() 在未找到时会抛出 ValueError，而 find() 返回 -1 —— 在需要避免异常处理时更安全。
⑰ startswith(prefix[, start[, end]])。
用途：判断字符串是否以指定前缀 prefix 开头；prefix 可以是字符串或字符串元组（多个前缀任一匹配即为真）。可通过 start、end 指定检查范围。
返回值：布尔值 True 或 False。
示例：
s = "python.txt"print(s.startswith("py")) # Trueprint(s.startswith(("py", "ja"))) # Trueprint(s.startswith("t", 2)) # True （从索引2开始）
常见用途：判断文件扩展名、URL 前缀、快速判断字符串类型等。
⑱ endswith(suffix[, start[, end]])。
用途：判断字符串是否以指定后缀 suffix 结尾；参数与 startswith 类似，suffix 可为字符串或元组。
返回值：布尔值。
示例：
filename = "report.pdf"print(filename.endswith(".pdf")) # Trueprint(filename.endswith((".pdf", ".docx"))) # True
常见用途：判断文件类型、URL 是否以特定尾缀结束等。
11. 字符串的其他规则
在掌握常用字符串方法之后，还需要进一步了解字符串的一些重要特性与使用规则。这些内容虽然不属于具体方法调用，但在实际开发中同样具有重要影响，直接关系到字符串的使用方式与程序行为。下面将从字符串的不可变性、特殊运算形式以及格式化方式等方面进行补充说明。
① 不可变性（Immutability）
- 对字符串调用任何方法（如
replace、upper、strip 等）都不会修改原字符串，而是返回一个新的字符串。如果需要保存结果，必须把返回值赋回变量或另存，示例代码如下。
s = "hello"s.upper()print(s) # 仍为 "hello"s = s.upper() # 现在 s -> "HELLO"
这点在阅读代码时非常关键：误以为方法会就地修改字符串，常会导致程序逻辑错误。
- 在 Python 中，字符串是不可变的（immutable）。这意味着，一旦字符串被创建，它的内容就不能被直接修改。任何对字符串“修改”的操作，实际上都会生成一个新的字符串对象，而原有的字符串保持不变。示例代码如下。
s = "Hello"s[0] = "h" # 错误：字符串内容不可修改
- 如果希望改变字符串的内容，只能通过重新赋值来实现，示例代码如下。
s = "Hello"s = "h" + s[1:] # 创建一个新字符串 "hello"print(s) # 输出：hello
这种设计让字符串在多线程或函数调用中更加安全，也方便被缓存和优化，因此几乎所有现代语言（如 Java、JavaScript）都采用类似的机制。
② 字符串与数字的相乘
在 Python 中，字符串和整数之间的“乘法”是一种合法且非常实用的操作。这一特性可能会让来自其他语言的开发者感到惊讶。语法形式如下。
该语句的作用是重复字符串指定的次数，例如：
print("Hi" * 3) # 输出：HiHiHiprint("-" * 10) # 输出：----------
这种写法在生成分隔线、重复输出或格式化输出时非常方便。例如：
title = "Python 字符串"print(title)print("=" * len(title)) # 输出长度匹配的下划线
这比手动拼接字符串更高效、语义更清晰，也是 Python 表达式灵活性的体现。
③ 字符串的格式化方式
在程序中，我们经常需要在字符串中嵌入变量或表达式的值。Python 提供了多种方式实现字符串格式化，其中最常用的有两种：format() 方法和 f-string（格式化字符串字面值）。
format() 方法通过占位符 {} 在字符串中预留位置，然后用 format() 传入的参数进行替换。这个在上文中已经介绍过了。
- 使用 f-string（Python 3.6+ 推荐语法）
f-string 是 Python 3.6 引入的格式化方式，语法更简洁、更高效。在字符串前加 f，并在花括号 {} 中直接嵌入变量或表达式：
name = "David"age = 25print(f"My name is {name} and I am {age} years old.")
甚至可以直接在花括号中计算表达式：
print(f"Next year, I will be {age + 1}.")
输出：
format() 和 f-string 的功能本质相同，都是为了在字符串中插入动态内容。区别在于：
format()- f-string 可读性更高、性能更优，适合现代 Python 开发。
例如，下面两种写法的效果完全相同：
# 使用 format()print("Welcome, {}!".format("Lucy"))# 使用 f-stringname = "Lucy"print(f"Welcome, {name}!")
12. 列表（List）
在 Python 中，列表（List） 是一种用于存储有序数据序列的数据结构。列表中的每个元素都按照插入的顺序被存储和访问，例如：
my_list = [12, "Hello", True]
在其他编程语言中，列表的概念类似于数组（Array），但 Python 的列表更加灵活。它不仅可以存放相同类型的数据，还可以在同一个列表中同时包含整数、字符串、布尔值、甚至其他列表。这种灵活性使得列表成为 Python 中最常用、最强大的数据结构之一。
① 列表的特点。
- 有序性（Ordered）列表中的元素都有固定的顺序，可以通过索引（index）访问。第一个元素的索引是 0，第二个是 1，依此类推。
data = [10, 20, 30]print(data[0]) # 输出 10
- 可变性（Mutable）列表是可变的数据类型，允许在创建后进行修改。例如，可以直接修改某个元素的值：
data[1] = 200print(data) # 输出 [10, 200, 30]
- 可嵌套（Nested）列表中可以再嵌套其他列表，形成“列表的列表”（List of Lists）。这种结构常用于“表示矩阵（Matrix）”或二维数据。例如：
matrix = [ [1, 2, 3], [4, 5, 6], [7, 8, 9]]print(matrix[1][2]) # 输出 6
上述代码定义了一个 3×3 的矩阵，并访问了第二行第三列的元素。
② 列表的常见用途。
- 存储同类数据
- 批量处理
- 矩阵运算：通过列表的嵌套结构，可以实现二维或多维数据的表示和计算。
13. 列表的基本操作
在掌握了列表的基本概念之后，需要进一步了解它的常用操作。Python 提供了许多内置函数与方法，使得对列表的查询、修改、拼接与统计都非常便捷。
① 查看列表长度：len() 函数。
len() 函数用于返回列表中元素的个数。例如：
data = [10, 20, 30, 40]print(len(data)) # 输出 4
无论列表中包含什么类型的元素，len() 都会准确计算元素数量，这在循环遍历或判断列表是否为空时非常有用。
② 索引与切片规则。
与字符串类似，列表的元素也可以通过索引（index）访问。索引从 0 开始，负数索引表示从末尾反向访问：
nums = [1, 2, 3, 4, 5]print(nums[0]) # 输出 1（第一个元素）print(nums[-1]) # 输出 5（最后一个元素）
同样，列表支持切片（slicing）操作，可以提取出子列表：
print(nums[1:4]) # 输出 [2, 3, 4]
③ 统计与查找。
示例：
fruits = ["apple", "banana", "apple", "cherry"]print(fruits.count("apple")) # 输出 2print(fruits.index("banana")) # 输出 1
④ 列表与集合的转换。
使用 set() 函数可以将列表转换为集合，从而去除重复元素。例如：
data = [1, 2, 2, 3, 3, 3]unique = set(data)print(unique) # 输出 {1, 2, 3}
转换为集合后，元素顺序会丢失，因为集合（set）是无序的数据结构。
⑤ 列表拼接与重复。
a = [1, 2]b = [3, 4]c = a + bprint(c) # 输出 [1, 2, 3, 4]
x = ["Hi"]print(x * 3) # 输出 ['Hi', 'Hi', 'Hi']
这种语法在快速生成初始化数据或测试数据时非常实用。
⑥ 可变性（Mutability）。
列表是可变（mutable）的数据类型，这意味着它的内容可以被修改。例如：
items = ["A", "B", "C"]items[1] = "X"print(items) # 输出 ['A', 'X', 'C']
相比之下，字符串（String）是不可变的，无法像列表那样直接修改其中的字符。这也是列表在数据存储和动态处理上比字符串更灵活的重要原因。
14. Python 列表的内置方法
除了基本的索引与切片操作外，Python 还为列表（List）提供了一系列内置方法（Built-in Methods），用于实现插入、删除、清空、排序、反转、复制等常见操作。这些方法使得列表在数据处理、算法实现和结构化存储中都极为灵活。
① insert() —— 在指定位置插入元素。
insert() 方法用于在列表的指定索引处插入一个新元素。语法格式：
list.insert(index, element)
示例：
numbers = [10, 20, 30]numbers.insert(1, 15)print(numbers) # 输出 [10, 15, 20, 30]
插入操作不会覆盖原有元素，而是将其向后顺移。
② remove() —— 删除指定元素。
remove() 方法用于删除列表中第一个匹配的指定值。如果该值不存在，将引发 ValueError 错误。
fruits = ["apple", "banana", "apple", "cherry"]fruits.remove("apple")print(fruits) # 输出 ['banana', 'apple', 'cherry']
③ clear() —— 清空列表。
clear() 方法会删除列表中的所有元素，使其变为空列表。
data = [1, 2, 3]data.clear()print(data) # 输出 []
④ sort() —— 列表排序。
sort() 方法用于对列表进行原地排序（in-place sort），即直接修改原列表的顺序。默认按升序排列，也可通过参数 reverse=True 进行降序排序。
nums = [5, 2, 9, 1]nums.sort()print(nums) # 输出 [1, 2, 5, 9]nums.sort(reverse=True)print(nums) # 输出 [9, 5, 2, 1]
注意：sort() 方法只能用于可以比较的元素，如数字或字符串。
⑤ reverse() —— 反转列表。
reverse() 方法会将列表中元素的顺序反转，同样是原地修改操作。
letters = ["A", "B", "C"]letters.reverse()print(letters) # 输出 ['C', 'B', 'A']
⑥ append() —— 在末尾追加元素。
append() 方法用于在列表的末尾添加一个新元素。
colors = ["red", "green"]colors.append("blue")print(colors) # 输出 ['red', 'green', 'blue']
此方法常用于动态构建列表，如循环中逐步收集数据。
⑦ pop() —— 弹出元素。
pop() 方法用于删除并返回指定索引位置的元素（默认是最后一个）。
data = [10, 20, 30]x = data.pop()print(x) # 输出 30print(data) # 输出 [10, 20]
当需要获取并同时移除元素时，pop() 是非常实用的方法。
⑧ copy() —— 复制列表。
在 Python 中，列表（list）属于引用类型，而非基本数据类型。如果直接通过赋值操作进行复制，实际上只是复制了引用，两者会指向同一块内存区域，例如：
data = [10, 20, 30]x = data.pop()print(x) # 输出 30print(data) # 输出 [10, 20]
要创建真正的副本，应使用 copy() 方法：
a = [1, 2, 3]b = a.copy()b.append(4)print(a) # 输出 [1, 2, 3]print(b) # 输出 [1, 2, 3, 4]
这样即可实现独立的浅拷贝（shallow copy），避免相互影响。
15. 字典（Dictionaries）
在 Python 中，字典（Dictionary） 是一种用于存储无序键值对（key-value pairs）的数据结构。字典中的每个元素由两个部分组成：键（key） 和 值（value），二者通过冒号 : 分隔，多个键值对之间使用逗号 , 分隔。例如：
person = {"name": "Wilson", "age": 25}
在其他编程语言中，字典的概念与 对象（object） 或 映射（map） 类似。Python 字典是可变（mutable）的，这意味着可以在创建后对其内容进行修改、添加或删除。
（1）字典的特点
① 键值映射（Key-Value Mapping）。
字典通过键（key）访问对应的值（value），而不是依靠索引位置。
print(person["name"]) # 输出 Wilson
② 键的唯一性。
字典中的键必须是唯一的；如果定义时出现重复键，后者会覆盖前者的值。
data = {"a": 1, "b": 2, "a": 3}print(data) # 输出 {'a': 3, 'b': 2}
③ 可变性（Mutable）。
字典的内容可以随时修改：
person["age"] = 26print(person) # 输出 {'name': 'Wilson', 'age': 26}
③ 键的类型限制。
键（key）必须是可哈希（hashable）的类型，通常为不可变类型，如字符串、数字或元组。值（value）则没有限制，可以是任意 Python 对象。
（2）字典的常用方法
Python 提供了多种内置方法用于快速访问字典中的键、值和键值对。
① keys()：返回所有键的视图对象。
person = {"name": "Wilson", "age": 25}print(person.keys()) # 输出 dict_keys(['name', 'age'])
② values()：返回所有值的视图对象。
print(person.values()) # 输出 dict_values(['Wilson', 25])
③ items()：返回所有键值对的视图对象。
print(person.items()) # 输出 dict_items([('name', 'Wilson'), ('age', 25)])
这些“视图对象”虽然看起来像列表，但实际上是可迭代的动态视图，会随字典内容的变化而更新。
（3）字典的常见操作
操作 | 示例 | 说明 |
访问值 | person["name"]
| 根据键访问对应的值 |
添加键值对 | person["gender"] = "male"
| 新增键与值 |
修改值 | person["age"] = 26
| 更新已有键对应的值 |
删除键值对 | del person["age"]
| 删除指定键及其对应值 |
判断键是否存在 | "name" in person
| 返回布尔值 |
示例：
person = {"name": "Wilson", "age": 25}person["gender"] = "male" # 添加person["age"] = 26 # 修改del person["name"] # 删除print(person) # 输出 {'age': 26, 'gender': 'male'}
（4）进阶知识：字典的哈希原理
Python 中的字典底层是通过哈希表（hash table）实现的，这意味着它在设计上追求快速查找与插入的性能。
哈希表通过对键（key）进行哈希运算，将其映射到特定的内存位置，从而实现常数时间复杂度 O(1) 的查找。无论字典中存放 10 个还是 10 万个键值对，访问某个键所需的时间几乎不变。
这种高效机制使得字典成为 Python 中最常用的数据结构之一，尤其适合需要快速查询或建立映射关系的场景。例如，学生成绩表、配置项、数据缓存等应用中都能见到字典的身影。
💡 对比说明：
16. 什么可以作为字典的键（Key）
在 Python 的字典（Dictionary）中，键（key） 是用于标识和访问对应值（value）的唯一标识符。由于字典底层基于哈希表（hash table）实现，因此对“键”的使用有严格的限制条件。理解这些限制，是正确使用字典的关键。
① 键必须是不可变的（Immutable）。
所谓不可变，是指对象在创建后，其内容无法被修改。如果键是可变的，那么它的哈希值就可能发生改变，这将导致字典无法准确定位对应的值。
Python 中常见的不可变类型包括：
以上类型都可以安全地用作字典的键。例如：
data = { 1: "one", 3.14: "pi", True: "yes", "name": "Alice", (10, 20): "coordinates"}print(data["name"]) # 输出 Aliceprint(data[(10, 20)]) # 输出 coordinates
② 键必须是可哈希的（Hashable）。
哈希（hashing） 是一种将对象转换为固定长度数值的过程。Python 字典通过哈希值快速定位键的位置，从而实现常数时间复杂度 O(1) 的查找。
一个对象若想作为键，必须满足两个条件：
可哈希对象意味着它能参与哈希计算，并在字典中被唯一识别。例如：
print(hash("hello")) # 输出一个哈希值，例如：696005672print(hash((1, 2, 3))) # 元组也可被哈希
相反，列表（list）、集合（set）等可变对象因为内容可随时改变，无法被哈希，因此不能作为字典键。
data = {}# 以下操作会报错：TypeError: unhashable type: 'list'data[[1, 2]] = "test"
③ 用元组替代列表作为键。
在某些应用场景中，我们希望使用多个值组合来作为键，例如地理坐标（经纬度）、三维坐标点等。由于列表不可哈希，Python 通常使用元组（tuple）来代替：
locations = { (39.90, 116.40): "Beijing", (34.05, -118.24): "Los Angeles"}print(locations[(39.90, 116.40)]) # 输出 Beijing
元组是不可变的，因此它是构建多维键的理想选择。
④ 自定义类型的哈希实现。
在高级用法中，若希望自定义类的对象也能作为字典键，可通过实现 __hash__() 和 __eq__() 方法来自定义哈希规则。例如：
class Point: def __init__(self, x, y): self.x, self.y = x, y def __hash__(self): return hash((self.x, self.y)) # 基于坐标生成哈希值 def __eq__(self, other): return (self.x, self.y) == (other.x, other.y)p1 = Point(1, 2)p2 = Point(1, 2)data = {p1: "A point"}print(data[p2]) # 输出 A point（因为哈希值与比较结果一致）
通过自定义哈希函数，我们可以让自定义对象像内置类型一样作为键使用。
17. 元组（Tuples）
元组（Tuple） 是一种有序且不可变（immutable）的序列类型，用于存储一组不可修改的数据。例如：
t = (10, "100", "Hello")
与列表类似，元组也可以包含不同类型的元素，但与列表不同的是，元组一旦创建就不能修改，这意味着不能添加、删除或更改其中的元素。
① 元组的基本特征。
mixed = (10, "Python", True, 3.14)
print(mixed[1]) # 输出 "Python"
nested = (1, (2, 3), 4)print(nested[1][0]) # 输出 2
② 常用内置函数与方法。
方法/函数 | 功能说明 | 示例 |
len()
| 返回元组中元素的个数 | len(t)→ 3
|
count(x)
| 统计元素 x 出现的次数 | (1, 2, 1, 3).count(1)→ 2
|
index(x)
| 返回元素 x 第一次出现的位置索引 | (1, 2, 3, 2).index(2) → 1
|
set()
| 将元组转换为集合（去除重复） | set((1, 2, 2, 3)) → {1, 2, 3}
|
③ 元组的不可变性。
元组的最大特点是不可变性。创建后不能执行如下操作：
t = (1, 2, 3)t.append(4) # ❌ 报错：tuple 没有 append 方法t.pop() # ❌ 报错：tuple 没有 pop 方法t[0] = 99 # ❌ 报错：元组元素不可修改
④ 使用场景与优势。
- 可以作为字典的键（key）或集合的元素（set element）（因为其不可变）
元组（Tuple）是 Python 中常用的数据结构之一。为了更高效地处理多值数据，Python 提供了元组打包（Tuple Packing）与元组解包（Tuple Unpacking） 这两项非常实用的特性。
18. 元组的打包与解包（Tuple Packing & Unpacking）
① 元组打包（Tuple Packing）。
元组打包 指的是：Python 会自动将多个用逗号分隔的值打包成一个元组。
换句话说，即使不显式加上圆括号 ()，Python 也能识别出一个元组。
# 显式打包t = (10, 20, 30)# 隐式打包（省略括号）t = 10, 20, 30print(t) # 输出 (10, 20, 30)print(type(t)) # 输出 <class 'tuple'>
这种方式常用于同时返回多个值的场景，例如函数返回多个结果时：
def get_point(): return 10, 20 # 自动打包成元组point = get_point()print(point) # 输出 (10, 20)
② 元组解包（Tuple Unpacking）。
元组解包 指的是：将元组中的多个元素，按顺序分别赋值给多个变量。
这是一种非常简洁且高效的写法。
t = (10, 20, 30)a, b, c = t # 解包print(a, b, c) # 输出 10 20 30
如果解包的变量数量与元组元素数量不匹配，会触发 ValueError 异常。
t = (1, 2, 3)a, b = t # ❌ 报错：too many values to unpack
为了解决这种情况，可以使用星号（*）语法接收多余的值：
a, *b = (10, 20, 30, 40)print(a) # 10print(b) # [20, 30, 40]
或仅保留最后一个值：
*a, b = (10, 20, 30, 40)print(a) # [10, 20, 30]print(b) # 40
③ 应用场景示例。
- 在机器学习与数据分析中，元组解包是一项 极为常用的技巧，例如：
# 导入numpy库，用于数值计算与统计分析import numpy as np# 设定随机种子，保证每次运行结果一致np.random.seed(0)# 生成两个长度为5的随机数组x、y，作为相关系数计算的样本数据x, y = np.random.rand(5), np.random.rand(5)# 计算x与y的相关系数矩阵，并提取[0,1]位置的相关系数值# 同时手动设定显著性水平p_value为0.05corr, p_value = np.corrcoef(x, y)[0, 1], 0.05# 输出计算得到的相关系数与设定的显著性水平。print(corr, p_value)
上述代码可能的执行结果：
# 使用 enumerate() 同时遍历列表的索引和对应元素for index, value in enumerate(["A", "B", "C"]): # 输出索引值和对应的元素内容。 print(index, value)
上述代码的输出结果：
19. 集合（Sets）
集合（Set）是 无序且元素唯一 的数据结构，用于存储一组 不重复的对象。在 Python 中，可以使用大括号 {} 或 set() 函数创建集合，例如：
my_set = {"a", "b", 20}print(my_set) # 输出：{'a', 'b', 20}print(type(my_set)) # 输出：<class 'set'>
集合中的每个元素都必须是 可哈希（hashable） 的，也就是说，它们的内容在生命周期中不可改变。因此，整数、字符串、元组等都可以作为集合元素，但列表、字典等可变对象则不行。
（1）集合的特点
① 无序性（Unordered）。
集合中的元素没有固定顺序，因此不能通过索引访问。
② 唯一性（Unique Elements）。
集合会自动去重。例如：
s = {1, 2, 1, 3}print(s) # 输出：{1, 2, 3}
③ 可变性（Mutable）。
集合本身是可变的，可以添加或删除元素。
④ 数学特性。
Python 集合的设计借鉴了 离散数学（Discrete Mathematics） 的集合概念，因此它支持交集、并集、差集等数学运算。
（2）常用的集合内置方法
方法 | 功能说明 | 示例 |
add(elem)
| 向集合中添加元素，若元素已存在则忽略 | s.add("x")
|
clear()
| 清空集合所有元素，使其变为空集 | s.clear()
|
copy()
| 返回集合的浅拷贝 | new_s = s.copy()
|
discard(elem)
| 移除指定元素，若不存在不报错 | s.discard("y")
|
remove(elem)
| 移除指定元素，若不存在则报错 | s.remove("y")
|
pop()
| 随机移除一个元素（集合无序，无法指定） | s.pop()
|
（3）集合的数学运算方法
Python 集合支持多种 数学集合运算，如下表所示：
运算类型 | 方法 | 含义 | 示例 |
并集（Union） | union()
| 合并两个集合的所有元素（去重） | a.union(b)
或 a | b |
交集（Intersection） | intersection()
| 取两个集合的公共元素 | a.intersection(b)
或 a & b |
差集（Difference） | difference()
| 取当前集合中有、其他集合中没有的元素 | a.difference(b)
或 a - b |
对称差集（Symmetric Difference） | symmetric_difference()
| 取只存在于一个集合中的元素 | a.symmetric_difference(b)
或 a ^ b |
子集判断 | issubset()
| 判断当前集合是否为另一个集合的子集 | a.issubset(b)
或 a <= b |
超集判断 | issuperset()
| 判断当前集合是否包含另一个集合 | a.issuperset(b)
或 a >= b |
不相交判断 | isdisjoint()
| 判断两个集合是否没有交集 | a.isdisjoint(b)
|
（4）示例代码
A = {1, 2, 3, 4}B = {3, 4, 5, 6}print(A.union(B)) # 并集：{1, 2, 3, 4, 5, 6}print(a | b) # 并集：{1, 2, 3, 4, 5, 6}print(A.intersection(B)) # 交集：{3, 4}print(A.difference(B)) # 差集：{1, 2}print(A.symmetric_difference(B)) # 对称差集：{1, 2, 5, 6}
（5）应用场景举例
集合在实际开发中应用广泛，例如：
names = ["Alice", "Bob", "Alice", "Tom"]unique_names = set(names)print(unique_names) # {'Alice', 'Bob', 'Tom'}
s = {"python", "java", "c++"}print("python" in s) # True
# 比较两位学生喜欢的编程语言stu1 = {"Python", "C++", "Java"}stu2 = {"Python", "Go", "Rust"}print(stu1 & stu2) # 两人共同喜欢：{'Python'}
20. 布尔类型（Boolean）
在编程中，我们经常需要判断某件事情的结果是“真（True）”还是“假（False）”。
例如，在一个电影院售票系统中，我们可能会设置如下规则：
height = 110if height < 120: print("免费入场")else: print("票价：100元")
在这个示例中，表达式 height < 120 的计算结果是一个 布尔值（Boolean），其取值只有两种可能：
布尔类型是 Python 中的一种基本数据类型，用于表示逻辑判断的结果。
① 布尔值的基本概念。
Python 中的布尔类型只有两个常量：
务必注意，它们的 首字母必须大写。
例如：
is_adult = Truehas_ticket = False
如果误写为 true 或 false，Python 会提示错误：
>>> trueNameError: name 'true' is not defined
② 布尔类型的来源。
实际上，Python 的布尔类型是从整数类型（int）派生而来：
print(isinstance(True, int)) # 输出：Trueprint(True == 1) # 输出：Trueprint(False == 0) # 输出：True
这意味着布尔值可以参与数值运算：
print(True + True + False) # 输出：2
③ 常见的布尔运算。
运算符 | 含义 | 示例 | 结果 |
==
| 判断相等 | 3 == 3
| True
|
!=
| 判断不等 | 3 != 4
| True
|
< 、>
| 判断大小 | 5 > 2
| True
|
<= 、>=
| 判断大小关系 | 6 >= 6
| True
|
and
| 逻辑与（同时为真） | True and False
| False
|
or
| 逻辑或（任一为真） | True or False
| True
|
not
| 逻辑非（取反） | not True
| False
|
这些运算通常用于控制语句（如 if、while）中，用来决定程序的执行路径。
④ 布尔值的隐式转换。
在 Python 中，任何对象都可以被转换为布尔值。以下对象在布尔上下文中被视为 False：
0（整数零）0.0（浮点数零）''（空字符串）[]（空列表）{}（空字典）set()（空集合）None
其他所有对象都被视为 True。
例如：
print(bool(0)) # Falseprint(bool("")) # Falseprint(bool([1])) # Trueprint(bool("Hi")) # Tru⑤ 为什么 True 和 False 必须首字母大写？
在 Python 中，保持语言内部一致性 是首要设计原则之一。所有内置常量（如 None、True、False）的首字母均采用 大写形式，以与变量区分。这也是 Python 与许多其他语言（如 JavaScript 的 true、false）在语法风格上的区别。
官方文档对此有明确说明，可参考：📘Python 官方文档 - Built-in Constants
21. Python 中的注释（Comments）
在编程过程中，注释（Comment） 是一种非常重要的书写习惯。它不会被 Python 解释器执行，主要用于解释代码逻辑、记录设计意图或提示使用方法。
编写高质量注释不仅能帮助自己更好地理解代码，也能让他人更轻松地维护与协作。
① 为什么需要注释？
当你在几个月后回看旧代码时，注释可以帮助你快速回忆代码的逻辑和设计思路。在团队开发中，代码常由多人共同维护。清晰的注释能让团队成员更快理解你的意图，减少沟通成本。如果你将代码发布到 GitHub、Gitee 等平台，良好的注释能让他人更容易理解并复用你的代码。② 单行注释（Single-line Comment）。
在 Python 中，单行注释 以井号 # 开头，解释器会忽略该符号后的所有内容。
# 这是一个单行注释name = "Alice" # 给变量赋值
✅提示：在 VS Code 中，可选中要注释的代码，按下快捷键：
- Windows / Linux：
Ctrl + / - macOS：
Command + /
即可快速为多行代码添加或取消注释。
③ 多行注释（Multi-line Comment）。
Python 没有专门的多行注释语法，但可以使用 三个引号（''' 或 """） 包裹多行文本，实现类似效果：
'''这是一个多行注释的示例可用于解释模块、函数或复杂逻辑'''print("Hello, Python!")
这种写法常用于 文档说明（Documentation） 或 函数说明（Docstring），例如：
def greet(name): """ 函数说明： greet(name) 用于打印问候语。 参数： name (str)：用户名。 返回： 无 """ print(f"Hello, {name}!")
④ 文档字符串（Docstring）。
Python 中的函数、类与模块都支持 文档字符串（Docstring），用于描述其用途、参数与返回值。Docstring 通常写在函数或类定义的首行，并使用三引号包裹。
示例：
def add(a, b): """返回两个数的和。""" return a + bprint(add.__doc__) # 输出：返回两个数的和。
💡建议：
- Docstring 用于函数、类或模块说明，是编写专业 Python 代码的必要习惯。
22. 类型检查（Type Checking）
在 Python 中，声明变量时无需指定数据类型。
这与 Java、C 等静态类型语言不同——在那些语言中，变量在声明时必须明确数据类型，而 Python 属于 动态类型语言（Dynamically Typed Language），变量类型会根据赋值内容自动推断。
例如：
x = 10 # 整数类型（int）y = "Python" # 字符串类型（str）z = 3.14 # 浮点数类型（float）
在编写代码时，这种灵活性让开发更加简洁，但有时也会带来一个问题：
“我们并不总能清楚变量当前是什么类型。”
为了解决这个问题，Python 提供了一个非常实用的内置函数——type()。
① type() 函数的基本用法。
type() 是 Python 的内置类型检查函数，用于 返回对象所属的数据类型。
基本语法如下：
其中：
object- 函数返回一个 类型对象（type object）。
示例：
a = 123b = "Hello"c = 3.14d = Trueprint(type(a)) # <class 'int'>print(type(b)) # <class 'str'>print(type(c)) # <class 'float'>print(type(d)) # <class 'bool'>
输出结果表明，type() 会返回对象对应的类型名称，例如 int、str、float、bool 等。
② type() 函数的典型应用场景。
user_input = input("请输入数字：")print(type(user_input)) # 输出：<class 'str'>
尽管输入的是数字，但 input() 函数总是返回字符串类型，因此在使用前通常需要类型转换。
data = [1, 2, 3]if type(data) == list: print("这是一个列表")
相比直接比较 type，更推荐使用 isinstance() 进行类型判断。
student = {"name": "Alice", "age": 18}print(type(student)) # <class 'dict'>
③ 与 isinstance() 的区别。
虽然 type() 可以判断变量类型，但在实际开发中，Python 更推荐使用 isinstance() 进行类型检测。
区别如下：
对比项 | type() | isinstance() |
判断精度 | 严格判断（类型必须完全匹配） | 支持继承判断（子类对象也可通过） |
推荐程度 | 一般用于调试、查看类型 | 推荐用于逻辑判断 |
示例 | type(x) == int
| isinstance(x, int)
|
示例说明：
class Animal: passclass Dog(Animal): passdog = Dog()print(type(dog) == Animal) # Falseprint(isinstance(dog, Animal)) # True ✅
23. 数据类型的其他信息
（1）复数（Complex Numbers）
在 Python 中，复数由实部与虚部组成，语法形式为：
其中：
a 是实部（real part），可以是整数或浮点数；b 是虚部（imaginary part）前的系数，j 表示虚数单位，等价于数学中的 √(−1)。
例如：
z = 3 + 2jw = 8 - 5jresult = z + wprint(result) # 输出 (11 - 3j)
Python 使用 j（而不是其他语言常用的 i）来表示虚数单位。
复数在科学计算、信号处理等领域非常常见，例如在 NumPy 中用于傅里叶变换等运算。
（2）None 类型
除了常见的数值、字符串、布尔值等类型，Python 还提供了一种特殊类型：None。
None 表示 “空” 或 “无值”，通常用于以下几种场景：
示例：
def hello(): print("Hello, Python!")result = hello() # 函数未返回任何内容print(result) # 输出 None
（3）函数引用与函数调用的区别
若定义了一个函数：
def hello(): return "Hello, World!"
print(hello)👉 输出函数对象的内存地址，例如：<function hello at 0x7f93f80ce280>这是函数在内存中的引用，而不是执行结果。print(hello())👉 正确调用函数，执行后输出：Hello, World!
这一区别在调试与传递函数参数时尤其重要。
（4）浮点数的精度问题（Floating Point Precision）
在 Python 中执行如下运算：
你可能直觉上认为结果应为 0，但实际输出为：
这是一个非常接近 0 的极小数。原因在于：二进制浮点数无法精确表示所有十进制小数。
例如，十进制的 0.1 在二进制中是一个无限循环小数，因此 Python 只能以近似值进行存储与计算。这种情况不仅出现在 Python 中，C、Java、JavaScript 等语言也存在相同的问题。
若需要精确的小数计算（如货币、财务运算），应使用：
from decimal import Decimalprint(Decimal('0.1') + Decimal('0.2') - Decimal('0.3')) # 输出 0.0
（5）一切皆对象（Everything is an Object）
Python 是一门面向对象（Object-Oriented）的语言。
这意味着：在 Python 中，一切数据都是对象，包括数字、字符串、列表、字典，甚至函数与模块。
每个对象都包含：
- 属性（Attributes）
- 方法（Methods）
举例：
name = "Python"print(name.upper()) # 输出 'PYTHON'
这里，字符串对象 name 拥有一个名为 .upper() 的方法，用于将字母转换为大写。同样，列表、字典、集合等类型也都有各自的方法与行为。
就像现实中的对象（汽车能行驶、手机能响铃）一样，Python 中的对象也能“做事”，这正是面向对象编程的核心思想。
（6）join() 方法的应用
join() 是字符串对象的一个常用方法，用于将一个可迭代对象（如列表、元组、集合）中的所有元素拼接成一个新的字符串。
语法：
示例：
words = ["Python", "is", "fun"]sentence = " ".join(words)print(sentence) # 输出：Python is fun
该方法在需要将多个字符串合并时非常高效，尤其是在从 列表、元组、集合 生成字符串的场景中常被使用。
24. 按值复制与按引用复制（Copy by Value or Reference）
在 Python 中，给变量赋值时，变量存储的并非值本身，而是对象或对象引用。
根据赋值方式不同，Python 的赋值可以分为 按值复制（Copy by Value） 和 按引用复制（Copy by Reference）。
① 按值复制（Copy by Value）。
按值复制指的是：
适用的数据类型主要是 不可变类型：
示例：
a = 10b = a # 按值复制b += 5print(a) # 10print(b) # 15
这里，a 与 b 分别指向不同的整数对象，修改 b 并不会影响 a。
② 按引用复制（Copy by Reference）。
按引用复制指的是：
适用的数据类型主要是 可变类型：
示例：
lst1 = [1, 2, 3]lst2 = lst1 # 按引用复制lst2.append(4)print(lst1) # [1, 2, 3, 4]print(lst2) # [1, 2, 3, 4]
可以看到，修改 lst2 同时也改变了 lst1，因为它们指向同一个列表对象。
③ 创建对象副本（Copying Objects）。
为了避免引用共享带来的副作用，可使用复制方法：
适用于列表、字典、集合，可创建对象的新副本，但只复制一层结构。
lst1 = [1, 2, 3]lst2 = lst1.copy() # 浅拷贝lst2.append(4)print(lst1) # [1, 2, 3]print(lst2) # [1, 2, 3, 4]
适用于元组或嵌套数据结构，需要使用 deepcopy() 函数：
from copy import deepcopyt1 = ([1, 2], [3, 4])t2 = deepcopy(t1)t2[0].append(99)print(t1) # ([1, 2], [3, 4])print(t2) # ([1, 2, 99], [3, 4])
💡注意：
- 元组本身是不可变的，但若元组中包含可变对象（如列表），按引用复制会导致嵌套对象共享；
deepcopy()
25. 排序（Sort）与 sorted() 函数
在编程中，排序是一项非常常见的操作。Python 提供了多种方式对数据进行排序，但需要注意的是：可变对象和不可变对象的排序方式不同。
① 列表的内置方法 sort()。
列表（list）是可变对象，因此可以使用 列表自身的 sort() 方法 对其进行排序。
numbers = [5, 2, 9, 1]numbers.sort() # 直接修改原列表print(numbers) # [1, 2, 5, 9]
示例（降序排序）：
numbers = [5, 2, 9, 1]numbers.sort(reverse=True)print(numbers) # [9, 5, 2, 1]
② 不可变对象与 sorted() 函数。
对于 不可变数据类型（如元组、字符串）以及其他可迭代对象（如集合、字典的键或值），它们 没有内置的排序方法。
Python 提供了一个内置函数 sorted()，可以从任何可迭代对象生成一个 新的排序后的列表，并且不会修改原始数据。
# 元组排序t = (4, 1, 7, 3)sorted_t = sorted(t)print(sorted_t) # [1, 3, 4, 7]print(t) # (4, 1, 7, 3)# 字符串排序s = "python"sorted_s = sorted(s)print(sorted_s) # ['h', 'n', 'o', 'p', 't', 'y']# 集合排序set_data = {5, 2, 9, 1}sorted_set = sorted(set_data)print(sorted_set) # [1, 2, 5, 9]
⚡ 特点总结：
sorted()不会修改原对象- 无论原对象是否可变，
sorted() 都会返回一个 新列表； - 同样支持
reverse=True 与 key=函数名 参数。
③ 结合 key 参数的排序示例。
key 参数可以指定一个函数，用于从元素中提取用于排序的关键值。例如，对字符串按长度排序：
words = ["apple", "banana", "fig", "cherry"]sorted_words = sorted(words, key=len)print(sorted_words) # ['fig', 'apple', 'banana', 'cherry']
26. Python 中的成员运算符
在编程中，我们经常需要判断某个元素是否存在于一个序列或集合中。Python 提供了 成员运算符（Membership Operators） 来实现这一功能，使判断操作简单而高效。
① 成员运算符概览。
运算符 | 描述 |
in
| 若元素存在于指定序列中，返回 True；否则返回 False |
not in
| 若元素不存在于指定序列中，返回 True；否则返回 False |
⚡ 注意：成员运算符可用于所有 序列类型 和 集合类型，包括字符串、列表、元组、字典和集合。
② 示例演示。
text = "Python"print("y" in text) # Trueprint("z" not in text) # True
numbers = [1, 2, 3, 4, 5]print(3 in numbers) # Trueprint(6 not in numbers) # True
colors = ("red", "green", "blue")print("green" in colors) # Trueprint("yellow" not in colors) # True
student = {"name": "Alice", "age": 18}print("name" in student) # Trueprint("Alice" in student) # False，字典默认检查键而非值
fruits = {"apple", "banana", "cherry"}print("banana" in fruits) # Trueprint("orange" not in fruits) # True
③ 成员运算符的优势。
💡 如果没有成员运算符，你可能需要借助循环或算法判断元素是否存在于序列中，这会繁琐且易出错。
27. 本章小结
本章系统介绍了 Python 中的数据类型体系及其核心使用方式。首先，从编程基础出发，阐述了数据类型在程序设计中的重要性，并说明了 Python 的基本语法规则，如大小写敏感性、缩进结构及代码块划分方式。随后，对常见数据类型进行了整体概述，明确了基础类型与容器类型的分类，以及按值复制与按引用复制的区别。
在具体内容上，本章重点讲解了数字类型及其运算规则、常用内置函数与 math 模块的使用；结合变量与赋值，帮助读者理解数据在内存中的存储与变化机制。针对字符串，系统介绍了其基本特性、拼接方式、内置方法以及不可变性等关键规则，并补充了格式化输出与特殊操作技巧。
在数据结构部分，详细分析了列表、字典、元组与集合的定义方式、核心特征及典型应用场景，重点强调了可变与不可变对象的差异及其对程序行为的影响。同时，通过字典键的限制、元组的打包与解包、集合的数学运算等内容，进一步深化了对数据结构的理解。
此外，本章还介绍了布尔类型与逻辑运算、注释规范、类型检查方法（type 与 isinstance）、以及复数、None、浮点精度等补充知识，并对排序操作（sort 与 sorted）及成员运算符的使用进行了说明。
通过本章的学习，读者应能够全面掌握 Python 数据类型的基本概念、常用操作及其底层特性，为后续控制结构、函数设计及面向对象编程等内容的学习奠定坚实基础。
