在 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 中常见的数据类型

从上表可以看出，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）。

• 整数
  用于表示没有小数点的数值，如 -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 = 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

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

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

例如：

def add(x, y):    return x + yresult = 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.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.e
  ：自然常数，约等于 2.718。
• math.pi
  ：圆周率常数，约等于 3.14159。

② 常用方法：

• math.floor(x)
  ：向下取整，返回小于或等于 x 的最大整数。
• math.ceil(x)
  ：向上取整，返回大于或等于 x 的最小整数。
• math.sqrt(x)
  ：返回 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 = 5x = x + 1print(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")

输出结果为：

HelloWorld

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

② 使用加号 + 进行拼接。

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

示例：

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

输出结果为：

Hello Alice

③ 字符串与数字的拼接。

需要注意的是，在 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。

参数：

• 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"))       # 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() 方法通过占位符 {} 在字符串中预留位置，然后用 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}.")

输出：

Next year, I will be 26.

• format() 与 f-string 的区别

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

• format()
   可用于早期 Python 版本（兼容性更好）；
• 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]

③ 统计与查找。

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

示例：

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": "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"])     # 输出 Aliceprint(data[(10, 20)])   # 输出 coordinates

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

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

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

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

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

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

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

① 元组的基本特征。

• 使用圆括号 () 定义

numbers = (1, 2, 3)

• 支持不同类型的元素

mixed = (10, "Python", True, 3.14)

• 可通过索引访问

print(mixed[1])  # 输出 "Python"

• 支持嵌套

nested = (1, (2, 3), 4)print(nested[1][0])  # 输出 2

② 常用内置函数与方法。

③ 元组的不可变性。

元组的最大特点是不可变性。创建后不能执行如下操作：

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)

上述代码可能的执行结果：

0.123456789 0.05

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

# 使用 enumerate() 同时遍历列表的索引和对应元素for index, value in enumerate(["A", "B", "C"]):    # 输出索引值和对应的元素内容。    print(index, value)

上述代码的输出结果：

0 A1 B2 C

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）常用的集合内置方法

（3）集合的数学运算方法

Python 集合支持多种 数学集合运算，如下表所示：

（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），其取值只有两种可能：

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

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

① 布尔值的基本概念。

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

TrueFalse

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

例如：

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

③ 常见的布尔运算。

这些运算通常用于控制语句（如 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 解释器执行，主要用于解释代码逻辑、记录设计意图或提示使用方法。

编写高质量注释不仅能帮助自己更好地理解代码，也能让他人更轻松地维护与协作。

① 为什么需要注释？

• 帮助自己理解代码功能

• 帮助同事阅读与协作

• 帮助社区开发者学习

② 单行注释（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 的内置类型检查函数，用于 返回对象所属的数据类型。

基本语法如下：

type(object)

其中：

• 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() 进行类型检测。

区别如下：

示例说明：

class Animal:    passclass Dog(Animal):    passdog = Dog()print(type(dog) == Animal)       # Falseprint(isinstance(dog, Animal))   # True ✅

23. 数据类型的其他信息

（1）复数（Complex Numbers）

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

a + bj

其中：

• 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 表示 “空” 或 “无值”，通常用于以下几种场景：

• 函数没有返回值时
  ，默认返回 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 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() 是字符串对象的一个常用方法，用于将一个可迭代对象（如列表、元组、集合）中的所有元素拼接成一个新的字符串。

语法：

'分隔符'.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 = 10b = a          # 按值复制b += 5print(a)  # 10print(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）。

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

• 浅拷贝（Shallow Copy）

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

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

• 深拷贝（Deep Copy）

适用于元组或嵌套数据结构，需要使用 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]

• 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） 来实现这一功能，使判断操作简单而高效。

① 成员运算符概览。

⚡ 注意：成员运算符可用于所有 序列类型 和 集合类型，包括字符串、列表、元组、字典和集合。

② 示例演示。

• 字符串。

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 数据类型的基本概念、常用操作及其底层特性，为后续控制结构、函数设计及面向对象编程等内容的学习奠定坚实基础。