json.dumps({a:1,n:2}) #Python 字典类型转换为 JSON 对象。相当于jsonify
data2 = json.loads(json_str)#将 JSON 对象转换为 Python 字典
异步编程：在异步编程中，程序可以启动一个长时间运行的任务，然后继续执行其他任务，而无需等待该任务完成。
基于async & await关键字的协程可以实现异步编程，这也是目前python异步相关的主流技术。协程通过 async def 关键字定义，并通过 await 关键字暂停执行，等待异步操作完成。

import asyncio
 
 
async 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 result
    return 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/python3

import threading
import time

class myThread (threading.Thread):
    def __init__(self, threadID, name, delay):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.delay = delay
    def 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 -= 1

threadLock = 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/python3

import queue
import threading
import time

exitFlag = 0

class myThread (threading.Thread):
    def __init__(self, threadID, name, q):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.q = q
    def 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.0
 
    def __init__(self, value):
        self.value = value
 
print("[4] 开始实例化")
obj = MyClass(100)

输出结果：

[1] 进入元类 __new__
    类名: MyClass
    基类: ()
    命名空间: dict_keys(['__module__', '__qualname__', 'version', '__init__'])
[2] 进入元类 __init__
[4] 开始实例化
[3] 进入元类 __call__

new：负责类的实际创建

init：完成类的初始化

call：控制实例化过程