1. 程式人生 > 實用技巧 >python 程序的建立

python 程序的建立

python多程序基本的三個步驟

1、引入模組multiprocessing

2、用程序類建立程序

3、start程序

程序可以加快程式執行速度,例如:

import multiprocessing
import time
def sing(num):
    for i in range(num):
        print('sing')
        time.sleep(0.5)
def dance(num):
    for i in range(num):
        print('dance')
        time.sleep(0.5)
if __name__ == '
__main__': before = time.time() sing(3) dance(3) dis = time.time() - before print(dis)

花費了大約三秒,下面用程序來實現

import multiprocessing
import time
def sing():
    for i in range(3):
        print('sing')
        time.sleep(0.5)
def dance():
    for i in range(3):
        print('dance
') time.sleep(0.5) if __name__ == '__main__': before = time.time() one = multiprocessing.Process(target=sing) two = multiprocessing.Process(target=dance) one.start() two.start() one.join() two.join() dis = time.time() - before print(dis)

只用了1.6s

上面是沒有帶引數的程序建立,下面看看帶引數的程序建立

程序的引數帶入有兩種格式,一是args元組形式,而實kwargs列表形式,args是按照從前往後的順序進行傳參的,kwargs是按照鍵值對相對應的關係進行傳參的

import multiprocessing
import time
def sing(num):
    for i in range(num):
        print('sing')
        time.sleep(0.5)
def dance(num):
    for i in range(num):
        print('dance')
        time.sleep(0.5)
if __name__ == '__main__':
    before = time.time()
    one = multiprocessing.Process(target=sing,args=(3,))
    two = multiprocessing.Process(target=dance,args=(3, ))
    one.start()
    two.start()
    one.join()
    two.join()
    dis = time.time() - before
    print(dis)

建立成功

下面是列表形式傳多個引數

import multiprocessing
import time
def sing(num,name):
    for i in range(num):
        print(name)
        print('sing')
        time.sleep(0.5)
def dance(num,name):
    for i in range(num):
        print(name)
        print('dance')
        time.sleep(0.5)
if __name__ == '__main__':
    before = time.time()
    one = multiprocessing.Process(target=sing,args=(3,'lilei'))
    two = multiprocessing.Process(target=dance,args=(3, 'meimei'))
    one.start()
    two.start()
    one.join()
    two.join()
    dis = time.time() - before
    print(dis)

正確

如果多個引數中有些事元組,有些是普通字元,有些是數字,怎麼通過元組形式進行區分呢?

在這裡建議使用字典形式

下面進行字典形式的傳參

import multiprocessing
import time
def sing(num,name):
    for i in range(num):
        print(name)
        print('sing')
        time.sleep(0.5)
def dance(num,name):
    for i in range(num):
        print(name)
        print('dance')
        time.sleep(0.5)
if __name__ == '__main__':
    before = time.time()
    one = multiprocessing.Process(target=sing,kwargs={'name' : 'DC', 'num' : 3})
    two = multiprocessing.Process(target=dance,kwargs={'name' : 'KZL', 'num' : 3})
    one.start()
    two.start()
    one.join()
    two.join()
    dis = time.time() - before
    print(dis)

用字典形式傳參就不會導致傳參不正確

到現在就知道了怎麼建立程序了,下面看一些注意事項

★預設子程序不會等待子程序,父程序結束了子程序也不會結束

也從一個例子說起

import multiprocessing
import time
def sing():
    for i in range(3):
        print("DC")
        print('sing')
        time.sleep(0.5)
if __name__=='__main__':
    print("演出開始")
    one = multiprocessing.Process(target=sing)
    one.start()
    print('演出結束')

主程序演出已經結束了,但是DC還在唱歌,這裡就說明了子程序並沒有因為父程序的結束而結束

這裡可以通過join函式實現這裡程序的同步,讓子程序結束了父程序才結束

import multiprocessing
import time
def sing():
    for i in range(3):
        print("DC")
        print('sing')
        time.sleep(0.5)
if __name__=='__main__':
    print("演出開始")
    one = multiprocessing.Process(target=sing)
    one.start()
    one.join()
    print('演出結束')

實現了,這裡需要注意,join必須在start的後面,如果有多個程序,每個子程序的join函式都需要在所有子程序的start函式後面。

join相當於強制執行當前程序

同時可以通過設定守護程序,讓主程序結束後,子程序跟著結束

import multiprocessing
import time
def sing():
    for i in range(3):
        print("DC")
        print('sing')
        time.sleep(0.5)
if __name__=='__main__':
    print("演出開始")
    start_process = multiprocessing.Process(target=sing)
    start_process.daemon = True
    start_process.start()
    time.sleep(1)
    print('演出結束')

因為只有大約1S的時間,所以DC只唱了兩次歌

接著就需要看看程序的程序號獲取

獲取程序號可以通過os模組,當讓也可以用multiprocessing.current_process().pid

os.getpid:獲取當前程序的程序號

os.getppid:獲取父程序的程序號

定義程序處理類

此種方法會定義一個新的程序process類的新類

需要重新寫__init__,然後將需要執行的目標函式放在run函式,一旦呼叫該類的start函式,就會自動呼叫該run函式

import multiprocessing
import time
# 定義程序處理類
class MyProcess(multiprocessing.Process):
    def __init__(self,name,delay,count):
        super().__init__(name=name)
        self.__delay = delay
        self.count = count
    def run(self):
        for i in range(self.count):
            print("目前程序號是:{0},程序的名稱是:{1}".format(multiprocessing.current_process().pid,multiprocessing.current_process().name))
if __name__=='__main__':
    one = MyProcess(name='leilei', count=3, delay=0.1)
    one.start()

需要注意,設定程序名字那裡需要用super呼叫父類的方法。

run函式也可以直接呼叫,但是此時就沒有子程序生成,而是主程序直接呼叫該函式

程序控制

Process類程序控制的方法

  • terminate(self) 關閉程序
  • is_alive(self) 判斷程序是否存活
  • join(self,out) 程序強制執行

在關閉程序之前必須判斷程序是否存活

守護程序

守護程序是執行在後臺的特殊程序,當其專屬程序結束時,守護程序也會結束。

守護程序就相當於監聽。

創立守護程序時,只要將daemon設定為True。

import multiprocessing,time
def sing():
    two = multiprocessing.Process(target=protect, daemon=True)
    two.start()
    for i in range(5):
        a = 'I\'m sing'
        print('I\'m sing')
        time.sleep(0.5)
def protect():
    for i in range(10):
        print("I'm protecting you!")
        time.sleep(0.5)
if __name__ == '__main__':
    one = multiprocessing.Process(target=sing)
    one.start()

I'm sing
I'm protecting you!
I'm sing
I'm protecting you!
I'm sing
I'm protecting you!
I'm sing
I'm protecting you!
I'm sing
I'm protecting you!

I'm protecting you!應該列印10次,但是因為sing函式結束了,所以守護程序protect也結束了