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

# 添加環境變量
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 服務器。
• -c，執行一段 Python 代碼，python3 -c "print('Hello, World!')"。
• -i，交互式解釋器，執行完命令后保持交互模式，python3 -i。
• -v，輸出 Python 解釋器啟動時的版本和版權信息，python3 -v。
• -V，輸出 Python 解釋器的版本，python3 -V。
• -O，優化模式，移除文檔字符串，python3 -O your_script.py。
• -OO，進一步優化，移除文檔字符串并進行一些優化，python3 -OO your_script.py。
• -B，在執行前不寫入 __pycache__ 目錄，python3 -B your_script.py。
• --check，檢查源文件中的語法錯誤，python3 -m py_compile your_script.py。
• -W，控制警告消息的顯示，python3 -W all your_script.py。
• -I，在交互模式下不導入 sys 和 site 模塊，python3 -I。
• -E，在執行前忽略環境變量，python3 -E your_script.py。
• -x，在執行前忽略源文件編碼聲明，python3 -x your_script.py。
• -u，強制 Python 以非緩沖的方式運行，python3 -u your_script.py。
• -S，在執行前不導入 site.py，python3 -S your_script.py。
• -R，在執行前不運行 site.py 中的 site.main()，python3 -R your_script.py。
• -E，在執行前不設置 PYTHON* 環境變量，python3 -E your_script.py。
• -X，啟用或禁用特定的警告，python3 -X faulthandler your_script.py。
• --help，顯示命令行選項的幫助信息，python3 --help。

2.基礎知識

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

常量：

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

內置類型：

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

內置函數：

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

內置異常：

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

內置模塊：

• __name__：當前模塊的名稱。
• __file__：當前模塊的文件路徑。
• __builtins__：內置函數和變量的字典。
• 常量
• 在Python中，雖然沒有專門的語法來聲明常量，但按照慣例，常量名稱通常使用全大寫字母來表示。在Python中，任何不可變的數據類型都可以用來作為字典（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 進行條件判斷。

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

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

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

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

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

遍歷元組：

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 語句來實現的。

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

5.字符串操作

創建字符串：

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

字符串連接：

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

字符串重復：

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

字符串切片：

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

字符串方法：

• .upper()：轉換為大寫。
• .lower()：轉換為小寫。
• .capitalize()：首字母大寫。
• .title()：每個單詞的首字母大寫。
• .strip()：移除字符串開頭和結尾的空白字符。
• .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')  # 編碼為字節串
decoded = encoded.decode('utf-8')  # 解碼為字符串

字符串前綴：

• f或 F：表示格式化字符串字面量（f-string），允許在字符串中直接嵌入表達式。
• r 或 R：表示原始字符串，忽略字符串中的轉義字符。
• b 或 B：表示字節字符串，用于處理二進制數據。

6.模塊和包

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

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

# 導入特定的功能
from mymodule import greet, Calculator

greet("Bob")
calculator = Calculator()

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

包是包含多個模塊的目錄，它必須包含一個名為 __init__.py 的文件（可以為空），該文件標識該目錄為 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()

# 相對導入
from . import module_1


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

7.元組、列表、字典

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

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

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

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

# 解包
a, b, c = my_tuple

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

# 創建
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()

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

# 創建
my_dict = {'name': 'Alice', 'age': 25}
empty_dict = {}

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

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

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

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

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

# 添加元素
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

推導式（Comprehension）是 Python 中的一種語法結構，它提供了一種簡潔的方式來創建列表、字典、集合等數據結構。

# 列表推導式
[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：對每個元素進行的操作。
• item：從 iterable 中依次取出的元素。
• iterable：一個序列、集合或其他迭代器。
• condition（可選）：一個布爾表達式，只有滿足條件的元素才會被包括在內。

# 字典推導式
{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.函數

閉包是在一個函數內部定義的另一個函數，內部函數引用了外部函數的變量。在外部函數返回內部函數時，會形成一個閉包，因為內部函數攜帶了外部函數的上下文，即使外部函數已經執行完畢。

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

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

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

函數內使用外部變量：

x = 10  # 全局變量

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

my_function()

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

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

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

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

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

# 關鍵字參數
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

# 默認參數
def func(a, b, c=0):
    print(a, b, c)

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

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

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

# 關鍵字可變參數
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.面向對象

Python 是一種支持面向對象編程（Object-Oriented Programming, OOP）的高級編程語言。面向對象編程是一種編程范式，它使用“對象”來設計應用程序和程序的結構。

類（Class）：

• 類是創建對象的模板或藍圖。它定義了一組屬性（變量）和方法（函數）。
• 類可以包含構造器（__init__），這是一個特殊的方法，當創建類的新實例時會自動調用。

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

對象（Object）：

• 對象是類的實例。創建類的新實例時，會創建一個對象。
• 對象可以接收數據（即類的屬性）和執行操作（即類的方法）。

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

繼承（Inheritance）：

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

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

封裝（Encapsulation）：

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

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

多態（Polymorphism）：

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

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

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

屬性（Attributes）：

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

方法（Methods）：

• 方法是對象的行為，即對象可以執行的操作。
• 方法通常用來修改對象的狀態或執行與對象相關的操作。

類變量和實例變量：

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

類方法和靜態方法：

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

特殊方法：

• __init__(self, ...): 類的構造器，當一個實例被創建時調用。
• __del__(self): 類的析構器，當一個實例被銷毀時調用。
• __call__(self, ...): 允許一個實例像函數那樣被調用。
• __getitem__(self, key): 獲取序列的元素，如 obj[key]。
• __setitem__(self, key, value): 設置序列的元素，如 obj[key] = value。
• __delitem__(self, key): 刪除序列的元素，如 del obj[key]。
• __len__(self): 返回容器中元素的數量，如 len(obj)。
• __iter__(self): 返回對象的迭代器，用于迭代操作，如 for x in obj。
• __next__(self): 返回迭代器的下一個元素。
• __repr__(self): 返回對象的“官方”字符串表示，通常用于調試。
• __str__(self): 返回對象的“非官方”字符串表示，用于打印。
• __bytes__(self): 返回對象的字節串表示。
• __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): 當訪問一個不存在的屬性時調用。
• __setattr__(self, name, value): 當設置一個屬性的值時調用。
• __delattr__(self, name): 當刪除一個屬性時調用。
• __getattribute__(self, name): 在訪問屬性之前調用，可以重寫以攔截屬性訪問。
• __dir__(self): 返回對象的屬性目錄。
• __enter__(self), __exit__(self, exc_type, exc_value, traceback): 用于定義上下文管理器，如 with obj。
• __copy__(self), __deepcopy__(self, memo): 用于定義對象的淺拷貝和深拷貝行為。
• __new__(cls, ...): 創建并返回類的新實例。

10.多線程

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

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

常用示例：

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

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

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

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

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

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

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

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

# 釋放鎖
lock.release()

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

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

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

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

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，條件變量用于復雜的線程同步，允許一個或多個線程等待，直到被另一個線程通知：

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 中是一種語法結構，它用于包裹執行代碼塊，以確保資源的正確管理，特別是在處理文件操作、線程鎖和其他需要設置和清除資源的場合。

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

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

# 線程鎖
lock = threading.Lock()
with lock:
    # 執行臨界區代碼
    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 模塊被引入作為標準庫，提供了異步編程的支持。

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

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

事件循環（Event Loop）：

• 事件循環是 asyncio 的核心，它不斷地執行事件和任務，直到沒有更多的事件和任務為止。
• 事件循環負責調度協程，處理 I/O 事件，執行回調函數等。

# 在函數定義前加上 async 關鍵字定義異步函數
import asyncio

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

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

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

# 并發運行多個異步任務，并等待它們全部完成
async def main():
    # 并發運行多個異步任務
    await asyncio.gather(
        say_after(1, 'hello'),
        say_after(2, 'world')
    )

asyncio.run(main())

# 創建任務（Task）來并發運行協程。任務是協程的執行單元。
async def main():
    # 創建任務
    task1 = asyncio.create_task(say_after(1, 'hello'))
    task2 = asyncio.create_task(say_after(2, 'world'))

    # 等待任務完成
    await task1
    await task2

asyncio.run(main())

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

asyncio.run(main())

# 取消任務
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())

# 在異步函數中使用 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數據轉Json：

import json

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

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

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

Json轉字典：

import json

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

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

14.日期與時間

datetime 模塊是 Python 標準庫中處理日期和時間的核心模塊。它提供了以下類：

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

常用函數和方法

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

time 模塊提供了各種與時間相關的函數，主要用于處理時間戳。

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

calendar 模塊提供了生成日歷的功能和一些與日歷相關的函數。

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

from datetime import datetime

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

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

# 時間戳格式化輸出

import time
from datetime import datetime

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

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

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

# 字符串轉時間戳

from datetime import datetime

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

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

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

15.獲取指定數據的類型

# 獲取不同類型的數據類型
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() 函數獲取類型
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): 創建一個新目錄。
• os.makedirs(path): 創建新目錄，如果中間的目錄不存在也會一并創建。
• os.rmdir(path): 刪除一個空目錄。
• os.removedirs(path): 刪除目錄及其所有內容。
• 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.基礎命令

相關地址：https://mirrors4.tuna.tsinghua.edu.cn/help/pypi/

pip和pip3的區別

pip 和 pip3 都是 Python 的包管理工具，用于安裝和管理 Python 包。它們的主要區別在于它們默認關聯的 Python 版本。

相關命令：

# 安裝最新的包
pip3 install package_name

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

# 卸載包
pip3 uninstall package_name

# 安裝指定文件內的包
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虛擬環境（venv）

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

1.創建虛擬環境

# 建一個名為venv的虛擬環境
python3 -m venv venv

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

2.激活虛擬環境

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

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

# 在Windows上
.venv/Scripts/activate

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

3.退出虛擬環境

# 退出虛擬環境
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 查詢字符串參數。例如，對于請求 ?key=value，可以通過 request.args.get('key') 來獲取值。
• request.form:一個不可變的 MultiDict 類型，包含了表單數據（通常是 POST 請求中的數據）。可以通過 request.form.get('key') 來獲取特定的表單字段。
• request.json:如果請求的內容類型是 application/json，那么 request.json 將是一個解析后的對象（通常是字典或列表），包含 JSON 數據。
• request.headers:一個不可變的 EnvironHeaders 類型，包含了 HTTP 請求頭。例如，request.headers.get('Content-Type') 可以獲取內容類型。
• request.cookies:一個不可變的 MultiDict 類型，包含了 HTTP cookies。
• request.files:一個不可變的 ImmutableMultiDict 類型，包含了上傳的文件。可以通過 request.files.get('file') 來獲取特定的文件對象。
• request.data:包含請求體的數據，通常是 POST 請求的數據。默認情況下，它是一個字節字符串，但你可以使用 request.data.decode() 將其解碼為字符串。
• request.method:表示請求使用的 HTTP 方法（如 GET, POST, PUT, DELETE 等）。
• request.path:請求的路徑部分，例如 /home.
• request.url:完整的請求 URL。
• request.base_url:包含 URL 的基礎部分（包括域名和端口，如果有的話），但不包括查詢字符串。
• 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:發出請求的客戶端 IP 地址。
• request.is_xhr:一個布爾值，表示請求是否由一個 Ajax 請求發出（通過檢查 X-Requested-With 請求頭）。
• request.access_route:包含客戶端到服務器的路由列表。
• request.scheme:請求使用的協議，通常是 http 或 https。

要使用 request 對象，你需要從 flask 模塊中導入它：

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

response 對象代表了客戶端接收到的 HTTP 響應。這個對象通常是通過 Flask 的 make_response 函數或者 jsonify 函數創建的。

from flask import Flask, make_response, jsonify

app = Flask(__name__)

@app.route('/')
def index():
    # 使用 make_response 創建響應對象
    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 創建 JSON 響應
    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.獲取請求參數

獲取 GET 參數：

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 編碼的請求體中獲取數據，通常用于處理表單提交的數據。以下是 Form 支持的參數：

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

獲取POST參數：

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 的查詢字符串中獲取數據。它支持以下參數：

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

獲取JSON參數：

from fastapi import FastAPI

app = FastAPI()

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

2.Request對象

Request 對象代表了進入應用的 HTTP 請求。

from fastapi import FastAPI, Request

app = FastAPI()

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

3.Response 對象

Response 對象用于構建和返回 HTTP 響應。

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"  # 設置響應頭
    response.status_code = 200  # 設置狀態碼
    return response  # 返回 Response 對象
    

4.校驗JSON參數

在 FastAPI 中，當你在路徑操作函數中聲明一個參數，并將其類型指定為 Pydantic 模型時，FastAPI 會自動將請求體解析為 JSON 并進行驗證。

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}

卷積神經網絡

卷積神經網絡（Convolutional Neural Networks，CNN）是人工智能領域中一種重要的深度學習模型，被廣泛應用于圖像識別、目標檢測、自然語言處理等領域。

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

大模型：

• 文字轉語音：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 的背景去除工具，它使用深度學習技術來從圖像中去除背景。

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

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

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

1.基礎知識

相關名詞介紹：

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

開源地址：

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

2.關于訓練模型

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

3.問題記錄

importing onnxruntime_pybind11_state: 找不到指定的模塊

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

FunASR

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

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

1.安裝

服務端部署文檔：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