json.dumps({a:1,n:2}) #Python 字典類型轉換為 JSON 對象。相當于jsonify
data2 = json.loads(json_str)#將 JSON 對象轉換為 Python 字典
異步編程：在異步編程中，程序可以啟動一個長時間運行的任務，然后繼續執行其他任務，而無需等待該任務完成。
基于async & await關鍵字的協程可以實現異步編程，這也是目前python異步相關的主流技術。協程通過 async def 關鍵字定義，并通過 await 關鍵字暫停執行，等待異步操作完成。

import asyncioasync def func1():print(1)await asyncio.sleep(2)print(2)async def func2():print(3)await asyncio.sleep(2)print(4)tasks = [asyncio.ensure_future(func1()),asyncio.ensure_future(func2())
]loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

生成器
在 Python 中，使用了 yield 的函數被稱為生成器（generator）。當在生成器函數中使用 yield 語句時，函數的執行將會暫停，并將 yield 后面的表達式返回。然后，每次調用 next() 方法或用for循環迭代時，函數會從上次暫停的地方繼續執行，直到再次遇到 yield 語句。這樣，生成器函數可以逐步產生值，而不需要一次性計算并返回所有結果。

lambda匿名函數語法格式：
lambda arguments: expression
lambda是 Python 的關鍵字，用于定義 lambda 函數。
arguments 是參數列表，可以包含零個或多個參數，但必須在冒號(:)前指定。
expression 是一個表達式，用于計算并返回函數的結果。

x = lambda a : a + 10
print(x(5))#15

裝飾器：
Python 裝飾器允許在不修改原有函數代碼的基礎上，動態地增加或修改函數的功能。將原始函數作為輸入，返回一個wrapper對象。

def decorator_function(original_function):def wrapper(*args, **kwargs):# 這里是在調用原始函數前添加的新功能before_call_code()result = original_function(*args, **kwargs)# 這里是在調用原始函數后添加的新功能after_call_code()return resultreturn wrapper# 使用裝飾器
@decorator_function
def target_function(arg1, arg2):pass  # 原始函數的實現

當我們使用 @decorator_function 前綴在 target_function 定義前，Python會自動將 target_function 作為參數傳遞給 decorator_function，然后用返回的 wrapper 函數替換掉原來的 target_function。

異常：
Python 使用 raise 語句拋出一個指定的異常。

x = 10
if x > 5:raise Exception('x 不能大于 5。x 的值為: {}'.format(x))

raise 唯一的一個參數指定了要被拋出的異常。如果你只想知道這是否拋出了一個異常，并不想去處理它，那么一個簡單的 raise 語句就可以再次把它拋出。

線程同步
如果多個線程共同對某個數據修改，則可能出現不可預料的結果，為了保證數據的正確性，需要對多個線程進行同步。

使用 Thread 對象的 Lock 和 Rlock 可以實現簡單的線程同步，這兩個對象都有 acquire 方法和 release 方法，對于那些需要每次只允許一個線程操作的數據，可以將其操作放到 acquire 和 release 方法之間。

考慮這樣一種情況：一個列表里所有元素都是 0，線程 “set” 從后向前把所有元素改成 1，而線程 “print” 負責從前往后讀取列表并打印。
那么，可能線程"set"開始改的時候，線程"print"便來打印列表了，輸出就成了一半0一半1，這就是數據的不同步。為了避免這種情況，引入了鎖的概念。
每當一個線程比如"set"要訪問共享數據時，必須先獲得鎖定；如果已經有別的線程比如"print"獲得鎖定了，那么就讓線程"set"暫停，也就是同步阻塞；等到線程"print"訪問完畢，釋放鎖以后，再讓線程"set"繼續。

#!/usr/bin/python3import threading
import timeclass myThread (threading.Thread):def __init__(self, threadID, name, delay):threading.Thread.__init__(self)self.threadID = threadIDself.name = nameself.delay = delaydef run(self):print ("開啟線程： " + self.name)# 獲取鎖，用于線程同步threadLock.acquire()print_time(self.name, self.delay, 3)# 釋放鎖，開啟下一個線程threadLock.release()def print_time(threadName, delay, counter):while counter:time.sleep(delay)print ("%s: %s" % (threadName, time.ctime(time.time())))counter -= 1threadLock = threading.Lock()
threads = []# 創建新線程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)# 開啟新線程
thread1.start()
thread2.start()# 添加線程到線程列表
threads.append(thread1)
threads.append(thread2)# 等待所有線程完成
for t in threads:t.join()
print ("退出主線程")

線程優先級隊列（ Queue）

#!/usr/bin/python3import queue
import threading
import timeexitFlag = 0class myThread (threading.Thread):def __init__(self, threadID, name, q):threading.Thread.__init__(self)self.threadID = threadIDself.name = nameself.q = qdef run(self):print ("開啟線程：" + self.name)process_data(self.name, self.q)print ("退出線程：" + self.name)def process_data(threadName, q):while not exitFlag:queueLock.acquire()if not workQueue.empty():data = q.get()queueLock.release()print ("%s processing %s" % (threadName, data))else:queueLock.release()time.sleep(1)threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = queue.Queue(10)
threads = []
threadID = 1# 創建新線程
for tName in threadList:thread = myThread(threadID, tName, workQueue)thread.start()threads.append(thread)threadID += 1# 填充隊列
queueLock.acquire()
for word in nameList:workQueue.put(word)
queueLock.release()# 等待隊列清空
while not workQueue.empty():pass# 通知線程是時候退出
exitFlag = 1# 等待所有線程完成
for t in threads:t.join()
print ("退出主線程")

元類：
在Python中，type類型位于類型體系的頂端，它不僅是所有內置類型的元類，也是用戶自定義類的默認創建者。這種設計形成了獨特的自舉系統——type的元類就是它自身。
元類可以理解為：
類的模板：決定類如何被構造
類的工廠：實際生產類對象的機器
類的類型：所有類對象的類型標識

當解釋器執行class語句時，實際發生的是：
1、收集類命名空間（屬性和方法）
2、解析繼承關系
3、調用元類的__new__和__init__方法
4、返回最終的類對象

元類工作機制深度剖析：

class DetailMeta(type):def __new__(cls, name, bases, namespace):print(f"[1] 進入元類 __new__")print(f"    類名: {name}")print(f"    基類: {bases}")print(f"    命名空間: {namespace.keys()}")return super().__new__(cls, name, bases, namespace)def __init__(cls, name, bases, namespace):print(f"[2] 進入元類 __init__")super().__init__(name, bases, namespace)def __call__(cls, *args, **kwargs):print("[3] 進入元類 __call__")return super().__call__(*args, **kwargs)class MyClass(metaclass=DetailMeta):version = 1.0def __init__(self, value):self.value = valueprint("[4] 開始實例化")
obj = MyClass(100)

輸出結果：

[1] 進入元類 __new__類名: MyClass基類: ()命名空間: dict_keys(['__module__', '__qualname__', 'version', '__init__'])
[2] 進入元類 __init__
[4] 開始實例化
[3] 進入元類 __call__

new：負責類的實際創建

init：完成類的初始化

call：控制實例化過程