python高级特性

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：控制实例化过程