如何在Python中获取当前的CPU和RAM使用情况？

Question

在Python中获取当前系统状态（当前CPU，RAM，可用磁盘空间等）的首选方式是什么？ * nix和Windows平台的奖励积分。

似乎有提取，从我搜索的一些可能的方式：

1. 使用库如PSI（目前似乎不积极地开发和不支持多平台）或类似pystatgrab什么（自2007年以来似乎再也没有活动，并且不支持Windows）。

2. 使用特定于平台的代码，如使用ctypes.windll.kernel32一个os.popen("ps")或为* nix系统相似，MEMORYSTATUS（见this recipe on ActiveState）针对Windows平台。人们可以将Python类与所有这些代码片段放在一起。

这不是说那些方法不好，但是已经有了一个很好的支持多平台的方法来做同样的事情吗？

Answer 1

The psutil library会给你各种平台的一些系统信息（CPU /内存使用率） ：

psutil是提供通过使用Python，落实如ps，顶部和Windows任务管理器工具提供了许多功能取回与在便携方式运行的进程和系统利用率（CPU，内存）的信息的接口的模块。

它目前支持Linux版本，Windows，OSX，Sun Solaris，FreeBSD，OpenBSD和NetBSD，都是32位和64位体系结构，Python版本从2.6到3.5（Python 2.4和2.5的用户可能使用2.1。 3版）。

Answer 2

我不相信有一个良好支持的多平台库可用。请记住，Python本身是用C语言编写的，因此任何库都将根据您上面的建议做出关于哪个OS特定代码片段运行的明智决定。

Answer 3

“...当前系统状态（当前CPU，RAM，可用磁盘空间等）”和“* nix和Windows平台”可能是一个难以实现的组合。

操作系统在管理这些资源的方式上有着根本性的不同。事实上，他们在核心概念方面有所不同，例如定义什么是系统，什么是应用程序时间。

“可用磁盘空间”？什么算作“磁盘空间？”所有设备的所有分区？多引导环境下的外部分区怎么样？

我不认为Windows和* nix之间有足够明确的共识，这使得这成为可能。事实上，在称为Windows的各种操作系统之间可能甚至没有达成共识。是否有一个适用于XP和Vista的Windows API？

Answer 4

这是前段时间我放在一起的东西，它只是Windows，但可以帮助您获得所需的部分内容。

来源于： “可用MEM SYS” http://msdn2.microsoft.com/en-us/library/aa455130.aspx

“单个工序信息和Python脚本示例” http://www.microsoft.com/technet/scriptcenter/scripts/default.mspx?mfr=true

注：WMI接口/过程也可用于执行类似任务 我没有在这里使用它，因为当前的方法覆盖了我的需求，但是如果有一天需要扩展或改进，那么可能需要调查WMI工具。

WMI的Python：

http://tgolden.sc.sabren.com/python/wmi.html

代码：

''' 
Monitor window processes 

derived from: 
>for sys available mem 
http://msdn2.microsoft.com/en-us/library/aa455130.aspx 

> individual process information and python script examples 
http://www.microsoft.com/technet/scriptcenter/scripts/default.mspx?mfr=true 

NOTE: the WMI interface/process is also available for performing similar tasks 
     I'm not using it here because the current method covers my needs, but if someday it's needed 
     to extend or improve this module, then may want to investigate the WMI tools available. 
     WMI for python: 
     http://tgolden.sc.sabren.com/python/wmi.html 
''' 

__revision__ = 3 

import win32com.client 
from ctypes import * 
from ctypes.wintypes import * 
import pythoncom 
import pywintypes 
import datetime 


class MEMORYSTATUS(Structure): 
    _fields_ = [ 
       ('dwLength', DWORD), 
       ('dwMemoryLoad', DWORD), 
       ('dwTotalPhys', DWORD), 
       ('dwAvailPhys', DWORD), 
       ('dwTotalPageFile', DWORD), 
       ('dwAvailPageFile', DWORD), 
       ('dwTotalVirtual', DWORD), 
       ('dwAvailVirtual', DWORD), 
       ] 


def winmem(): 
    x = MEMORYSTATUS() # create the structure 
    windll.kernel32.GlobalMemoryStatus(byref(x)) # from cytypes.wintypes 
    return x  


class process_stats: 
    '''process_stats is able to provide counters of (all?) the items available in perfmon. 
    Refer to the self.supported_types keys for the currently supported 'Performance Objects' 

    To add logging support for other data you can derive the necessary data from perfmon: 
    --------- 
    perfmon can be run from windows 'run' menu by entering 'perfmon' and enter. 
    Clicking on the '+' will open the 'add counters' menu, 
    From the 'Add Counters' dialog, the 'Performance object' is the self.support_types key. 
    --> Where spaces are removed and symbols are entered as text (Ex. # == Number, % == Percent) 
    For the items you wish to log add the proper attribute name in the list in the self.supported_types dictionary, 
    keyed by the 'Performance Object' name as mentioned above. 
    --------- 

    NOTE: The 'NETFramework_NETCLRMemory' key does not seem to log dotnet 2.0 properly. 

    Initially the python implementation was derived from: 
    http://www.microsoft.com/technet/scriptcenter/scripts/default.mspx?mfr=true 
    ''' 
    def __init__(self,process_name_list=[],perf_object_list=[],filter_list=[]): 
     '''process_names_list == the list of all processes to log (if empty log all) 
     perf_object_list == list of process counters to log 
     filter_list == list of text to filter 
     print_results == boolean, output to stdout 
     ''' 
     pythoncom.CoInitialize() # Needed when run by the same process in a thread 

     self.process_name_list = process_name_list 
     self.perf_object_list = perf_object_list 
     self.filter_list = filter_list 

     self.win32_perf_base = 'Win32_PerfFormattedData_' 

     # Define new datatypes here! 
     self.supported_types = { 
            'NETFramework_NETCLRMemory': [ 
                     'Name', 
                     'NumberTotalCommittedBytes', 
                     'NumberTotalReservedBytes', 
                     'NumberInducedGC',  
                     'NumberGen0Collections', 
                     'NumberGen1Collections', 
                     'NumberGen2Collections', 
                     'PromotedMemoryFromGen0', 
                     'PromotedMemoryFromGen1', 
                     'PercentTimeInGC', 
                     'LargeObjectHeapSize' 
                    ], 

            'PerfProc_Process':    [ 
                      'Name', 
                      'PrivateBytes', 
                      'ElapsedTime', 
                      'IDProcess',# pid 
                      'Caption', 
                      'CreatingProcessID', 
                      'Description', 
                      'IODataBytesPersec', 
                      'IODataOperationsPersec', 
                      'IOOtherBytesPersec', 
                      'IOOtherOperationsPersec', 
                      'IOReadBytesPersec', 
                      'IOReadOperationsPersec', 
                      'IOWriteBytesPersec', 
                      'IOWriteOperationsPersec'  
                     ] 
           } 

    def get_pid_stats(self, pid): 
     this_proc_dict = {} 

     pythoncom.CoInitialize() # Needed when run by the same process in a thread 
     if not self.perf_object_list: 
      perf_object_list = self.supported_types.keys() 

     for counter_type in perf_object_list: 
      strComputer = "." 
      objWMIService = win32com.client.Dispatch("WbemScripting.SWbemLocator") 
      objSWbemServices = objWMIService.ConnectServer(strComputer,"root\cimv2") 

      query_str = '''Select * from %s%s''' % (self.win32_perf_base,counter_type) 
      colItems = objSWbemServices.ExecQuery(query_str) # "Select * from Win32_PerfFormattedData_PerfProc_Process")# changed from Win32_Thread   

      if len(colItems) > 0:   
       for objItem in colItems: 
        if hasattr(objItem, 'IDProcess') and pid == objItem.IDProcess: 

          for attribute in self.supported_types[counter_type]: 
           eval_str = 'objItem.%s' % (attribute) 
           this_proc_dict[attribute] = eval(eval_str) 

          this_proc_dict['TimeStamp'] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.') + str(datetime.datetime.now().microsecond)[:3] 
          break 

     return this_proc_dict  


    def get_stats(self): 
     ''' 
     Show process stats for all processes in given list, if none given return all processes 
     If filter list is defined return only the items that match or contained in the list 
     Returns a list of result dictionaries 
     '''  
     pythoncom.CoInitialize() # Needed when run by the same process in a thread 
     proc_results_list = [] 
     if not self.perf_object_list: 
      perf_object_list = self.supported_types.keys() 

     for counter_type in perf_object_list: 
      strComputer = "." 
      objWMIService = win32com.client.Dispatch("WbemScripting.SWbemLocator") 
      objSWbemServices = objWMIService.ConnectServer(strComputer,"root\cimv2") 

      query_str = '''Select * from %s%s''' % (self.win32_perf_base,counter_type) 
      colItems = objSWbemServices.ExecQuery(query_str) # "Select * from Win32_PerfFormattedData_PerfProc_Process")# changed from Win32_Thread 

      try: 
       if len(colItems) > 0: 
        for objItem in colItems: 
         found_flag = False 
         this_proc_dict = {} 

         if not self.process_name_list: 
          found_flag = True 
         else: 
          # Check if process name is in the process name list, allow print if it is 
          for proc_name in self.process_name_list: 
           obj_name = objItem.Name 
           if proc_name.lower() in obj_name.lower(): # will log if contains name 
            found_flag = True 
            break 

         if found_flag: 
          for attribute in self.supported_types[counter_type]: 
           eval_str = 'objItem.%s' % (attribute) 
           this_proc_dict[attribute] = eval(eval_str) 

          this_proc_dict['TimeStamp'] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.') + str(datetime.datetime.now().microsecond)[:3] 
          proc_results_list.append(this_proc_dict) 

      except pywintypes.com_error, err_msg: 
       # Ignore and continue (proc_mem_logger calls this function once per second) 
       continue 
     return proc_results_list  


def get_sys_stats(): 
    ''' Returns a dictionary of the system stats''' 
    pythoncom.CoInitialize() # Needed when run by the same process in a thread 
    x = winmem() 

    sys_dict = { 
        'dwAvailPhys': x.dwAvailPhys, 
        'dwAvailVirtual':x.dwAvailVirtual 
       } 
    return sys_dict 


if __name__ == '__main__': 
    # This area used for testing only 
    sys_dict = get_sys_stats() 

    stats_processor = process_stats(process_name_list=['process2watch'],perf_object_list=[],filter_list=[]) 
    proc_results = stats_processor.get_stats() 

    for result_dict in proc_results: 
     print result_dict 

    import os 
    this_pid = os.getpid() 
    this_proc_results = stats_processor.get_pid_stats(this_pid) 

    print 'this proc results:' 
    print this_proc_results 

http://monkut.webfactional.com/blog/archive/2009/1/21/windows-process-memory-logging-python

Answer 5

您可以使用psutil或PSMEM与子 示例代码

import subprocess 
cmd = subprocess.Popen(['sudo','./ps_mem'],stdout=subprocess.PIPE,stderr=subprocess.PIPE) 
out,error = cmd.communicate() 
memory = out.splitlines() 

参考http://techarena51.com/index.php/how-to-install-python-3-and-flask-on-linux/

https://github.com/Leo-g/python-flask-cmd

Answer 6

使用psutil library。对于我在Ubuntu上，pip安装了0.4.3。你可以通过做

from __future__ import print_function 
import psutil 
print(psutil.__versi‌​on__) 

在Python中检查你的版本。

为了得到一些内存和CPU的统计：

from __future__ import print_function 
import psutil 
print(psutil.cpu_percent()) 
print(psutil.virtual_memory()) # physical memory usage 

我也喜欢做的事：

import os 
import psutil 
pid = os.getpid() 
py = psutil.Process(pid) 
memoryUse = py.memory_info()[0]/2.**30 # memory use in GB...I think 
print('memory use:', memoryUse) 

这给当前的内存使用您的Python脚本的。

上有pypi page for 4.3.0和0.5.0一些更深入的例子。

对于Ubuntu的16和14，从PIP安装给我的版本4.3.0，它不具有phymem_usage（）方法。获得0.5.0,download the tar.gz file，然后做

tar -xvzf psutil-0.5.0.tar.gz‌​ 
cd psutil-0.5.0 
sudo python setup.py install 

Answer 7

下面的代码，没有外部库为我工作。我在Python 2.7测试。9

CPU使用率

import os 

    CPU_Pct=str(round(float(os.popen('''grep 'cpu ' /proc/stat | awk '{usage=($2+$4)*100/($2+$4+$5)} END {print usage }' ''').readline()),2)) 

    #print results 
    print("CPU Usage = " + CPU_Pct) 

和RAM使用，共，使用和免费

import os 
mem=str(os.popen('free -t -m').readlines()) 
""" 
Get a whole line of memory output, it will be something like below 
['    total  used  free  shared buffers  cached\n', 
'Mem:   925  591  334   14   30  355\n', 
'-/+ buffers/cache:  205  719\n', 
'Swap:   99   0   99\n', 
'Total:  1025  591  434\n'] 
So, we need total memory, usage and free memory. 
We should find the index of capital T which is unique at this string 
""" 
T_ind=mem.index('T') 
""" 
Than, we can recreate the string with this information. After T we have, 
"Total:  " which has 14 characters, so we can start from index of T +14 
and last 4 characters are also not necessary. 
We can create a new sub-string using this information 
""" 
mem_G=mem[T_ind+14:-4] 
""" 
The result will be like 
1025  603  422 
we need to find first index of the first space, and we can start our substring 
from from 0 to this index number, this will give us the string of total memory 
""" 
S1_ind=mem_G.index(' ') 
mem_T=mem_G[0:S1_ind] 
""" 
Similarly we will create a new sub-string, which will start at the second value. 
The resulting string will be like 
603  422 
Again, we should find the index of first space and than the 
take the Used Memory and Free memory. 
""" 
mem_G1=mem_G[S1_ind+8:] 
S2_ind=mem_G1.index(' ') 
mem_U=mem_G1[0:S2_ind] 

mem_F=mem_G1[S2_ind+8:] 
print 'Summary = ' + mem_G 
print 'Total Memory = ' + mem_T +' MB' 
print 'Used Memory = ' + mem_U +' MB' 
print 'Free Memory = ' + mem_F +' MB' 

Answer 8

一衬里只有STDLIB依赖性RAM用法：

import os 
tot_m, used_m, free_m = map(int, os.popen('free -t -m').readlines()[-1].split()[1:])