第9章模塊與包¶

在Python編程中，隨着項目規模的增長，將所有代碼寫在一個文件中會變得難以維護。模塊和包是Python提供的代碼組織和重用機制，它們讓我們能夠將相關的功能分組，提高代碼的可讀性、可維護性和可重用性。本章將深入探討Python的模塊和包系統，從基本概念到高級應用，幫助你構建更好的Python項目結構。

本系列文章所使用到的示例源碼：Python從入門到精通示例代碼

9.1 模塊的概念與導入¶

模塊的定義¶

模塊是什麼

模塊（Module）是包含Python代碼的文件，通常以.py爲擴展名。一個模塊可以包含函數、類、變量以及可執行的代碼。模塊的主要目的是將相關的功能組織在一起，便於代碼的重用和維護。

模塊的作用和優勢

代碼重用：一次編寫，多次使用
命名空間管理：避免命名衝突
代碼組織：將相關功能分組
維護性：便於代碼的修改和調試
協作開發：不同開發者可以獨立開發不同模塊

模塊 vs 腳本

腳本：直接執行的Python文件，通常包含主程序邏輯
模塊：被其他程序導入使用的Python文件，提供特定功能

同一個.py文件既可以作爲腳本運行，也可以作爲模塊導入。

Python模塊的類型¶

Python中有四種類型的模塊：

內置模塊（built-in modules）：用C語言編寫，編譯到Python解釋器中
標準庫模塊（standard library）：Python安裝時自帶的模塊
第三方模塊（third-party modules）：由社區開發的模塊
自定義模塊（user-defined modules）：用戶自己編寫的模塊

模塊的創建¶

創建一個模塊非常簡單，只需要創建一個.py文件即可。讓我們創建一個示例模塊：

"""這是一個示例模塊
用於演示模塊的基本概念和使用方法
"""

# 模塊級別的變量
MODULE_VERSION = "1.0.0"
PI = 3.14159

# 模塊級別的函數
def greet(name):
    """問候函數

    Args:
        name (str): 要問候的人的姓名

    Returns:
        str: 問候語
    """
    return f"Hello, {name}!"

def calculate_area(radius):
    """計算圓的面積

    Args:
        radius (float): 圓的半徑

    Returns:
        float: 圓的面積
    """
    return PI * radius ** 2

# 模塊級別的類
class Calculator:
    """簡單的計算器類"""

    def __init__(self):
        """初始化計算器"""
        self.result = 0

    def add(self, x, y):
        """加法運算"""
        self.result = x + y
        return self.result

    def multiply(self, x, y):
        """乘法運算"""
        self.result = x * y
        return self.result

# 當模塊被直接運行時執行的代碼
if __name__ == "__main__":
    print("這是my_module模塊的測試代碼")
    print(f"模塊版本: {MODULE_VERSION}")
    print(greet("Python"))

    calc = Calculator()
    print(f"5 + 3 = {calc.add(5, 3)}")
    print(f"圓的面積 (半徑=2): {calculate_area(2)}")

當我們直接運行這個模塊時，輸出如下：

這是my_module模塊的測試代碼
模塊版本: 1.0.0
Hello, Python!
5 + 3 = 8
圓的面積 (半徑=2): 12.56636

模塊名的命名規範

使用小寫字母
單詞之間用下劃線分隔
避免使用Python關鍵字
名稱應該簡潔且有意義

模塊的文檔字符串

模塊的第一個字符串（如果存在）會被視爲模塊的文檔字符串，可以通過模塊名.__doc__訪問。

基本導入語法¶

Python提供了多種導入模塊的方式：

1. import語句

import my_module

# 使用模塊中的功能
print(my_module.MODULE_VERSION)
print(my_module.greet("Alice"))
calc = my_module.Calculator()

2. from…import語句

from my_module import greet, PI

# 直接使用導入的對象
print(greet("Bob"))
print(f"PI值: {PI}")

3. import…as語句

import my_module as mm

# 使用別名
print(mm.greet("Charlie"))

4. 導入所有內容

from my_module import *

# 可以直接使用所有公共對象
print(greet("David"))

注意：不推薦使用from module import *，因爲它可能導致命名衝突。

讓我們看一個完整的使用示例：

# 導入模塊的示例

# 方法1: 導入整個模塊
import my_module

# 方法2: 從模塊導入特定對象
from my_module import greet, PI

# 方法3: 導入模塊並使用別名
import my_module as mm

print("\n方法1: 導入整個模塊")
print(f"模塊版本: {my_module.MODULE_VERSION}")
print(my_module.greet("Alice"))
print(f"圓的面積 (半徑=3): {my_module.calculate_area(3)}")

calc1 = my_module.Calculator()
print(f"2 * 4 = {calc1.multiply(2, 4)}")

print("\n方法2: 從模塊導入特定對象")
print(greet("Bob"))
print(f"PI值: {PI}")

print("\n方法3: 導入模塊並使用別名")
print(mm.greet("Charlie"))
calc2 = mm.Calculator()
print(f"10 + 5 = {calc2.add(10, 5)}")

運行結果：

方法1: 導入整個模塊
模塊版本: 1.0.0
Hello, Alice!
圓的面積 (半徑=3): 28.27431
2 * 4 = 8

方法2: 從模塊導入特定對象
Hello, Bob!
PI值: 3.14159

方法3: 導入模塊並使用別名
Hello, Charlie!
10 + 5 = 15

導入的本質（名稱綁定）

導入操作實際上是將模塊對象綁定到當前命名空間中的一個名稱。當我們執行import my_module時，Python會：

查找並加載模塊
創建模塊對象
將模塊對象綁定到名稱my_module

9.2 模塊的搜索路徑¶

Python模塊搜索機制¶

當Python遇到import語句時，它會按照特定的順序搜索模塊：

sys.path列表

sys.path是一個包含搜索路徑的列表，Python會按照這個列表中的順序搜索模塊。

import sys
import os

print("=== Python模塊搜索路徑演示 ===")
print("\n當前sys.path內容:")
for i, path in enumerate(sys.path):
    print(f"{i+1}. {path}")

print(f"\n當前工作目錄: {os.getcwd()}")
print(f"腳本所在目錄: {os.path.dirname(os.path.abspath(__file__))}")

運行結果：

=== Python模塊搜索路徑演示 ===

當前sys.path內容:
1. C:\Users\yeyupiaoling/Python從入門到精通\test_files
2. D:\Anaconda\python312.zip
3. D:\Anaconda\DLLs
4. D:\Anaconda\Lib
5. D:\Anaconda
6. D:\Anaconda\Lib\site-packages
7. D:\Anaconda\Lib\site-packages\win32
8. D:\Anaconda\Lib\site-packages\win32\lib
9. D:\Anaconda\Lib\site-packages\Pythonwin

搜索順序

當前目錄：腳本所在的目錄或當前工作目錄
PYTHONPATH環境變量：用戶設置的額外搜索路徑
標準庫目錄：Python標準庫的安裝目錄
site-packages目錄：第三方包的安裝目錄

動態修改搜索路徑¶

sys.path.append()

import sys

# 添加新的搜索路徑
new_path = r"C:\temp\my_modules"
sys.path.append(new_path)
print(f"添加新路徑: {new_path}")
print(f"當前sys.path長度: {len(sys.path)}")

sys.path.insert()

# 在指定位置插入搜索路徑
sys.path.insert(0, r"C:\priority\modules")

PYTHONPATH環境變量設置

在Windows中設置PYTHONPATH：

set PYTHONPATH=C:\my_modules;%PYTHONPATH%

在Linux/Mac中設置PYTHONPATH：

export PYTHONPATH=/path/to/my_modules:$PYTHONPATH

模塊緩存機制¶

sys.modules字典

Python使用sys.modules字典來緩存已導入的模塊，避免重複加載。

import sys

print(f"已加載的模塊數量: {len(sys.modules)}")
print("\n部分已加載的模塊:")
module_names = list(sys.modules.keys())[:10]
for name in module_names:
    print(f"  - {name}")

# 檢查特定模塊是否已加載
if 'my_module' in sys.modules:
    print("\nmy_module已在緩存中")
else:
    print("\nmy_module未在緩存中")

# 導入模塊後再次檢查
import my_module
if 'my_module' in sys.modules:
    print("導入後，my_module已在緩存中")
    print(f"模塊對象: {sys.modules['my_module']}")
    print(f"模塊文件路徑: {sys.modules['my_module'].__file__}")

運行結果：

已加載的模塊數量: 50

部分已加載的模塊:
  - sys
  - builtins
  - _frozen_importlib
  - _imp
  - _thread
  - _warnings
  - _weakref
  - winreg
  - _io
  - marshal

my_module未在緩存中
導入後，my_module已在緩存中
模塊對象: <module 'my_module' from 'C:\\Users\\yeyupiaoling\\GitHub\\Python從入門到精通\\test_files\\my_module.py'>
模塊文件路徑: C:\Users\yeyupiaoling/Python從入門到精通\test_files\my_module.py

模塊的重新加載

由於模塊緩存機制，再次導入同一個模塊不會重新執行模塊代碼。如果需要重新加載模塊，可以使用importlib.reload()：

import importlib
import my_module

print("第一次導入my_module:")
print(f"模塊版本: {my_module.MODULE_VERSION}")

# 修改模塊中的變量
my_module.MODULE_VERSION = "2.0.0"
print(f"修改後的模塊版本: {my_module.MODULE_VERSION}")

# 重新加載模塊
my_module = importlib.reload(my_module)
print(f"重新加載後的模塊版本: {my_module.MODULE_VERSION}")

運行結果：

第一次導入my_module:
模塊版本: 1.0.0
修改後的模塊版本: 2.0.0
重新加載後的模塊版本: 1.0.0

模塊的編譯¶

.pyc文件

Python會將模塊編譯成字節碼並保存爲.pyc文件，以提高後續導入的速度。

__pycache__目錄

從Python 3.2開始，.pyc文件存儲在__pycache__目錄中，文件名包含Python版本信息。

字節碼緩存

字節碼緩存的優勢：
- 提高模塊導入速度
- 減少重複編譯的開銷
- 自動管理，無需手動干預

9.3 包的創建與使用¶

包的概念¶

包是模塊的容器

包（Package）是一種組織模塊的方式，它是包含多個模塊的目錄。包可以包含子包，形成層次結構。

包的層次結構

mypackage/
    __init__.py
    math_utils.py
    string_utils.py
    data_utils.py
    subpackage/
        __init__.py
        advanced_math.py

包 vs 目錄

普通目錄和包的區別在於包必須包含__init__.py文件（Python 3.3+中這不是強制要求，但仍然推薦）。

包的創建¶

讓我們創建一個完整的包示例：

1. 包的初始化文件（__init__.py）

"""mypackage包的初始化文件

這個包演示了Python包的基本概念和使用方法
"""

# 包的版本信息
__version__ = "1.0.0"
__author__ = "Python學習者"

# 從子模塊導入常用的類和函數
from .math_utils import add, multiply, divide
from .string_utils import capitalize_words, reverse_string
from .data_utils import DataProcessor

# 定義包的公共API
__all__ = [
    'add', 'multiply', 'divide',
    'capitalize_words', 'reverse_string',
    'DataProcessor'
]

print(f"mypackage包已加載，版本: {__version__}")

2. 數學工具模塊（math_utils.py）

"""數學工具模塊

提供基本的數學運算功能
"""

def add(a, b):
    """加法運算"""
    return a + b

def multiply(a, b):
    """乘法運算"""
    return a * b

def divide(a, b):
    """除法運算"""
    if b == 0:
        raise ValueError("除數不能爲0")
    return a / b

3. 字符串工具模塊（string_utils.py）

"""字符串工具模塊

提供字符串處理功能
"""

def capitalize_words(text):
    """將字符串中每個單詞的首字母大寫"""
    return ' '.join(word.capitalize() for word in text.split())

def reverse_string(text):
    """反轉字符串"""
    return text[::-1]

def count_words(text):
    """統計字符串中的單詞數量"""
    return len(text.split())

4. 數據處理模塊（data_utils.py）

"""數據處理工具模塊

提供數據處理和分析功能
"""

class DataProcessor:
    """數據處理器類"""

    def __init__(self):
        """初始化數據處理器"""
        self.data = []

    def add_data(self, item):
        """添加數據項"""
        self.data.append(item)

    def get_average(self):
        """計算數據的平均值"""
        if not self.data:
            raise ValueError("數據爲空，無法計算平均值")
        return sum(self.data) / len(self.data)

    def get_max(self):
        """獲取最大值"""
        if not self.data:
            raise ValueError("數據爲空，無法獲取最大值")
        return max(self.data)

包的導入¶

創建包使用示例：

# 演示包的使用方法

print("=== 包的導入和使用演示 ===")

# 方法1: 導入整個包
import mypackage
print(f"\n包版本: {mypackage.__version__}")
print(f"包作者: {mypackage.__author__}")

# 使用包中的函數
print(f"\n使用包中的函數:")
print(f"5 + 3 = {mypackage.add(5, 3)}")
print(f"4 * 6 = {mypackage.multiply(4, 6)}")
print(f"大寫單詞: {mypackage.capitalize_words('hello world python')}")
print(f"反轉字符串: {mypackage.reverse_string('Python')}")

# 使用包中的類
print(f"\n使用包中的類:")
processor = mypackage.DataProcessor()
processor.add_data(10)
processor.add_data(20)
processor.add_data(30)
print(f"數據平均值: {processor.get_average()}")
print(f"數據最大值: {processor.get_max()}")

# 方法2: 從包導入特定模塊
print(f"\n=== 導入特定模塊 ===")
from mypackage import math_utils, string_utils

print(f"10 / 2 = {math_utils.divide(10, 2)}")
print(f"單詞數量: {string_utils.count_words('Python is awesome')}")

運行結果：

=== 包的導入和使用演示 ===
mypackage包已加載，版本: 1.0.0

包版本: 1.0.0
包作者: Python學習者

使用包中的函數:
5 + 3 = 8
4 * 6 = 24
大寫單詞: Hello World Python
反轉字符串: nohtyP

使用包中的類:
數據平均值: 20.0
數據最大值: 30

=== 導入特定模塊 ===
10 / 2 = 5.0
單詞數量: 3

子包的創建¶

我們可以在包中創建子包：

子包的__init__.py

"""子包的初始化文件

演示包的層次結構
"""

from .advanced_math import factorial, fibonacci

__all__ = ['factorial', 'fibonacci']

print("子包subpackage已加載")

高級數學模塊（advanced_math.py）

"""高級數學運算模塊

提供更復雜的數學運算功能
"""

def factorial(n):
    """計算階乘"""
    if n < 0:
        raise ValueError("階乘的參數必須是非負整數")
    if n == 0 or n == 1:
        return 1
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

def fibonacci(n):
    """計算斐波那契數列的第n項"""
    if n < 0:
        raise ValueError("斐波那契數列的參數必須是非負整數")
    if n == 0:
        return 0
    if n == 1:
        return 1

    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b

使用子包：

# 導入子包
from mypackage.subpackage import factorial, fibonacci

print(f"5的階乘: {factorial(5)}")
print(f"斐波那契數列第10項: {fibonacci(10)}")

運行結果：

子包subpackage已加載
5的階乘: 120
斐波那契數列第10項: 55

9.4 init.py文件¶

init.py的作用¶

__init__.py文件有以下幾個重要作用：

標識包目錄：告訴Python這是一個包
包的初始化代碼：在包被導入時執行
控制包的導入行爲：定義包的公共接口

init.py的內容¶

1. 空文件

最簡單的__init__.py可以是空文件，僅用於標識包。

2. 初始化代碼

# 包級別的初始化
print("包正在初始化...")

# 設置包級別的變量
PACKAGE_NAME = "MyAwesomePackage"
VERSION = "1.0.0"

# 執行初始化邏輯
def _initialize_package():
    """包的初始化函數"""
    print(f"初始化{PACKAGE_NAME} v{VERSION}")

_initialize_package()

3. 導入子模塊

# 從子模塊導入常用功能
from .module1 import function1, Class1
from .module2 import function2
from .subpackage import advanced_function

# 簡化導入路徑
from .utils.helpers import helper_function as help

4. 定義__all__列表

# 定義包的公共API
__all__ = [
    'function1',
    'Class1', 
    'function2',
    'advanced_function'
]

all變量¶

__all__變量控制from package import *的行爲：

# 在__init__.py中定義
__all__ = ['add', 'multiply', 'Calculator']

# 只有__all__中列出的名稱會被導入
from mypackage import *  # 只導入add, multiply, Calculator

公共API的定義

使用__all__可以明確定義包的公共接口，隱藏內部實現細節：

# __init__.py
from .internal_module import _private_function
from .public_module import public_function

# 只暴露公共函數
__all__ = ['public_function']

# _private_function不會被from package import *導入

最佳實踐

總是定義__all__列表
只包含真正的公共API
保持__all__列表的更新
使用有意義的名稱

包的版本信息¶

在__init__.py中定義版本信息是常見做法：

# 版本信息
__version__ = "1.2.3"
__author__ = "Your Name"
__email__ = "your.email@example.com"
__license__ = "MIT"

# 版本號管理
VERSION_INFO = (1, 2, 3)
__version__ = '.'.join(map(str, VERSION_INFO))

9.5 相對導入與絕對導入¶

絕對導入¶

從頂級包開始的完整路徑

絕對導入使用完整的模塊路徑，從頂級包開始：

# 絕對導入示例
from mypackage.math_utils import add
from mypackage.subpackage.advanced_math import factorial
import mypackage.string_utils

明確性和可讀性

絕對導入的優勢：
- 路徑明確，易於理解
- 不依賴當前模塊的位置
- 便於代碼重構和移動

推薦的導入方式

絕對導入是推薦的導入方式，特別是在大型項目中。

相對導入¶

相對於當前模塊的位置

相對導入使用.和..語法，相對於當前模塊的位置：

# 在mypackage/relative_import_demo.py中

# 相對導入同級模塊
from . import math_utils, string_utils

# 相對導入子包
from .subpackage import advanced_math

# 相對導入上級包（如果存在）
from .. import some_module

def demo_relative_imports():
    """演示相對導入的函數"""
    print("=== 相對導入演示 ===")

    # 使用同級模塊的函數
    print(f"使用math_utils: 8 + 2 = {math_utils.add(8, 2)}")
    print(f"使用string_utils: {string_utils.capitalize_words('relative import demo')}")

    # 使用子包的函數
    print(f"使用advanced_math: 4的階乘 = {advanced_math.factorial(4)}")
    print(f"使用advanced_math: 斐波那契數列第7項 = {advanced_math.fibonacci(7)}")

.和..語法

.：當前包
..：上級包
...：上上級包（以此類推）

相對導入的限制

只能在包內部使用
不能在主模塊中使用
模塊必須作爲包的一部分被導入

導入的最佳實踐¶

1. 優先使用絕對導入

# 推薦
from mypackage.utils import helper_function

# 不推薦（除非在包內部）
from .utils import helper_function

2. 避免循環導入

循環導入是指兩個或多個模塊相互導入，可能導致導入錯誤。

# module_a.py
from module_b import function_b

def function_a():
    return function_b()

# module_b.py  
from module_a import function_a  # 循環導入！

def function_b():
    return function_a()

3. 導入語句的組織

按照PEP 8的建議組織導入語句：

# 1. 標準庫導入
import os
import sys
from pathlib import Path

# 2. 第三方庫導入
import requests
import numpy as np

# 3. 本地應用/庫導入
from mypackage import utils
from .local_module import local_function

循環導入問題¶

循環導入的原因

循環導入通常由以下原因造成：
- 模塊設計不合理
- 功能劃分不清晰
- 過度耦合

解決循環導入的方法

重新設計模塊結構

# 將共同依賴提取到單獨的模塊
# common.py
def shared_function():
    return "shared"

# module_a.py
from common import shared_function

# module_b.py
from common import shared_function

延遲導入技術

# module_a.py
def function_a():
    # 在函數內部導入，避免模塊級循環導入
    from module_b import function_b
    return function_b()

使用字符串導入

# 使用importlib動態導入
import importlib

def get_function_from_module(module_name, function_name):
    module = importlib.import_module(module_name)
    return getattr(module, function_name)

9.6 第三方模塊的安裝與使用¶

pip包管理器¶

pip的基本使用

pip是Python的標準包管理工具，用於安裝和管理第三方包。

# 安裝包
pip install requests

# 安裝特定版本
pip install requests==2.28.1

# 安裝最新版本
pip install --upgrade requests

# 卸載包
pip uninstall requests

# 查看已安裝的包
pip list

# 查看包信息
pip show requests

# 搜索包
pip search keyword

包的搜索、安裝、升級、卸載

# 從PyPI安裝
pip install numpy

# 從Git倉庫安裝
pip install git+https://github.com/user/repo.git

# 從本地文件安裝
pip install ./my_package

# 安裝開發版本
pip install -e ./my_package

requirements.txt文件

requirements.txt文件用於管理項目依賴：

# requirements.txt
requests==2.28.1
numpy>=1.21.0
pandas>=1.3.0,<2.0.0
matplotlib
flask==2.2.2

使用requirements.txt：

# 安裝所有依賴
pip install -r requirements.txt

# 生成requirements.txt
pip freeze > requirements.txt

pip freeze命令

# 查看當前環境的所有包及版本
pip freeze

# 輸出示例
numpy==1.21.5
pandas==1.4.2
requests==2.28.1

虛擬環境¶

虛擬環境的概念和作用

虛擬環境是Python的獨立運行環境，可以：
- 隔離不同項目的依賴
- 避免包版本衝突
- 便於項目部署和分發

venv模塊的使用

# 創建虛擬環境
python -m venv myenv

# 激活虛擬環境（Windows）
myenv\Scripts\activate

# 激活虛擬環境（Linux/Mac）
source myenv/bin/activate

# 停用虛擬環境
deactivate

虛擬環境的創建和激活

完整的虛擬環境工作流程：

# 1. 創建項目目錄
mkdir my_project
cd my_project

# 2. 創建虛擬環境
python -m venv venv

# 3. 激活虛擬環境
venv\Scripts\activate  # Windows
# source venv/bin/activate  # Linux/Mac

# 4. 安裝依賴
pip install requests numpy

# 5. 生成依賴文件
pip freeze > requirements.txt

# 6. 停用虛擬環境
deactivate

虛擬環境的管理

# 查看虛擬環境中的包
pip list

# 刪除虛擬環境（刪除目錄即可）
rmdir /s venv  # Windows
# rm -rf venv   # Linux/Mac

# 複製虛擬環境配置
pip freeze > requirements.txt
# 在新環境中：pip install -r requirements.txt

包的分發¶

setup.py文件

setup.py是Python包的構建腳本：

from setuptools import setup, find_packages

setup(
    name="mypackage",
    version="1.0.0",
    author="Your Name",
    author_email="your.email@example.com",
    description="A sample Python package",
    long_description=open("README.md").read(),
    long_description_content_type="text/markdown",
    url="https://github.com/yourusername/mypackage",
    packages=find_packages(),
    classifiers=[
        "Programming Language :: Python :: 3",
        "License :: OSI Approved :: MIT License",
        "Operating System :: OS Independent",
    ],
    python_requires='>=3.6',
    install_requires=[
        "requests>=2.25.0",
        "numpy>=1.19.0",
    ],
)

包的打包和發佈

# 安裝構建工具
pip install build twine

# 構建包
python -m build

# 上傳到PyPI（測試）
twine upload --repository testpypi dist/*

# 上傳到PyPI（正式）
twine upload dist/*

PyPI（Python Package Index）

PyPI是Python官方的包倉庫，包含數十萬個第三方包。訪問 https://pypi.org 可以搜索和瀏覽包。

常用第三方庫介紹¶

1. requests：HTTP庫

import requests

# GET請求
response = requests.get('https://api.github.com/users/octocat')
print(response.json())

# POST請求
data = {'key': 'value'}
response = requests.post('https://httpbin.org/post', json=data)
print(response.status_code)

2. numpy：數值計算

import numpy as np

# 創建數組
arr = np.array([1, 2, 3, 4, 5])
print(f"數組: {arr}")
print(f"平均值: {np.mean(arr)}")

# 矩陣運算
matrix = np.array([[1, 2], [3, 4]])
print(f"矩陣:\n{matrix}")
print(f"轉置:\n{matrix.T}")

3. pandas：數據分析

import pandas as pd

# 創建DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['New York', 'London', 'Tokyo']}
df = pd.DataFrame(data)
print(df)

# 數據篩選
young_people = df[df['Age'] < 30]
print(young_people)

4. matplotlib：數據可視化

import matplotlib.pyplot as plt
import numpy as np

# 創建圖表
x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.figure(figsize=(10, 6))
plt.plot(x, y, label='sin(x)')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Sine Wave')
plt.legend()
plt.grid(True)
plt.show()

5. flask：Web框架

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

@app.route('/api/data')
def get_data():
    return jsonify({'message': 'Hello from Flask API'})

if __name__ == '__main__':
    app.run(debug=True)

總結¶

本章詳細介紹了Python的模塊和包系統，這是構建大型Python應用的基礎。通過學習本章內容，你應該掌握：

模塊的基本概念：理解模塊的作用、類型和創建方法
導入機制：掌握各種導入語法和最佳實踐
搜索路徑：瞭解Python如何查找模塊，以及如何自定義搜索路徑
包的組織：學會創建和使用包，理解包的層次結構
相對導入與絕對導入：知道何時使用哪種導入方式
第三方包管理：掌握pip的使用和虛擬環境的管理

模塊和包是Python編程的重要組成部分，合理的模塊化設計能夠提高代碼的可維護性、可重用性和可擴展性。在實際項目中，建議：

優先使用絕對導入
合理組織包結構
使用虛擬環境管理依賴
編寫清晰的文檔字符串
定義明確的公共API

掌握這些知識後，你就能夠構建結構清晰、易於維護的Python項目了。

第9章 模塊與包¶

9.1 模塊的概念與導入¶

模塊的定義¶

Python模塊的類型¶

模塊的創建¶

基本導入語法¶

9.2 模塊的搜索路徑¶

Python模塊搜索機制¶

動態修改搜索路徑¶

模塊緩存機制¶

模塊的編譯¶

9.3 包的創建與使用¶

包的概念¶

包的創建¶

包的導入¶

子包的創建¶

9.4 init.py文件¶

init.py的作用¶

init.py的內容¶

__all__變量¶

包的版本信息¶

9.5 相對導入與絕對導入¶

絕對導入¶

相對導入¶

導入的最佳實踐¶

循環導入問題¶

9.6 第三方模塊的安裝與使用¶

pip包管理器¶

虛擬環境¶

包的分發¶

常用第三方庫介紹¶

總結¶

相關文章

第9章模塊與包¶

all變量¶