本章掌握 Python 的基础语法规则与常用数据类型，重点记忆关键语法细节，为后续编码实践奠定基础。

1. Python 数据类型简介

关键语法规则：

• 大小写敏感性
  Python 是区分大小写的编程语言。
  例如，变量名age与Age会被识别为两个不同的变量，不可混淆使用。
• 代码块标识方式
  Python 通过缩进来划分代码块，这与其他多数编程语言不同。
  其他语言通常使用分号（;）结尾语句、花括号（{}）包裹代码块。
• 缩进规范
  缩进可使用制表符（Tab）或空格，两者均可。
  常规约定中，1 个制表符的长度等同于 4 个空格。
  必须保持缩进方式完全一致，否则会触发 “IndentationError: unindent does not match any outer indentation level.”（缩进错误：取消缩进与任何外层缩进级别不匹配）。

2. Python 常用数据类型概述

在 Python 中，数据类型（Data Type） 是变量存储数据的形式，它决定了变量在内存中的表现方式以及可进行的操作类型。Python 是一种动态类型语言，变量在定义时无需显式声明类型，解释器会根据赋值内容自动推断。
下面表格列出了 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 = 10
b = a
b = 20
print(a)  # 输出 10，不受影响

# 容器类型：引用复制
x = [1, 2, 3]
y = x
y.append(4)
print(x)  # 输出 [1, 2, 3, 4]，原列表被修改

上例中，int 类型变量 a 和 b 是独立的内存副本；而 list 类型变量 x 和 y 实际上指向同一个列表对象，因此当 y 发生修改时，x 也随之改变。

Python 的这种数据类型设计既提供了灵活性，也要求开发者在编写程序时关注可变与不可变对象的差异，以避免在函数传参或数据共享时出现意外的逻辑错误。

3. 数字类型（Number）

数字是 Python 中最常用的数据类型之一，主要分为两种：整数（int）和浮点数（float）。

• 整数用于表示没有小数点的数值，如 -5、0、42。
• 浮点数用于表示带有小数点的数值，如 3.14、0.5、-2.75。

Python 支持丰富的数值运算，包括：

• 加法（+）：如 3 + 2，结果为 5
• 减法（-）：如 5 - 2，结果为 3
• 乘法（*）：如 4 * 3，结果为 12
• 除法（/）：如 10 / 4，结果为 2.5
• 取余（%）：如 10 % 3，结果为 1
• 幂运算（**）：如 2 ** 3，结果为 8

示例代码如下：

a = 10
b = 3

print(a + b)   # 加法：13
print(a - b)   # 减法：7
print(a * b)   # 乘法：30
print(a / b)   # 除法：3.333...
print(a % b)   # 取余：1
print(a ** b)  # 幂运算：1000

通过这些基本的算术运算，Python 可以方便地完成从日常计算到复杂数学建模等多种任务。

4. 函数（Function）

如果你是编程初学者，不妨先从“函数”这个概念开始。
在 Python 中，函数（Function）就像数学中的函数一样，用来接收输入并产生输出。
回想一下数学课上的例子：

f(x)=3x+6

在这个公式中，f 是函数名，x 是输入（参数），而 3x + 6 的结果就是输出。每次给出一个输入值 x，就会得到唯一的输出结果。

同样的道理，在 Python 中，函数也具有类似的结构。一个函数可以接收输入参数，也可以没有输入参数；它可以返回一个输出值，也可以不返回值。函数的作用就是把一段可以重复使用的逻辑封装起来，方便在程序中多次调用。

例如：

def add(x, y):
    return x + y

result = add(3, 5)
print(result)  # 输出 8

在上面的代码中：

• def 是定义函数的关键字；
• add 是函数名；
• x 和 y 是函数的输入参数；
• return 表示函数的输出结果。

通过定义函数，我们可以让代码更加简洁、清晰、易于维护，也能避免重复编写相同的逻辑。

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 还提供了三个常用的类型转换函数：

• str(x)：将数字 x 转换为字符串类型。
• int(x)：将数值或可转换的字符串转换为整数类型。
• float(x)：将数值或可转换的字符串转换为浮点数类型。

示例：

num = -4.7

print(abs(num))            # 输出 4.7
print(pow(2, 5))           # 输出 32
print(max(10, 20, 5))      # 输出 20
print(round(3.14159, 2))   # 输出 3.14

print(str(100))            # 输出 "100"
print(int(3.6))            # 输出 3
print(float("2.5"))        # 输出 2.5

这些内置方法使数字的处理更加灵活，既能方便地进行数学计算，也能完成不同类型之间的转换，为后续编程打下坚实的基础。

6. 数学模块（Math Module）

在 Python 中，除了内置的数值运算和函数外，还有许多功能更强大的数学方法需要借助 数学模块（math） 才能使用。

所谓模块（Module），可以理解为一个功能集合，它将一组相关的函数、常量和类组织在一起，方便我们在程序中直接调用。关于模块的详细用法，我们将在后续章节中深入介绍。这里先重点了解数学模块中一些常用的常量和方法。

① 常用常量：

• math.e：自然常数，约等于 2.718。
• math.pi：圆周率常数，约等于 3.14159。

② 常用方法：

• math.floor(x)：向下取整，返回小于或等于 x 的最大整数。
• math.ceil(x)：向上取整，返回大于或等于 x 的最小整数。
• math.sqrt(x)：返回 x 的平方根。

示例代码如下：

import math

print(math.e)        # 输出 2.718281828459045
print(math.pi)       # 输出 3.141592653589793

num = 9.8
print(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 = 5
x = x + 1
print(x)

执行后，变量 x 的结果为 6。
这是因为第二行代码表示“取出当前的 x 值（即 5），加上 1，再把结果存回变量 x 中”。

Python 还提供了一种更简洁的写法，称为语法糖（Syntax Sugar），可以把 x = x + 1 简化为：

x += 1

这两种写法效果完全相同，只是后者更加简洁高效。类似的还有：

• x -= 1 表示 x = x - 1
• x *= 2 表示 x = x * 2
• x /= 3 表示 x = x / 3

这种复合赋值运算符在实际编程中非常常见，既能让代码更短，也能提升可读性。

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 时，会将其后的内容输出到下一行。

示例：

print("Hello\nWorld")

输出结果为：

Hello
World

这在格式化输出或打印多行文本时非常实用。

② 使用加号 + 进行拼接。

如果在两个字符串之间使用加号 +，Python 会将它们拼接成一个新的字符串。

示例：

greeting = "Hello"
name = "Alice"
message = greeting + " " + name
print(message)

输出结果为：

Hello Alice

③ 字符串与数字的拼接。

需要注意的是，在 Python 中字符串和数字不能直接拼接。
以下代码会报错：

age = 18
print("I am " + age + " years old")  # ❌ 错误

正确的做法是先将数字转换为字符串：

age = 18
print("I am " + str(age) + " years old")  # ✅ 正确

④ 字符串的不可变性（Immutable）。

Python 中的字符串是不可变的（immutable），也就是说，一旦字符串被创建，其内容就无法被直接修改。
当我们进行拼接操作时，其实是生成了一个新的字符串对象，而不是在原字符串上修改内容。

示例：

text = "Hello"
text += " World"
print(text)  # 实际上创建了一个新的字符串 "Hello World"

理解这一特性对于编写高效的 Python 程序非常重要，尤其是在处理大量字符串拼接的场景中，应优先考虑使用 join() 或格式化字符串（如 f-string）来提升性能。

10. 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 = 18
print("I am " + str(age) + " years old.")  
# 输出：I am 18 years old.

在字符串拼接时常用此方法。

⑥ upper()。

作用： 将字符串中的所有字母转换为大写。

text = "hello"
print(text.upper())   # 输出 HELLO

⑦ lower()。

作用： 将字符串中的所有字母转换为小写。

text = "PYTHON"
print(text.lower())   # 输出 python

⑧ isupper()。

作用： 判断字符串是否全为大写字母，返回布尔值（True / False）。

text1 = "HELLO"
text2 = "Hello"
print(text1.isupper())   # 输出 True
print(text2.isupper())   # 输出 False

⑨ index()。

作用： 返回指定字符（或子字符串）在字符串中第一次出现的位置索引。

text = "Python Programming"
print(text.index("P"))     # 输出 0
print(text.index("gram"))  # 输出 10

⚠️ 如果未找到匹配项，会抛出 ValueError 异常。

⑪ replace(old, new[, count])。

用途：返回一个新字符串，将原字符串中出现的 old 子串全部（或最多 count 次）替换为 new。

参数

• old：要被替换的子串（必需）。
• new：替换成的子串（必需）。
• count：可选，指定最多替换多少次（从左到右）。

返回值：替换后的新字符串（原字符串不变）。

示例：

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"))       # 3
print(s.count("aba"))     # 1
print(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"))    # 4
print(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"))            # True
print(s.startswith(("py", "ja")))    # True
print(s.startswith("t", 2))          # True （从索引2开始）

常见用途：判断文件扩展名、URL 前缀、快速判断字符串类型等。

⑱ endswith(suffix[, start[, end]])。

用途：判断字符串是否以指定后缀 suffix 结尾；参数与 startswith 类似，suffix 可为字符串或元组。

返回值：布尔值。

示例：

filename = "report.pdf"
print(filename.endswith(".pdf"))      # True
print(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)     # 输出：HiHiHi
print("-" * 10)     # 输出：----------

这种写法在生成分隔线、重复输出或格式化输出时非常方便。例如：

title = "Python 字符串"
print(title)
print("=" * len(title))   # 输出长度匹配的下划线

这比手动拼接字符串更高效、语义更清晰，也是 Python 表达式灵活性的体现。

③ 字符串的格式化方式

在程序中，我们经常需要在字符串中嵌入变量或表达式的值。Python 提供了多种方式实现字符串格式化，其中最常用的有两种：format() 方法和 f-string（格式化字符串字面值）。

• 使用 format() 方法

format() 方法通过占位符 {} 在字符串中预留位置，然后用 format() 传入的参数进行替换：

name = "Alice"
age = 20
print("My name is {} and I am {} years old.".format(name, age))

输出：

My name is Alice and I am 20 years old.

这种方式可以通过位置或关键字参数控制插入顺序：

print("Name: {0}, Age: {1}".format("Bob", 18))
print("Name: {name}, Age: {age}".format(name="Carol", age=22))

• 使用 f-string（Python 3.6+ 推荐语法）

f-string 是 Python 3.6 引入的格式化方式，语法更简洁、更高效。在字符串前加 f，并在花括号 {} 中直接嵌入变量或表达式：

name = "David"
age = 25
print(f"My name is {name} and I am {age} years old.")

甚至可以直接在花括号中计算表达式：

print(f"Next year, I will be {age + 1}.")

输出：

Next year, I will be 26.

• format() 与 f-string 的区别

format() 和 f-string 的功能本质相同，都是为了在字符串中插入动态内容。
区别在于：

• • format() 可用于早期 Python 版本（兼容性更好）；
  • f-string 可读性更高、性能更优，适合现代 Python 开发。

例如，下面两种写法的效果完全相同：

# 使用 format()
print("Welcome, {}!".format("Lucy"))

# 使用 f-string
name = "Lucy"
print(f"Welcome, {name}!")

在 Python 中，列表（List） 是一种用于存储有序数据序列的数据结构。列表中的每个元素都按照插入的顺序被存储和访问，例如：

my_list = [12, "Hello", True]

在其他编程语言中，列表的概念类似于数组（Array），但 Python 的列表更加灵活。它不仅可以存放相同类型的数据，还可以在同一个列表中同时包含整数、字符串、布尔值、甚至其他列表。
这种灵活性使得列表成为 Python 中最常用、最强大的数据结构之一。

12. 列表（List）

① 列表的特点。

• 有序性（Ordered）
  列表中的元素都有固定的顺序，可以通过索引（index）访问。第一个元素的索引是 0，第二个是 1，依此类推。

data = [10, 20, 30]
print(data[0])  # 输出 10

• 可变性（Mutable）
  列表是可变的数据类型，允许在创建后进行修改。例如，我们可以直接修改某个元素的值：

data[1] = 200
print(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]

③ 统计与查找。

• count() 方法：用于统计指定元素在列表中出现的次数。
• index() 方法：用于返回指定元素第一次出现的位置索引。

示例：

fruits = ["apple", "banana", "apple", "cherry"]
print(fruits.count("apple"))  # 输出 2
print(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 + b
print(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)      # 输出 30
print(data)   # 输出 [10, 20]

当需要获取并同时移除元素时，pop() 是非常实用的方法。

⑧ copy() —— 复制列表。

在 Python 中，列表（list）属于引用类型，而非基本数据类型。如果直接通过赋值操作进行复制，实际上只是复制了引用，两者会指向同一块内存区域：

a = [1, 2, 3]
b = a
b.append(4)
print(a)  # 输出 [1, 2, 3, 4]（a 也被修改了）

要创建真正的副本，应使用 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"] = 26
print(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 中最常用的数据结构之一，尤其适合需要快速查询或建立映射关系的场景。
例如，学生成绩表、配置项、数据缓存等应用中都能见到字典的身影。

💡 对比说明：

• 字典查找：通过哈希计算定位 → 时间复杂度 O(1)
• 列表查找：通过逐项遍历索引 → 时间复杂度 O(n)

16. 什么可以作为字典的键（Key）

在 Python 的字典（Dictionary）中，键（key） 是用于标识和访问对应值（value）的唯一标识符。
由于字典底层基于哈希表（hash table）实现，因此对“键”的使用有严格的限制条件。理解这些限制，是正确使用字典的关键。

① 键必须是不可变的（Immutable）。

所谓不可变，是指对象在创建后，其内容无法被修改。
如果键是可变的，那么它的哈希值就可能发生改变，这将导致字典无法准确定位对应的值。

Python 中常见的不可变类型包括：

• 整数（int）
• 浮点数（float）
• 布尔值（bool）
• 字符串（str）
• 元组（tuple）

以上类型都可以安全地用作字典的键。
例如：

data = {
    1: "one",
    3.14: "pi",
    True: "yes",
    "name": "Alice",
    (10, 20): "coordinates"
}
print(data["name"])     # 输出 Alice
print(data[(10, 20)])   # 输出 coordinates

② 键必须是可哈希的（Hashable）。

哈希（hashing） 是一种将对象转换为固定长度数值的过程。
Python 字典通过哈希值快速定位键的位置，从而实现常数时间复杂度 O(1) 的查找。

一个对象若想作为键，必须满足两个条件：

• 该对象在生命周期中哈希值不会改变；
• 它实现了 __hash__() 方法。

可哈希对象意味着它能参与哈希计算，并在字典中被唯一识别。
例如：

print(hash("hello"))  # 输出一个哈希值，例如：696005672
print(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")

与列表类似，元组也可以包含不同类型的元素，但与列表不同的是，元组一旦创建就不能修改，这意味着不能添加、删除或更改其中的元素。

① 元组的基本特征。

• 使用圆括号 () 定义

numbers = (1, 2, 3)

• 支持不同类型的元素

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, 30

print(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)  # 10
print(b)  # [20, 30, 40]

或仅保留最后一个值：

*a, b = (10, 20, 30, 40)
print(a)  # [10, 20, 30]
print(b)  # 40

③ 应用场景示例。

在机器学习与数据分析中，元组解包是一项极为常用的技巧，例如：

# 同时返回多个结果
import numpy as np

x, y = np.random.rand(5), np.random.rand(5)
corr, p_value = np.corrcoef(x, y)[0, 1], 0.05  # 解包计算结果
print(corr, p_value)

或在循环中同时遍历索引与值：

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
交集（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.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 = 110

if height < 120:
    print("免费入场")
else:
    print("票价：100元")

在这个示例中，表达式 height < 120 的计算结果是一个 布尔值（Boolean），其取值只有两种可能：

• True —— 表示条件成立（真）
• False —— 表示条件不成立（假）

布尔类型是 Python 中的一种基本数据类型，用于表示逻辑判断的结果。

① 布尔值的基本概念。

Python 中的布尔类型只有两个常量：

True
False

务必注意，它们的 首字母必须大写。

例如：

is_adult = True
has_ticket = False

如果误写为 true 或 false，Python 会提示错误：

>>> true
NameError: name 'true' is not defined

② 布尔类型的来源。

实际上，Python 的布尔类型是从整数类型（int）派生而来：

print(isinstance(True, int))  # 输出：True
print(True == 1)              # 输出：True
print(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))      # False
print(bool(""))     # False
print(bool([1]))    # True
print(bool("Hi"))   # True

⑤ 为什么 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 + b

print(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 的内置类型检查函数，用于 返回对象所属的数据类型。

基本语法如下：

type(object)

其中：

• object 表示要检测的变量或值；
• 函数返回一个 类型对象（type object）。

示例：

a = 123
b = "Hello"
c = 3.14
d = True

print(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("这是一个列表")

⚠️ 不过，更推荐使用 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:
    pass

class Dog(Animal):
    pass

dog = Dog()

print(type(dog) == Animal)       # False
print(isinstance(dog, Animal))   # True ✅

23. 补充信息

（1）复数（Complex Numbers）

在 Python 中，复数由实部与虚部组成，语法形式为：

a + bj

其中：

• a 是实部（real part），可以是整数或浮点数；
• b 是虚部（imaginary part）前的系数，j 表示虚数单位，等价于数学中的 √(−1)。

例如：

z = 3 + 2j
w = 8 - 5j
result = z + w
print(result)   # 输出 (11 - 3j)

Python 使用 j（而不是其他语言常用的 i）来表示虚数单位。

复数在科学计算、信号处理等领域非常常见，例如在 NumPy 中用于傅里叶变换等运算。

（2）None 类型

除了常见的数值、字符串、布尔值等类型，Python 还提供了一种特殊类型：None。

None 表示 “空” 或 “无值”，通常用于以下几种场景：

• 函数没有返回值时，默认返回 None；
• 表示变量尚未赋值 或 占位；
• 用作条件判断，例如 if result is 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 中执行如下运算：

print(0.1 + 0.2 - 0.3)

你可能直觉上认为结果应为 0，但实际输出为：

5.551115123125783e-17

这是一个非常接近 0 的极小数。
原因在于：二进制浮点数无法精确表示所有十进制小数。

例如，十进制的 0.1 在二进制中是一个无限循环小数，因此 Python 只能以近似值进行存储与计算。
这种情况不仅出现在 Python 中，C、Java、JavaScript 等语言也存在相同的问题。

若需要精确的小数计算（如货币、财务运算），应使用：

from decimal import Decimal
print(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() 是字符串对象的一个常用方法，用于将一个可迭代对象（如列表、元组、集合）中的所有元素拼接成一个新的字符串。

语法：

'分隔符'.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）。

按值复制指的是：

• 复制对象本身的值；
• 生成一个全新的对象；
• 将这个新对象存入变量。

适用的数据类型主要是 不可变类型：

• 整数（int）
• 浮点数（float）
• 布尔值（bool）
• 字符串（str）

示例：

a = 10
b = a          # 按值复制
b += 5

print(a)  # 10
print(b)  # 15

这里，a 与 b 分别指向不同的整数对象，修改 b 并不会影响 a。

② 按引用复制（Copy by Reference）。

按引用复制指的是：

• 复制对象在内存中的 引用地址；
• 变量指向 同一个对象；
• 对该对象的修改会影响所有引用该对象的变量。

适用的数据类型主要是 可变类型：

• 列表（list）
• 字典（dict）
• 集合（set）
• 元组（tuple，如果元组包含可变元素）

示例：

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）。

为了避免引用共享带来的副作用，可使用复制方法：

1. 浅拷贝（Shallow Copy）

适用于列表、字典、集合，可创建对象的新副本，但只复制一层结构。

lst1 = [1, 2, 3]
lst2 = lst1.copy()  # 浅拷贝
lst2.append(4)

print(lst1)  # [1, 2, 3]
print(lst2)  # [1, 2, 3, 4]

1. 深拷贝（Deep Copy）

适用于元组或嵌套数据结构，需要使用 deepcopy() 函数：

from copy import deepcopy

t1 = ([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]

• sort() 方法会 直接修改原列表，不会返回新列表；
• 支持关键字参数：

• • reverse=True：降序排序
  • key=函数名：按照指定规则排序

示例（降序排序）：

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)      # True
print("z" not in text)  # True

• 列表

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

• 元组

colors = ("red", "green", "blue")
print("green" in colors)      # True
print("yellow" not in colors) # True

• 字典

student = {"name": "Alice", "age": 18}
print("name" in student)      # True
print("Alice" in student)     # False，字典默认检查键而非值

• 集合

fruits = {"apple", "banana", "cherry"}
print("banana" in fruits)      # True
print("orange" not in fruits)  # True

③ 成员运算符的优势。

• 简洁高效：无需写复杂算法或循环即可判断元素是否存在；
• 通用性强：可作用于多种序列和集合类型；
• 提高可读性：代码更加直观，逻辑清晰。

💡 如果没有成员运算符，你可能需要借助循环或算法判断元素是否存在于序列中，这会繁琐且易出错。