# 1. 導(dǎo)入整個(gè)math模塊
import math
# 2. 通過模塊名調(diào)用函數(shù)/變量
# 計(jì)算圓周率π（math.pi是math模塊中的變量）
print("圓周率π的值：", math.pi)  # 輸出：3.141592653589793
# 計(jì)算正弦函數(shù)sin(π/2)（關(guān)聯(lián)高數(shù)三角函數(shù)）
sin_value = math.sin(math.pi / 2)
print("sin(π/2)的值：", sin_value)  # 輸出：1.0
# 計(jì)算平方根√16（關(guān)聯(lián)高數(shù)基本運(yùn)算）
sqrt_value = math.sqrt(16)
print("√16的值：", sqrt_value)  # 輸出：4.0

# 1. 導(dǎo)入numpy模塊，起別名np（行業(yè)通用別名，新手要記?。?
import numpy as np
# 2. 通過別名np調(diào)用函數(shù)
# 創(chuàng)建一個(gè)2×3的矩陣（關(guān)聯(lián)線代矩陣概念）
matrix = np.array([[1, 2, 3], [4, 5, 6]])
print("2×3矩陣：\n", matrix)
# 輸出：
# [[1 2 3]
#  [4 5 6]]
# 計(jì)算矩陣的轉(zhuǎn)置（關(guān)聯(lián)線代矩陣轉(zhuǎn)置）
transpose_matrix = matrix.T
print("矩陣的轉(zhuǎn)置：\n", transpose_matrix)
# 輸出：
# [[1 4]
#  [2 5]
#  [3 6]]

# 1. 從math模塊中導(dǎo)入指定的函數(shù)和變量
from math import pi, sin, sqrt
# 2. 直接使用函數(shù)名/變量名，不需要寫math.
print("圓周率π的值：", pi)
print("sin(π/2)的值：", sin(pi / 2))
print("√16的值：", sqrt(16))
# 3. 也可以一次導(dǎo)入多個(gè)，用逗號分隔
from math import cos, tan, log
print("cos(0)的值：", cos(0))  # 輸出：1.0

# 假設(shè)你有一個(gè)ai_tools包，里面有math_utils.py模塊
from ai_tools import math_utils
# 使用時(shí)通過模塊名調(diào)用
math_utils.my_sin(pi / 2)

# 從math模塊中導(dǎo)入所有內(nèi)容
from math import *
# 直接使用
print(pi)
print(sin(pi / 2))

# my_calculator.py - 自定義計(jì)算器模塊
# 定義模塊級變量（可以被導(dǎo)入）
PI = 3.1415926  # 模擬圓周率
# 定義加法函數(shù)
def add(a, b):
    """計(jì)算兩個(gè)數(shù)的和"""
    return a + b
# 定義減法函數(shù)
def subtract(a, b):
    """計(jì)算兩個(gè)數(shù)的差"""
    return a - b
# 定義乘法函數(shù)
def multiply(a, b):
    """計(jì)算兩個(gè)數(shù)的積"""
    return a * b
# 定義除法函數(shù)
def divide(a, b):
    """計(jì)算兩個(gè)數(shù)的商，除數(shù)不能為0"""
    if b == 0:
        raise ValueError("除數(shù)不能為0")  # 拋出異常
    return a / b
# 定義私有函數(shù)（以下劃線開頭，不會被from module import *導(dǎo)入）
def _private_function():
    """這是一個(gè)私有函數(shù)，僅在模塊內(nèi)部使用"""
    print("這是私有函數(shù)，外部不應(yīng)該直接調(diào)用")
# 模塊的測試代碼（僅在直接運(yùn)行該模塊時(shí)執(zhí)行，導(dǎo)入時(shí)不執(zhí)行）
if __name__ == "__main__":
    print("測試my_calculator模塊：")
    print("1 + 2 =", add(1, 2))
    print("5 - 3 =", subtract(5, 3))
    print("2 × 3 =", multiply(2, 3))
    print("6 ÷ 2 =", divide(6, 2))

# test_module.py - 測試自定義模塊
# 方式1：導(dǎo)入整個(gè)模塊
import my_calculator
print("方式1：")
print("PI的值：", my_calculator.PI)
print("3 + 4 =", my_calculator.add(3, 4))
# 方式2：導(dǎo)入指定函數(shù)
from my_calculator import subtract, multiply
print("\n方式2：")
print("10 - 5 =", subtract(10, 5))
print("4 × 5 =", multiply(4, 5))
# 方式3：導(dǎo)入模塊并起別名
import my_calculator as mc
print("\n方式3：")
print("8 ÷ 2 =", mc.divide(8, 2))

ai_utils/                # 包的根文件夾
    __init__.py          # 包的標(biāo)識文件（可以為空，也可以寫初始化代碼）
    math_tools.py        # 高數(shù)工具模塊
    linear_algebra.py    # 線代工具模塊
一鍵獲取完整項(xiàng)目代碼
步驟2：編寫包中的模塊
math_tools.py（高數(shù)工具模塊）：
# ai_utils/math_tools.py - 高數(shù)工具模塊
import math
# 計(jì)算正弦函數(shù)（角度制轉(zhuǎn)弧度制）
def sin_degree(degree):
    """輸入角度，返回正弦值"""
    radian = math.radians(degree)  # 角度轉(zhuǎn)弧度
    return math.sin(radian)
# 計(jì)算余弦函數(shù)（角度制）
def cos_degree(degree):
    """輸入角度，返回余弦值"""
    radian = math.radians(degree)
    return math.cos(radian)

linear_algebra.py（線代工具模塊，簡化版）：
# ai_utils/linear_algebra.py - 線代工具模塊
# 計(jì)算兩個(gè)向量的點(diǎn)積（關(guān)聯(lián)線代向量點(diǎn)積）
def vector_dot_product(v1, v2):
    """計(jì)算兩個(gè)列表表示的向量的點(diǎn)積，要求長度相同"""
    if len(v1) != len(v2):
        raise ValueError("兩個(gè)向量長度必須相同")
    # 用zip并行遍歷兩個(gè)向量，對應(yīng)元素相乘后求和
    return sum(a * b for a, b in zip(v1, v2))
一鍵獲取完整項(xiàng)目代碼
__init__.py（可以為空，也可以寫初始化代碼，比如導(dǎo)入常用模塊）：
# ai_utils/__init__.py - 包的初始化文件
# 可選：導(dǎo)入包中的常用模塊，方便用戶直接從包導(dǎo)入
from . import math_tools
from . import linear_algebra

# test_package.py - 測試自定義包
# 方式1：導(dǎo)入包中的模塊
from ai_utils import math_tools, linear_algebra
print("方式1：")
print("sin(30°) =", math_tools.sin_degree(30))  # 輸出：0.5
print("向量[1,2,3]和[4,5,6]的點(diǎn)積：", linear_algebra.vector_dot_product([1,2,3], [4,5,6]))  # 輸出：32
# 方式2：從模塊中導(dǎo)入指定函數(shù)
from ai_utils.math_tools import cos_degree
print("\n方式2：")
print("cos(60°) =", cos_degree(60))  # 輸出：0.5

import random
# 生成0-1之間的隨機(jī)浮點(diǎn)數(shù)
print(random.random())
# 生成指定范圍內(nèi)的隨機(jī)整數(shù)（左閉右閉）
print(random.randint(1, 10))  # 生成1-10的整數(shù)
# 從列表中隨機(jī)選擇一個(gè)元素
fruits = ["蘋果", "香蕉", "橙子"]
print(random.choice(fruits))
# 從列表中隨機(jī)選擇多個(gè)元素（不重復(fù)）
print(random.sample(fruits, 2))
# 打亂列表的順序（原地修改）
random.shuffle(fruits)
print(fruits)

import os
# 獲取當(dāng)前工作目錄
print("當(dāng)前目錄：", os.getcwd())
# 列出指定目錄下的所有文件和文件夾
print("目錄內(nèi)容：", os.listdir("."))  # "."表示當(dāng)前目錄
# 創(chuàng)建目錄（如果不存在）
if not os.path.exists("test_dir"):
    os.mkdir("test_dir")
# 拼接路徑（跨平臺兼容，Windows用\，Linux用/）
file_path = os.path.join("test_dir", "test.txt")
print("文件路徑：", file_path)
# 判斷文件/目錄是否存在
print("文件是否存在：", os.path.exists(file_path))
print("是否是目錄：", os.path.isdir("test_dir"))
print("是否是文件：", os.path.isfile(file_path))

import sys
# 獲取Python版本
print("Python版本：", sys.version)
# 獲取命令行參數(shù)（運(yùn)行腳本時(shí)傳入的參數(shù)）
print("命令行參數(shù)：", sys.argv)
# 獲取模塊搜索路徑（Python導(dǎo)包時(shí)會從這些路徑找模塊）
print("模塊搜索路徑：", sys.path)
# 退出程序
# sys.exit()

# 臨時(shí)添加模塊搜索路徑的示例
import sys
import os
# 獲取模塊所在目錄的絕對路徑
module_dir = os.path.abspath("path/to/your/module")
# 添加到模塊搜索路徑
if module_dir not in sys.path:
    sys.path.append(module_dir)
# 現(xiàn)在可以導(dǎo)入模塊了
import your_module

# 錯(cuò)誤示例：命名沖突
from math import sin
# 自己定義的sin函數(shù)
def sin(x):
    print("這是我自己的sin函數(shù)")
# 調(diào)用時(shí)，自己的函數(shù)覆蓋了math的sin函數(shù)
sin(math.pi / 2)  # 輸出：這是我自己的sin函數(shù)

# 正確示例：給導(dǎo)入的函數(shù)起別名
from math import sin as math_sin
def sin(x):
    print("這是我自己的sin函數(shù)")
# 調(diào)用math的sin函數(shù)
print(math_sin(math.pi / 2))  # 輸出：1.0
# 調(diào)用自己的sin函數(shù)
sin(0)  # 輸出：這是我自己的sin函數(shù)

module_a.py：
# module_a.py
import module_b
def func_a():
    print("這是func_a")
    module_b.func_b()
一鍵獲取完整項(xiàng)目代碼
module_b.py：
# module_b.py
import module_a
def func_b():
    print("這是func_b")
    module_a.func_a()

# 修正后的module_a.py
def func_a():
    print("這是func_a")
    # 延遲導(dǎo)入：在函數(shù)內(nèi)部導(dǎo)入
    import module_b
    module_b.func_b()

# 不推薦：導(dǎo)入私有成員
from my_calculator import _private_function
_private_function()  # 雖然可以運(yùn)行，但不符合規(guī)范