异常处理

异常就是程序运行时发生错误的信号，在python中,错误触发的异常如下

异常的种类：

AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性xIOError 输入/输出异常；基本上是无法打开文件ImportError 无法引入模块或包；基本上是路径问题或名称错误IndentationError 语法错误（的子类） ；代码没有正确对齐IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]KeyError 试图访问字典里不存在的键KeyboardInterrupt Ctrl+C被按下NameError 使用一个还未被赋予对象的变量SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）TypeError 传入对象类型与要求的不符合UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它ValueError 传入一个调用者不期望的值，即使值的类型是正确的

常用异常

异常处理：

python为每一种异常定制了一个类型，然后提供了一种特定的语法结构用来进行异常处理。

1 try:2     被检测的代码块3 except 异常类型：4     try中一旦检测到异常，就执行这个位置的逻辑

基本语法

异常类只能用来处理指定的异常情况，如果非指定异常则无法处理。

1 # 未捕获到异常，程序直接报错2  3 s1 = ‘hello‘4 try:5     int(s1)6 except IndexError as e:7     print e

View Code

多分支

1 s1 = ‘hello‘2 try:3     int(s1)4 except IndexError as e:5     print(e)6 except KeyError as e:7     print(e)8 except ValueError as e:9     print(e)

View Code

万能异常

在python的异常中，有一个万能异常：Exception，他可以捕获任意异常，即：

1 s1 = ‘hello‘2 try:3     int(s1)4 except Exception as e:5     print(e)

View Code

1、如果你统一用Exception，没错，是可以捕捉所有异常，但意味着你在处理所有异常时都使用同一个逻辑去处理（这里说的逻辑即当前expect下面跟的代码块）

2.如果你想要的效果是，对于不同的异常我们需要定制不同的处理逻辑，那就需要用到多分支了。

s1 = ‘hello‘try:    int(s1)except IndexError as e:    print(e)except KeyError as e:    print(e)except ValueError as e:    print(e)

多分支

结论：

只有在有些异常无法预知的情况下，才应该加上try...except，其他的逻辑错误应该尽量修正。

操作系统

程序员无法把所有的硬件操作细节都了解到，管理这些硬件并且加以优化使用是非常繁琐的工作，这个繁琐的工作就是操作系统来干的，有了他，程序员就从这些繁琐的工作中解脱了出来，只需要考虑自己的应用软件的编写就可以了，应用软件直接使用操作系统提供的功能来间接使用硬件。

精简的说的话，操作系统就是一个协调、管理和控制计算机硬件资源和软件资源的控制程序。

操作系统的两大作用：

作用一：为应用程序提供如何使用硬件资源的抽象

作用二：管理硬件资源

二：多路复用

现代计算机或者网络都是多用户的，多个用户不仅共享硬件，而且共享文件，数据库等信息，共享意味着冲突和无序。

操作系统主要使用来

1.记录哪个程序使用什么资源

2.对资源请求进行分配

3.为不同的程序和用户调解互相冲突的资源请求。

我们可将上述操作系统的功能总结为：处理来自多个程序发起的多个（多个即多路）共享（共享即复用）资源的请求，简称多路复用。

1.时间上的复用

当一个资源在时间上复用时，不同的程序或用户轮流使用它，第一个程序获取该资源使用结束后，在轮到第二个。。。第三个。。。

例如：只有一个cpu，多个程序需要在该cpu上运行，操作系统先把cpu分给第一个程序，在这个程序运行的足够长的时间（时间长短由操作系统的算法说了算）或者遇到了I/O阻塞，操作系统则把cpu分配给下一个程序，以此类推，直到第一个程序重新被分配到了cpu然后再次运行，由于cpu的切换速度很快，给用户的感觉就是这些程序是同时运行的，或者说是并发的，或者说是伪并行的。至于资源如何实现时间复用，或者说谁应该是下一个要运行的程序，以及一个任务需要运行多长时间，这些都是操作系统的工作。

2.空间上的复用

每个客户都获取了一个大的资源中的一小部分资源，从而减少了排队等待资源的时间。

例如：多个运行的程序同时进入内存，硬件层面提供保护机制来确保各自的内存是分割开的，且由操作系统控制，这比一个程序独占内存一个一个排队进入内存效率要高的多。

有关空间复用的其他资源还有磁盘，在许多系统中，一个磁盘同时为许多用户保存文件。分配磁盘空间并且记录谁正在使用哪个磁盘块是操作系统资源管理的典型任务。

这两种方式合起来便是多道技术

进程线程

对于操作系统来说，一个任务就是一个进程（Process），比如打开一个浏览器就是启动一个浏览器进程，打开一个记事本就启动了一个记事本进程，打开两个记事本就启动了两个记事本进程，打开一个Word就启动了一个Word进程。

有些进程还不止同时干一件事，比如Word，它可以同时进行打字、拼写检查、打印等事情。在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，我们把进程内的这些“子任务”称为线程（Thread）。
由于每个进程至少要干一件事，所以，一个进程至少有一个线程。当然，像Word这种复杂的进程可以有多个线程，多个线程可以同时执行，多线程的执行方式和多进程是一样的，也是由操作系统在多个线程之间快速切换，让每个线程都短暂地交替运行，看起来就像同时执行一样。当然，真正地同时执行多线程需要多核CPU才可能实现。
我们前面编写的所有的Python程序，都是执行单任务的进程，也就是只有一个线程。如果我们要同时执行多个任务怎么办？

有两种解决方案：

一种是启动多个进程，每个进程虽然只有一个线程，但多个进程可以一块执行多个任务。
还有一种方法是启动一个进程，在一个进程内启动多个线程，这样，多个线程也可以一块执行多个任务。
当然还有第三种方法，就是启动多个进程，每个进程再启动多个线程，这样同时执行的任务就更多了，当然这种模型更复杂，实际很少采用。
总结一下就是，多任务的实现有3种方式：

? 多进程模式；
? 多线程模式；
? 多进程+多线程模式。
同时执行多个任务通常各个任务之间并不是没有关联的，而是需要相互通信和协调，有时，任务1必须暂停等待任务2完成后才能继续执行，有时，任务3和任务4又不能同时执行，所以，多进程和多线程的程序的复杂度要远远高于前面写的单进程单线程的程序。

有很多时候，没有多任务还真不行。想想在电脑上看电影，就必须由一个线程播放视频，另一个线程播放音频，否则，单线程实现的话就只能先把视频播放完再播放音频，或者先把音频播放完再播放视频，这显然是不行的。

Python既支持多进程，又支持多线程。

总结：
线程是最小的执行单元，而进程由至少一个线程组成。如何调度进程和线程，完全由操作系统决定，程序自己不能决定什么时候执行，执行多长时间。
多进程和多线程的程序涉及到同步、数据共享的问题，编写起来更复杂。

并发与并行

 无论是并行还是并发，在用户看来都是‘同时‘运行的，不管是进程还是线程，都只是一个任务而已，真是干活的是cpu，cpu来做这些任务，而一个cpu同一时刻只能执行一个任务

　　并行：同时运行，只有具备多个cpu才能实现并行

      并发：是伪并行，即看起来是同时运行。单个cpu+多道技术就可以实现并发，（并行也属于并发）

线程

在传统操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程

　　多线程（即多个控制线程）的概念是，在一个进程中存在多个控制线程，多个控制线程共享该进程的地址空间

　　进程只是用来把资源集中到一起（进程只是一个资源单位，或者说资源集合），而线程才是cpu上的执行单位，

      例如，北京地铁与上海地铁是不同的进程，而北京地铁里的13号线是一个线程，北京地铁所有的线路共享北京地铁所有的资源，比如所有的乘客可以被所有线路拉。

为何要用多线程

　多线程指的是，在一个进程中开启多个线程，简单的讲：如果多个任务共用一块地址空间，那么必须在一个进程内开启多个线程。详细的讲分为4点：

　　1. 多线程共享一个进程的地址空间

      2. 线程比进程更轻量级，线程比进程更容易创建可撤销，在许多操作系统中，创建一个线程比创建一个进程要快10-100倍，在有大量线程需要动态和快速修改时，这一特性很有用

      3. 若多个线程都是cpu密集型的，那么并不能获得性能上的增强，但是如果存在大量的计算和大量的I/O处理，拥有多个线程允许这些活动彼此重叠运行，从而会加快程序执行的速度。

      4. 在多cpu系统中，为了最大限度的利用多核，可以开启多个线程（比开进程开销要小的多）

多线程应用举例：

开启一个字处理软件进程，该进程肯定需要办不止一件事情，比如监听键盘输入，处理文字，定时自动将文字保存到硬盘，这三个任务操作的都是同一块数据，因而不能用多进程。只能在一个进程里并发地开启三个线程,如果是单线程，那就只能是，键盘输入时，不能处理文字和自动保存，自动保存时又不能输入和处理文字。

python并发编程之多进程

multiprocessing模块介绍

python中的多线程无法利用多核优势，如果想要充分地使用多核CPU的资源（os.cpu_count()查看），在python中大部分情况需要使用多进程。Python提供了非常好用的多进程包multiprocessing。
    multiprocessing模块用来开启子进程，并在子进程中执行我们定制的任务（比如函数），该模块与多线程模块threading的编程接口类似。

　 multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。

    需要再次强调的一点是：与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。

 Process类的介绍

创建进程的类：

Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）强调：1. 需要使用关键字的方式来指定参数2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号参数介绍：1 group参数未使用，值始终为None2 3 target表示调用对象，即子进程要执行的任务4 5 args表示调用对象的位置参数元组，args=(1,2,‘egon‘,)6 7 kwargs表示调用对象的字典,kwargs={‘name‘:‘egon‘,‘age‘:18}8 9 name为子进程的名称

方法介绍：

 1 p.start()：启动进程，并调用该子进程中的p.run()  2 p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法   3  4 p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁 5 p.is_alive():如果p仍然运行，返回True 6  7 p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程  

属性介绍：

1 p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置2 3 p.name:进程的名称4 5 p.pid：进程的pid6 7 p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)8 9 p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）

Process类的使用

=====================part1：创建并开启子进程的两种方式

注意：在windows中Process()必须放到# if __name__ == ‘__main__‘:下

Since Windows has no fork, the multiprocessing module starts a new Python process and imports the calling module. 
If Process() gets called upon import, then this sets off an infinite succession of new processes (or until your machine runs out of resources). 
This is the reason for hiding calls to Process() inside

if __name__ == "__main__"
since statements inside this if-statement will not get called upon import.

由于Windows没有fork，多处理模块启动一个新的Python进程并导入调用模块。 
如果在导入时调用Process（），那么这将启动无限继承的新进程（或直到机器耗尽资源）。 
这是隐藏对Process（）内部调用的原，使用if __name__ == “__main __”，这个if语句中的语句将不会在导入时被调用。

#开进程的方法一:import timeimport randomfrom multiprocessing import Processdef piao(name):    print(‘%s piaoing‘ %name)    time.sleep(random.randrange(1,5))    print(‘%s piao end‘ %name)p1=Process(target=piao,args=(‘egon‘,)) #必须加,号p2=Process(target=piao,args=(‘alex‘,))p3=Process(target=piao,args=(‘wupeqi‘,))p4=Process(target=piao,args=(‘yuanhao‘,))p1.start()p2.start()p3.start()p4.start()print(‘主线程‘)

开进程的方法一:

#开进程的方法二:import timeimport randomfrom multiprocessing import Processclass Piao(Process):    def __init__(self,name):        super().__init__()        self.name=name    def run(self):        print(‘%s piaoing‘ %self.name)        time.sleep(random.randrange(1,5))        print(‘%s piao end‘ %self.name)p1=Piao(‘egon‘)p2=Piao(‘alex‘)p3=Piao(‘wupeiqi‘)p4=Piao(‘yuanhao‘)p1.start() #start会自动调用runp2.start()p3.start()p4.start()print(‘主线程‘)

开进程的方法二

练习一：把上周学的socket通信变成并发的形式

from socket import *from multiprocessing import Processserver=socket(AF_INET,SOCK_STREAM)server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)server.bind((‘127.0.0.1‘,8080))server.listen(5)def talk(conn,client_addr):    while True:        try:            msg=conn.recv(1024)            if not msg:break            conn.send(msg.upper())        except Exception:            breakif __name__ == ‘__main__‘: #windows下start进程一定要写到这下面    while True:        conn,client_addr=server.accept()        p=Process(target=talk,args=(conn,client_addr))        p.start()

server端

from socket import *client=socket(AF_INET,SOCK_STREAM)client.connect((‘127.0.0.1‘,8080))while True:    msg=input(‘>>: ‘).strip()    if not msg:continue    client.send(msg.encode(‘utf-8‘))    msg=client.recv(1024)    print(msg.decode(‘utf-8‘))

多个client端

每来一个客户端，都在服务端开启一个进程，如果并发来一个万个客户端，要开启一万个进程吗，你自己尝试着在你自己的机器上开启一万个，10万个进程试一试。解决方法：进程池

9 异常处理 操作系统 进程线程 队列+生产消费者模型 进程同步 回调函数