python获取进程

发布时间: 2022-08-16 19:51:15

⑴ python使用标准库根据进程名如何获取进程的

在Python中，我们通过标准库中的subprocess包来fork一个子进程，并运行一个外部的程序。
使用subprocess包中的函数创建子进程的时候，要注意:
1) 在创建子进程之后，父进程是否暂停，并等待子进程运行。
2) 函数返回什么
3) 当returncode不为0时，父进程如何处理。

⑵ python如何获取进程和线程状态

threading.active_count()
Return the number of Thread objects currently alive. The returned count is equal to the length of the list returned by enumerate().
active_count可以返回当前活动的线程枚举
我一般是这么用的

def getHeatsParallel(self): threads = [] for i in range(0, self.threadCount): t = threading.Thread(target=self.SomeFunction, name=str(i)) threads.append(t) t.start() for t in threads: t.join()

⑶ python中怎么根据进程号获取进程名

安装第三方库

pipinstallpsutil

使用如下,假设进程号为3213

importpsutil
proc=psutil.Process(pid=3213)
printproce.name()

⑷ python根据进程pid获取进程cpu等信息时出错

(x):
p=psutil.get_process_list()
forrinp:
aa=str(r)
f=re.compile(x,re.I)
iff.search(aa):
#printaa.split('pid=')[1].split(',')[0]
printaa.split('pid=')processinfo(sys.argv[1])

⑸ 怎样使用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')

⑹ python怎么获得进程的pid

#-*-encoding:UTF-8-*-
importos
importsys
importstring
importpsutil
importre

defget_pid(name):
process_list=psutil.get_process_list()
regex="pid=(d+),sname='"+name+"'"
printregex
pid=0
forlineinprocess_list:
process_info=str(line)
ini_regex=re.compile(regex)
result=ini_regex.search(process_info)
ifresult!=None:
pid=string.atoi(result.group(1))
printresult.group()
break
defmain(argv):<br>name=argv[1]<br>get_pid(name)

if__name__=="__main__":
main(sys.argv)

⑺ 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 获取指定进程pid，怎么总是错

简答：
通过知道对应的进程名，可以获得进程，然后进一步获取进程信息。

详解，自己去看吧：
【记录】折腾Python中的psutil：一个用于获得处理器和系统相关信息的模块
(此处不能贴地址，请自己用google搜标题，即可找到帖子地址)

⑽ 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.

python获取进程

与python获取进程相关的资讯