Python

安裝Python：

# 下載源文件
wget https://www.python.org/ftp/python/3.12.6/Python-3.12.6.tgz

# 解壓 
tar -zxvf Python-3.12.6.tgz
cd Python-3.12.6

# 編譯
./configure --prefix=/root/training/Python-3.6.5
make
make install

# 添加環(huán)境變量
vim ~/.bashrc

Pip：https://pip.pypa.io/en/stable/installation/

1.命令行

常用的 Python 3 命令行工具和選項：

• python3，用途：運行 Python 腳本。python3 your_script.py。
• -m，運行庫模塊作為腳本，python3 -m http.server 8000 啟動一個簡單的 HTTP 服務(wù)器。
• -c，執(zhí)行一段 Python 代碼，python3 -c "print('Hello, World!')"。
• -i，交互式解釋器，執(zhí)行完命令后保持交互模式，python3 -i。
• -v，輸出 Python 解釋器啟動時的版本和版權(quán)信息，python3 -v。
• -V，輸出 Python 解釋器的版本，python3 -V。
• -O，優(yōu)化模式，移除文檔字符串，python3 -O your_script.py。
• -OO，進(jìn)一步優(yōu)化，移除文檔字符串并進(jìn)行一些優(yōu)化，python3 -OO your_script.py。
• -B，在執(zhí)行前不寫入 __pycache__ 目錄，python3 -B your_script.py。
• --check，檢查源文件中的語法錯誤，python3 -m py_compile your_script.py。
• -W，控制警告消息的顯示，python3 -W all your_script.py。
• -I，在交互模式下不導(dǎo)入 sys 和 site 模塊，python3 -I。
• -E，在執(zhí)行前忽略環(huán)境變量，python3 -E your_script.py。
• -x，在執(zhí)行前忽略源文件編碼聲明，python3 -x your_script.py。
• -u，強制 Python 以非緩沖的方式運行，python3 -u your_script.py。
• -S，在執(zhí)行前不導(dǎo)入 site.py，python3 -S your_script.py。
• -R，在執(zhí)行前不運行 site.py 中的 site.main()，python3 -R your_script.py。
• -E，在執(zhí)行前不設(shè)置 PYTHON* 環(huán)境變量，python3 -E your_script.py。
• -X，啟用或禁用特定的警告，python3 -X faulthandler your_script.py。
• --help，顯示命令行選項的幫助信息，python3 --help。

2.基礎(chǔ)知識

Python 中有一些全局常量和變量，它們是內(nèi)置的，可以在任何地方使用，而不需要導(dǎo)入任何模塊。

常量：

• True：布爾類型中的真值。
• False：布爾類型中的假值。
• None：表示空值或無值的狀態(tài)。

內(nèi)置類型：

• bool：布爾類型。
• int：整數(shù)類型。
• float：浮點數(shù)類型。
• complex：復(fù)數(shù)類型。
• str：字符串類型。
• list：列表類型。
• tuple：元組類型。
• dict：字典類型。
• set：集合類型。
• frozenset：不可變集合類型。
• bytes：字節(jié)串類型。
• bytearray：可變字節(jié)串類型。
• memoryview：內(nèi)存視圖類型。

內(nèi)置函數(shù)：

• abs()：絕對值。
• all()：判斷給定的可迭代參數(shù) iterable 中的所有元素是否都為 True。
• any()：判斷給定的可迭代參數(shù) iterable 中是否至少有一個元素為 True。
• ascii()：返回對象的 ASCII 表示。
• bin()：返回整數(shù)的二進(jìn)制表示。
• bool()：將值轉(zhuǎn)換為布爾類型。
• bytearray()：返回可變的字節(jié)串。
• bytes()：返回不可變的字節(jié)串。
• callable()：判斷對象是否可調(diào)用。
• chr()：將 ASCII 碼轉(zhuǎn)為對應(yīng)的字符。
• classmethod()：創(chuàng)建一個類方法。
• compile()：編譯源代碼為可執(zhí)行的代碼或字節(jié)碼。
• complex()：返回一個復(fù)數(shù)。
• delattr()：刪除對象的屬性。
• dict()：返回一個新的字典。
• dir()：返回對象的屬性列表。
• divmod()：返回商和余數(shù)。
• enumerate()：返回枚舉對象，結(jié)合索引和元素。
• eval()：執(zhí)行字符串中的 Python 表達(dá)式。
• exec()：執(zhí)行字符串中的 Python 代碼。
• filter()：過濾序列，過濾掉不符合條件的元素。
• float()：將值轉(zhuǎn)換為浮點數(shù)。
• format()：格式化字符串。
• frozenset()：返回一個不可變集合。
• getattr()：獲取對象的屬性。
• globals()：返回當(dāng)前全局符號表的字典。
• hasattr()：判斷對象是否有指定的屬性。
• hash()：返回對象的哈希值。
• help()：返回對象的幫助文檔。
• hex()：返回整數(shù)的十六進(jìn)制表示。
• id()：返回對象的唯一標(biāo)識符。
• input()：獲取用戶輸入。
• int()：將值轉(zhuǎn)換為整數(shù)。
• isinstance()：判斷對象是否是給定類型的實例。
• issubclass()：判斷一個類是否是另一個類的子類。
• iter()：返回對象的迭代器。
• len()：返回對象的長度。
• list()：返回一個新的列表。
• locals()：返回當(dāng)前局部符號表的字典。
• map()：對序列的每個元素應(yīng)用函數(shù)。
• max()：返回最大值。
• memoryview()：返回內(nèi)存視圖。
• min()：返回最小值。
• next()：返回迭代器的下一個元素。
• object()：返回一個新對象。
• oct()：返回整數(shù)的八進(jìn)制表示。
• open()：打開文件。
• ord()：返回字符的 ASCII 碼。
• pow()：返回 x 的 y 次冪。
• print()：打印輸出。
• property()：創(chuàng)建一個屬性。
• range()：返回一個整數(shù)序列。
• repr()：返回對象的官方字符串表示。
• reversed()：反轉(zhuǎn)序列。
• round()：四舍五入。
• set()：返回一個新的集合。
• setattr()：設(shè)置對象的屬性。
• slice()：返回一個切片對象。
• sorted()：返回排序后的列表。
• staticmethod()：創(chuàng)建一個靜態(tài)方法。
• str()：將值轉(zhuǎn)換為字符串。
• sum()：返回序列的總和。
• super()：返回對象的父類。
• tuple()：返回一個新的元組。
• type()：返回對象的類型。
• vars()：返回對象的 dict 屬性。
• zip()：將多個迭代器壓縮在一起。

內(nèi)置異常：

• BaseException：所有內(nèi)置異常的基類。
• Exception：常規(guī)異常的基類。
• ArithmeticError：所有算術(shù)錯誤異常的基類。
• AssertionError：斷言錯誤。
• AttributeError：屬性錯誤。
• EOFError：文件結(jié)束錯誤。
• FloatingPointError：浮點錯誤。
• GeneratorExit：生成器退出異常。
• ImportError：導(dǎo)入模塊失敗。
• IndentationError：縮進(jìn)錯誤。
• IndexError：索引錯誤。
• KeyError：鍵錯誤。
• KeyboardInterrupt：鍵盤中斷。
• LookupError：查找錯誤。
• MemoryError：內(nèi)存錯誤。
• NameError：名稱錯誤。
• NotImplementedError：未實現(xiàn)錯誤。
• OSError：操作系統(tǒng)錯誤。
• OverflowError：溢出錯誤。
• RecursionError：遞歸錯誤。
• ReferenceError：引用錯誤。
• RuntimeError：運行時錯誤。
• StopIteration：停止迭代。
• SyntaxError：語法錯誤。
• SystemError：系統(tǒng)錯誤。
• SystemExit：系統(tǒng)退出。
• TypeError：類型錯誤。
• ValueError：值錯誤。
• ZeroDivisionError：除零錯誤。

內(nèi)置模塊：

• __name__：當(dāng)前模塊的名稱。
• __file__：當(dāng)前模塊的文件路徑。
• __builtins__：內(nèi)置函數(shù)和變量的字典。
• 常量
• 在Python中，雖然沒有專門的語法來聲明常量，但按照慣例，常量名稱通常使用全大寫字母來表示。在Python中，任何不可變的數(shù)據(jù)類型都可以用來作為字典（map）的鍵。由于常量通常是不變的，所以它們可以作為字典的鍵。

3.基本語法

三元運算：

# 三元運算符
max_num = num1 if num1 >= num2 else num2

base_path = (
    user_path
    / format_file_name(kwargs.get("naming", "{create}_{desc}"), aweme_data_dict)
    if kwargs.get("folderize")
    else user_path
)

條件語句：使用 if, elif, else 進(jìn)行條件判斷。

if x > 0:
    print("Positive")
elif x == 0:
    print("Zero")
else:
    print("Negative")

循環(huán)：for 循環(huán)用于遍歷序列（如列表、元組、字典等），while 循環(huán)用于在滿足條件時重復(fù)執(zhí)行代碼塊。

range() 函數(shù)在 Python 中返回的是一個 range 類型的對象。range 類型是一個不可變的序列，它提供了一種高效的方式來迭代一系列數(shù)字。range() 函數(shù)有三個參數(shù)：start（起始值，默認(rèn)為 0），stop（結(jié)束值，不包含此值），和 step（步長，默認(rèn)為 1）。你可以使用 step 參數(shù)來指定步長。

# for循環(huán)
for i in range(5):
    print(i)

# while循環(huán)
counter = 0
while counter < 5:
    print("counter 的值為：", counter)
    counter += 1  # 等同于 counter = counter + 1
    
    
    提示
    在 Python 中，break 語句只能用來退出最內(nèi)層的循環(huán)。與某些其他編程語言不同，Python 不支持直接使用標(biāo)簽或指定層級來跳出多層嵌套循環(huán)。

遍歷元組：

my_tuple = (1, 2, 3, 4, 5)

# 直接遍歷
for item in my_tuple:
    print(item)

# 使用 enumerate() 遍歷索引和元素
for index, item in enumerate(my_tuple):
    print(index, item)

遍歷列表：

my_list = [1, 2, 3, 4, 5]

# 直接遍歷
for item in my_list:
    print(item)

# 使用 enumerate() 遍歷索引和元素
for index, item in enumerate(my_list):
    print(index, item)

遍歷字典：

my_dict = {'a': 1, 'b': 2, 'c': 3}

# 遍歷鍵
for key in my_dict:
    print(key)

# 遍歷值
for value in my_dict.values():
    print(value)

# 遍歷鍵值對
for key, value in my_dict.items():
    print(key, value)

4.異常和錯誤處理

在 Python 中，異常處理是通過使用 try 和 except 語句來實現(xiàn)的。

try:
    result = 10 / 0
    raise ValueError("這是一個錯誤")
except ExceptionType1:
    # 處理 ExceptionType1 的代碼塊
    pass
except (ExceptionType2, ExceptionType3) as e:
    # 同時處理 ExceptionType2 和 ExceptionType3 的代碼塊
    print(e)
except ZeroDivisionError:
    print("不能除以零！")
    raise  # 重新拋出當(dāng)前捕獲的異常
except ZeroDivisionError:
    print("不能除以零！")
    raise  # 重新拋出當(dāng)前捕獲的異常
except Exception as e:
    print(f"發(fā)生了異常：{e}")
    raise  # 拋出新的異?；蛑匦聮伋霎?dāng)前捕獲的異常
else:
    print("沒有異常發(fā)生")
finally:
    print("這是 finally 塊，總是被執(zhí)行")

5.字符串操作

創(chuàng)建字符串：

s1 = 'Hello, World!'
s2 = "Hello, World!"
s3 = '''Hello,
World!'''
s4 = """Hello,
World!"""

字符串連接：

greeting = "Hello, "
name = "World"
message = greeting + name + "!"
print(message)  # 輸出：Hello, World!

字符串重復(fù)：

repeated = "hello " * 3
print(repeated)  # 輸出：hello hello hello

字符串切片：

s = "Hello, World!"
print(s[0:5])  # 輸出：Hello
print(s[7:])   # 輸出：World!

字符串方法：

• .upper()：轉(zhuǎn)換為大寫。
• .lower()：轉(zhuǎn)換為小寫。
• .capitalize()：首字母大寫。
• .title()：每個單詞的首字母大寫。
• .strip()：移除字符串開頭和結(jié)尾的空白字符。
• .split()：按照指定分隔符切分字符串。
• .join()：將序列中的元素以指定的字符連接生成一個新的字符串。
• .find() 或 .index()：查找子字符串并返回索引位置。
• .replace()：替換字符串中的某些字符。
• .len()：返回字符串長度。

字符串格式化：

name = "World"
greeting = "Hello, %s!" % name
print(greeting)  # 輸出：Hello, World!

greeting = "Hello, {}!".format(name)
print(greeting)  # 輸出：Hello, World!

greeting = f"Hello, {name}!"
print(greeting)  # 輸出：Hello, World!

字符串編碼：

s = "Hello, World!"
encoded = s.encode('utf-8')  # 編碼為字節(jié)串
decoded = encoded.decode('utf-8')  # 解碼為字符串

字符串前綴：

• f或 F：表示格式化字符串字面量（f-string），允許在字符串中直接嵌入表達(dá)式。
• r 或 R：表示原始字符串，忽略字符串中的轉(zhuǎn)義字符。
• b 或 B：表示字節(jié)字符串，用于處理二進(jìn)制數(shù)據(jù)。

6.模塊和包

Python 模塊是包含 Python 代碼的文件，通常是一個 .py 文件。模塊可以定義函數(shù)、類和變量，也可以包含可執(zhí)行的代碼。

# 導(dǎo)入模塊
import mymodule
mymodule.greet("Alice")

# 導(dǎo)入特定的功能
from mymodule import greet, Calculator

greet("Bob")
calculator = Calculator()

# 使用別名
import mymodule as mm
mm.greet("Charlie")

包是包含多個模塊的目錄，它必須包含一個名為 __init__.py 的文件（可以為空），該文件標(biāo)識該目錄為 Python 包。

mypackage/
│
├── __init__.py
├── module1.py
└── module2.py

引入包中的模塊：

# 包中指定的模塊
from mypackage import module1
module1.foo() 

# 這樣引入，每次使用都得指定全名
import e.e1.module_1

# 引入子包
from e.e1 import module_1 
module_1.func_1()

# 相對導(dǎo)入
from . import module_1


訪問權(quán)限
公共成員是模塊的一部分，可以被模塊外部的代碼訪問和使用。在 Python 中，任何不在變量名、函數(shù)名或類名前加前綴 _ 的成員都被認(rèn)為是公共的。

7.元組、列表、字典

元組是一個不可變的序列，一旦創(chuàng)建就不能被修改。

# 創(chuàng)建
my_tuple = (1, 2, 3)
empty_tuple = ()

# 訪問
print(my_tuple[1])  # 輸出：2

# 切片
print(my_tuple[1:3])  # 輸出：(2, 3)

# 解包
a, b, c = my_tuple

列表是一個可變的序列，可以修改、添加或刪除其中的元素。

# 創(chuàng)建
my_list = [1, 2, 3]
empty_list = []

# 訪問
print(my_list[1])  # 輸出：2

# 切片
print(my_list[1:3])  # 輸出：[2, 3]

# 添加
my_list.append(4)

# 刪除
my_list.remove(2)
last_item = my_list.pop()

字典是一個無序的鍵值對集合，鍵必須是不可變類型，如字符串或元組。

# 創(chuàng)建
my_dict = {'name': 'Alice', 'age': 25}
empty_dict = {}

# 訪問
print(my_dict['name'])  # 輸出：Alice

#刪除
del my_dict['age']
removed_item = my_dict.pop('gender')

集合（Set）是一個無序的、不包含重復(fù)元素的集合。它類似于數(shù)學(xué)中的集合概念，可以進(jìn)行數(shù)學(xué)上的集合運算，如并集、交集、差集等。集合是一個可變的數(shù)據(jù)類型，其元素是唯一的。

# 創(chuàng)建
my_set = {1, 2, 3}
my_set = set([1, 2, 3])

# 使用大括號 {} 創(chuàng)建空集合是無效的，因為空集在 Python 中用 set() 函數(shù)表示。

# 添加元素
my_set.add(4)

# 刪除元素
my_set.remove(2)
my_set.discard(5)  # 即使 5 不存在，也不會報錯

# 清空集合
my_set.clear()

# 是否存在
print(3 in my_set)  # 輸出：True

# 集合的大小
print(len(my_set))

# 交集
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)  # 或者 set1 | set2

# 差集
difference_set = set1.difference(set2)  # 或者 set1 - set2

推導(dǎo)式（Comprehension）是 Python 中的一種語法結(jié)構(gòu)，它提供了一種簡潔的方式來創(chuàng)建列表、字典、集合等數(shù)據(jù)結(jié)構(gòu)。

# 列表推導(dǎo)式
[expression for item in iterable if condition]

squares = [x**2 for x in range(10)]
print(squares)  # 輸出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

• expression：對每個元素進(jìn)行的操作。
• item：從 iterable 中依次取出的元素。
• iterable：一個序列、集合或其他迭代器。
• condition（可選）：一個布爾表達(dá)式，只有滿足條件的元素才會被包括在內(nèi)。

# 字典推導(dǎo)式
{key_expression: value_expression for item in iterable if condition}

squares_dict = {x: x**2 for x in range(10)}
print(squares_dict)  # 輸出：{0: 0, 1: 1, 2: 4, 3: 9, ...}

• key_expression：字典的鍵。
• value_expression：字典的值。

8.函數(shù)

閉包是在一個函數(shù)內(nèi)部定義的另一個函數(shù)，內(nèi)部函數(shù)引用了外部函數(shù)的變量。在外部函數(shù)返回內(nèi)部函數(shù)時，會形成一個閉包，因為內(nèi)部函數(shù)攜帶了外部函數(shù)的上下文，即使外部函數(shù)已經(jīng)執(zhí)行完畢。

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

# 創(chuàng)建一個閉包
closure = outer_function(2)

# 使用閉包
print(closure(3))  # 輸出：5

函數(shù)內(nèi)使用外部變量：

x = 10  # 全局變量

def my_function():
    y = 5  # 局部變量
    print(x)  # 可以訪問全局變量

my_function()

在 Python 中，所有的參數(shù)傳遞都是按引用傳遞。然而，由于 Python 中的數(shù)字、字符串和元組等是不可變類型，所以當(dāng)它們作為參數(shù)傳遞給函數(shù)時，表現(xiàn)得像是按值傳遞。

• 不可變類型（按值傳遞）：如果參數(shù)是不可變類型，對參數(shù)的修改不會影響原始數(shù)據(jù)。
• 可變類型（按引用傳遞）：如果參數(shù)是可變類型（如列表、字典等），則可以在函數(shù)內(nèi)部修改它們，并且這些修改會影響到原始數(shù)據(jù)。
• global
• 在函數(shù)外部定義的變量默認(rèn)是全局變量，但在函數(shù)內(nèi)部定義的變量默認(rèn)是局部變量。如果你想在函數(shù)內(nèi)部修改全局變量，你需要使用 global 關(guān)鍵字來聲明。

函數(shù)參數(shù)可以通過多種方式傳遞給函數(shù)。以下是一些常見的參數(shù)傳遞方式：

# 位置參數(shù)
def func(a, b, c):
    print(a, b, c)

func(1, 2, 3)  # 輸出: 1 2 3

# 關(guān)鍵字參數(shù)
def func(a, b, c):
    print(a, b, c)

func(a=1, b=2, c=3)  # 輸出: 1 2 3
func(c=3, a=1, b=2)  # 輸出: 1 2 3

# 默認(rèn)參數(shù)
def func(a, b, c=0):
    print(a, b, c)

func(1, 2)        # 輸出: 1 2 0
func(1, 2, 3)     # 輸出: 1 2 3

# 可變參數(shù)
def func(*args):
    for arg in args:
        print(arg, end=' ')

func(1, 2, 3)  # 輸出: 1 2 3

# 關(guān)鍵字可變參數(shù)
def func(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

func(a=1, b=2, c=3)  # 輸出: a: 1 b: 2 c: 3

9.面向?qū)ο?/h3>

Python 是一種支持面向?qū)ο缶幊蹋∣bject-Oriented Programming, OOP）的高級編程語言。面向?qū)ο缶幊淌且环N編程范式，它使用“對象”來設(shè)計應(yīng)用程序和程序的結(jié)構(gòu)。

類（Class）：

• 類是創(chuàng)建對象的模板或藍(lán)圖。它定義了一組屬性（變量）和方法（函數(shù)）。
• 類可以包含構(gòu)造器（__init__），這是一個特殊的方法，當(dāng)創(chuàng)建類的新實例時會自動調(diào)用。

class Car:
    def __init__(self, make, model):
        self.make = make
        self.model = model

對象（Object）：

• 對象是類的實例。創(chuàng)建類的新實例時，會創(chuàng)建一個對象。
• 對象可以接收數(shù)據(jù)（即類的屬性）和執(zhí)行操作（即類的方法）。

my_car = Car("Toyota", "Corolla")

繼承（Inheritance）：

• 繼承是一種創(chuàng)建新類的方式，新類可以從現(xiàn)有類中繼承屬性和方法。
• 子類（派生類）繼承父類（基類）的特性，并可以添加或覆蓋它們。

class ElectricCar(Car):
    def __init__(self, make, model, battery_size):
        super().__init__(make, model)
        self.battery_size = battery_size

封裝（Encapsulation）：

• 封裝是將數(shù)據(jù)（屬性）和代碼（方法）捆綁在一起的過程，并對對象的某些部分隱藏起來，只暴露有限的接口。
• 在 Python 中，可以通過在屬性名前加雙下劃線（__）來實現(xiàn)屬性的私有化。

class Car:
    def __init__(self, make, model):
        self.__make = make
        self.__model = model

多態(tài)（Polymorphism）：

• 多態(tài)性是指允許不同類的對象對同一消息做出響應(yīng)的能力，即同一個接口，使用不同的實例而執(zhí)行不同操作。
• 在 Python 中，多態(tài)可以通過方法重載和重寫來實現(xiàn)。

class Car:
    def start(self):
        print("Car is starting")

class ElectricCar(Car):
    def start(self):
        print("Electric Car is starting with no noise")

屬性（Attributes）：

• 屬性是對象的狀態(tài)信息，即對象的變量。
• 屬性可以是公有的，也可以是私有的。

方法（Methods）：

• 方法是對象的行為，即對象可以執(zhí)行的操作。
• 方法通常用來修改對象的狀態(tài)或執(zhí)行與對象相關(guān)的操作。

類變量和實例變量：

• 類變量是定義在類中的變量，所有實例共享同一個類變量。
• 實例變量是定義在方法中的變量，每個實例都有自己的實例變量。

類方法和靜態(tài)方法：

• 類方法不接收隱式的 self 參數(shù)，而是接收 cls 作為第一個參數(shù)，它是屬于類的，而不是實例的。
• 靜態(tài)方法不接收 self 或 cls 參數(shù)，它們可以不依賴于對象或類直接被調(diào)用。

特殊方法：

• __init__(self, ...): 類的構(gòu)造器，當(dāng)一個實例被創(chuàng)建時調(diào)用。
• __del__(self): 類的析構(gòu)器，當(dāng)一個實例被銷毀時調(diào)用。
• __call__(self, ...): 允許一個實例像函數(shù)那樣被調(diào)用。
• __getitem__(self, key): 獲取序列的元素，如 obj[key]。
• __setitem__(self, key, value): 設(shè)置序列的元素，如 obj[key] = value。
• __delitem__(self, key): 刪除序列的元素，如 del obj[key]。
• __len__(self): 返回容器中元素的數(shù)量，如 len(obj)。
• __iter__(self): 返回對象的迭代器，用于迭代操作，如 for x in obj。
• __next__(self): 返回迭代器的下一個元素。
• __repr__(self): 返回對象的“官方”字符串表示，通常用于調(diào)試。
• __str__(self): 返回對象的“非官方”字符串表示，用于打印。
• __bytes__(self): 返回對象的字節(jié)串表示。
• __format__(self, format_spec): 定義對象的格式化字符串表示。
• __lt__(self, other), __le__(self, other), __eq__(self, other), __ne__(self, other), __gt__(self, other), __ge__(self, other): 定義對象的比較操作。
• __hash__(self): 返回對象的哈希值。
• __bool__(self): 定義布爾值測試。
• __getattr__(self, name): 當(dāng)訪問一個不存在的屬性時調(diào)用。
• __setattr__(self, name, value): 當(dāng)設(shè)置一個屬性的值時調(diào)用。
• __delattr__(self, name): 當(dāng)刪除一個屬性時調(diào)用。
• __getattribute__(self, name): 在訪問屬性之前調(diào)用，可以重寫以攔截屬性訪問。
• __dir__(self): 返回對象的屬性目錄。
• __enter__(self), __exit__(self, exc_type, exc_value, traceback): 用于定義上下文管理器，如 with obj。
• __copy__(self), __deepcopy__(self, memo): 用于定義對象的淺拷貝和深拷貝行為。
• __new__(cls, ...): 創(chuàng)建并返回類的新實例。

10.多線程

Python 多線程是指在 Python 程序中同時運行多個線程的能力。線程是操作系統(tǒng)能夠進(jìn)行運算調(diào)度的最小單位。它被包含在進(jìn)程之中，是進(jìn)程中的實際運作單位。Python 提供了 threading 模塊來支持多線程編程。

• threading.Thread 類：用于創(chuàng)建線程?？梢酝ㄟ^繼承 Thread 類并重寫其 run() 方法來定義線程任務(wù)。
  start() 方法：啟動線程。必須在 Thread 實例上調(diào)用此方法以開始線程的執(zhí)行。
• join() 方法：阻塞調(diào)用它的線程，直到線程終止。這通常用于等待線程完成其任務(wù)。
• is_alive() 方法：返回線程是否仍然存活（即正在運行或等待）。
• getName() 方法：返回線程的名稱。
• setName() 方法：設(shè)置線程的名稱。
• current_thread() 函數(shù)：返回當(dāng)前線程的 Thread 實例。
• enumerate() 函數(shù)：返回一個列表，包含當(dāng)前活動的線程。
• active_count() 函數(shù)：返回當(dāng)前活動線程的數(shù)量。
• Lock 類：用于線程同步的鎖?？梢杂糜诒Ｗo(hù)共享資源，避免競爭條件。
• RLock 類：可重入鎖。它允許同一個線程多次獲得鎖。
• Semaphore 類：信號量。用于限制對共享資源的訪問數(shù)量。
• BoundedSemaphore 類：有界信號量。與 Semaphore 類似，但初始化時需要指定一個最大值。
• Event 類：事件。用于線程間的通信，允許一個線程通知其他線程某個事件已經(jīng)發(fā)生。
• Condition 類：條件變量。用于復(fù)雜的線程同步，允許一個或多個線程等待，直到被另一個線程通知。
• Barrier 類：屏障。用于多線程同步，使得一組線程相互等待，直到到達(dá)某個共同點。
• Timer 類：計時器。在指定的時間后執(zhí)行一個函數(shù)。
• local 和 stack_local 類：用于創(chuàng)建線程局部數(shù)據(jù)。
• ThreadError 異常：當(dāng)線程操作出錯時拋出的異常。
• settrace() 函數(shù)：設(shè)置一個全局的線程追蹤函數(shù)。
• setprofile() 函數(shù)：設(shè)置一個全局的線程分析函數(shù)。

常用示例：

import threading

class MyThread(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name = name

    def run(self):
        print(f"Thread {self.name} is running")

# 創(chuàng)建線程
t1 = MyThread(name="Thread-1")
t2 = MyThread(name="Thread-2")

# 啟動線程
t1.start()
t2.start()

# 等待線程結(jié)束
t1.join()
t2.join()

線程同步是確保多個線程在訪問共享資源時避免數(shù)據(jù)不一致和競態(tài)條件的重要機制。Python 提供了多種同步原語，如鎖（Lock）、事件（Event）、條件（Condition）和信號量（Semaphore）等。

鎖（Lock），鎖是最基本的同步原語，用于確保同一時間只有一個線程可以執(zhí)行某個代碼段：

# 創(chuàng)建鎖
import threading
lock = threading.Lock()

# 使用 .acquire() 方法獲取鎖。如果鎖已被其他線程獲取，則當(dāng)前線程將阻塞，直到鎖被釋放。
lock.acquire()

# 釋放鎖
lock.release()

# Lock 對象可以作為上下文管理器使用，確保在離開代碼塊時自動釋放鎖
with lock:
    # 執(zhí)行臨界區(qū)代碼
    pass

# 嘗試獲取鎖，如果鎖已經(jīng)被其他線程獲取，則立即返回 False 而不是等待。
if lock.try_acquire():
    try:
        # 執(zhí)行臨界區(qū)代碼
        pass
    finally:
        lock.release()

# .acquire(timeout=...) 方法可以設(shè)置超時時間，如果在指定的時間內(nèi)無法獲取鎖，則拋出 TimeoutError。
try:
    lock.acquire(timeout=5)
except threading.TimeoutError:
    print("Could not acquire lock within the timeout period")

Event（事件） ，事件用于線程之間的通信，一個線程可以等待事件被另一個線程設(shè)置：

import threading

event = threading.Event()

def waiter():
    event.wait()
    print("Event is set")

def setter():
    print("Waiting for 5 seconds...")
    threading.sleep(5)
    event.set()

t1 = threading.Thread(target=waiter)
t2 = threading.Thread(target=setter)

t1.start()
t2.start()

t1.join()
t2.join()

Condition，條件變量用于復(fù)雜的線程同步，允許一個或多個線程等待，直到被另一個線程通知：

import threading

c = threading.Condition()

def consumer():
    with c:
        print("Consumer is waiting for data")
        c.wait()
        print("Consumer received data")

def producer():
    with c:
        print("Producer is producing data")
        c.notify()
        print("Data produced")

t1 = threading.Thread(target=consumer)
t2 = threading.Thread(target=producer)

t1.start()
t2.start()

t1.join()
t2.join()

11.with語句

with 語句在 Python 中是一種語法結(jié)構(gòu)，它用于包裹執(zhí)行代碼塊，以確保資源的正確管理，特別是在處理文件操作、線程鎖和其他需要設(shè)置和清除資源的場合。

• 當(dāng)執(zhí)行到 with 語句時，Python 會調(diào)用上下文管理器的 __enter__ 方法，并且通常會將 __enter__ 方法的返回值賦值給 as 后面的變量。
• 執(zhí)行 with 代碼塊內(nèi)的代碼。
• 代碼塊執(zhí)行完成后，無論是否發(fā)生異常，都會調(diào)用上下文管理器的 __exit__ 方法。如果發(fā)生異常，__exit__ 方法的參數(shù)會接收到異常的類型、值和 traceback 對象，否則這些參數(shù)都是 None。

# 文件操作
with open('file.txt', 'r') as file:
    data = file.read()
    # 文件會在此處自動關(guān)閉

# 線程鎖
lock = threading.Lock()
with lock:
    # 執(zhí)行臨界區(qū)代碼
    pass
# 鎖會在此處自動釋放

# 上下文管理器
class ManagedResource:
    def __enter__(self):
        print("Entering context.")
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Exiting context.")
        # 可以在這里處理異常
with ManagedResource() as resource:
    # 使用資源
    pass

12. asyncio  

在 Python 3.4 版本中，asyncio 模塊被引入作為標(biāo)準(zhǔn)庫，提供了異步編程的支持。

從 Python 3.5 開始，async 和 await 關(guān)鍵字被引入，使得編寫異步代碼更加直觀和簡潔。

Python 3.7 版本進(jìn)一步優(yōu)化了 asyncio，引入了 asyncio.run() 這樣的高級方法，讓編寫和管理異步程序變得更加簡單。

事件循環(huán)（Event Loop）：

• 事件循環(huán)是 asyncio 的核心，它不斷地執(zhí)行事件和任務(wù)，直到?jīng)]有更多的事件和任務(wù)為止。
• 事件循環(huán)負(fù)責(zé)調(diào)度協(xié)程，處理 I/O 事件，執(zhí)行回調(diào)函數(shù)等。

# 在函數(shù)定義前加上 async 關(guān)鍵字定義異步函數(shù)
import asyncio

async def say_after(delay, what):
    await asyncio.sleep(delay)  # 模擬異步操作，比如網(wǎng)絡(luò)請求
    print(what)

# 使用 asyncio.run() 來運行主異步函數(shù)
asyncio.run(say_after(1, 'hello'))

# 異步的主函數(shù)，它調(diào)度多個異步任務(wù)
async def main():
    await say_after(1, 'hello')
    await say_after(2, 'world')

# 并發(fā)運行多個異步任務(wù)，并等待它們?nèi)客瓿?async def main():
    # 并發(fā)運行多個異步任務(wù)
    await asyncio.gather(
        say_after(1, 'hello'),
        say_after(2, 'world')
    )

asyncio.run(main())

# 創(chuàng)建任務(wù)（Task）來并發(fā)運行協(xié)程。任務(wù)是協(xié)程的執(zhí)行單元。
async def main():
    # 創(chuàng)建任務(wù)
    task1 = asyncio.create_task(say_after(1, 'hello'))
    task2 = asyncio.create_task(say_after(2, 'world'))

    # 等待任務(wù)完成
    await task1
    await task2

asyncio.run(main())

# 為異步操作設(shè)置超時，或者取消正在運行的任務(wù)。
async def main():
    try:
        # 設(shè)置超時
        await asyncio.wait_for(say_after(10, 'this takes too long'), timeout=5)
    except asyncio.TimeoutError:
        print('Timeout occurred!')

asyncio.run(main())

# 取消任務(wù)
async def main():
    task = asyncio.create_task(say_after(10, 'this will be cancelled'))
    await asyncio.sleep(2)
    task.cancel()
    try:
        await task
    except asyncio.CancelledError:
        print('Task was cancelled')

asyncio.run(main())

# 在異步函數(shù)中使用 try/except 塊來捕獲和處理異常
async def main():
    try:
        await say_after(1, 'this will raise an exception')
    except Exception as e:
        print(f'An error occurred: {e}')

asyncio.run(main())

13. json處理

Python數(shù)據(jù)轉(zhuǎn)Json：

import json

# 一個 Python 字典
data = {
    "name": "John",
    "age": 30,
    "city": "New York"
}

# 輸出到文件
json_str = json.dump(data, file)

# 轉(zhuǎn)換為 JSON 字符串
json_str = json.dumps(data)

Json轉(zhuǎn)字典：

import json

# 一個 JSON 字符串
json_str = '{"name": "John", "age": 30, "city": "New York"}'

# 解析為 Python 字典
data = json.loads(json_str)

14.日期與時間

datetime 模塊是 Python 標(biāo)準(zhǔn)庫中處理日期和時間的核心模塊。它提供了以下類：

• datetime.date：表示日期（年、月、日）。
• datetime.time：表示時間（時、分、秒、微秒）。
• datetime.datetime：表示日期和時間。
• datetime.timedelta：表示兩個日期或時間之間的差異。
• datetime.tzinfo：所有時區(qū)信息類的基類。
• datetime.timezone：用于表示固定時區(qū)偏移量的類。

常用函數(shù)和方法

• date.today()：返回當(dāng)前本地日期。
• datetime.now()：返回當(dāng)前日期和時間。
• datetime.utcnow()：返回當(dāng)前的 UTC 日期和時間。
• datetime.combine(date, time)：將日期和時間合并為一個 datetime 對象。
• datetime.strptime(date_string, format)：根據(jù)指定的格式將字符串解析為 datetime 對象。
• datetime.strftime(format)：將 datetime 對象格式化為字符串。

time 模塊提供了各種與時間相關(guān)的函數(shù)，主要用于處理時間戳。

• time.time()：返回當(dāng)前時間的時間戳。
• time.sleep(seconds)：暫停執(zhí)行指定的秒數(shù)。
• time.localtime([secs])：根據(jù)給定的時間戳返回本地時間的 struct_time 對象。
• time.gmtime([secs])：根據(jù)給定的時間戳返回 UTC 時間的 struct_time 對象。
• time.mktime(tuple)：將 struct_time 對象轉(zhuǎn)換為時間戳。

calendar 模塊提供了生成日歷的功能和一些與日歷相關(guān)的函數(shù)。

• calendar.month(year, month)：返回一個多行字符串，顯示一個月的日歷。
• calendar.monthcalendar(year, month)：返回一個列表，包含一個月中的每一天是星期幾。
• calendar.monthrange(year, month)：返回一個月的第一天是星期幾和該月的天數(shù)。

from datetime import datetime

# 獲取當(dāng)前日期和時間
now = datetime.now()

# 格式化日期和時間
formatted_date = now.strftime("%Y-%m-%d %H:%M:%S")
print("格式化后的日期和時間:", formatted_date)

# 時間戳格式化輸出

import time
from datetime import datetime

# 獲取當(dāng)前時間的時間戳
timestamp = time.time()

# 將時間戳轉(zhuǎn)換為日期時間對象
dt_object = datetime.fromtimestamp(timestamp)
print("時間戳轉(zhuǎn)日期時間:", dt_object)

# 也可以使用 utcfromtimestamp() 來獲取 UTC 時間
dt_utc = datetime.utcfromtimestamp(timestamp)
print("UTC 時間戳轉(zhuǎn)日期時間:", dt_utc)

# 字符串轉(zhuǎn)時間戳

from datetime import datetime

# 日期時間字符串
date_string = "2024-05-29 12:30:45"

# 將字符串解析為日期時間對象
dt_object = datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S")

# 將日期時間對象轉(zhuǎn)換為時間戳
timestamp = dt_object.timestamp()
print("字符串轉(zhuǎn)時間戳:", timestamp)

15.獲取指定數(shù)據(jù)的類型

# 獲取不同類型的數(shù)據(jù)類型
number = 10
string = "Hello, World!"
list_data = [1, 2, 3]
dict_data = {'key': 'value'}
tuple_data = (1, 2, 3)
set_data = {1, 2, 3}
frozenset_data = frozenset([1, 2, 3])
bool_value = True

# 使用 type() 函數(shù)獲取類型
print(type(number))          # <class 'int'>
print(type(string))          # <class 'str'>
print(type(list_data))       # <class 'list'>
print(type(dict_data))       # <class 'dict'>
print(type(tuple_data))      # <class 'tuple'>
print(type(set_data))        # <class 'set'>
print(type(frozenset_data))  # <class 'frozenset'>
print(type(bool_value))      # <class 'bool'>

16.文件和目錄

• os.remove(file)，刪除指定文件
• os.listdir(path): 列出指定路徑下的所有文件和目錄名。
• os.mkdir(path): 創(chuàng)建一個新目錄。
• os.makedirs(path): 創(chuàng)建新目錄，如果中間的目錄不存在也會一并創(chuàng)建。
• os.rmdir(path): 刪除一個空目錄。
• os.removedirs(path): 刪除目錄及其所有內(nèi)容。
• os.path.exists(path): 檢查指定路徑是否存在。
• os.path.isfile(path): 檢查指定路徑是否為文件。
• os.path.isdir(path): 檢查指定路徑是否為目錄。
• os.path.join(path, *paths): 將多個路徑組合成一個路徑。
• os.path.getsize(path): 獲取文件的大小。
• os.path.basename(path): 獲取路徑的基本名稱。
• os.path.dirname(path): 獲取路徑的目錄名稱。
• os.rename(src, dst): 重命名文件或目錄。

Pip使用方法

1.基礎(chǔ)命令

相關(guān)地址：https://mirrors4.tuna.tsinghua.edu.cn/help/pypi/

pip和pip3的區(qū)別

pip 和 pip3 都是 Python 的包管理工具，用于安裝和管理 Python 包。它們的主要區(qū)別在于它們默認(rèn)關(guān)聯(lián)的 Python 版本。

相關(guān)命令：

# 安裝最新的包
pip3 install package_name

# 安裝指定版本的包
pip3 install package_name==version

# 卸載包
pip3 uninstall package_name

# 安裝指定文件內(nèi)的包
pip install -r requirements.txt 

# 查看已安裝
pip3 list

# 查看指定包的安裝信息
pip3 show funasr



版本管理
https://github.com/pyenv/pyenv

2.其它包管理

PDM：https://github.com/pdm-project/pdm

PipEnv：https://pipenv.pypa.io/en/latest/

Python虛擬環(huán)境（venv）

Python虛擬環(huán)境是一個獨立的Python解釋器和庫的副本。它允許您在不影響系統(tǒng)全局Python安裝的情況下安裝和管理項目特定的包。

1.創(chuàng)建虛擬環(huán)境

# 建一個名為venv的虛擬環(huán)境
python3 -m venv venv

這將在項目目錄中創(chuàng)建一個名為venv的文件夾，其中包含您的虛擬環(huán)境。您可以將該文件夾命名為其他名稱，但通常將其命名為venv是一個很好的做法。

2.激活虛擬環(huán)境

激活虛擬環(huán)境將確保您在該環(huán)境中安裝的包和運行的Python命令是隔離的。

# 在Unix或macOS上
source venv/bin/activate

# 在Windows上
.venv/Scripts/activate

# 激活虛擬環(huán)境后，您的終端或命令提示符將顯示虛擬環(huán)境的名稱
(venv) $

3.退出虛擬環(huán)境

# 退出虛擬環(huán)境
deactivate

Flask

中文文檔：https://dormousehole.readthedocs.io/en/latest/index.html

• 命令行說明：https://dormousehole.readthedocs.io/en/latest/cli.html#shell

1.request

• request.args:一個不可變的 MultiDict 類型，包含了 URL 查詢字符串參數(shù)。例如，對于請求 ?key=value，可以通過 request.args.get('key') 來獲取值。
• request.form:一個不可變的 MultiDict 類型，包含了表單數(shù)據(jù)（通常是 POST 請求中的數(shù)據(jù)）?？梢酝ㄟ^ request.form.get('key') 來獲取特定的表單字段。
• request.json:如果請求的內(nèi)容類型是 application/json，那么 request.json 將是一個解析后的對象（通常是字典或列表），包含 JSON 數(shù)據(jù)。
• request.headers:一個不可變的 EnvironHeaders 類型，包含了 HTTP 請求頭。例如，request.headers.get('Content-Type') 可以獲取內(nèi)容類型。
• request.cookies:一個不可變的 MultiDict 類型，包含了 HTTP cookies。
• request.files:一個不可變的 ImmutableMultiDict 類型，包含了上傳的文件。可以通過 request.files.get('file') 來獲取特定的文件對象。
• request.data:包含請求體的數(shù)據(jù)，通常是 POST 請求的數(shù)據(jù)。默認(rèn)情況下，它是一個字節(jié)字符串，但你可以使用 request.data.decode() 將其解碼為字符串。
• request.method:表示請求使用的 HTTP 方法（如 GET, POST, PUT, DELETE 等）。
• request.path:請求的路徑部分，例如 /home.
• request.url:完整的請求 URL。
• request.base_url:包含 URL 的基礎(chǔ)部分（包括域名和端口，如果有的話），但不包括查詢字符串。
• request.host:請求的主機名，例如 example.com.
• request.host_url:主機名和請求路徑的組合，例如 http://example.com/home.
• request.script_root:與 request.path 相同，通常用于重定向。
• request.url_root:與 request.base_url 相同，通常用于重定向。
• request.referrer:表示引用請求的頁面 URL（即 HTTP Referer 頭部的值）。
• request.remote_addr:發(fā)出請求的客戶端 IP 地址。
• request.is_xhr:一個布爾值，表示請求是否由一個 Ajax 請求發(fā)出（通過檢查 X-Requested-With 請求頭）。
• request.access_route:包含客戶端到服務(wù)器的路由列表。
• request.scheme:請求使用的協(xié)議，通常是 http 或 https。

要使用 request 對象，你需要從 flask 模塊中導(dǎo)入它：

from flask import request

@app.route('/some-path', methods=['POST'])
def some_function():
    user_id = request.form.get('user_id')
    content_type = request.headers.get('Content-Type')
    is_ajax = request.is_xhr
    # ... 其他操作

2.response

• response.data:設(shè)置響應(yīng)體的內(nèi)容。這是一個字符串屬性，你可以賦予它任何想要返回給客戶端的數(shù)據(jù)。
• response.status_code:設(shè)置 HTTP 狀態(tài)碼。例如，200 表示成功，404 表示未找到。
• response.headers:一個字典對象，用于設(shè)置響應(yīng)頭。你可以添加、修改或刪除頭部字段。
• response.mimetype:設(shè)置響應(yīng)的內(nèi)容類型（MIME 類型）。默認(rèn)通常是 text/html，但你可以更改它，比如設(shè)置為 application/json。
• response.location:設(shè)置 HTTP 頭中的 Location 字段，通常用于重定向。
• response.charset:設(shè)置響應(yīng)編碼。默認(rèn)是 utf-8。
• response.cookies:一個字典對象，用于設(shè)置客戶端的 cookies。
• response.set_cookie(key, value, expires=None, max_age=None, domain=None, path=None, secure=None, httponly=None, samesite=None):用于設(shè)置一個 cookie。你可以指定 expires、max_age、domain、path、secure、httponly 和 samesite 等參數(shù)。
• response.delete_cookie(key, path='/', domain=None):用于刪除一個 cookie。
• response.autocorrect_location_header(url):自動糾正 Location 頭字段中的相對 URL。
• response.get_data():獲取響應(yīng)體的內(nèi)容。如果內(nèi)容被編碼，它將返回編碼后的版本。
• response.get_json():如果響應(yīng)體是 JSON 格式的，這個方法可以解析并返回一個 Python 對象。

response 對象代表了客戶端接收到的 HTTP 響應(yīng)。這個對象通常是通過 Flask 的 make_response 函數(shù)或者 jsonify 函數(shù)創(chuàng)建的。

from flask import Flask, make_response, jsonify

app = Flask(__name__)

@app.route('/')
def index():
    # 使用 make_response 創(chuàng)建響應(yīng)對象
    response = make_response('<h1>Hello World</h1>', 200)
    response.headers['Content-Type'] = 'text/html'
    response.headers['X-Custom-Header'] = 'Custom Value'
    return response

@app.route('/json')
def json_response():
    # 使用 jsonify 創(chuàng)建 JSON 響應(yīng)
    data = {'key': 'value'}
    response = jsonify(data)
    response.status_code = 200
    response.headers['X-Custom-Header'] = 'Custom Value'
    return response

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

FastAPI

FastAPI：https://fastapi.tiangolo.com/zh/

1.獲取請求參數(shù)

獲取 GET 參數(shù)：

from fastapi import FastAPI, Query

app = FastAPI()

@app.get("/items/")
async def read_query_item(q: str = Query(...)):
    return {"q": q}

Form 用于從 application/x-www-form-urlencoded 或 multipart/form-data 編碼的請求體中獲取數(shù)據(jù)，通常用于處理表單提交的數(shù)據(jù)。以下是 Form 支持的參數(shù)：

• default: 設(shè)置參數(shù)的默認(rèn)值。
• min_length: 字符串的最小長度。
• max_length: 字符串的最大長度。
• regex: 字符串必須匹配的正則表達(dá)式。
• required: 指定字段是否為必填項，默認(rèn)為 True。

獲取POST參數(shù)：

from fastapi import FastAPI, Form

app = FastAPI()

@app.post("/items/")
async def create_item(name: str = Form(...), price: float = Form(...)):
    return {"name": name, "price": price}

Query 用于從 URL 的查詢字符串中獲取數(shù)據(jù)。它支持以下參數(shù)：

• default: 設(shè)置參數(shù)的默認(rèn)值。
• alias: 為參數(shù)設(shè)置一個別名，這在 URL 中使用的名稱與函數(shù)參數(shù)名稱不一致時非常有用。
• title: 為參數(shù)設(shè)置一個標(biāo)題，這通常用于 API 文檔。
• description: 為參數(shù)提供一個描述，這在 API 文檔中顯示，有助于說明參數(shù)的用途。
• gt (greater than): 參數(shù)值必須大于指定的值。
• lt (less than): 參數(shù)值必須小于指定的值。
• ge (greater than or equal to): 參數(shù)值必須大于或等于指定的值。
• le (less than or equal to): 參數(shù)值必須小于或等于指定的值。
• min_length: 參數(shù)的最小長度（對于字符串）。
• max_length: 參數(shù)的最大長度（對于字符串）。
• regex: 參數(shù)值必須匹配指定的正則表達(dá)式。
• example: 為參數(shù)提供一個示例值，這在 API 文檔中顯示。

獲取JSON參數(shù)：

from fastapi import FastAPI

app = FastAPI()

@app.post("/items/")
async def create_item(item: dict):
    return {"item": item}
    

2.Request對象

Request 對象代表了進(jìn)入應(yīng)用的 HTTP 請求。

from fastapi import FastAPI, Request

app = FastAPI()

@app.get("/items/")
async def read_items(request: Request):
    query_param = request.query_params("query")  # 獲取查詢參數(shù)
    headers = request.headers  # 獲取請求頭
    body = await request.json()  # 獲取 JSON 請求體
    return {"query_param": query_param, "headers": dict(headers), "body": body}

3.Response 對象

Response 對象用于構(gòu)建和返回 HTTP 響應(yīng)。

from fastapi import FastAPI, Response

app = FastAPI()

@app.get("/items/")
async def read_items(response: Response):
    content = {"item": "some item"}
    response.headers["X-Custom-Header"] = "Value"  # 設(shè)置響應(yīng)頭
    response.status_code = 200  # 設(shè)置狀態(tài)碼
    return response  # 返回 Response 對象
    

4.校驗JSON參數(shù)

在 FastAPI 中，當(dāng)你在路徑操作函數(shù)中聲明一個參數(shù)，并將其類型指定為 Pydantic 模型時，F(xiàn)astAPI 會自動將請求體解析為 JSON 并進(jìn)行驗證。

from fastapi import FastAPI
from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

app = FastAPI()

@app.post("/items/")
async def create_item(item: Item):
    return {"name": item.name, "description": item.description}

卷積神經(jīng)網(wǎng)絡(luò)

卷積神經(jīng)網(wǎng)絡(luò)（Convolutional Neural Networks，CNN）是人工智能領(lǐng)域中一種重要的深度學(xué)習(xí)模型，被廣泛應(yīng)用于圖像識別、目標(biāo)檢測、自然語言處理等領(lǐng)域。

1.大模型平臺

• 昇思大模型平臺：https://xihe.mindspore.cn/
• 魔搭：https://modelscope.cn/
• HugFace：https://huggingface.co/
• PP飛漿：https://www.paddlepaddle.org.cn/

Python項目

收集一些很厲害的Python倉庫：

• pyinstaller：https://github.com/pyinstaller/pyinstaller，將Python腳本打包成exe；
• pyVideoTrans：https://github.com/jianchang512/pyvideotrans，視頻翻譯配音
• FastAPI：https://fastapi.tiangolo.com/zh/
• ASGI：https://www.uvicorn.org/
• Redis：https://github.com/redis/redis-py、https://redis-py.pythonlang.cn/en/stable/
• aioredis：https://github.com/aio-libs-abandoned/aioredis-py

大模型：

• 文字轉(zhuǎn)語音：https://github.com/fishaudio/fish-speech/
• 快速部署大模型接口：https://github.com/gradio-app/gradio
• comfyUI：https://github.com/comfyanonymous/ComfyUI

實用庫：

• edge-tts：https://github.com/rany2/edge-tts

Rembg

Rembg 是一個基于 Python 的背景去除工具，它使用深度學(xué)習(xí)技術(shù)來從圖像中去除背景。

Pytorch：https://pytorch.org/get-started/locally/

開源地址：https://github.com/danielgatis/rembg

詳見Github倉庫的說明：https://github.com/danielgatis/rembg

1.基礎(chǔ)知識

相關(guān)名詞介紹：

• U2-Net是由Xuebin Qin等人開發(fā)的一種用于顯著目標(biāo)檢測（Salient Object Detection, SOD）的深度學(xué)習(xí)模型。
• ONNXRuntime是由微軟推出，用于優(yōu)化和加速機器學(xué)習(xí)推理和訓(xùn)練，適用于ONNX模型，是一個跨平臺推理和訓(xùn)練機器學(xué)習(xí)加速器(ONNX Runtime is a cross-platform inference and training machine-learning accelerator)
• Rembg和U2-Net之間的關(guān)系是工具與核心算法的關(guān)系，Rembg利用U2-Net作為其圖像分割的引擎。

開源地址：

• ONNXRuntime：https://github.com/microsoft/onnxruntime
• U2-Net：https://github.com/xuebinqin/U-2-Net

2.關(guān)于訓(xùn)練模型

• 數(shù)據(jù)收集：人工或自動化工具收集數(shù)據(jù)，這可能包括從數(shù)據(jù)庫、文件、網(wǎng)絡(luò)或其他數(shù)據(jù)源獲取數(shù)據(jù)。
• 數(shù)據(jù)清洗：人工檢查數(shù)據(jù)集，識別并處理缺失值、異常值和錯誤數(shù)據(jù)。
• 特征選擇：人工或使用自動化算法選擇對模型預(yù)測有用的特征。
• 數(shù)據(jù)標(biāo)注：對于監(jiān)督學(xué)習(xí)，需要人工標(biāo)注數(shù)據(jù)，例如在圖像識別中標(biāo)記圖像中的物體，在文本分類中為文本分配類別標(biāo)簽。
• 數(shù)據(jù)分割：人工或使用自動化方法將數(shù)據(jù)集分割為訓(xùn)練集、驗證集和測試集。
• 模型選擇：根據(jù)問題的性質(zhì)和數(shù)據(jù)的特點，人工選擇或設(shè)計一個合適的模型。
• 模型配置：人工設(shè)置模型參數(shù)，如神經(jīng)網(wǎng)絡(luò)的層數(shù)和節(jié)點數(shù)，選擇損失函數(shù)和優(yōu)化器。
• 訓(xùn)練過程：通常由自動化腳本執(zhí)行，但人工可能需要監(jiān)控訓(xùn)練過程，調(diào)整參數(shù)以優(yōu)化模型性能。
• 模型評估：使用驗證集或測試集評估模型，人工分析評估結(jié)果，確定模型是否滿足要求。
• 模型調(diào)優(yōu)：根據(jù)評估結(jié)果，人工調(diào)整模型結(jié)構(gòu)或參數(shù)，進(jìn)行超參數(shù)優(yōu)化。
• 模型驗證：人工驗證模型在實際應(yīng)用中的性能，確保模型的泛化能力。
• 模型部署：將訓(xùn)練好的模型部署到生產(chǎn)環(huán)境，可能需要人工配置和監(jiān)控。

3.問題記錄

importing onnxruntime_pybind11_state: 找不到指定的模塊

安裝VC_redist：https://aka.ms/vs/16/release/VC_redist.x64.exe

FunASR

FunASR是一個基礎(chǔ)語音識別工具包，提供多種功能，包括語音識別（ASR）、語音端點檢測（VAD）、標(biāo)點恢復(fù)、語言模型、說話人驗證、說話人分離和多人對話語音識別等。

Github：https://github.com/modelscope/FunASR/blob/main/README_zh.md#%E5%AE%89%E8%A3%85%E6%95%99%E7%A8%8B

1.安裝

服務(wù)端部署文檔：https://github.com/modelscope/FunASR/blob/main/runtime/readme_cn.md

# 安裝
pip3 install torch torchvision torchaudio

# 安裝
pip3 install -U funasr

Segment Anything

Github：https://github.com/facebookresearch/segment-anything