复习知识点

熟练掌握python语言

1、简介

python是一个高层次的结合了解释型、编译型、互动性和面向对象的脚本语言。

2、发展史

python是由Guido van Rossum在1989年圣诞节设计出来的

3、特点

1、语法简介清晰
2、拥有强大的类库
3、胶水语言（能调用其他语言的类库）
4、纯面向对象语言
次要特点：
	代码量少
	跨平台

零碎知识点

1、可变数据类型和不可变数据类型
	可变数据类型 list dict set （其余的都是不可变数据类型）
区别
	可变数据类型中，即便对数据进行更改，数据的id也不会发生变化，而不可变数据类型中，只要对数据的值进行更改，则数据的id就发生变化。

2、深拷贝和浅拷贝的实现方式、区别
浅拷贝的创建
	列表 copy list[:]等，通常被应用于夫妻共同的账号
	husband = 【'husband'，【money，500】】
	wife = husband.copy()
	wife[0] = 'wife'
深拷贝
	数据备份
	
3、__new__和__init__的区别
	new是创建对象的调用，init只是初始化参数

面向对象思想

1、简介

面向对象编程的基本元素是对象，其包含的数据成员称之为属性，函数成员称之为方法

2、三大特性（封装、继承和多态）

封装

简介：
	把客观事物封装成抽象的类，并且类可以把自己的数据和方法让可信任的类或对象使用
优点：
	增强安全性和减少编程

继承

简介：
	实现代码复用的特点，继承使现有类无需改变或添加代码的情况下扩展其他类的功能或数据
优点：
	提高了代码的复用率

钻石继承

class A:
	pass
class B(A):
	pass
class C(A):
	pass
class D(B,C):
	pass	
解释：
	当这样调用父类的方法时，会重复输出父类的方法，也就是输出了两次，为了解决这个问题
    创建MRO（方法关系列表method relation order)
    钻石继承（又叫菱形继承)
    可以通过类名.__mro__		查看列表
    或类名.mro()
原理：
	会把当前子类的父类编写成一个列表，取值的时候，按照列表的顺序取值，当继承多个的时候，
	谁在前面就是类在列表中的顺序靠前，然后根据列表的顺序调用

多态

简介：
	指一种事物的不同形态，对不同的人发送相同的信息有不同的反应
优点：
	消除类型之间的耦合关系
	可替换性
	可扩充性
	灵活性
	接口性
	简化性
多态性（又叫鸭子模型）：
	指不同功能的函数可以使用相同的函数名，统一操作于不同的对象，可以有不同的解释，产生不同的结果

装饰器（又叫语法糖）

作用：
	在不改变原有类的情况下，对类的功能进行扩充
来源：
	是一种著名的设计模式。被用于有切片需求的场景
使用：
	@装饰器

通过格式

def outer(flag):					#控制是否开启装饰器
	def décor(func):				#修饰的函数
		def inner(*args,**kwargs):	 #修饰函数的参数
			if flag:
				之前操作的
				res=func(*args,**kwargs)	#运行函数
				之后要做的
				return res
		return inner
	return decor

@outer(flag)		#@decor  相当于decor = fun()
def fun():
	print('a')

种类

双层装饰器	
	就是先第一个装饰器装饰完之后，传递给第二个装饰器
装饰类
	相当于把类作为参数传进去
装饰装饰器
	就是把装饰器看做函数进行装饰
类作为装饰器
	其实就是对象最为装饰器，且把函数作为参数传递给类的对象
	相当于调用类里面的call（让类的实例可以被调用）魔术方法
class A:	
	def __call__(self,args):		#让类的实例可以被调用
		self.args=args
		return self.inner
      def inner(self):
              self.args()
@A()
def fun():
	print('aaa')

线程、进程和协程

线程

简介

	线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

方法

模块：
	threading
类：
	Thread(group=None, target=None, name=None, args=(), kwargs=None, *, daemon=None)
	start            线程准备就绪，等待CPU调度
　　setName      设置线程名称
　　getName      获取线程名称
　　setDaemon   把一个主进程设置为Daemon线程后，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论有没执行完成，都会停止
　　join              逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义　　
　　run              线程被cpu调度后自动执行线程对象的run方法

调用方式

方式一：使用target参数
	def hello(name):
        pass
	t1=threading.Thread(target=hello,args=("zhangsan",)) #生成线程实例
    t1.start()
    t1.join()			#阻塞主线程，等待结束在执行主线程
方式二：重写Thread的run方法
	class MyThread(threading.Thread):
    def __init__(self,name):
        threading.Thread.__init__(self)
        self.name = name
    def run(self):
        print("Hello %s"%self.name)
        time.sleep(3)

线程锁

原因：
	一个进程下可以启动多个线程，多个线程共享父进程的内存空间，每个线程可以访问同一份数据，所以当多个线程同时要修改同一份数据时，就会出现错误
模块：
	threading
类：
	Lock()		
	acquire()			加锁
	release()			解锁
使用：
	需要对哪块代码加锁，直接加锁即可
产生的问题:
	当对同一块的代码多次加锁时，会产生死锁问题
解决：
	RLock()

进程

组成

	程序：用户描述进程要完成的功能，是控制进程执行的指令集
	数据集合：是程序在执行的时候说需要的数据和工作区
	进程控制块：包含进程的描述信息和控制信息，是进程存在的唯一标识
分类：
	单进程和多进程

特点

动态性：进程的实质是程序在多道程序系统中的一次执行过程，进程是动态产生，动态消亡的。
并发性：任何进程都可以同其他进程一起并发执行。
独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位。
异步性：由于进程间的相互制约，使进程具有执行的间断性，即进程按各自独立的、不可预知的速度向前推进。

多进程

解决：
	多线程的限制
引用：
	计算密集型的程序（CPU密集型程序，cpu是用于计算的
模块：
	multiprocessing
类：
	Process()	参数与线程一样
模块包含:
	Lock()		进程锁
	Pool()		进程池
	Queue()		对列，实现进程之间的通信，单向
	Pipe()		管道，可以实现进程之间的双向通信
	RLock()		解决进程之间的死锁问题

进程池

应用：
	创建多个进程的时候，单个创建太麻烦，所以创建进程池
方法：
	apply()			阻塞的执行池中的进程
	apply_async(self,func,args=(),kwargs=None)	异步的执行池中的过程，就是可以同时执行
	close()			关闭进程池
	terminate()		关闭进程池
	join()			阻塞
创建：
	Pool([maxsize])	可以指定进程池的数量，如果不指定，系统默认为一个
理解：
	进程池，当进程池满的时候。外边的进程会等待，直到进程池里面有空余位置，在进入进程池中执行
进程池中进程的执行必须：
			close()
			join()
			或
			terminate()
			join()

队列Queue

作用：
	进程之间的相互通信，先进先出
	堆栈：先进后出
模块：multiprocessing
类：Queue(maxsize=0)
	实现进程之间的数据交换（进程之间内存不共享)
方法：
	put(blocked=True,timeout=None)		发送数据
	blocked		设置是否等待，就是当队列满的时候，进程是否等待，timeout为等待的时间。当
	timeout大于零的时候，超过时间还没有数据的时候，会报Queue.Full异常
	
	get(blocked=True,timeout=None)	获取数据
	同上，当没有数据的时候，是否等待，超时就报Queue.Empty，当为False，直接抛出
	
	get_nowait()			相当于get(False)
	put_nowait()			相当于put(False)
	empty（）					是否为空
	full()					是否满了
	qsize()					获取队列的个数

管道

作用：
	同上
模块：
	multiprocessing
类：
	Pipe(dumplex=True)		当为True时，表示全双工，就是两端都可以发收信息
创建：
	p=multiprocessing.Pipe(dumplex=Fasle)
	得到一个元组con1,con2(con1用于接收数据recv)（con2用于发送数据send)
	当管道关闭时，会报EOFError

线程的队列

模块：
	queue
类：
	Queue()
作用：
	线程之间的通信
应用：
	消费者与生产者
使用：
	同进程队列

线程绑定

在线程使用的时候都是使用系统的变量，为了让线程都拥有自己的变量，就有了线程绑定。
模块：
	threading
类：
	Local()
使用：
	import threading
	l=threading.Local()
	def fun(value):
		l.value=value

使用map实现多线程

模块：
	multiprocessing.dummy
类：
	Pool()
方法：
	map(fun,*iterable)

协程

方法：
	async , await实现协程
async 后面定义的函数为协程函数
await 用来声明程序的挂起，当执行await时，先执行await后面的函数
例子：
	async func():
		print()
		await fun2()
		print()
	async fun2():
		pritnt(0)
分析：
	当执行到await时，先执行fun2