异常处理
异常就是程序在运行时发生的错误的信号
python解释器检测到错误，触发异常（也允许程序员自己触发异常）
程序员编写特定的代码，专门用来捕捉这个异常（这段代码与程序逻辑无关，与异常处理有关）
如果捕捉成功则进入另外一个处理分支，执行你为其定制的逻辑，使程序不会崩溃，这就是异常处理
#为何要进行异常处理
python解析器去执行程序，检测到了一个错误时，触发异常，异常触发后且没被处理的情况下，程序就在当前异常处终止，后面的代码不会运行，谁会去用一个运行着突然就崩溃的软件。
所以你必须提供一种异常处理机制来增强你程序的健壮性与容错性
#如何进行异常处理
异常是由程序的错误引起的，语法上的错误跟异常处理无关，必须在程序运行前就修正
1.使用if判断式
2.python为每一种异常定制了一个类型，然后提供了一种特定的语法结构用来进行异常处理
python异常类处理
基本语法：
try:
被检测的代码块
except 异常类型：
try中一旦检测到异常，就执行这个位置的逻辑
f=open('a.txt')
g=(line.strip() for line in f)
'''
next(g)会触发迭代f，依次next(g)就可以读取文件的一行行内容，无论文件a.txt有多大，同一时刻内存中只有一行内容。
提示：g是基于文件句柄f而存在的，因而只能在next(g)抛出异常StopIteration后才可以执行f.close()
'''
f=open('a.txt')
g=(line.strip() for line in f)
for line in g:
print(line)
else:
f.close()
try:
f=open('a.txt')
g=(line.strip() for line in f)
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
except StopIteration:
f.close()
异常类只能用来处理指定的异常情况，如果非指定异常则无法处理。
# 未捕获到异常，程序直接报错
s1 = 'hello'
try:
int(s1)
except IndexError as e:
print e
多分支
s1 = 'hello'
try:
int(s1)
except IndexError as e:
print(e)
except KeyError as e:
print(e)
except ValueError as e:
print(e)
万能异常
在python的异常中，有一个万能异常：Exception，他可以捕获任意异常
s1 = 'hello'
try:
int(s1)
except Exception as e:
print(e)
异常的其他机构
s1 = 'hello'
try:
int(s1)
except IndexError as e:
print(e)
except KeyError as e:
print(e)
except ValueError as e:
print(e)
else:
print('try内代码块没有异常则执行我')
finally:
print('无论异常与否,都会执行该模块,通常是进行清理工作')
主动触发异常
#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
try:
raise TypeError('类型错误')
except Exception as e:
print(e)
自定义异常
__author__ = 'Linhaifeng'
class EgonException(BaseException):
def __init__(self,msg):
self.msg=msg
def __str__(self):
return self.msg
try:
raise EgonException('类型错误')
except EgonException as e:
print(e)
断言
assert 条件
assert 1 == 1
assert 1 == 2
try..except的方式比较if的方式的好处
_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
# num1=input('>>: ') #输入一个字符串试试
# if num1.isdigit():
# int(num1) #我们的正统程序放到了这里,其余的都属于异常处理范畴
# elif num1.isspace():
# print('输入的是空格,就执行我这里的逻辑')
# elif len(num1) == 0:
# print('输入的是空,就执行我这里的逻辑')
# else:
# print('其他情情况,执行我这里的逻辑')
#第二段代码
# num2=input('>>: ') #输入一个字符串试试
# int(num2)
#第三段代码
# num3=input('>>: ') #输入一个字符串试试
# int(num3)
try:
#第一段代码
num1=input('>>: ') #输入一个字符串试试
int(num1) #我们的正统程序放到了这里,其余的都属于异常处理范畴
#第二段代码
num2=input('>>: ') #输入一个字符串试试
int(num2)
#第三段代码
num3=input('>>: ') #输入一个字符串试试
int(num3)
except ValueError as e:
print(e)
使用try..except的方式
1：把错误处理和真正的工作分开来
2：代码更易组织，更清晰，复杂的工作任务更容易实现；
3：毫无疑问，更安全了，不至于由于一些小的疏忽而使程序意外崩溃了；
语法错误
在程序运行前就应该修正的
#print（1）
#def test:
pass
#class Foo
pass
#print(haha
逻辑错误
用户输入不完整(比如输入为空)或者输入非法(输入不是数字)
#num=input(">>: ")
int(num)
#1=[1,2]
1[1000]
#d={'a':1}
d['b'] #KeyError
1/0 zeroDivisionError
常用异常
AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
IOError 输入/输出异常；基本上是无法打开文件
ImportError 无法引入模块或包；基本上是路径问题或名称错误
IndentationError 语法错误（的子类） ；代码没有正确对齐
IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
KeyError 试图访问字典里不存在的键
KeyboardInterrupt Ctrl+C被按下
NameError 使用一个还未被赋予对象的变量
SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
TypeError 传入对象类型与要求的不符合
UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，
导致你以为正在访问它
ValueError 传入一个调用者不期望的值，即使值的类型是正确的
更多异常
ArithmeticError
AssertionError
AttributeError
BaseException
BufferError
BytesWarning
DeprecationWarning
EnvironmentError
EOFError
Exception
FloatingPointError
FutureWarning
GeneratorExit
ImportError
ImportWarning
IndentationError
IndexError
IOError
KeyboardInterrupt
KeyError
LookupError
MemoryError
NameError
NotImplementedError
OSError
OverflowError
PendingDeprecationWarning
ReferenceError
RuntimeError
RuntimeWarning
StandardError
StopIteration
SyntaxError
SyntaxWarning
SystemError
SystemExit
TabError
TypeError
UnboundLocalError
UnicodeDecodeError
UnicodeEncodeError
UnicodeError
UnicodeTranslateError
UnicodeWarning
UserWarning
ValueError
Warning
ZeroDivisionError
触发indexError
l=['egon','aa']
l[3]
触发keyError
dic={'name':'egon'}
dic['age']
触发valueError
s='hello'
int(s)
进程线程
进程：一个正在执行的任务，是一块包含了某些资源的内存区域。操作系统利用进程把它的工作划分为一些功能单元。
线程: 只能归属于一个进程并且它只能访问该进程所拥有的资源。当操作系统创建一个进程后，该进程会自动申请一个名为主线程或首要线程的线程。主线程将执行运行时宿主, 而运行时宿主会负责载入CLR。线程允许单个任务分成不同的部分运行。
并行和并发
并行：同时运行，具有具备多个cpu才能实现并行
并发：是伪并行，即开起来是同时运行，单个cpu+多道技术就可以实现并发（并行也属于并发）
同步和异步
同步是指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程将会一直等待下去，知道收到返回信息才继续执行下去
异步是指进行不需要一直等下去看，而是继续执行下面的操作，不管其他进程的状态。当有消息返回时系统会通知进程进行处理，这样可以提高执行的效率
例如：打电话就是同步通信，发信息是异步通信
创建进程
创建进程方式一：
#不加sleep的情况下，start创建进程，不会等待，所以先出现的是print('父进程')，再出现后面创建的子进程。如果加了sleep，所以看谁快了。因为10秒足够子进程创建完了，所以显示的结果就变成了先出现子进程，然后才打印了父进程
from multiprocessing import Process
import time
import random
import os
print(os.cpu_count()) #查看cpu个数
def piao(name):
print('%s is piaoing' %name)
time.sleep(random.randint(1,3)) #随机等待1,3秒，也可以指定具体秒数。 time.sleep(3)
print('%s is piao end' %name)
if __name__ == '__main__': #必须写在他的下面
p1=Process(target=piao,args=('egon',),) #加，是为了只给一个参数
p1.start() #开一个进程
time.sleep(10) #停止主进程十秒，谁先做完谁打印
print('父进程')
返回值：
4 #4个cpu
4
egon is piaoing
egon is piao end
父进程
#如果只sleep 1秒的情况下
from multiprocessing import Process
import time
import random
import os
print(os.cpu_count())
def piao(name):
print('%s is piaoing' %name)
time.sleep(random.randint(1,3)) #随机等待1,3秒，也可以指定具体秒数。 time.sleep(3)
print('%s is piao end' %name)
if __name__ == '__main__': #必须写在他的下面
p1=Process(target=piao,args=('egon',),) #加，是为了只给一个参数
p1.start() #开一个进程
time.sleep(1) #停止主进程1秒的情况下，打印结果
print('父进程')
返回值：
4
4
egon is piaoing
父进程
egon is piao end
创建进程方式二：
#自定义自己的进程类
from multiprocessing import Process
import time
import random
import os
print(os.cpu_count())
class piao(Process):
def __init__(self,name):
super(piao, self).__init__()
self.name=name
def run(self): #run方法
print('%s is piaoing' %self)
time.sleep(1)
print('%s is piao end' %self)
if __name__ == '__main__': #必须写在他的下面
p1=piao('egon') #使用自己的定义类
p1.start() #开一个进程
# time.sleep(1) #停止主进程1秒的情况下，打印结果
print('父进程')
process类的介绍
创建进程的类：
Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）
强调：
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号
#参数介绍：
group参数未使用，值始终为None
target表示调用对象，即子进程要执行的任务
args表示调用对象的位置参数元组，args=(1,2,'egon',)
kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}
name为子进程的名称
#方法介绍
p.start()：启动进程，并调用该子进程中的p.run()
p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法
p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():如果p仍然运行，返回True
p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程
#属性介绍
p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
p.name:进程的名称
p.pid：进程的pid
p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)
p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）
join的用法
join，等待进程的结束再执行下面的任务
from multiprocessing import Process
import time
import random
import os
print(os.cpu_count())
def piao(name):
print('%s is piaoing' %name)
time.sleep(random.randint(1,3)) #随机等待1,3秒，也可以指定具体秒数。 time.sleep(3)
print('%s is piao end' %name)
if __name__ == '__main__': #必须写在他的下面
p1=Process(target=piao,args=('egon',),) #加，是为了只给一个参数
p1.start() #开一个进程
p1.join()
print('父进程')
进程同步（锁）
进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,
共享同一打印终端，发现会有多行内容打印到一行的现象（多个进程共享并抢占同一个打印终端，乱了）
#多进程共享一个打印终端(用python2测试看两个进程同时往一个终端打印,出现打印到一行的错误)
from multiprocessing import Process
import time
class Logger(Process):
def __init__(self):
super(Logger,self).__init__()
def run(self):
print(self.name)
for i in range(1000000):
l=Logger()
l.start()
#part2：共享同一个文件,会出现两个问题：1.效率 2.需要自己加锁处理
#多进程共享一套文件系统
from multiprocessing import Process
import time,random
def work(f,msg):
f.write(msg)
f.flush()
f=open('a.txt','w') #在windows上无法把f当做参数传入，可以传入一个文件名，然后在work内用a+的方式打开文件，进行写入测试
for i in range(5):
p=Process(target=work,args=(f,str(i)))
p.start()
#加锁的目的是为了保证多个进程修改同一块数据时，同一时间只能有一个修改，即串行的修改，没错，速度是慢了，牺牲了速度而保证了数据安全
#模拟抢票（Lock互斥锁）
#文件db的内容为：{"count":1}
#注意一定要用双引号，不然json无法识别
from multiprocessing import Process,Lock
import json
import time
import random
import os
def work(filename,lock): #买票
# lock.acquire()
with lock:
with open(filename,encoding='utf-8') as f:
dic=json.loads(f.read())
# print('剩余票数: %s' % dic['count'])
if dic['count'] > 0:
dic['count']-=1
time.sleep(random.randint(1,3)) #模拟网络延迟
with open(filename,'w',encoding='utf-8') as f:
f.write(json.dumps(dic))
print('%s 购票成功' %os.getpid())
else:
print('%s 购票失败' %os.getpid())
# lock.release()
if __name__ == '__main__':
lock=Lock()
p_l=[]
for i in range(100):
p=Process(target=work,args=('db',lock))
p_l.append(p)
p.start()
for p in p_l:
p.join()
print('主线程')
队列
进程彼此之间互相隔离，要实现进程间通信（IPC），multiprocessing模块支持两种形式：队列和管道，这两种方式都是使用消息传递的
创建队列的类（底层就是以管道和锁定的方式实现）：
Queue([maxsize]):创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。
#参数介绍:
maxsize是队列中允许最大项数，省略则无大小限制
方法介绍：
主要方法：
应用
生产者消费者模型
在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。
为什么要使用生产者和消费者模式
在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。
什么是生产者消费者模式
生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。
基于队列实现生产者消费者模型
from multiprocessing import Process,Queue
import time,random,os
def consumer(q):
while True:
time.sleep(random.randint(1,3))
res=q.get()
print('\033[45m消费者拿到了：%s\033[0m' %res)
def producer(seq,q):
for item in seq:
time.sleep(random.randint(1,3))
print('\033[46m生产者生产了：%s\033[0m' %item)
q.put(item)
if __name__ == '__main__':
q=Queue()
seq=('包子%s' %i for i in range(10))
c=Process(target=consumer,args=(q,))
c.start()
producer(seq,q)
print('主线程')
#主线程等待消费者结束（生产者发送结束信号给消费者）
from multiprocessing import Process,Queue
import time,random,os
def consumer(q):
while True:
time.sleep(random.randint(1,3))
res=q.get()
if res is None:break
print('\033[45m消费者拿到了：%s\033[0m' %res)
def producer(seq,q):
for item in seq:
time.sleep(random.randint(1,3))
print('\033[46m生产者生产了：%s\033[0m' %item)
q.put(item)
if __name__ == '__main__':
q=Queue()
c=Process(target=consumer,args=(q,))
c.start()
producer(('包子%s' %i for i in range(10)),q)
q.put(None)
c.join()
print('主线程')
进程间通信-管道（不建议）
进程间通信--共享数据（不建议）
进程池
# 创建进程池的类：
Pool([numprocess [,initializer [, initargs]]]):创建进程池
# 参数介绍：
numprocess:要创建的进程数，如果省略，将默认使用cpu_count()的值
initializer：是每个工作进程启动时要执行的可调用对象，默认为None
initargs：是要传给initializer的参数组
#方法介绍：
1 p.apply(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。需要强调的是：此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数，必须从不同线程调用p.apply()函数或者使用p.apply_async()
2 p.apply_async(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。此方法的结果是AsyncResult类的实例，callback是可调用对象，接收输入参数。当func的结果变为可用时，将理解传递给callback。callback禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。
3
4 p.close():关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成5 P.jion():等待所有工作进程退出。此方法只能在close（）或teminate()之后调用
复制代码
#其他方法：
1 方法apply_async()和map_async（）的返回值是AsyncResul的实例obj。实例具有以下方法
2 obj.get():返回结果，如果有必要则等待结果到达。timeout是可选的。如果在指定时间内还没有到达，将引发一场。如果远程操作中引发了异常，它将在调用此方法时再次被引发。
3 obj.ready():如果调用完成，返回True
4 obj.successful():如果调用完成且没有引发异常，返回True，如果在结果就绪之前调用此方法，引发异常
5 obj.wait([timeout]):等待结果变为可用。
6 obj.terminate()：立即终止所有工作进程，同时不执行任何清理或结束任何挂起工作。如果p被垃圾回收，将自动调用此函数
#应用：
提交任务，并在主进程中拿到结果（之前的Process是执行任务，结果放到队列里，现在可以在主进程中直接拿到结果）
from multiprocessing import Pool
import time
def work(n):
print('开工啦...')
time.sleep(3)
return n**2
if __name__ == '__main__':
q=Pool()
#异步apply_async用法：如果使用异步提交的任务，主进程需要使用jion，等待进程池内任务都处理完，然后可以用get收集结果，否则，主进程结束，进程池可能还没来得及执行，也就跟着一起结束了
res=q.apply_async(work,args=(2,))
q.close()
q.join() #join在close之后调用
print(res.get())
#同步apply用法：主进程一直等apply提交的任务结束后才继续执行后续代码
# res=q.apply(work,args=(2,))
# print(res)
回调函数
不需要回调函数的场景：如果在主进程中等待进程池中所有任务都执行完毕后，再统一处理结果，则无需回调函数
from multiprocessing import Pool
import time,random,os
def work(n):
time.sleep(1)
return n**2
if __name__ == '__main__':
p=Pool()
res_l=[]
for i in range(10):
res=p.apply_async(work,args=(i,))
res_l.append(res)
p.close()
p.join() #等待进程池中所有进程执行完毕
nums=[]
for res in res_l:
nums.append(res.get()) #拿到所有结果
print(nums) #主进程拿到所有的处理结果,可以在主进程中进行统一进行处理
2.需要回调函数的场景：进程池中任何一个任务一旦处理完了，就立即告知主进程：我好了额，你可以处理我的结果了。主进程则调用一个函数去处理该结果，该函数即回调函数
我们可以把耗时间（阻塞）的任务放到进程池中，然后指定回调函数（主进程负责执行），这样主进程在执行回调函数时就省去了I/O的过程，直接拿到的是任务的结果。
from multiprocessing import Pool
import time,random,os
def get_page(url):
print('(进程 %s) 正在下载页面 %s' %(os.getpid(),url))
time.sleep(random.randint(1,3))
return url #用url充当下载后的结果
def parse_page(page_content):
print('<进程 %s> 正在解析页面: %s' %(os.getpid(),page_content))
time.sleep(1)
return '{%s 回调函数处理结果:%s}' %(os.getpid(),page_content)
if __name__ == '__main__':
urls=[
'http://maoyan.com/board/1',
'http://maoyan.com/board/2',
'http://maoyan.com/board/3',
'http://maoyan.com/board/4',
'http://maoyan.com/board/5',
'http://maoyan.com/board/7',
]
p=Pool()
res_l=[]
#异步的方式提交任务,然后把任务的结果交给callback处理
#注意:会专门开启一个进程来处理callback指定的任务(单独的一个进程,而且只有一个)
for url in urls:
res=p.apply_async(get_page,args=(url,),callback=parse_page)
res_l.append(res)
#异步提交完任务后,主进程先关闭p(必须先关闭),然后再用p.join()等待所有任务结束(包括callback)
p.close()
p.join()
print('{主进程 %s}' %os.getpid())
#收集结果,发现收集的是get_page的结果
#所以需要注意了:
#1. 当我们想要在将get_page的结果传给parse_page处理,那么就不需要i.get(),通过指定callback,就可以将i.get()的结果传给callback执行的任务
#2. 当我们想要在主进程中处理get_page的结果,那就需要使用i.get()获取后,再进一步处理
for i in res_l: #本例中,下面这两步是多余的
callback_res=i.get()
print(callback_res)
#打印结果
(进程 52346) 正在下载页面 http://maoyan.com/board/1
(进程 52347) 正在下载页面 http://maoyan.com/board/2
(进程 52348) 正在下载页面 http://maoyan.com/board/3
(进程 52349) 正在下载页面 http://maoyan.com/board/4
(进程 52348) 正在下载页面 http://maoyan.com/board/5
<进程 52345> 正在解析页面: http://maoyan.com/board/3
(进程 52346) 正在下载页面 http://maoyan.com/board/7
<进程 52345> 正在解析页面: http://maoyan.com/board/1
<进程 52345> 正在解析页面: http://maoyan.com/board/2
<进程 52345> 正在解析页面: http://maoyan.com/board/4
<进程 52345> 正在解析页面: http://maoyan.com/board/5
<进程 52345> 正在解析页面: http://maoyan.com/board/7
{主进程 52345}
http://maoyan.com/board/1
http://maoyan.com/board/2
http://maoyan.com/board/3
http://maoyan.com/board/4
http://maoyan.com/board/5
http://maoyan.com/board/7
浙公网安备 33010602011771号