python遍歷進程

Ⅰ python腳本怎麼獲取遠程linux伺服器的進程名

進程信息
/proc目錄包含了所有正運行的進程目錄。這些目錄的名字和進程的標識符是一樣的。所以，如果你遍歷/proc目錄下那些使用數字作為它們的名字的目錄，你就會獲得所有現在正在運行的進程列表。在下面的代碼中process_list()函數返回所有現在正在運行的進程的標識符列表。當你執行這個程序後，這個列表的長度就是在系統上運行的總進程數。

復制代碼 代碼如下:

#!/usr/bin/env python
"""
List of all process IDs currently active
"""
from __future__ import print_function
import os
def process_list():
pids = []
for subdir in os.listdir('/proc'):
if subdir.isdigit():
pids.append(subdir)
return pids

if __name__=='__main__':
pids = process_list()
print('Total number of running processes:: {0}'.format(len(pids)))

上面的程序當執行後會顯示和下面類似的輸出：

復制代碼 代碼如下:
Total number of running processes:: 229

每個進程目錄包含了一些其他文件和目錄，如進程命令的調用，它正使用的共享庫以及其它的。
建議看看《Linux就該這么學》這本書

Ⅱ python怎麼獲取軟體進程並執行

你是ssh遠程執行嗎？本機的話不應該這樣啊是不是你中間的代碼出現異常了

Ⅲ 如何使用Python實現多進程編程

1.Process
創建進程的類：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()之前設置。

例1.1：創建函數並將其作為單個進程
importmultiprocessing
importtime

defworker(interval):
n=5
whilen>0:
print("Thetimeis{0}".format(time.ctime()))
time.sleep(interval)
n-=1

if__name__=="__main__":
p=multiprocessing.Process(target=worker,args=(3,))
p.start()
print"p.pid:",p.pid
print"p.name:",p.name
print"p.is_alive:",p.is_alive()
結果
12345678p.pid:8736p.name:Process-1p.is_alive:TrueThetimeisTueApr2120:55:122015ThetimeisTueApr2120:55:152015ThetimeisTueApr2120:55:182015ThetimeisTueApr2120:55:212015ThetimeisTueApr2120:55:242015

例1.2：創建函數並將其作為多個進程
importmultiprocessing
importtime

defworker_1(interval):
print"worker_1"
time.sleep(interval)
print"endworker_1"

defworker_2(interval):
print"worker_2"
time.sleep(interval)
print"endworker_2"

defworker_3(interval):
print"worker_3"
time.sleep(interval)
print"endworker_3"

if__name__=="__main__":
p1=multiprocessing.Process(target=worker_1,args=(2,))
p2=multiprocessing.Process(target=worker_2,args=(3,))
p3=multiprocessing.Process(target=worker_3,args=(4,))

p1.start()
p2.start()
p3.start()

print("ThenumberofCPUis:"+str(multiprocessing.cpu_count()))
forpinmultiprocessing.active_children():
print("childp.name:"+p.name+"	p.id"+str(p.pid))
print"END!!!!!!!!!!!!!!!!!"
結果
1234567891011ThenumberofCPUis:4childp.name:Process-3p.id7992childp.name:Process-2p.id4204childp.name:Process-1p.id6380END!!!!!!!!!!!!!!!!!worker_1worker_3worker_2endworker_1endworker_2endworker_3

例1.3：將進程定義為類
importmultiprocessing
importtime

classClockProcess(multiprocessing.Process):
def__init__(self,interval):
multiprocessing.Process.__init__(self)
self.interval=interval

defrun(self):
n=5
whilen>0:
print("thetimeis{0}".format(time.ctime()))
time.sleep(self.interval)
n-=1

if__name__=='__main__':
p=ClockProcess(3)
p.start()
註：進程p調用start()時，自動調用run()
結果
12345thetimeisTueApr2120:31:302015thetimeisTueApr2120:31:332015thetimeisTueApr2120:31:362015thetimeisTueApr2120:31:392015thetimeisTueApr2120:31:422015

Ⅳ python遍歷獲取進程信息這個錯誤是什麼情況

import tracebacktraceback.print_exc( file=文件對象 )

Ⅳ python 多進程的順序問題

因為進程池一次只能運行4個進程，0,1,2,3是四個進程同時執行，那麼4隻能等待。當進程池中任意一個進程結束後，4立即執行，所以在0結束後4開始執行，接著1,2,3陸續結束，4最後結束。

Ⅵ python怎麼實現一個進程

想要充分利用多核CPU資源，Python中大部分情況下都需要使用多進程，Python中提供了multiprocessing這個包實現多進程。multiprocessing支持子進程、進程間的同步與通信，提供了Process、Queue、Pipe、Lock等組件。

開辟子進程

multiprocessing中提供了Process類來生成進程實例

Process([group [, target [, name [, args [, kwargs]]]]])1

• group分組，實際上不使用

• target表示調用對象，你可以傳入方法的名字

• args表示給調用對象以元組的形式提供參數，比如target是函數a，他有兩個參數m，n，那麼該參數為args=(m, n)即可

• kwargs表示調用對象的字典

• name是別名，相當於給這個進程取一個名字

先來個小例子：

• # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):


• n = 0


• while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime()) #獲取當前進程號和正在運行是的時間


• time.sleep(wTime) #等待（休眠）


• n += 1if __name__ == "__main__":


• p = Process(target=run_proc, args=(2,)) #申請子進程


• p.start() #運行進程


• print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())12345678910111213141516171819



運行結果：

Parent process run. subProcess is 30196
Parent process end,Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:23 2017
subProcess 30196 run, Mon Mar 27 11:20:25 2017

根據運行結果可知，父進程運行結束後子進程仍然還在運行，這可能造成僵屍（ zombie）進程。

通常情況下，當子進程終結時，它會通知父進程，清空自己所佔據的內存，並在內核里留下自己的退出信息。父進程在得知子進程終結時，會從內核中取出子進程的退出信息。但是，如果父進程早於子進程終結，這可能造成子進程的退出信息滯留在內核中，子進程成為僵屍（zombie）進程。當大量僵屍進程積累時，內存空間會被擠占。

有什麼辦法可以避免僵屍進程呢？
這里介紹進程的一個屬性 deamon，當其值為TRUE時，其父進程結束，該進程也直接終止運行（即使還沒運行完）。
所以給上面的程序加上p.deamon = true，看看效果。

• # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):


• n = 0


• while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())


• time.sleep(wTime)


• n += 1if __name__ == "__main__":


• p = Process(target=run_proc, args=(2,))


• p.daemon = True #加入daemon


• p.start() print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())



執行結果：

Parent process run. subProcess is 31856
Parent process end,Mon Mar 27 11:40:10 2017

這是問題又來了，子進程並沒有執行完，這不是所期望的結果。有沒辦法將子進程執行完後才讓父進程結束呢？
這里引入p.join()方法，它使子進程執行結束後，父進程才執行之後的代碼

• # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):


• n = 0


• while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())


• time.sleep(wTime)


• n += 1if __name__ == "__main__":


• p = Process(target=run_proc, args=(2,))


• p.daemon = True


• p.start()


• p.join() #加入join方法


• print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())21



執行結果：

subProcess 32076 run, Mon Mar 27 11:46:07 2017
subProcess 32076 run, Mon Mar 27 11:46:09 2017
subProcess 32076 run, Mon Mar 27 11:46:11 2017
Parent process run. subProcess is 32076
Parent process end,Mon Mar 27 11:46:13 2017

這樣所有的進程就能順利的執行了。

將進程定義成類

通過繼承Process類，來自定義進程類，實現run方法。實例p通過調用p.start()時自動調用run方法。
如下：

• # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timeclass Myprocess(Process):



• def __init__(self, wTime):


• Process.__init__(self)


• self.wTime = wTime def run(self):


• n = 0


• while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())


• time.sleep(self.wTime)


• n += 1if __name__ == "__main__":


• p = Myprocess(2)


• p.daemon = True


• p.start() #自動調用run方法


• p.join() print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())2122232425262728



執行結果和上一個例子相同。

創建多個進程

很多時候系統都需要創建多個進程以提高CPU的利用率，當數量較少時，可以手動生成一個個Process實例。當進程數量很多時，或許可以利用循環，但是這需要程序員手動管理系統中並發進程的數量，有時會很麻煩。這時進程池Pool就可以發揮其功效了。可以通過傳遞參數限制並發進程的數量，默認值為CPU的核數。
直接上例子：

• # -*- coding:utf-8 -*-from multiprocessing import Process,Poolimport os,timedef run_proc(name): ##定義一個函數用於進程調用


• for i in range(5):


• time.sleep(0.2) #休眠0.2秒


• print 'Run child process %s (%s)' % (name, os.getpid())#執行一次該函數共需1秒的時間if __name__ =='__main__': #執行主進程


• print 'Run the main process (%s).' % (os.getpid())


• mainStart = time.time() #記錄主進程開始的時間


• p = Pool(8) #開辟進程池


• for i in range(16): #開辟14個進程


• p.apply_async(run_proc,args=('Process'+str(i),))#每個進程都調用run_proc函數，


• #args表示給該函數傳遞的參數。



• print 'Waiting for all subprocesses done ...'


• p.close() #關閉進程池


• p.join() #等待開辟的所有進程執行完後，主進程才繼續往下執行


• print 'All subprocesses done'


• mainEnd = time.time() #記錄主進程結束時間


• print 'All process ran %0.2f seconds.' % (mainEnd-mainStart) #主進程執行時間21222324



執行結果：
開頭部分

Run the main process (30920).
Waiting for all subprocesses done …
Run child process Process0 (32396)
Run child process Process3 (25392)
Run child process Process1 (28732)
Run child process Process2 (32436)

末尾部分：

Run child process Process15 (25880)
All subprocesses done
All process last 2.49 seconds.

相關說明：

這里進程池對並發進程的限制數量為8個，而程序運行時會產生16個進程，進程池將自動管理系統內進程的並發數量，其餘進程將會在隊列中等待。限制並發數量是因為，系統中並發的進程不是越多越好，並發進程太多，可能使CPU大部分的時間用於進程調度，而不是執行有效的計算。

採用多進程並發技術時，就單個處理機而言，其對進程的執行是串列的。但具體某個時刻哪個進程獲得CPU資源而執行是不可預知的（如執行結果的開頭部分，各進程的執行順序不定），這就體現了進程的非同步性。

如果單個程序執行14次run_proc函數，那麼它會需要至少16秒,通過進程的並發，這里只需要2.49秒，可見並發的優勢。

Ⅶ python使用標准庫根據進程名如何獲取進程的

在Python中，我們通過標准庫中的subprocess包來fork一個子進程，並運行一個外部的程序。
使用subprocess包中的函數創建子進程的時候，要注意:
1) 在創建子進程之後，父進程是否暫停，並等待子進程運行。
2) 函數返回什麼
3) 當returncode不為0時，父進程如何處理。

Ⅷ Python中for循環遍歷數據有點慢，有沒有像java一樣做一個多進程的呢，如何做呢，有demo嗎謝謝！！

你遍歷的什麼數據啊，是列表，還是文件，python中的for是用c實現的，這個應該不是瓶頸，你可以使用timeit測試一下，看看哪塊比較耗時間，你也可以貼出你的代碼。

如果解決了您的問題請採納！
如果未解決請繼續追問

Ⅸ Python中的進程是什麼

什麼是進程

進程（Process）是計算機中的程序關於某數據集合上的一次運行活動，是系統進行資源分配和調度的基本單位，是操作系統結構的基礎。在早期面向進程設計的計算機結構中，進程是程序的基本執行實體；在當代面向線程設計的計算機結構中，進程是線程的容器。程序是指令、數據及其組織形式的描述，進程是程序的實體。

狹義定義：進程是正在運行的程序的實例（an instance of a computer program that is being executed）。

廣義定義：進程是一個具有一定獨立功能的程序關於某個數據集合的一次運行活動。它是操作系統動態執行的基本單元，在傳統的操作系統中，進程既是基本的分配單元，也是基本的執行單元。

進程的概念主要有兩點：第一，進程是一個實體。每一個進程都有它自己的地址空間，一般情況下，包括文本區域（text region）、數據區域（data region）和堆棧（stack region）。文本區域存儲處理器執行的代碼；數據區域存儲變數和進程執行期間使用的動態分配的內存；堆棧區域存儲著活動過程調用的指令和本地變數。第二，進程是一個「執行中的程序」。程序是一個沒有生命的實體，只有處理器賦予程序生命時（操作系統執行之），它才能成為一個活動的實體，我們稱其為進程。

相關推薦：《Python視頻教程》

程序和進程的關系

編寫完畢的代碼，在沒有運?的時候，稱之為程序。

正在運行著的代碼，就成為進程。

進程除了包含代碼以外還有需要運行的環境等所以和程序是有區別的。

相關推薦：

Python中的多進程是什麼

Ⅹ 怎樣使用python查詢系統某一進程是否存在

只需要一小段python代碼，就可以解決用python查詢判斷系統進程是否存在的操作。具休是怎麼樣判斷進程是不是存在，看下邊的python代碼就會明白了。
正常我們在編寫python代碼時，要殺死一個進程之前，一定要做的事情就是要知道這個進程是不是存在，存在要怎麼樣操作、不存在又怎麼樣操作。如何查找一個進程是否存在，用Python代碼來判斷一下最好不過了。
如何用python代碼查找一個進程是否存在的源代碼如下：
?

12345678910111213141516171819
#-*- coding:utf-8 -*-#編碼聲明 import win32com.client#導入方法 def check_exsit(process_name): WMI = win32com.client.GetObject('winmgmts:') processCodeCov = WMI.ExecQuery('select * from Win32_Process where Name="%s"' % process_name) if len(processCodeCov) > 0:#判斷操作 www.iplaypy.com print '%s is exists' % process_name else: print '%s is not exists' % process_name if __name__ == '__main__': check_exsit('chrome.exe')