Bagaimana cara mendapatkan penggunaan CPU dan RAM saat ini di Python?

Apa cara yang Anda sukai untuk mendapatkan status sistem saat ini (CPU saat ini, RAM, ruang disk kosong, dll.) Dengan Python? Poin bonus untuk * nix dan platform Windows.

Tampaknya ada beberapa cara yang memungkinkan untuk mengekstraksi itu dari pencarian saya:

1. Menggunakan perpustakaan seperti PSI (yang saat ini tampaknya tidak dikembangkan secara aktif dan tidak didukung pada banyak platform) atau sesuatu seperti pystatgrab (sekali lagi tidak ada aktivitas sejak 2007 tampaknya dan tidak ada dukungan untuk Windows).

2. Menggunakan kode khusus platform seperti menggunakan os.popen("ps")atau serupa untuk sistem * nix dan MEMORYSTATUSmasuk ctypes.windll.kernel32(lihat resep ini di ActiveState ) untuk platform Windows. Orang bisa menempatkan kelas Python bersama dengan semua potongan kode itu.

Bukannya metode-metode itu buruk tetapi apakah sudah ada cara multi-platform yang didukung dengan baik untuk melakukan hal yang sama?

Pustaka psutil memberi Anda informasi tentang CPU, RAM, dll., Pada berbagai platform:

psutil adalah modul yang menyediakan antarmuka untuk mengambil informasi tentang proses yang sedang berjalan dan pemanfaatan sistem (CPU, memori) secara portabel dengan menggunakan Python, mengimplementasikan banyak fungsi yang ditawarkan oleh alat-alat seperti ps, top dan Windows task manager.

Saat ini mendukung Linux, Windows, OSX, Sun Solaris, FreeBSD, OpenBSD dan NetBSD, baik arsitektur 32-bit dan 64-bit, dengan versi Python dari 2,6 ke 3.5 (pengguna Python 2.4 dan 2.5 dapat menggunakan versi 2.1.3).

Beberapa contoh:

#!/usr/bin/env python
import psutil
# gives a single float value
psutil.cpu_percent()
# gives an object with many fields
psutil.virtual_memory()
# you can convert that object to a dictionary 
dict(psutil.virtual_memory()._asdict())
# you can have the percentage of used RAM
psutil.virtual_memory().percent
79.2
# you can calculate percentage of available memory
psutil.virtual_memory().available * 100 / psutil.virtual_memory().total
20.8

Berikut dokumentasi lain yang menyediakan lebih banyak konsep dan konsep menarik:

• https://psutil.readthedocs.io/en/latest/

Gunakan perpustakaan psutil . Pada Ubuntu 18.04, pip diinstal 5.5.0 (versi terbaru) pada 1-30-2019. Versi yang lebih lama mungkin berperilaku agak berbeda. Anda dapat memeriksa versi psutil Anda dengan melakukan ini dengan Python:

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

Untuk mendapatkan statistik memori dan CPU:

from __future__ import print_function
import psutil
print(psutil.cpu_percent())
print(psutil.virtual_memory())  # physical memory usage
print('memory % used:', psutil.virtual_memory()[2])

The virtual_memory(tuple) akan memiliki memori persen digunakan sistem. Ini tampaknya terlalu tinggi beberapa persen untuk saya di Ubuntu 18,04.

Anda juga bisa mendapatkan memori yang digunakan oleh instance Python saat ini:

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)

yang memberikan memori saat ini menggunakan skrip Python Anda.

Ada beberapa contoh yang lebih mendalam pada halaman pypi untuk psutil .

Only for Linux: One-liner untuk penggunaan RAM dengan hanya ketergantungan stdlib:

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

sunting: ketergantungan OS solusi yang ditentukan

Kode di bawah ini, tanpa perpustakaan eksternal bekerja untuk saya. Saya diuji di Python 2.7.9

Penggunaan 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)

Dan Ram Penggunaan, Total, Bekas dan Gratis

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'

Ini adalah sesuatu yang saya kumpulkan beberapa saat yang lalu, ini hanya windows tetapi dapat membantu Anda mendapatkan bagian dari apa yang perlu Anda lakukan.

Berasal dari: "untuk sys tersedia mem" http://msdn2.microsoft.com/en-us/library/aa455130.aspx

"informasi proses individu dan contoh skrip python" http://www.microsoft.com/technet/scriptcenter/scripts/default.mspx?mfr=true

CATATAN: antarmuka / proses WMI juga tersedia untuk melakukan tugas serupa Saya tidak menggunakannya di sini karena metode saat ini mencakup kebutuhan saya, tetapi jika suatu hari diperlukan untuk memperluas atau meningkatkan ini, maka mungkin ingin menyelidiki alat WMI yang tersedia .

WMI untuk python:

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

Kode:

'''
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

Kami memilih untuk menggunakan sumber informasi yang biasa untuk ini karena kami dapat menemukan fluktuasi instan dalam memori bebas dan merasa meminta sumber data meminfo sangat membantu. Ini juga membantu kami mendapatkan beberapa parameter terkait lainnya yang telah diurai sebelumnya.

Kode

import os

linux_filepath = "/proc/meminfo"
meminfo = dict(
    (i.split()[0].rstrip(":"), int(i.split()[1]))
    for i in open(linux_filepath).readlines()
)
meminfo["memory_total_gb"] = meminfo["MemTotal"] / (2 ** 20)
meminfo["memory_free_gb"] = meminfo["MemFree"] / (2 ** 20)
meminfo["memory_available_gb"] = meminfo["MemAvailable"] / (2 ** 20)

Output untuk referensi (kami menghapus semua baris baru untuk analisis lebih lanjut)

MemTotal: 1014500 kB MemFree: 562680 kB MemTersedia: 646364 kB Buffer: 15144 kB Cached: 210720 kB SwapCached: 0 kB Aktif: 261476 kB Tidak aktif: 128888 kB Aktif (anon): 167092 kB Tidak aktif (anon): 20888 kB aktif (anon): file aktif) : 94384 kB Tidak aktif (file): 108000 kB Tidak dapat dibatalkan: 3652 kB Dicekal: 3652 kB SwapJumlah: 0 kB SwapGratis: 0 kB Kotor: 0 kB Penulisan kembali: 0 kB AnonPages: 168160 kB Dipetakan: 81352 kB Slab: 348 kB Slab: 3449 SReclaimable: 18044 kBNklaim: 16448 kBKernelStack: 2672 kB HalamanTabel: 8180 kB NFS_Unstable: 0 kB Bouncing: 0 kB WitebackTmp: 0 kB CommitLimit: 507248 kB Committed_AS: 1038756 kB Vmallallallemallgallemememilikiballallallallemememilikibanyakballupemallallallallallallemememiliki: totalallallallallemememilikibanyak: semuaallememememilikibanyakbarang :memilikibanyakbanyakbarang :memilikibanyakbanyakbarang :memilikibanyakbanyakbarang :memilikibanyakbarangbisa: totalmememilikibanyakbarang :memilikibanyakmemilikibanyakbarang :memilikibanyakbarang :memilikibanyakmemilikibanyak :memilikibanyakbanyakmemilikibanyak :memilikibanyak :memilikibanyakkemuatanmemilikibanyak: KernelStack: 2672 kB Halaman: 8180 kB 0 kB AnonHugePages: 88064 kB CmaTotal: 0 kB CmaGratis: 0 kBHugePages_Total: 0 HugePages_Free: 0 HugePages_Rsvd: 0 HugePages_Surp: 0 Hugepagesize:2048 kB DirectMap4k: 43008 kB DirectMap2M: 1005568 kB

Saya merasa seperti jawaban-jawaban ini ditulis untuk Python 2, dan dalam hal apa pun tidak ada yang menyebutkan resourcepaket standar yang tersedia untuk Python 3. Ia menyediakan perintah untuk memperoleh batas sumber daya dari proses yang diberikan (proses Python panggilan secara default). Ini tidak sama dengan mendapatkan penggunaan sumber daya saat ini oleh sistem secara keseluruhan, tetapi bisa menyelesaikan beberapa masalah yang sama seperti misalnya "Saya ingin memastikan saya hanya menggunakan X banyak RAM dengan skrip ini."

"... status sistem saat ini (CPU saat ini, RAM, ruang disk kosong, dll.)" Dan "* nix dan platform Windows" dapat menjadi kombinasi yang sulit untuk dicapai.

Sistem operasi pada dasarnya berbeda dalam cara mereka mengelola sumber daya ini. Memang, mereka berbeda dalam konsep inti seperti mendefinisikan apa yang dianggap sebagai sistem dan apa yang dianggap sebagai waktu aplikasi.

"Ruang diska kosong"? Apa yang dianggap sebagai "ruang disk?" Semua partisi semua perangkat? Bagaimana dengan partisi asing di lingkungan multi-boot?

Saya tidak berpikir ada konsensus yang cukup jelas antara Windows dan * nix yang memungkinkan ini. Memang, bahkan mungkin tidak ada konsensus antara berbagai sistem operasi yang disebut Windows. Apakah ada satu API Windows yang berfungsi untuk XP dan Vista?

Script ini untuk penggunaan CPU:

import os

def get_cpu_load():
    """ Returns a list CPU Loads"""
    result = []
    cmd = "WMIC CPU GET LoadPercentage "
    response = os.popen(cmd + ' 2>&1','r').read().strip().split("\r\n")
    for load in response[1:]:
       result.append(int(load))
    return result

if __name__ == '__main__':
    print get_cpu_load()

• Untuk detail CPU gunakan pustaka psutil

  https://psutil.readthedocs.io/en/latest/#cpu

• Untuk Frekuensi RAM (dalam MHz) gunakan dmidecode pustaka Linux bawaan dan sedikit manipulasi hasilnya;). perintah ini membutuhkan izin root, maka sediakan juga kata sandi Anda. cukup salin perintah berikut untuk mengganti mypass dengan kata sandi Anda

import os

os.system("echo mypass | sudo -S dmidecode -t memory | grep 'Clock Speed' | cut -d ':' -f2")

------------------- Output ---------------------------
1600 MT / s
Tidak Dikenal
1600 MT / s
Tidak Diketahui 0

• lebih spesifik
  [i for i in os.popen("echo mypass | sudo -S dmidecode -t memory | grep 'Clock Speed' | cut -d ':' -f2").read().split(' ') if i.isdigit()]

-------------------------- keluaran ----------------------- -
['1600', '1600']

Untuk mendapatkan memori baris-demi-baris dan analisis waktu dari program Anda, saya sarankan menggunakan memory_profilerdan line_profiler.

Instalasi:

# Time profiler
$ pip install line_profiler
# Memory profiler
$ pip install memory_profiler
# Install the dependency for a faster analysis
$ pip install psutil

Bagian yang umum adalah, Anda menentukan fungsi mana yang ingin Anda analisis dengan menggunakan dekorator masing-masing.

Contoh: Saya memiliki beberapa fungsi di file Python main.pysaya yang ingin saya analisis. Salah satunya adalah linearRegressionfit(). Saya perlu menggunakan dekorator @profileyang membantu saya membuat profil kode sehubungan dengan keduanya: Waktu & Memori.

Buat perubahan berikut pada definisi fungsi

@profile
def linearRegressionfit(Xt,Yt,Xts,Yts):
    lr=LinearRegression()
    model=lr.fit(Xt,Yt)
    predict=lr.predict(Xts)
    # More Code

Untuk Pembuatan Profil Waktu ,

Lari:

$ kernprof -l -v main.py

Keluaran

Total time: 0.181071 s
File: main.py
Function: linearRegressionfit at line 35

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
    35                                           @profile
    36                                           def linearRegressionfit(Xt,Yt,Xts,Yts):
    37         1         52.0     52.0      0.1      lr=LinearRegression()
    38         1      28942.0  28942.0     75.2      model=lr.fit(Xt,Yt)
    39         1       1347.0   1347.0      3.5      predict=lr.predict(Xts)
    40                                           
    41         1       4924.0   4924.0     12.8      print("train Accuracy",lr.score(Xt,Yt))
    42         1       3242.0   3242.0      8.4      print("test Accuracy",lr.score(Xts,Yts))

Untuk Memory Profileing ,

Lari:

$ python -m memory_profiler main.py

Keluaran

Filename: main.py

Line #    Mem usage    Increment   Line Contents
================================================
    35  125.992 MiB  125.992 MiB   @profile
    36                             def linearRegressionfit(Xt,Yt,Xts,Yts):
    37  125.992 MiB    0.000 MiB       lr=LinearRegression()
    38  130.547 MiB    4.555 MiB       model=lr.fit(Xt,Yt)
    39  130.547 MiB    0.000 MiB       predict=lr.predict(Xts)
    40                             
    41  130.547 MiB    0.000 MiB       print("train Accuracy",lr.score(Xt,Yt))
    42  130.547 MiB    0.000 MiB       print("test Accuracy",lr.score(Xts,Yts))

Selain itu, hasil memori profiler juga dapat diplot menggunakan matplotlibmenggunakan

$ mprof run main.py
$ mprof plot

Catatan: Diuji pada

line_profiler versi == 3.0.2

memory_profiler versi == 0,57.0

psutil versi == 5.7.0

Anda dapat menggunakan psutil atau psmem dengan kode contoh subproses

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

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

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

Berdasarkan kode penggunaan cpu oleh @Hrabal, inilah yang saya gunakan:

from subprocess import Popen, PIPE

def get_cpu_usage():
    ''' Get CPU usage on Linux by reading /proc/stat '''

    sub = Popen(('grep', 'cpu', '/proc/stat'), stdout=PIPE, stderr=PIPE)
    top_vals = [int(val) for val in sub.communicate()[0].split('\n')[0].split[1:5]]

    return (top_vals[0] + top_vals[2]) * 100. /(top_vals[0] + top_vals[2] + top_vals[3])

Saya tidak percaya bahwa ada perpustakaan multi-platform yang didukung dengan baik tersedia. Ingatlah bahwa Python itu sendiri ditulis dalam C sehingga setiap perpustakaan hanya akan membuat keputusan cerdas tentang potongan kode spesifik OS mana yang akan dijalankan, seperti yang Anda sarankan di atas.