Computer science foundation note COMPUTER SCIENCE 2nd

第 1 章 Python 概览

1.1 Python 简介

Python 是一种解释型、交互式、高级动态编程语言，由 Guido van Rossum 于 1991 年正式发布。
其设计哲学是“简单明了、可读性强”，强调代码可维护性和开发效率。

主要特点：

• 语法简洁、接近自然语言；
• 拥有强大的标准库；
• 支持多种编程范式：面向对象、过程式、函数式编程；
• 跨平台，可运行于 Windows、macOS、Linux 等操作系统。

常见应用领域：

• 数据分析与科学计算（NumPy、Pandas、SciPy）
• Web 开发（Django、Flask）
• 自动化脚本与测试
• 人工智能与机器学习（TensorFlow、PyTorch）
• 网络爬虫、系统运维、工具开发等。

1.2 Python 的执行机制

Python 是典型的 解释型语言。与 C/C++ 等编译型语言不同，它不将源代码直接编译为机器码，而是：

1. 由解释器读取 .py 源文件；
2. 编译为 字节码（.pyc）；
3. 字节码由 Python 虚拟机（PVM）解释执行。

因此，Python 程序无需手动编译，修改后可直接运行。
运行速度上略慢于编译型语言，但灵活性和开发速度更高。

1.3 编译型与解释型语言的区别

Python 实际是“半编译半解释”的语言：先编译为字节码，再由解释器运行。

1.4 Python 的版本与环境

目前主流版本为 Python 3.x，Python 2 已于 2020 年停止维护。
建议使用 Python 3.9 或以上版本以获得更好的性能与库兼容性。

可通过以下命令检查版本：

python --version
# 或
python3 --version

推荐安装方式

• 官方网站下载安装包（https://www.python.org）
• 使用 Anaconda 发行版（内置科学计算工具）
• macOS/Linux 系统可直接使用包管理器（如 apt、brew、yum）

1.5 Python 解释器

常见解释器包括：

• CPython（官方默认实现）
• PyPy（基于 JIT 加速的实现）
• Jython（运行在 JVM 上的实现）
• IronPython（基于 .NET 的实现）

CPython 是最常用的版本，通常也是我们默认使用的 “python” 命令对应的解释器。

1.6 Python 程序的运行方法

方一：命令行执行

将以下代码保存为 hello.py：

print("Hello, Python!")

然后在终端运行：

python hello.py

方二：交互式模式

启动解释器后可直接执行语句：

python
>>> print("Hello, world!")
Hello, world!

方三：使用 Jupyter Notebook

适合教学、实验与交互式脚本，可通过：

jupyter notebook

在浏览器界面逐行执行代码。

1.7 命令行基础操作

在学习 Python 前，掌握基本终端命令会提高开发效率。常见命令包括：

第 2 章 基础语法与数据类型

2.1 概述

本章介绍 Python 程序设计的基础语法规则及常用数据类型。掌握这些要点是理解更高级概念的前提。

Python 的语法特点：

• 通过 缩进 体现语句块结构；
• 强调 可读性；
• 使用 动态类型系统，无需声明变量类型；
• 一切数据皆对象。

2.2 标识符与命名规则

在 Python 中，标识符用于命名变量、函数、类、模块等。

命名规则：

1. 只能由 字母、数字、下划线（_） 组成；
2. 不能以数字开头；
3. 区分大小写；
4. 不可与 关键字 同名；
5. 建议遵循 [PEP 8 命名规范]：

查看 Python 关键字

import keyword
print(keyword.kwlist)

2.3 缩进与语句块

Python 使用 缩进（indentation）表示语句块，而非大括号 {}。
标准缩进为 4 个空格，混用 Tab 与空格会导致错误。

示例：

if True:
    print("缩进正确")
else:
    print("缩进错误可能导致语法错误")

注意：同一层级的语句缩进必须一致。

2.4 注释

注释用于提高代码可读性。Python 支持两种注释方式：

单行注释

以 # 开头：

# 这是单行注释

多行注释（或文档字符串）

"""
多行注释可用于模块、函数说明
"""

2.5 变量与赋值

变量在首次赋值时自动声明，类型根据右侧值动态确定：

name = "Alice"
age = 20
height = 1.68

Python 是 动态类型语言，无需指定类型，可以随时改变：

a = 10
a = "text"

可一次声明多个变量：

x, y, z = 1, 2, 3

2.6 基本数据类型

Python 的常用基础数据类型如下：

可以通过 type() 查询类型：

print(type(3.14))      # <class 'float'>
print(type(True))      # <class 'bool'>

2.7 类型转换

常见类型转换函数：

示例：

a = 10
b = "20"
c = int(b) + a   # 字符串转整数
print(c)

2.8 运算符与表达式

Python 支持多种运算符。

算术运算符

比较运算符

逻辑运算符

成员运算符与身份运算符

a = [1, 2, 3]
print(2 in a)      # True
x = y = [4, 5]
print(x is y)      # True

2.9 输入与输出

输入：input()

name = input("请输入姓名：")
print("你好，", name)

注意：input() 返回的类型始终为字符串。

输出：print()

print("年龄：", 18)
print(f"{name} 的年龄是 {age}")

2.10 代码示例：简单计算器

# 简单计算器
a = float(input("输入第一个数："))
b = float(input("输入第二个数："))
print("加法结果:", a + b)
print("乘法结果:", a * b)

第 3 章 控制结构（Control Structures）—— 决策与循环（Decision & Looping）

3.1 概述（Overview）

在程序设计中，控制结构（Control Structure） 用于控制程序的执行流程。
Python 拥有三种基本控制结构（Basic Control Flow Types）：

1. 顺序结构（Sequential Structure） — 从上到下依次执行语句；
2. 分支结构（Selection / Branching Structure） — 根据条件执行不同分支；
3. 循环结构（Looping Structure） — 重复执行特定语句块。

3.2 if 单分支语句（Single-Branch if Statement）

基本格式（Syntax）

if 条件表达式 (condition):
    执行语句块 (statement_block)

示例：

age = 18
if age >= 18:
    print("You are an adult.")  # 输出：已成年

⚠️ 注意（Note）：Python 中 冒号 ”:” 表示代码块开始，
缩进（Indentation） 为结构的一部分，通常使用 4 个空格。

3.3 if-else 双分支（Two-Way Selection）

当条件为假（False）时执行另一分支：

if 条件 (condition):
    语句块1
else:
    语句块2

示例：

age = 16
if age >= 18:
    print("Allowed to enter.")
else:
    print("Access denied.")

3.4 嵌套 if（Nested if Statement）

可在判断内部嵌套二次判断：

score = 85
if score >= 60:
    if score >= 90:
        print("Excellent")
    else:
        print("Pass")
else:
    print("Fail")

避免过多嵌套，重构为 if-elif-else 更清晰。

3.5 双 if 与 if-elif-else 比较

(1) 双 if（Multiple Independent ifs）

每个条件独立检查，不互斥（not mutually exclusive）：

score = 95
if score >= 60:
    print("Pass")
if score >= 90:
    print("Excellent")

输出：

Pass
Excellent

(2) if-elif-else（Mutually Exclusive Branches）

仅执行第一个满足条件的分支：

score = 95
if score >= 90:
    print("Excellent")
elif score >= 60:
    print("Pass")
else:
    print("Fail")

输出：

Excellent

3.6 条件表达式（三元运算符, Ternary Operator）

简化条件赋值的单行写法：

result = "Adult" if age >= 18 else "Minor"

等价于：

if age >= 18:
    result = "Adult"
else:
    result = "Minor"

3.7 while 循环（while Loop）

基本格式（Syntax）：

while 条件 (condition):
    执行语句块 (statement_block)

执行流程：当条件为真（True）时执行语句块，否则退出循环。

示例：

count = 1
while count <= 3:
    print("Count:", count)
    count += 1

3.8 for 循环（for Loop）

用于遍历可迭代对象（Iterable Object）。

语法：

for 变量 (variable) in 可迭代对象 (iterable):
    执行语句块

示例：

for i in range(5):
    print("Index:", i)

常见可迭代对象（Iterable Types）：

• 字符串（String）
• 列表（List）
• 元组（Tuple）
• 集合（Set）
• 字典（Dictionary）
• 序列（Sequence）或 range()

3.9 循环类型比较（Comparison of Loop Types）

示例：

# for loop
for i in range(3):
    print("for:", i)

# while loop
i = 0
while i < 3:
    print("while:", i)
    i += 1

3.10 循环控制语句（Loop Control Statements）

Python 提供三种循环控制关键字：

示例：

for i in range(5):
    if i == 2:
        continue      # Skip value 2
    if i == 4:
        break         # Stop the loop
    print("i =", i)

输出：

i = 0
i = 1
i = 3

3.11 循环中的 else（Loop with else Clause）

当循环 未被 break 中断 时，else 块将被执行。

for i in range(3):
    print(i)
else:
    print("Loop finished normally.")

3.12 综合案例：质数检测（Prime Number Check）

num = int(input("Enter an integer: "))

if num > 1:
    for n in range(2, num):
        if num % n == 0:
            print(num, "is not a prime number.")
            break
    else:
        print(num, "is a prime number.")
else:
    print("Number should be greater than 1.")

输出示例：

Enter an integer: 7
7 is a prime number.

第 4 章 函数与模块化编程

(Chapter 4: Functions & Modular Programming)

4.1 概述（Overview）

在程序开发中，函数（Function） 用于将重复或逻辑性强的代码封装到一个可复用的单元中。
模块化编程（Modular Programming）鼓励把复杂问题拆分成多个小的功能模块。

Python 通过函数（def）和模块（import）支持这种结构化思想。

4.2 函数的定义与调用（Defining and Calling Functions）

基本语法（Syntax）

def 函数名(function_name)(参数列表 parameters):
    语句块 (function_body)
    [return 返回值 (optional return_value)]

示例：

def greet(name):
    print(f"Hello, {name}!")

greet("Alice")   # 调用时传入实参 (argument)

4.3 return 语句（Return Statement）

功能

return 用于 将函数的计算结果返回给调用方（Return a value to caller）。

如果函数只是输出结果而不需要返回，则可以省略 return。
未写 return 时，Python 默认返回 None。

示例

def add(a, b):
    return a + b  # 返回计算值给调用方

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

多个返回值（Multiple Returns）

def get_user_info():
    return "Alice", 25, "Student"

name, age, role = get_user_info()

🔸 什么时候需要使用 return？（When to Use return）

💡 示例：

def calculate_discount(price):
    if price < 0:
        return "Invalid price"  # 提前结束函数
    return price * 0.9  # 返回计算值

discounted_price = calculate_discount(100)

4.4 实参与形参（Arguments vs Parameters）

定义区分

示例：

def greet(name):       # “name” 是形参 (parameter)
    print("Hello", name)

greet("Bob")           # "Bob" 是实参 (argument)

🔸 什么时候要加入实参？（When to Pass Arguments）

💡 示例：

def greet(name="Guest"):
    print(f"Hello, {name}")

greet()         # 使用默认值 Guest
greet("Alice")  # 传入实参，覆盖默认值

4.5 参数类型（Parameter Types）

4.6 综合示例：return 与实参的配合使用

def calc_area(length, width):
    """计算矩形面积 (Calculate rectangle area)"""
    return length * width    # 返回结果

def show_area(l, w):
    """显示面积结果 (Display area)"""
    area = calc_area(l, w)   # 调用并传入实参
    print(f"Area = {area}")

show_area(5, 10)

输出：

Area = 50

说明：

• calc_area 使用 return 把结果“交还”给调用者；
• 调用时需要传入实参 l 和 w；
• 另一函数 show_area 使用这个返回值进行显示。

4.7 补充技巧：不返回值 vs 返回值的区别

示例对比：

# 无 return：只打印，不返回结果
def print_sum(a, b):
    print(a + b)

# 有 return：返回结果供后续使用
def calc_sum(a, b):
    return a + b

print_sum(3, 4)             # 输出: 7
result = calc_sum(3, 4)     # 保存结果
print("Result =", result)   # 输出: Result = 7

第 5 章 数据结构与序列类型

(Chapter 5: Data Structures & Sequence Types)

5.1 概述（Overview）

数据结构（Data Structures） 是程序设计中组织与存储数据的方式。
Python 提供了丰富的内置容器类型（Built-in Container Types），用于 存储、访问与操作数据集合（data collections）。

主要序列与集合类型：

5.2 列表（List）

列表是最常用的可变序列（Mutable Sequence），可存储任意类型元素。

创建列表（Create List）

fruits = ["apple", "banana", "cherry"]

访问与修改（Access & Modify）

print(fruits[0])      # 访问第一个元素 -> apple
fruits[1] = "pear"    # 修改第二个元素

添加与删除元素（Add & Remove Elements）

fruits.append("orange")      # 尾部添加元素
fruits.insert(1, "mango")    # 指定位置插入
fruits.remove("pear")        # 删除指定值
deleted = fruits.pop()       # 删除并返回最后一个元素

列表切片（List Slicing）

nums = [0, 1, 2, 3, 4, 5]
print(nums[1:4])   # [1, 2, 3]
print(nums[:3])    # [0, 1, 2]
print(nums[::2])   # [0, 2, 4]

列表常用方法（List Methods）

示例：

nums = [3, 1, 4, 2]
nums.sort()
print(nums)   # [1, 2, 3, 4]

5.3 元组（Tuple）

元组（Tuple） 是不可变序列（Immutable Sequence），通常用于固定数据集合。

创建与访问

colors = ("red", "green", "blue")
print(colors[0])

单元素元组要加逗号：

single = (5,)

元组 vs 列表

5.4 字符串（String）

字符串是不可变序列（Immutable Sequence），由字符（characters）组成。

基本操作

s = "Hello World"
print(len(s))       # 11
print(s.upper())    # HELLO WORLD
print(s.lower())    # hello world

切片与索引

print(s[0])      # 'H'
print(s[1:5])    # 'ello'

拼接与格式化（Concatenation & Formatting）

name = "Alice"
print("Hello, " + name)
print(f"Hello, {name}")     # f-string 格式化

5.5 集合（Set）

集合（Set）是一种无序且不重复的容器（Unordered, Unique Container）。

创建（Create）

nums = {1, 2, 3, 3, 2}
print(nums)   # {1, 2, 3}

集合运算（Set Operations）

A = {1, 2, 3}
B = {3, 4, 5}

print(A | B)   # 并集 union → {1, 2, 3, 4, 5}
print(A & B)   # 交集 intersection → {3}
print(A - B)   # 差集 difference → {1, 2}
print(A ^ B)   # 对称差 symmetric difference → {1, 2, 4, 5}

常用方法

5.6 字典（Dictionary）

字典是键值对（Key-Value Pairs）组成的映射结构（Mapping Type）。

创建字典（Create Dict）

person = {"name": "Alice", "age": 25, "city": "Beijing"}

访问字典

print(person["name"])
print(person.get("age"))

修改字典（Modify）

person["age"] = 26     # 修改
person["email"] = "alice@example.com"  # 新增键值

删除键值（Delete）

del person["city"]
person.pop("email")

遍历字典（Iteration）

for key, value in person.items():
    print(key, ":", value)

常用方法

5.7 序列通用操作（Common Sequence Operations）

Python 中大多数序列类型（list、tuple、str）都支持以下操作：

5.8 列表推导式（List Comprehension）

是一种简洁生成列表的方式（Compact Syntax for List Creation）。

nums = [1, 2, 3, 4, 5]
squares = [x**2 for x in nums if x % 2 == 1]
print(squares)   # [1, 9, 25]

结构：

[ expression for variable in iterable if condition ]

5.9 嵌套数据结构（Nested Structures）

Python 支持嵌套组合（Nested Combination）：

students = [
    {"name": "Alice", "score": [85, 90, 92]},
    {"name": "Bob", "score": [78, 88, 80]},
]
print(students[0]["score"][1])  # 输出 90

5.10 深浅拷贝（Shallow vs Deep Copy）

浅拷贝（Shallow Copy）

仅复制最外层引用：

import copy
a = [1, [2, 3]]
b = copy.copy(a)
b[1][0] = 99
print(a)   # [1, [99, 3]]

深拷贝（Deep Copy）

复制所有层级的新对象：

c = copy.deepcopy(a)
c[1][0] = 100
print(a)   # 不受影响

5.11 小结（Summary）

第 6 章 文件与异常处理

(Chapter 6: Files & Exception Handling)

6.1 概述（Overview）

在程序中，文件操作（File Operations） 与 异常处理（Exception Handling） 是两个非常实用的概念。

• 文件操作：用于从文件中读取数据、写入内容或创建记录。
• 异常处理：确保程序在出现错误（Error）时能够优雅处理，而不是直接崩溃。

本章内容帮助你掌握：

1. 如何打开、读取、写入文件；
2. 如何处理异常与错误；
3. 使用 with 语句管理资源。

6.2 文件路径与模式（File Paths & Modes）

在 Python 中，通过函数 open() 操作文件：

open(file, mode, encoding=None)

💡 提示（Tip）：
建议总是指定 encoding='utf-8'，以避免中文字符出现乱码。

f = open("demo.txt", "r", encoding="utf-8")

6.3 文件读取（Reading Files）

方式 1：一次性读取整个文件

f = open("hello.txt", "r", encoding="utf-8")
content = f.read()
print(content)
f.close()

方式 2：逐行读取

f = open("hello.txt", "r", encoding="utf-8")
for line in f:
    print(line.strip())
f.close()

方式 3：一次读取一行

f = open("hello.txt", "r", encoding="utf-8")
line = f.readline()
print(line)
f.close()

6.4 文件写入（Writing Files）

写入字符串

f = open("output.txt", "w", encoding="utf-8")
f.write("Hello, Python!\n")
f.write("This is a new line.")
f.close()

追加内容

f = open("output.txt", "a", encoding="utf-8")
f.write("\n追加的文字 (Appended text)")
f.close()

6.5 使用 with 管理文件（Using with Statement）

with 可以自动关闭文件，无需手动调用 close()，推荐使用。

with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)

优点：

• 自动释放文件资源；
• 更简洁、安全。

6.6 文件与路径操作（File and Path Operations）

Python 的 os 与 pathlib 模块可辅助管理文件与文件夹。

import os
print(os.getcwd())          # 获取当前目录
os.mkdir("new_folder")      # 创建文件夹
os.remove("data.txt")       # 删除文件
os.listdir(".")             # 列出当前目录下所有文件

使用现代的 pathlib：

from pathlib import Path

p = Path("data.txt")
print(p.exists())           # 判断文件是否存在
print(p.name)               # 文件名
print(p.parent)             # 上一级目录

6.7 异常（Exceptions）

定义

异常是程序运行期间发生的错误事件（Error event），会打断程序的正常执行流程。

常见异常类型：

6.8 异常处理（Exception Handling）

Python 使用 try - except 结构处理异常。

基本格式

try:
    可能出错的代码 (code that may fail)
except ExceptionType:
    如果出错则执行的代码

示例：

try:
    x = int(input("请输入数字："))
    print(10 / x)
except ZeroDivisionError:
    print("错误：除数不能为零！")
except ValueError:
    print("错误：输入的不是数字！")

6.9 else 和 finally 子句（else & finally Blocks）

try 块可以搭配 else 与 finally 使用。

try:
    f = open("data.txt", "r")
    data = f.read()
except FileNotFoundError:
    print("文件不存在！")
else:
    print("文件读取成功")
finally:
    f.close()
    print("文件已关闭")

执行流程：

• try：尝试执行；
• except：出错时执行；
• else：无错误时执行；
• finally：无论是否出错都执行（常用于清理资源）。

6.10 抛出异常（Raising Exceptions）

使用 raise 主动抛出异常（Manually Raise an Exception）。

def divide(a, b):
    if b == 0:
        raise ValueError("除数不能为 0")
    return a / b

调用：

try:
    result = divide(10, 0)
except ValueError as e:
    print("捕获异常:", e)

6.11 自定义异常（Custom Exception）

用户可以通过继承 Exception 类自定义异常类型。

class NegativeValueError(Exception):
    """自定义异常：输入负数"""
    pass

def check_age(age):
    if age < 0:
        raise NegativeValueError("年龄不能为负数")

try:
    check_age(-5)
except NegativeValueError as e:
    print("捕获自定义异常:", e)

6.12 将文件操作与异常结合使用（File + Exception）

def read_file(filename):
    try:
        with open(filename, 'r', encoding='utf-8') as f:
            return f.read()
    except FileNotFoundError:
        print("错误：文件不存在！")
        return None
    except Exception as e:
        print("发生未知错误：", e)
        return None

content = read_file("test.txt")

6.13 综合案例：学生成绩记录系统（Example Case）

示例功能：

• 从文件读取学生成绩；
• 添加新数据并写回；
• 使用异常保证稳定性。

def update_scores(filename):
    try:
        with open(filename, "r", encoding="utf-8") as f:
            scores = [int(line.strip()) for line in f.readlines()]
    except FileNotFoundError:
        print("文件未找到，创建新文件。")
        scores = []

    try:
        new_score = int(input("请输入新的成绩："))
        scores.append(new_score)
        with open(filename, "w", encoding="utf-8") as f:
            for s in scores:
                f.write(str(s) + "\n")
        print("成绩已保存！")
    except ValueError:
        print("输入无效，请输入数字。")

update_scores("scores.txt")

第 7 章 面向对象编程

(Chapter 7: Object-Oriented Programming - OOP)

7.1 概述（Overview）

面向对象编程（Object-Oriented Programming, OOP） 是一种通过对象（objects）来组织代码的编程思想。
相对于过程式编程（Procedural Programming），OOP 更强调：

• 数据（Data） 与 行为（Behavior） 一体化；
• 封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism） 三大特性。

核心理念：

“万物皆对象（Everything is an object）。”

7.2 类与对象（Classes & Objects）

关键概念

定义类（Defining a Class）

class Person:
    def __init__(self, name, age):
        self.name = name       # 属性
        self.age = age         # 属性

    def greet(self):           # 方法
        print(f"Hello, my name is {self.name}. I am {self.age} years old.")

创建对象（Creating an Object）

p1 = Person("Alice", 25)
p1.greet()

输出：

Hello, my name is Alice. I am 25 years old.

7.3 __init__ 构造方法（Constructor）

__init__ 是一个 构造函数（constructor），用于初始化对象的属性。
它在创建对象时 自动调用（called automatically）。

class Dog:
    def __init__(self, name):
        self.name = name
        print(f"Dog {self.name} has been created!")

调用：

d = Dog("Buddy")

输出：

Dog Buddy has been created!

7.4 self 关键字（The self Keyword）

• self 代表 当前对象自身（the current instance itself）。
• 类中任何方法的第一个参数必须是 self（Pythond 自动传入）。

示例：

class Cat:
    def set_name(self, name):
        self.name = name

    def get_name(self):
        return self.name

调用：

c = Cat()
c.set_name("Kitty")
print(c.get_name())

7.5 封装（Encapsulation）

封装（Encapsulation） 指把数据与操作数据的方法绑定在一起，防止外部直接访问内部细节。

私有属性（Private Attributes）

• 使用前缀 __ 定义私有属性；
• 外部不能直接访问，只能通过方法获取。

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        self.__balance += amount

    def get_balance(self):
        return self.__balance

使用：

account = BankAccount("Alice", 1000)
account.deposit(500)
print(account.get_balance())
# print(account.__balance)  # 错误：无法直接访问

7.6 继承（Inheritance）

继承 允许子类（Subclass）**复用父类（Parent Class）**的属性与方法，并可以进行扩展或重写。

class Animal:
    def speak(self):
        print("Some sound")

class Dog(Animal):
    def speak(self):           # 重写父类方法
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

调用：

d = Dog()
c = Cat()
d.speak()   # Woof!
c.speak()   # Meow!

super() 调用父类方法（Calling Parent Methods）

class Person:
    def __init__(self, name):
        self.name = name

class Student(Person):
    def __init__(self, name, grade):
        super().__init__(name)    # 调用父类构造函数
        self.grade = grade

7.7 多态（Polymorphism）

多态意为“多种形态”。
同一个接口（方法名），在不同对象中有不同实现。

class Bird:
    def sound(self):
        print("Chirp")

class Dog:
    def sound(self):
        print("Bark")

for animal in [Bird(), Dog()]:
    animal.sound()

输出：

Chirp
Bark

7.8 类属性与实例属性（Class vs Instance Attributes）

示例：

class Student:
    school = "Python University"   # 类属性

    def __init__(self, name):
        self.name = name           # 实例属性

s1 = Student("Alice")
s2 = Student("Bob")

print(s1.school, s2.school)   # 都能访问类属性
s1.school = "Another School"  # 为 s1 创建了同名实例属性
print(s1.school, s2.school)

7.9 特殊方法（Magic Methods / Dunder Methods）

特殊方法以 __ 开头结尾，例如：

示例：

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

p1 = Point(1, 2)
p2 = Point(3, 4)
print(p1 + p2)   # 输出 (4, 6)

7.10 静态方法与类方法（Static & Class Methods）

类方法（@classmethod）

• 第一个参数是 cls（代表类本身）；
• 可用于操作类属性。

class Student:
    count = 0

    def __init__(self, name):
        self.name = name
        Student.count += 1

    @classmethod
    def get_count(cls):
        return cls.count

print(Student.get_count())  # 0
a = Student("Alice")
b = Student("Bob")
print(Student.get_count())  # 2

静态方法（@staticmethod）

• 与类或实例无关；
• 用于执行与类逻辑相关、但不依赖实例数据的函数。

class MathTool:
    @staticmethod
    def add(a, b):
        return a + b

print(MathTool.add(2, 3))  # 5

7.11 封装 + 继承 + 多态 综合案例

class Shape:
    def area(self):
        pass

class Rectangle(Shape):
    def __init__(self, w, h):
        self.w, self.h = w, h

    def area(self):
        return self.w * self.h

class Circle(Shape):
    def __init__(self, r):
        self.r = r

    def area(self):
        return 3.14 * self.r * self.r

shapes = [Rectangle(3, 4), Circle(5)]

for s in shapes:
    print("Area:", s.area())

输出：

Area: 12
Area: 78.5

7.12 小结（Summary）

第8章 魔法函数与对象行为控制（Magic Functions & Object Behavior Control）

8.1 什么是魔法函数（Magic Functions）

魔法函数（Magic Methods）又被称为特殊方法（Special Methods），它们是 Python 类中以双下划线 __name__ 命名的特殊函数。

这些方法用于定义对象的 行为、运算方式、属性访问、迭代能力、上下文环境等，
使类可以像内置类型一样自然地被操作。

例如：

• 使用 __add__ 可以使对象支持 + 运算；
• 使用 __len__ 可以让对象支持 len()；
• 使用 __getitem__ 可以让对象支持索引操作。

8.2 基本分类与作用

魔法方法大致分为以下几类：

8.3 对象初始化与表示方法

__init__() — 初始化对象属性

定义对象创建时的行为。

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

stu = Student("Alice", 90)
print(stu.name)   # Alice

__repr__() 与 __str__() — 打印与显示

两者的区别在于：

• __repr__ 用于开发调试输出（正式、准确）
• __str__ 用于用户友好显示（简洁、美观）

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score
    
    def __repr__(self):
        return f"Student(name={self.name!r}, score={self.score!r})"
    
    def __str__(self):
        return f"{self.name} 的成绩：{self.score}"

stu = Student("Bob", 87)
print(repr(stu))  # 调试输出
print(str(stu))   # 友好输出

8.4 算术与比较方法

使类支持运算符重载。

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)
    
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(2, 3)
v2 = Vector(1, 4)
print(v1 + v2)     # Vector(3, 7)
print(v1 - v2)     # Vector(1, -1)
print(v1 == v2)    # False

8.5 容器行为控制

让类具备“类列表”或“类字典”的行为。

class DataCollection:
    def __init__(self):
        self.data = [10, 20, 30]
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, index):
        return self.data[index]
    
    def __setitem__(self, index, value):
        self.data[index] = value
    
    def __contains__(self, item):
        return item in self.data

c = DataCollection()
print(len(c))        # 3
print(c[1])          # 20
c[0] = 99
print(99 in c)       # True

8.6 可调用对象（__call__）

使类实例能像函数一样执行。

class Greeter:
    def __init__(self, prefix="Hello"):
        self.prefix = prefix
    
    def __call__(self, name):
        return f"{self.prefix}, {name}!"

g = Greeter()
print(g("Alice"))   # Hello, Alice!

8.7 上下文管理方法（__enter__ 和 __exit__）

允许类使用 with 语句进行安全的资源管理。

class FileHandler:
    def __init__(self, filename):
        self.filename = filename
    
    def __enter__(self):
        self.file = open(self.filename, "r", encoding="utf-8")
        return self.file
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.file.close()

# 使用示例
with FileHandler("data.txt") as f:
    content = f.read()

8.8 迭代行为（__iter__ 与 __next__）

自定义可迭代对象，使类能用于 for 循环。

class Countdown:
    def __init__(self, start):
        self.start = start
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.start <= 0:
            raise StopIteration
        self.start -= 1
        return self.start

for num in Countdown(5):
    print(num)

8.9 属性访问控制（__getattr__ / __setattr__ / __delattr__）

允许对象拦截或修改属性访问行为。

class Person:
    def __init__(self, name):
        self.__dict__["name"] = name
    
    def __getattr__(self, attr):
        return f"属性 {attr} 不存在"
    
    def __setattr__(self, attr, value):
        print(f"设置属性：{attr} = {value}")
        self.__dict__[attr] = value

p = Person("Tom")
p.age = 30
print(p.city)     # 属性 city 不存在

8.10 对象生命周期方法

__del__() — 对象销毁时触发。

class Temp:
    def __del__(self):
        print("对象已销毁")

t = Temp()
del t

__copy__ 与 __deepcopy__

用于自定义对象复制逻辑（配合 copy 模块）。

8.11 进阶示例：打造一个能“像列表+函数”的对象

class SmartList:
    def __init__(self, data):
        self.data = list(data)
    
    def __getitem__(self, idx):
        return self.data[idx]
    
    def __setitem__(self, idx, val):
        self.data[idx] = val
    
    def __call__(self, func):
        return [func(x) for x in self.data]
    
    def __repr__(self):
        return f"SmartList({self.data})"

nums = SmartList([1, 2, 3])
print(nums[1])          # 2
nums[0] = 10
print(nums(lambda x: x * 2))  # [20, 4, 6]

此类：

• 像列表一样可索引；
• 像函数一样可被“调用”并批量变换数据；
• 通过魔法函数，使行为高度灵活。

8.12 小结

魔法函数体现了 Python 的面向对象灵活性，
它们让自定义类几乎能完全模仿内置类型的行为。

第 9 章 文件与数据库

(Chapter 9: Files & Databases)

9.1 概述（Overview）

在现代应用中，我们需要 持久化（persistence） 数据：
即程序结束后，数据仍能被保存并再次使用。

Python 提供了两种主要的数据持久化方式：

1. 文件（File） – 轻量级存储，例如文本文件、CSV、JSON。
2. 数据库（Database） – 结构化数据存储，适用于复杂应用，例如 SQLite、MySQL。

9.2 文件与数据库的区别（Files vs Databases）

9.3 文件数据格式回顾（File Format Review）

Python 可处理多种文件类型：

1 文本文件（Text Files）

with open("notes.txt", "r", encoding="utf-8") as f:
    content = f.read()

2 CSV 文件（Comma-Separated Values）

用于表格数据（如 Excel 导出的数据）。

import csv

with open("data.csv", newline='', encoding='utf-8') as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

写入 CSV：

with open("data.csv", "w", newline='', encoding='utf-8') as f:
    writer = csv.writer(f)
    writer.writerow(["Name", "Score"])
    writer.writerow(["Alice", 88])

3 JSON 文件（JavaScript Object Notation）

JSON 是最通用的轻量级数据格式之一，用于数据交换（data exchange）。

import json

data = {"name": "Alice", "age": 25, "skills": ["Python", "[[SQL]]"]}

# 写入 JSON 文件
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=4)

# 读取 JSON 文件
with open("data.json", "r", encoding="utf-8") as f:
    info = json.load(f)
    print(info["skills"])

9.4 数据库存储（Databases）

1 什么是数据库（What is a Database）

数据库是有组织的数据集合（organized collection of data），
通过结构化查询语言（SQL）进行操作。

2 常见数据库类型

9.5 SQLite 简介（Introduction to SQLite）

SQLite 是 Python 内置支持的轻量级关系数据库（embedded relational database）。
无需安装服务器，只需 .db 文件即可使用。

9.6 SQLite 基本操作（Using sqlite3 Module）

连接数据库

import sqlite3

# 若文件不存在，则自动创建
conn = sqlite3.connect("students.db")
print("Opened database successfully!")

创建表（Create Table）

cursor = conn.cursor()

cursor.execute('''CREATE TABLE IF NOT EXISTS students (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    name TEXT,
                    age INTEGER,
                    grade REAL
                )''')

conn.commit()
print("Table created successfully!")

插入数据（Insert Data）

cursor.execute("INSERT INTO students (name, age, grade) VALUES (?, ?, ?)", 
               ("Alice", 20, 88.5))
conn.commit()

查询数据（Select Data）

cursor.execute("SELECT * FROM students")
rows = cursor.fetchall()
for row in rows:
    print(row)

更新与删除（Update & Delete）

cursor.execute("UPDATE students SET grade = 92 WHERE name = 'Alice'")
cursor.execute("DELETE FROM students WHERE name = 'Alice'")
conn.commit()

关闭连接（Close Connection）

conn.close()

9.7 使用参数化查询（Parameterized Queries）

为防止 SQL 注入（SQL Injection），要使用 ? 占位符。

name = input("Enter name: ")
cursor.execute("SELECT * FROM students WHERE name = ?", (name,))

9.8 事务（Transactions）

SQLite 默认支持事务管理，即一组操作要么全部执行，要么全部失败。

try:
    cursor.execute("UPDATE students SET grade=100 WHERE id=1")
    conn.commit()
except:
    conn.rollback()     # 发生错误则回滚

9.9 上下文管理简化操作（Using with Statement）

可以用 with 自动关闭连接：

import sqlite3

with sqlite3.connect("students.db") as conn:
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM students")
    print(cursor.fetchall())

9.10 将数据库结果保存为 JSON 文件

import sqlite3, json

with sqlite3.connect("students.db") as conn:
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM students")
    data = cursor.fetchall()

# 转为可序列化的结构
students = [{"id": r[0], "name": r[1], "age": r[2], "grade": r[3]} for r in data]

with open("students.json", "w", encoding="utf-8") as f:
    json.dump(students, f, ensure_ascii=False, indent=4)

9.11 综合案例：学生管理系统（Student Management System）

实现一个简易的数据库应用：

• 添加学生；
• 查询所有学生；
• 保存到文件。

import sqlite3

def create_table():
    with sqlite3.connect("school.db") as conn:
        conn.execute('''CREATE TABLE IF NOT EXISTS students
                        (id INTEGER PRIMARY KEY AUTOINCREMENT,
                         name TEXT, age INTEGER, grade REAL)''')

def add_student(name, age, grade):
    with sqlite3.connect("school.db") as conn:
        conn.execute("INSERT INTO students (name, age, grade) VALUES (?, ?, ?)",
                     (name, age, grade))
        print("Added student:", name)

def list_students():
    with sqlite3.connect("school.db") as conn:
        for row in conn.execute("SELECT * FROM students"):
            print(row)

# 测试
create_table()
add_student("Alice", 21, 90)
add_student("Bob", 19, 85)
list_students()

9.12 导出为 CSV 文件（Export as CSV）

import sqlite3, csv

with sqlite3.connect("school.db") as conn:
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM students")
    rows = cursor.fetchall()

with open("students.csv", "w", newline='', encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["ID", "Name", "Age", "Grade"])
    writer.writerows(rows)

9.13 使用 Pandas 访问数据库（Using Pandas with Databases）

如果安装了 pandas，可以更方便地操作 SQLite。

import sqlite3
import pandas as pd

conn = sqlite3.connect("school.db")
df = pd.read_sql_query("SELECT * FROM students", conn)
print(df)

9.14 小结（Summary）

第 10 章 图形用户界面编程

(Chapter 10: Graphical User Interface Programming - GUI Programming)

10.1 概述（Overview）

图形用户界面（Graphical User Interface, GUI）
用于让用户通过可视化方式（如按钮、文本框、菜单等）与程序交互。

Python 内置的 GUI 开发工具是 Tkinter（读作 Tee-Kay-Inter）。

优点：

• 内置模块，无需额外安装；
• 跨平台（Windows/Mac/Linux均支持）；
• 适合中小型桌面应用。

10.2 Tkinter 简介（About Tkinter）

导入 Tkinter：

import tkinter as tk

10.3 创建基本窗口（Creating a Basic Window）

import tkinter as tk

root = tk.Tk()                        # 创建主窗口
root.title("My First GUI")            # 设置窗口标题
root.geometry("300x200")              # 设置窗口大小（宽x高）

root.mainloop()                       # 进入消息循环

运行后出现一个简单空白窗口。

10.4 添加控件（Adding Widgets）

Tkinter 提供多种控件（widgets）：

示例：添加标签与按钮

import tkinter as tk

def say_hello():
    label.config(text="Hello, Tkinter!")

root = tk.Tk()
root.title("Greeting Example")

label = tk.Label(root, text="点击按钮开始！")
label.pack(pady=10)

button = tk.Button(root, text="Say Hello", command=say_hello)
button.pack()

root.mainloop()

10.5 布局管理（Layout Management）

Tkinter 有三种布局管理方式：

例：使用 grid() 实现登录表单

import tkinter as tk

root = tk.Tk()
root.title("Login Form")

tk.Label(root, text="Username:").grid(row=0, column=0, padx=5, pady=5)
tk.Label(root, text="Password:").grid(row=1, column=0, padx=5, pady=5)

entry_user = tk.Entry(root)
entry_pass = tk.Entry(root, show="*")

entry_user.grid(row=0, column=1)
entry_pass.grid(row=1, column=1)

def login():
    print("Username:", entry_user.get())
    print("Password:", entry_pass.get())

tk.Button(root, text="Login", command=login).grid(row=2, column=0, columnspan=2, pady=10)

root.mainloop()

10.6 文本输入与输出（Text and Input Widgets）

获取文本框输入

name = entry_user.get()

设置标签文字

label.config(text="新的文本")

清空输入框

entry_user.delete(0, tk.END)

10.7 复选框与单选框（Checkbutton & Radiobutton）

import tkinter as tk

root = tk.Tk()

agree = tk.BooleanVar()
tk.Checkbutton(root, text="I agree", variable=agree).pack()

choice = tk.StringVar(value="A")
tk.Radiobutton(root, text="Option A", variable=choice, value="A").pack()
tk.Radiobutton(root, text="Option B", variable=choice, value="B").pack()

def show():
    print("Agree:", agree.get())
    print("Choice:", choice.get())

tk.Button(root, text="Submit", command=show).pack()
root.mainloop()

10.8 列表框（Listbox）与滚动条（Scrollbar）

import tkinter as tk

root = tk.Tk()
scrollbar = tk.Scrollbar(root)
scrollbar.pack(side=tk.RIGHT, fill=tk.Y)

listbox = tk.Listbox(root, yscrollcommand=scrollbar.set)
for i in range(1, 51):
    listbox.insert(tk.END, f"Item {i}")
listbox.pack(side=tk.LEFT, fill=tk.BOTH)

scrollbar.config(command=listbox.yview)
root.mainloop()

10.9 弹出对话框（Messagebox）

import tkinter as tk
from tkinter import messagebox

def confirm_exit():
    if messagebox.askyesno("Exit", "Are you sure to quit?"):
        root.destroy()

root = tk.Tk()
tk.Button(root, text="Exit", command=confirm_exit).pack()
root.mainloop()

10.10 菜单（Menus）

import tkinter as tk

def about():
    tk.messagebox.showinfo("About", "This is a sample GUI app.")

root = tk.Tk()
menu_bar = tk.Menu(root)

file_menu = tk.Menu(menu_bar, tearoff=0)
file_menu.add_command(label="New")
file_menu.add_command(label="Exit", command=root.quit)

help_menu = tk.Menu(menu_bar, tearoff=0)
help_menu.add_command(label="About", command=about)

menu_bar.add_cascade(label="File", menu=file_menu)
menu_bar.add_cascade(label="Help", menu=help_menu)

root.config(menu=menu_bar)
root.mainloop()

10.11 画布（Canvas）绘图

import tkinter as tk

root = tk.Tk()
canvas = tk.Canvas(root, width=300, height=200, bg="white")
canvas.pack()

canvas.create_line(0, 0, 200, 100, fill="blue")
canvas.create_rectangle(50, 50, 150, 100, fill="yellow")
canvas.create_oval(100, 50, 180, 130, fill="red")

root.mainloop()

10.12 文件选择对话框（File Dialog）

from tkinter import filedialog, Tk

root = Tk()
root.withdraw()  # 隐藏主窗口

file_path = filedialog.askopenfilename(title="Select a file")
print("Selected:", file_path)

10.13 事件绑定（Event Binding）

可以将函数与用户动作（事件）绑定：

import tkinter as tk

def on_key_press(event):
    print(f"Key pressed: {event.keysym}")

root = tk.Tk()
root.bind("<KeyPress>", on_key_press)
root.mainloop()

常用事件：

10.14 案例：简单计算器（Simple Calculator）

import tkinter as tk

def calculate():
    try:
        result = eval(entry.get())
        label_result.config(text=f"Result: {result}")
    except:
        label_result.config(text="Error")

root = tk.Tk()
root.title("Simple Calculator")

entry = tk.Entry(root, width=20)
entry.pack(pady=5)

tk.Button(root, text="Calculate", command=calculate).pack(pady=5)
label_result = tk.Label(root, text="Result:")
label_result.pack()

root.mainloop()

10.15 综合案例：学生信息录入系统（Student Info Form）

import tkinter as tk
from tkinter import messagebox

def submit():
    name = entry_name.get()
    age = entry_age.get()
    if not name or not age:
        messagebox.showwarning("Warning", "Please enter all fields!")
    else:
        messagebox.showinfo("Submitted", f"Name: {name}\nAge: {age}")

root = tk.Tk()
root.title("Student Info Form")

tk.Label(root, text="Name:").grid(row=0, column=0)
entry_name = tk.Entry(root)
entry_name.grid(row=0, column=1)

tk.Label(root, text="Age:").grid(row=1, column=0)
entry_age = tk.Entry(root)
entry_age.grid(row=1, column=1)

tk.Button(root, text="Submit", command=submit).grid(row=2, column=0, columnspan=2, pady=10)
root.mainloop()

10.16 小结（Summary）

第 11 章：函数式与高级特性（Functional and Advanced Features）

11.1 高阶函数（Higher-order Functions）

定义（Definition）

高阶函数是指以函数作为参数或返回值为函数的函数。
常见的内置高阶函数包括 map(), filter(), reduce()。

1. map() 函数

作用（Purpose）：对可迭代对象（Iterable）中的每个元素执行相同的函数操作，返回新的迭代器。

语法（Syntax）：

map(function, iterable)

示例（Example）：

nums = [1, 2, 3, 4]
result = map(lambda x: x ** 2, nums)
print(list(result))  # 输出 [1, 4, 9, 16]

2. filter() 函数

作用（Purpose）：根据条件函数（返回 True/False）过滤可迭代对象的元素。

语法（Syntax）：

filter(function, iterable)

示例（Example）：

nums = [1, 2, 3, 4, 5, 6]
even = filter(lambda x: x % 2 == 0, nums)
print(list(even))  # 输出 [2, 4, 6]

3. reduce() 函数

作用（Purpose）：对序列进行连续累计运算，由 functools.reduce() 提供。

语法（Syntax）：

from functools import reduce
reduce(function, iterable, initializer(optional))

示例（Example）：

from functools import reduce
nums = [1, 2, 3, 4]
total = reduce(lambda a, b: a + b, nums)
print(total)  # 输出 10

说明（Explanation）：

• reduce() 每次取两个元素应用函数，将结果继续与下一个元素组合；
• 常用于累计计算、乘积、聚合等场景。

11.2 生成器与惰性计算（Generators and Lazy Evaluation）

定义（Definition）

生成器（Generator）是在函数中使用 yield 关键字定义的可迭代对象，用于惰性计算（Lazy Evaluation）。

惰性计算意味着数据按需生成，不会一次性创建全部结果，有效节省内存。

示例（Example）：

def countdown(n):
    while n > 0:
        yield n
        n -= 1

for value in countdown(3):
    print(value)

输出：

3
2
1

特性（Characteristics）：

• yield 暂停函数执行并返回中间结果；
• 下一次迭代从 yield 后继续；
• 生成器只可迭代一次。

典型应用（Common Use Case）

• 大文件逐行处理；
• 无限序列（如 Fibonacci 数列）；
• 数据流式计算。

11.3 迭代器协议（Iterator Protocol）

概念（Concept）

迭代器（Iterator）是实现了 __iter__() 和 __next__() 方法的对象。
它支持逐步访问数据，不用一次加载全部内容。

示例（Example）：

class Counter:
    def __init__(self, low, high):
        self.current = low
        self.high = high

    def __iter__(self):
        return self

    def __next__(self):
        if self.current > self.high:
            raise StopIteration
        value = self.current
        self.current += 1
        return value

for c in Counter(1, 3):
    print(c)

输出：

1
2
3

11.4 闭包内部结构解析（Closure Internal Structure）

定义（Definition）

闭包（Closure）是指内部函数引用外部函数的局部变量，并在外部函数执行结束后依然保留该变量的状态。

示例（Example）：

def make_multiplier(factor):
    def multiply(x):
        return x * factor
    return multiply

times3 = make_multiplier(3)
print(times3(10))  # 输出 30

解析（Explanation）：

• 内部函数 multiply() 引用外部作用域的 factor；
• factor 存储在 __closure__ 属性中。

查看闭包变量（Inspect Closure）

print(times3.__closure__[0].cell_contents)  # 输出 3

闭包能用来实现数据封装（Data Encapsulation）与装饰器基础逻辑。

11.5 装饰器应用与封装模式（Decorator Application and Encapsulation Patterns）

概念（Concept）

装饰器（Decorator）是一个用于动态修改函数或类行为的可调用对象，核心基于闭包原理。

函数型装饰器（Function Decorator）示例：

def log_call(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} finished")
        return result
    return wrapper

@log_call
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")

输出：

Calling greet
Hello, Alice!
greet finished

应用场景（Use Cases）

• 函数性能计时（Performance Timing）
• 权限验证（Access Control）
• 日志记录与追踪（Logging & Tracing）

11.6 内省与动态类型特性（Introspection and Dynamic Typing Features）

定义（Definition）

**内省（Introspection）**是 Python 的运行时特性，允许在程序执行期间访问对象的类型信息与属性结构。

常用函数（Common Built-ins）：

示例（Example）：

class Person:
    pass

p = Person()
setattr(p, "name", "Alice")
print(getattr(p, "name"))  # 输出 Alice

if hasattr(p, "name"):
    print("Attribute exists")

动态特性应用（Dynamic Typing in Practice）

• 反射模块加载（Dynamic Module Loading）；
• ORM 框架动态绑定字段；
• 动态创建类与方法。

第 12 章：模块、包与环境（Modules, Packages and Environments）

12.1 模块导入机制（Module Import Mechanism）

定义（Definition）

模块（Module）是一个包含 Python 代码的文件，用于组织函数、类和变量以提高代码可维护性与复用性。
Python 使用 import 语句引入模块。

导入方式（Import Methods）

1. 直接导入（Direct Import）

   import math
   print(math.sqrt(16))  # 输出 4.0

2. 选择性导入（Selective Import）

   from math import sqrt, pi
   print(sqrt(9), pi)

3. 模块别名（Module Alias）

   import numpy as np

4. 动态导入（Dynamic Import）

   mod = __import__('math')
   print(mod.factorial(5))  # 输出 120

模块搜索路径（Module Search Path）

Python 导入模块时按以下顺序搜索：

1. 当前工作目录（Current Directory）
2. 环境变量 PYTHONPATH 指定的目录
3. 标准库（Standard Library）目录
4. 第三方包（Third-party Packages）目录

可通过查看：

import sys
print(sys.path)

获取模块搜索路径。

12.2 自定义包与目录结构（Custom Packages and Directory Structure）

定义（Definition）

包（Package）是包含 __init__.py 文件的目录，用于组织多个模块。
使 Python 将该目录视为一个逻辑命名空间。

包结构（Package Structure）示例：

project/
│
├── main.py
└── utils/
    ├── __init__.py
    ├── file_ops.py
    └── string_ops.py

在 main.py 中导入方式：

from utils import file_ops
file_ops.read_file("data.txt")

__init__.py 的作用

• 标识目录为包；
• 可定义包级变量或自动加载模块。

示例：

# utils/__init__.py
print("utils package loaded")

12.3 虚拟环境（Virtual Environments）

定义（Definition）

虚拟环境（Virtual Environment）用于为不同项目创建相互独立的 Python 包依赖空间，避免版本冲突。

1. venv 虚拟环境

（Python 内置方式）

创建环境：

python -m venv venv_name

激活环境：

• Windows:

  venv_name\Scripts\activate

• macOS / Linux:

  source venv_name/bin/activate

退出环境：

deactivate

2. conda 环境

（适用于数据科学或复杂依赖场景）

常用命令：

conda create -n myenv python=3.11
conda activate myenv
conda install numpy pandas
conda deactivate