python异常机制、多进程与PyQt5中的QTimer、多线程
1.异常处理机制
def test(x):
try:
y = 10 / x
print(y)
#except Exception as e:
#print(e) #可以打印出异常的类型
except ZeroDivisionError: #抛出异常，执行下面的程序，如果是界面软件可以弹出一个窗口，提示用户输入错误
print(x)
else: #如果程序不存在异常，则执行该程序
print(100 / x)
finally:
print('the program end') #不管程序是否错误，始终都会执行
test(0)
# 0
# the program end
test(1)
# 10.0
# 100.0
# the program end 
def test2():
try:
assert False, 'error'
except:
print('another')
# 输出 another
def myLevel(level):
if level < 1:
raise ValueError('Invalid level', level) #自定义异常
try:
myLevel(0)
except ValueError:
print('level < 1')
#输出 ：level < 1
print('test 2--')
test2()2.多进程
引入多进程的库文件： import multiprocessing
多进程测试， 需要在主函数 main 中 进行测试
创建进程的类：Process([group [, target [, name [, args [, kwargs]]]]])，target表示调用对象，args表示调用对象的位置参数元组。kwargs表示调用对象的字典。name为别名。group实质上不使用。
方法：is_alive()、join([timeout])、run()、start()、terminate()。其中，Process以start()启动某个进程。
属性：authkey、daemon（要通过start()设置）、exitcode(进程在运行时为None、如果为–N，表示被信号N结束）、name、pid。其中daemon是父进程终止后自动终止，且自己不能产生新进程，必须在start()之前设置
daemon 是守护进程 ：daemon是父进程终止后自动终止，且自己不能产生新进程，必须在start()之前设置。#主线程执行完毕之后，不管子线程是否执行完毕都随着主线程一起结束。
def worker_1():
print('this is worker 1')
time.sleep(3)
print('worker 1 end')
# n = 3
# while n > 0:
# print("The time is {0}".format(time.ctime()))
# time.sleep(interval)
# n -= 1
def worker_2():
print('this is worker 2')
time.sleep(3)
print('worker 2 end')
def worker_3():
print('this is worker 3')
time.sleep(3)
print('worker 3 end')
if __name__ == "__main__":
p1 = multiprocessing.Process(target = worker_1, args = ())
p2 = multiprocessing.Process(target = worker_2, args = ())
p3 = multiprocessing.Process(target = worker_3, args = ())
# p1.daemon = True # 设置子程序为 守护进程， 主程序结束后，它就随之结束（即如果没有join函数，将不执行worker1函数）， 需要放在start 前面
p1.start() #进程调用 start 的时候，将自动调用 run 函数
p2.start()
p3.start() #运行3 个worker 程序花费的时间为3 s， 使用了3 个进程进行处理
p1.join()
p2.join()
p3.join() #添加 join 函数， 先执行 worker 函数， 再执行主进程函数
for p in multiprocessing.active_children(): #这是主进程函数
print('name is :' + p.name + 'pid is :' + str(p.pid) + 'is _alive: '+ str(p.is_alive()))
print('电脑的核数'+ str(multiprocessing.cpu_count())) # 电脑的核数4
print('end----')输出：
#---没有 join 函数---
# name is :Process-1pid is :6488is _alive: True
# name is :Process-2pid is :5660is _alive: True
# name is :Process-3pid is :7776is _alive: True
# 电脑的核数4
# end----
# this is worker 1
# this is worker 2
# this is worker 3
# worker 1 end
# worker 2 end
# worker 3 end
#---有 join 函数--- 等待所有子进程结束，再执行主进程
# this is worker 1
# this is worker 2
# this is worker 3
# worker 1 end
# worker 2 end
# worker 3 end
# 电脑的核数4 #此时执行完线程， active_children() 为空
# end---- 使用多个进程访问共享资源的时候，需要使用Lock 来避免访问的冲突
def worker_first(lock, f):
with lock:
with open(f, 'a+') as t: #with 自动关闭文件
n = 3
while n > 0:
t.write('first write ---')
n -= 1
def worker_second(lock, f):
lock.acquire() #获取锁
try:
with open(f, 'a+') as t:
n = 3
while n > 0:
t.write('second write ---')
n -= 1
finally:
lock.release() #使用异常机制，保证最后释放锁
def myProcess():
lock = multiprocessing.Lock()
f = r'D:\myfile1.txt'
p1 = multiprocessing.Process(target=worker_first, args=(lock, f, ))
p2 = multiprocessing.Process(target=worker_second, args=(lock, f, ))
p1.start()
p2.start()
print('end -----------')
if __name__ == '__main__':
myProcess()输出：
first write ---first write ---first write ---second write ---second write ---second write ---进程池
进程池 Pool
在利用Python进行系统管理的时候，特别是同时操作多个文件目录，或者远程控制多台主机，并行操作可以节约大量的时间。当被操作对象数目不大时，可以直接利用multiprocessing中的Process动态成生多个进程，十几个还好，但如果是上百个，上千个目标，手动的去限制进程数量却又太过繁琐，
此时可以发挥进程池的功效。Pool可以提供指定数量的进程，供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，
那么该请求就会等待，直到池中有进程结束，才会创建新的进程来它。
apply_async(func[, args[, kwds[, callback]]]) 它是非阻塞，apply(func[, args[, kwds]])是阻塞的
非阻塞和阻塞进程池
单个函数使用线程池：
def func(msg):
print('msg is :' + msg)
time.sleep(2)
print(msg + ' end')
return msg + ' re'
if __name__ == '__main__':
pool = multiprocessing.Pool(processes=3) #创建进程池
result = []
for i in range(4):
msg = '%d'%(i)
# result.append(pool.apply_async(func, (msg, )))
pool.apply_async(func, (msg, )) #非阻塞进程池， 维持总的进程数为 processes=3， 当一个进程结束后，添加另一个进程进去
# pool.apply(func, (msg, )) #阻塞进程池
print('start------')
pool.close() # close 函数需要在 join 函数之前， 关闭进程池后，没有进程加入到pool中
pool.join() # join函数等待所有子进程结束
print('all program done')
# print([re.get() for re in result]) #获取结果输出：
#---非阻塞进程池 输出------
# start------
# msg is :0
# msg is :1
# msg is :2
# 0 end
# msg is :3
# 1 end
# 2 end
# 3 end
# all program done
#---阻塞进程池 输出------ 顺序执行
# msg is :0
# 0 end
# msg is :1
# 1 end
# msg is :2
# 2 end
# msg is :3
# 3 end
# start------
# all program done多个函数使用线程池
def f1():
result = 0
print('this is one')
for i in range(100000):
result += i
return result
def f2():
result = 1
print('this is two')
for i in range(2, 100000):
result *= i
return result
if __name__ == '__main__':
start = time.time()
myPool = multiprocessing.Pool(processes=2)
result = []
print('start----')
myFunc = [f1, f2]
for f in myFunc:
result.append(myPool.apply_async(f)) #将输出结果保存到列表中
myPool.close()
myPool.join()
print([re.get() for re in result])
end = time.time()
print('花费的时间： ' + str(end-start)) #huafei de 时间： 8.397480010986328
print('end------')使用get() 函数，同样可以获取pandas 的数据结构；
def f1():
result = 0
print('this is one')
result = pd.DataFrame(np.arange(16).reshape(-1, 4))
return result
# for i in range(100000):
# result += i
# return result
def f2():
result = 1
print('this is two')
result = pd.DataFrame(np.arange(9).reshape(-1, 3))
return result
# for i in range(2, 100000):
# result *= i
# return result
if __name__ == '__main__':
start = time.time()
myPool = multiprocessing.Pool(processes=2)
result = []
print('start----')
myFunc = [f1, f2]
for f in myFunc:
result.append(myPool.apply_async(f)) #将输出结果保存到列表中
myPool.close()
myPool.join()
for re in result:
print(re.get())输出结果：
start----
this is one
this is two
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
3 12 13 14 15
0 1 2
0 0 1 2
1 3 4 5
2 6 7 8
花费的时间： 0.9370532035827637
end------
3.PyQt5 中的QTimer 模块
pyqt5中的多线程的应用，多线程技术涉及3种方法，1.使用计时器QTimer， 2.使用多线程模块QThread ，3.使用事件处理功能
1.使用QTimer模块，创建QTimer实例，将timeout信号连接到槽函数，并调用timeout 信号。 self.timer.start(1000)时间为毫秒
引入模块
from PyQt5.QtCore import QTimer, QDateTime
def timerTest():
class WinForm(QWidget):
def __init__(self,parent=None):
super(WinForm,self).__init__(parent)
self.setWindowTitle("QTimer demo")
self.listFile= QListWidget()
self.label = QLabel('显示当前时间')
self.startBtn = QPushButton('开始')
self.endBtn = QPushButton('结束')
layout = QGridLayout(self)
# 初始化一个定时器
self.timer = QTimer(self)
# showTime()方法
self.timer.timeout.connect(self.showTime) #
layout.addWidget(self.label,0,0,1,2)
layout.addWidget(self.startBtn,1,0)
layout.addWidget(self.endBtn,1,1)
self.startBtn.clicked.connect( self.startTimer) #首先按下start开始计时，到了2s后，触发timeout 信号
self.endBtn.clicked.connect( self.endTimer)
self.setLayout(layout)
QTimer.singleShot(5000, self.showmsg) #给定的时间间隔后，调用一个槽函数来发射信号
def showmsg(self):
QMessageBox.information(self, '提示信息', '你好')
def showTime(self):
# 获取系统现在的时间
time = QDateTime.currentDateTime() #获取当前时间
# 设置系统时间显示格式
timeDisplay = time.toString("yyyy-MM-dd hh:mm:ss dddd")
# 在标签上显示时间
self.label.setText( timeDisplay )
def startTimer(self):
# 设置计时间隔并启动
self.timer.start(1000) #时间为 1 s
self.startBtn.setEnabled(False)
self.endBtn.setEnabled(True)
def endTimer(self):
self.timer.stop()
self.startBtn.setEnabled(True) #依次循环
self.endBtn.setEnabled(False)
if __name__ == "__main__":
app = QApplication(sys.argv)
form = WinForm()
form.show()
# QTimer.singleShot(5000, app.quit) #界面运行5秒后，自动关闭
sys.exit(app.exec_())
timerTest()
QThread模块，使用该模块开始一个线程，可以创建它的一个子类，然后覆盖QThread.run() 的方法。调用自定义的线程时，调用start()方法，会自动调用run的方法，
QThread 还有 started , finished 信号，可以见信号连接到槽函数中
def threadTest():
class MainWidget(QWidget):
def __init__(self,parent=None):
super(MainWidget,self).__init__(parent)
self.setWindowTitle("QThread 例子")
self.thread = Worker() #创建线程
self.listFile = QListWidget()
self.btnStart = QPushButton('开始')
self.btnStop = QPushButton('结束')
layout = QGridLayout(self)
layout.addWidget(self.listFile,0,0,1,2)
layout.addWidget(self.btnStart,1,1)
layout.addWidget(self.btnStop,2,1)
self.btnStart.clicked.connect( self.slotStart ) #通过按钮状态实现 线程的开启
self.btnStop.clicked.connect(self.slotStop)
self.thread.sinOut.connect(self.slotAdd)
def slotStop(self):
self.btnStart.setEnabled(True)
self.thread.wait(2000)
def slotAdd(self,file_inf):
self.listFile.addItem(file_inf) #增加子项
def slotStart(self):
self.btnStart.setEnabled(False)
self.thread.start() #线程开始
#创建一个线程
class Worker(QThread):
sinOut = pyqtSignal(str) #自定义一个信号
def __init__(self, parent=None):
super(Worker, self).__init__(parent)
self.work = True
self.num = 0
def run(self):
while self.work == True:
listStr = 'this is index file {0}'.format(self.num)
self.sinOut.emit(listStr) #发射一个信号
self.num += 1
self.sleep(2) #休眠2 秒
def __del__(self):
self.work = False
self.wait()
if __name__ == "__main__":
app = QApplication(sys.argv)
demo = MainWidget()
demo.show()
sys.exit(app.exec_())
# threadTest()demo 2：
def threadTest2():
global sec
sec=0
class WorkThread(QThread): #自定义一个线程
trigger = pyqtSignal()
def __int__(self):
super(WorkThread,self).__init__()
def run(self):
for i in range(2000000000):
print('haha ' + str(i)) #此处放运行 量较大的程序
# 循环完毕后发出信号
self.trigger.emit()
def countTime():
global sec
sec += 1
# LED显示数字+1
lcdNumber.display(sec)
def work():
# 计时器每秒计数
timer.start(1000) #每秒运行完后，是lcd增加数字
# 计时开始
workThread.start()
# 当获得循环完毕的信号时，停止计数
workThread.trigger.connect(timeStop)
def timeStop():
timer.stop()
print("运行结束用时",lcdNumber.value())
global sec
sec=0
if __name__ == "__main__":
app = QApplication(sys.argv)
top = QWidget()
top.resize(300,120)
# 垂直布局类QVBoxLayout
layout = QVBoxLayout(top)
# 加个显示屏
lcdNumber = QLCDNumber()
layout.addWidget(lcdNumber)
button = QPushButton("测试")
layout.addWidget(button)
timer = QTimer()
workThread = WorkThread()
button.clicked.connect(work)
# 每次计时结束，触发 countTime
timer.timeout.connect(countTime)
top.show()
sys.exit(app.exec_())
threadTest2()
参考：
