Phenquestions
Aparatūras un sistēmas informācijas atrašana Linux ir ērts un interesants uzdevums. Izmantojot Linux vienkāršus pitona kodus, mēs varam iegūt operētājsistēmas informāciju, informāciju par lietotāju, informāciju par atmiņu, informāciju par procesoru un daudz ko citu. Lai gan daudzas no šīm lietām mēs varam veikt, izmantojot terminālu un bash skriptu, pitons ir daudz interesantāks.
Kā pitonu cienītājs mēs vēlamies, lai visi uzdevumi tiktu veikti, izmantojot šo valodu, tāpēc sistēmas un aparatūras informācijas iegūšana ar pitonu ir lielisks uzdevums. Mēs vienlaikus varam iemācīties gan Linux, gan pitonu. Šis raksts būs diezgan garš, tāpēc veltiet laiku, lai izlasītu visu rakstu un palaistu katru kodu labākai izpratnei.
Jūs varat kopēt katru kodu pitona IDE un palaist to. Ja jums nav pitona IDE vai vēlaties salīdzināt starp IDE, skatiet mūsu ceļvedi top 10 IDE Linux. Starp citu, koda rakstīšanai es izmantoju VS kodu kā IDE. Tas ir atvērtā koda un viegli lietojams. Ja vēlaties izmantot Visual Studio kodu, skatiet mūsu ceļvedi par VS koda instalēšanu Linux.
Sistēmas informācijas iegūšana, izmantojot Python
Šajā rakstā mēs izstrādāsim programmu, kurā tiks iegūta šāda informācija:
- Sistēmas pamatinformācija
- Informācija par CPU
- Informācija par atmiņu
- Diska lietošana
- Tīkla informācija
- Cita informācija par aparatūru
Lai iegūtu šo informāciju, mēs izmantosim moduļus, kas atrodas Python standarta bibliotēkā. Daži no izmantotajiem moduļiem ir OS, platforma utt. Es arī esmu ievietojis pirmkodu Github; jūs varat redzēt programmas demonstrāciju, lejupielādējot no manas Github krātuves un palaižot to.
Lai sekotu šai apmācībai, ieteicams savā sistēmā instalēt jaunāko python versiju. Jūs varat sekot mūsu ceļvedim par python instalēšanu Linux.
Prasības
Daudzas bibliotēkas, kuras izmantojam šajā apmācībā, atrodas pitona standarta bibliotēkā. Mums jāinstalē tikai pakotne psutils. To var pārbaudīt, importējot. Ja jums nav instalēts psutil, varat to viegli instalēt, izmantojot pip rīku. Lai instalētu pip mūsu sistēmā, mums terminālā ir jāpalaiž šāda komanda.
pip instalēt psutil
Sistēmas pamatinformācijas iegūšana
Tagad, kad esat instalējis psutil, redzēsim, kā to izmantot, lai savāktu OS, izmantojot python. Mēs izmantojām platforma modulis, kas atrodas python standarta bibliotēkā, lai apkopotu šo sistēmas pamatinformāciju. Jums ir jākopē šis kods jūsu iecienītākajā python IDE un jāpalaiž.
# nepieciešamo moduļu importēšana importēšanas platforma # OS drukas arhitektūras drukāšana ("[+] Arhitektūra:", platforma.arhitektūra () [0]) # Iekārtas drukas parādīšana ("[+] Mašīna:", platforma.mašīna ()) # operētājsistēmas izlaišanas informācijas drukāšana ("[+] Operētājsistēmas izlaidums:", platforma.release ()) # izdrukā pašlaik izmantoto sistēmas nosaukuma druku ("[+] Sistēmas nosaukums:", platforma.system ()) # Šī rinda izdrukās jūsu operētājsistēmas drukas versiju ("[+] Operētājsistēmas versija:", platforma.version ()) # Tas izdrukās jūsu operētājsistēmas drukas mezglu vai resursdatora nosaukumu ("[+] mezgls:" + platforma.mezgls ()) # Tas izdrukās jūsu sistēmas platformas druku ("[+] Platforma:", platforma.platform ()) # Tas izdrukās procesora informācijas druku ("[+] Procesors:", platforma.procesors ())Iepriekš minētajā kodā mēs vispirms importējām platformas moduli, kas atrodas python standarta bibliotēkā. Pēc moduļa importēšanas mēs izmantojam platformas moduļa funkcijas, lai iegūtu nepieciešamo informāciju. Palaižot kodu ierīcē, es saņēmu šādu izvadi.
Kā redzam izvadē, programma parāda daudzas svarīgas detaļas par operētājsistēmu, piemēram, sistēmas arhitektūru, platformu un daudz ko citu.
Sistēmas darbalaiks
Mēs varam arī iegūt sistēmas palaišanas laiku un sistēmas darbības laiku pitonā. Mums ir jāizmanto psutils bibliotēka, kuru esam instalējuši agrāk. Mēs varam iegūt sistēmas darbības laiku, lasot uptime failu, kas atrodas proc direktorijā Linux.
Lūdzu, nokopējiet šo kodu iecienītākajā pitona IDE un palaidiet to.
from datetime importēt datetime importēt psutil # psutil bibliotēkas izmantošana, lai iegūtu sistēmas sāknēšanas laiku boot_time = datetime.fromtimestamp (psutil.boot_time ()) print ("[+] Sistēmas sāknēšanas laiks:", boot_time) Šis kods izdrukās sāknēšanas laiku, kas nozīmē laiku, kad sistēma tika sāknēta. Palaižot programmu personālajā datorā, es saņēmu šādu izvadi.
Mēs varam redzēt arī sistēmas darbības laiku, kas ir laiks, kurā sistēma darbojas. Mums ir jāizlasa proc direktorijas uptime fails, kā parādīts zemāk esošajā kodā.
# iegūt sistēmas darbības laiku no uptime faila proc direktorijā ar atvērtu ("/ proc / uptime", "r") kā f: uptime = f.lasīt ().sadalīt ("") [0].strip () uptime = int (float (uptime)) uptime_hours = uptime // 3600 uptime_minutes = (uptime% 3600) // 60 print ("[+] System Uptime:" + str (uptime_hours) + ":" + str ( uptime_minutes) + "stundas")Palaižot kodu, man ir šāda izeja.
Procesi
Mēs varam arī izmantot pitonu, lai iegūtu pašlaik notiekošo procesu sarakstu, kurā nav visu procesu. Mums ir jāpalaiž šāds kods.
importēt os pids = [] apakšdirektoram os.listdir ('/ proc'): ja apakšdirektors.isdigit (): pids.pievienot (apakšdirektorija) druku ('Procesu kopējais skaits: 0'.formāts (len (pids))) Palaižot kodu, es saņēmu izvadi, kā parādīts zemāk esošajā attēlā.
Informācija par lietotāju
Mēs varam arī iegūt visu mūsu Linux ierīcē esošo lietotāju sarakstu, izmantojot pwd bibliotēku, kas atrodas python standarta bibliotēkā. Lai to izdarītu, jums ir jākopē šis kods Python IDE un jāpalaiž.
importēt pwd lietotājus = pwd.getpwall () lietotājam lietotājiem: print (user.pw_name, lietotājs.pw_shell)
Palaižot iepriekš minēto kodu, jūs saņemsiet visus lietotājus, kas atrodas jūsu ierīcē, un viņu čaulas.
Informācija par CPU
Tagad mēs esam apkopojuši Sistēmas detaļas, lai apkopotu informāciju par mūsu mašīnas izmantoto procesoru. Mēs varam savākt informāciju par procesoru no mūsu Linux mašīnas divos veidos. Pirmais un vienkāršākais veids ir izmantot psutils modulis, un otrais veids ir, lasot failu / proc / cpuinfo.
Apskatīsim, kā mēs varam izmantot psutil bibliotēku, lai iegūtu CPU informāciju. Šis kods ir jākopē iecienītajā python IDE un jāpalaiž.
# nepieciešamo pakotņu importēšana importējiet psutil # Šis kods izdrukās pašreizējo drukāto CPU kodolu skaitu ("[+] Fizisko kodolu skaits:", psutil.cpu_count (logisks = False)) print ("[+] Kopējo kodolu skaits:", psutil.cpu_count (logisks = True)) print ("\ n") # Tas izdrukās maksimālo, minimālo un pašreizējo CPU frekvenci cpu_frequency = psutil.cpu_freq () print (f "[+] Maksimālā frekvence: cpu_frequency.maks .:.2f Mhz ") druka (f" [+] Min frekvence: cpu_frequency.min:.2f Mhz ") druka (f" [+] Pašreizējā frekvence: cpu_frequency.pašreizējais:.2f Mhz ") print (" \ n ") # Tas izdrukās CPU izmantošanu vienā kodolā i, procentos uzskaitījumā (psutil.cpu_percent (percpu = True, intervāls = 1)): izdrukāt (f "[+] CPU Core i izmantošana: percent%") print (f "[+] CPU kopējais lietojums: psutil.cpu_percent ()% ")Apskatīsim, kas notiek iepriekš minētajā programmā. Pirmajā rindā mēs importējām psutils modulis, kas palīdzēs apkopot CPU datus. Otrajā un trešajā rindā mēs izmantojam cpu_count () funkcija psutils modulis, lai uzskaitītu CPU kodolu skaitu. Tad mēs izmantojām cpu_freq () funkciju, lai iegūtu maksimālo, min un pašreizējo frekvenci. Visbeidzot, mēs izmantojam cpu_percent funkciju fo psutil, lai atrastu CPU lietojumu. Palaižot kodu savā mašīnā, es saņēmu šādu izvadi.
Kā mēs redzam izvadē, ka visas CPU detaļas ir izvadījusi programma terminālā. Mēs varam arī iegūt CPU nosaukumu, lasot failu / proc / cpuinfo, izmantojot python. Lai to izdarītu, mums jāpalaiž šāds kods.
# lasot cpuinfo failu, lai drukātu # centrālā procesora nosaukumu ar atvērtu ("/ proc / cpuinfo", "r") kā f: file_info = f.readlines () cpuinfo = [x.sloksne ().split (":") [1] x faila_info failā, ja indeksam "modeļa nosaukums" x], vienums uzskaitījumā (cpuinfo): print ("[+] Procesors" + str (rādītājs) + ":" + vienums )Mēs varam arī savākt citu CPU informāciju, izmantojot failu / proc / cpuinfo. Es lasīju tikai CPU modeļa nosaukumu, bet jūs varat atvērt failu un redzēt citu failā esošo informāciju un tos izmantot programmā. Lūk, izeja.
Apkoposim informāciju par atmiņu, izmantojot pitonu.
Informācija par atmiņu
Tāpat kā CPU informāciju, arī atmiņu varam iegūt no divām vietām. Viens no tiem izmanto rīku psutil, bet otrais - lasot proc / meminfo failu. Vispirms sāksim vākt informāciju par atmiņu, izmantojot psutila bibliotēku. Lūdzu, nokopējiet šo kodu iecienītākajā pitona IDE un palaidiet to.
# pieprasīto moduļu importēšana importē psutil # funkcijas rakstīšana, lai baitus pārvērstu GigaByte def bytes_to_GB (baiti): gb = baiti / (1024 * 1024 * 1024) gb = apaļa (gb, 2) atgriešanās gb # Funkcijas virtual_memory () izmantošana tas atgriezīs virtuālās_atmiņas = psutil kopu.virtual_memory () # Tas izdrukās primārās atmiņas detaļas drukāt ("[+] Kopējā atmiņa:", baiti_to_GB (virtuālā_atmiņa).total), "Gb") print ("[+] Kopējā pieejamā atmiņa:", bytes_to_GB (virtual_memory.pieejams), "Gb") druka ("[+] Kopējā atmiņa izmantota:", baiti_to_GB (virtuālā_atmiņa).izmantots), "Gb") print ("[+] Izmantotā procentuālā daļa:", virtuālā_atmiņa.procenti, "%") print ("\ n") # Tas izdrukās informāciju par mijmaiņas atmiņu, ja pieejama swap = psutil.swap_memory () print (f "[+] Kopējā atmiņa: bytes_to_GB (swap.kopā) ") print (f" [+] Bezmaksas mijmaiņas atmiņa: bytes_to_GB (mijmaiņa.bezmaksas) ") print (f" [+] Izmantotā mijmaiņas atmiņa: bytes_to_GB (swap.lietota) ") print (f" [+] Izmantotā procentuālā daļa: apmainīt.procenti% ")Apskatīsim, kas notiek iepriekš minētajā kodā. Pirmajā rindiņā mēs importējām psutil bibliotēku, pēc tam izmantojām tās virtual_memory () funkciju, kas atgriež kopu ar virtuālās atmiņas informāciju. Tad mēs izmantojam funkciju swap_memory (), lai iegūtu informāciju par mijmaiņas atmiņu. Mēs izveidojām arī funkcijas nosaukumu bytes_to_GB (), kas pārvērsīs baitus par GigaBytes, lai nodrošinātu labāku lasāmību. Es saņēmu šādu izvadi.
Mēs varam arī izmantot meminfo failu, kas atrodas Linux proc direktorijā, lai izgūtu informāciju par atmiņu, piemēram, kopējo atmiņu, izmantoto atmiņu utt. Lai to izdarītu, palaidiet šo kodu.
# Atmiņas informācijas apkopošana no meminfo faila drukas ("\ nLasot / proc / meminfo failu: \ n") ar atvērtu ("/ proc / meminfo", "r") kā f: lines = f.readlines () print ("[+]" + līnijas [0].sloksne ()) druka ("[+]" + līnijas [1].sloksne ())Un šeit ir izeja:
Informācija par disku
Līdz šim mēs esam redzējuši dažas pamata sistēmas detaļas, procesora detaļas, informāciju par atmiņu. Tagad apskatīsim informāciju par mūsu mašīnā esošo disku. Lai iegūtu diska informāciju, mēs izmantosim moduli psutil, lai atvieglotu mūsu uzdevumu, un mums nav nepieciešams no jauna izgudrot riteni. Apskatiet zemāk redzamo kodu, lai redzētu koda piemēru. Jūs varat nokopēt kodu un palaist iecienītā pitona IDE.
# nepieciešamo moduļu importēšana importē psutil # piekļuve visiem diska nodalījumiem disk_partitions = psutil.disk_partitions () # funkcijas rakstīšana, lai pārvērstu baitus Giga baitos def baiti_to_GB (baiti): gb = baiti / (1024 * 1024 * 1024) gb = apaļi (gb, 2) atgriež gb #, parādot nodalījumu un nodalījuma lietošanas informāciju disk_partitions: print ("[+] Partition Device:", nodalījums.ierīce) print ("[+] File System:", nodalījums.fstype) print ("[+] Mountpoint:", nodalījums.mountpoint) disk_usage = psutil.disk_usage (nodalījums.mountpoint) print ("[+] Kopējā diska vieta:", baiti_to_GB (diska_lietojums.kopā), "GB") druka ("[+] brīva vieta diskā:", baiti_to_GB (diska_lietojums).bezmaksas), "GB") druka ("[+] Izmantotā diska vieta:", baiti_to_GB (diska_lietojums).lietota), "GB") print ("[+] Izmantotā procentuālā daļa:", diska_lietojums.procenti, "%") # iegūt lasīšanas / rakstīšanas statistiku kopš sāknēšanas diska_rw = psutil.disk_io_counters () print (f "[+] Kopā lasīts kopš sāknēšanas: bytes_to_GB (disk_rw.read_bytes) GB ") print (f" [+] Kopējā rakstīšanas sāknēšanas summa: bytes_to_GB (disk_rw.write_bytes) GB ") Kodā vispirms esam importējuši psutil bibliotēku, kas nepieciešama, lai apkopotu informāciju par disku. Tad mēs to izmantojām disk_partitions () funkciju, lai iegūtu pieejamo diska nodalījumu sarakstu ar viņu informāciju. Mēs arī izmantojam disk_usage () funkciju, lai iegūtu šo nodalījumu izmantošanu. Visbeidzot, mēs izmantojam disk_io_counters () funkcija, lai iegūtu kopējo diska lasīšanas / rakstīšanas laiku kopš sāknēšanas. Šeit ir izvades piemērs.
Atkarībā no diska un nodalījumiem var iegūt kādu citu izvadi.
Tīkla informācija
Mēs varam arī apkopot sistēmas tīkla informāciju, izmantojot psutil bibliotēku. Lai to izdarītu, nokopējiet šo kodu savā python IDE un palaidiet to.
# nepieciešamo moduļu importēšana importē psutil # funkcijas rakstīšana, lai baitus pārvērstu gigabaitos def bytes_to_GB (baiti): gb = baiti / (1024 * 1024 * 1024) gb = apaļi (gb, 2) atgriež gb # apkopo visas tīkla saskarnes ( virtuāls un fizisks) no sistēmas if_addrs = psutil.net_if_addrs () # katras tīkla saskarnes informācijas drukāšana interfeisa_nosaukumam, interfeisa_adreses sadaļā if_addrs.items (): adresei interfeisa_adresēs: print ("\ n") print (f "Interfeiss:", interfeisa_nosaukums) if str (adrese.ģimene) == 'AddressFamily.AF_INET ': print ("[+] IP adrese:", adrese.adrese) print ("[+] Netmask:", adrese.netmask) print ("[+] Broadcast IP:", adrese.apraide) elif str (adrese.ģimene) == 'AddressFamily.AF_PACKET ': print ("[+] MAC adrese:", adrese.adrese) print ("[+] Netmask:", adrese.netmask) print ("[+] Broadcast MAC:", adrese.apraide) # tīkla lasīšanas / rakstīšanas statistikas iegūšana kopš sāknēšanas drukas ("\ n") net_io = psutil.net_io_counters () print ("[+] Kopējais nosūtīto baitu skaits:", baiti_to_GB (net_io.bytes_sent)) print ("[+] Kopējais saņemto baitu skaits:", baiti_to_GB (net_io.bytes_recv))Šeit ir mana testa datora izvades piemērs.
Cita informācija par aparatūru
Mēs varam arī izmantot psutils bibliotēku, lai iegūtu citu informāciju par aparatūru, piemēram, informācija par akumulatoriem, ventilatoru rotācijas ātrums, dažādu ierīču temperatūra, utt. Apskatīsim, kā mēs to varam paveikt pa vienam.
Ja izmantojat klēpjdatoru, varat izmantot psutils.sensors_battery () funkciju, lai iegūtu informāciju par akumulatoru. Lai to izdarītu, nokopējiet un palaidiet šo kodu savā Python IDE.
importa psutila akumulators = psutils.sensors_battery () print ("[+] Akumulatora procentuālais daudzums:", apaļa (akumulatora akumulators).procenti, 1), "%") izdruka ("[+] Baterijas atlikušais laiks:", apaļa (akumulators.secsleft / 3600, 2), "hr") print ("[+] Strāvas padeve:", akumulators.strāvas avots) Iepriekš minētajā kodā mēs izmantojam sensors_battery () funkciju, lai iegūtu informāciju par akumulatoru, piemēram, akumulatora procentuālo daudzumu, atlikušo laiku, strāvas padevi vai nē. Palaižot kodu manā mašīnā, es saņēmu šādu izvadi.
Mēs varam arī izmantot psutil bibliotēku, lai iegūtu ventilatora apgriezienus minūtē (apgriezieni minūtē), izmantojot funkciju sensors_fan (), kamēr ventilators darbojas. Psutilu var izmantot arī, lai iegūtu dažādu ierīču temperatūru. Mēs to varam izdarīt, izmantojot psutila funkciju sensors_temperatures (). Es atstāju to darīt jums praksē.
Galīgais scenārijs
Tagad apvienosim visus kodus ar pēdējās programmas izveidi, lai apkopotu visas apspriestās sistēmas un aparatūras detaļas. Varat nokopēt šo programmu un palaist to savā python IDE.
# nepieciešamo moduļu importēšanas importēšanas platforma no datetime importēšanas datetime importēšanas psutil import os # Vispirms mēs izdrukāsim sistēmas pamatinformāciju # izmantojot platformas moduļa drukas ("\ n \ t \ t \ t Basic System Information \ n") print (" [+] Arhitektūra: ", platforma.arhitektūra () [0]) print ("[+] Mašīna:", platforma.machine ()) print ("[+] Operētājsistēmas izlaidums:", platforma.release ()) print ("[+] Sistēmas nosaukums:", platforma.system ()) print ("[+] Operētājsistēmas versija:", platforma.version ()) print ("[+] Node:" + platforma.node ()) print ("[+] Platforma:", platforma.platform ()) print ("[+] Procesors:", platforma.procesors ()) # Bibliotēkas psutil izmantošana, lai iegūtu sistēmas sāknēšanas laiku boot_time = datetime.fromtimestamp (psutil.boot_time ()) print ("[+] Sistēmas sāknēšanas laiks:", boot_time) # iegūt sistēmas darbības laiku no uptime faila proc direktorijā ar atvērtu ("/ proc / uptime", "r") kā f: uptime = f.lasīt ().sadalīt ("") [0].strip () uptime = int (float (uptime)) uptime_hours = uptime // 3600 uptime_minutes = (uptime% 3600) // 60 print ("[+] System Uptime:" + str (uptime_hours) + ":" + str ( uptime_minutes) + "hours") # iegūt kopējo procesu skaitu, kas pašlaik darbojas pids = [] apakšdirektoram os.listdir ('/ proc'): ja apakšdirektors.isdigit (): pids.pievienot (apakšdirektorija) druku ('Procesu kopējais skaits: 0'.formāts (len (pids))) # Parāda CPU informācijas izdruku ("\ n \ t \ t \ t CPU informācija \ n") # Šis kods izdrukās pašreizējo drukāto CPU kodolu skaitu ("[+] Fizisko datu skaits serdeņi: ", psutils.cpu_count (logisks = False)) print ("[+] Kopējo kodolu skaits:", psutil.cpu_count (logisks = True)) print ("\ n") # Tas izdrukās maksimālo, minimālo un pašreizējo CPU frekvenci cpu_frequency = psutil.cpu_freq () print (f "[+] Maksimālā frekvence: cpu_frequency.maks .:.2f Mhz ") druka (f" [+] Min frekvence: cpu_frequency.min:.2f Mhz ") druka (f" [+] Pašreizējā frekvence: cpu_frequency.pašreizējais:.2f Mhz ") print (" \ n ") # Tas izdrukās CPU izmantošanu vienā kodolā i, procentos uzskaitījumā (psutil.cpu_percent (percpu = True, intervāls = 1)): izdrukāt (f "[+] Centrālā procesora izmantošana i: percent%") izdrukāt (f "[+] CPU kopējais lietojums: psutil.cpu_percent ()% ") # lasot cpuinfo failu, lai izdrukātu # CPU nosaukumu ar atvērtu (" / proc / cpuinfo "," r ") kā f: file_info = f.readlines () cpuinfo = [x.sloksne ().split (":") [1] x faila_info failā, ja indeksam "modeļa nosaukums" x], vienums uzskaitījumā (cpuinfo): print ("[+] Procesors" + str (rādītājs) + ":" + vienums ) # funkcijas rakstīšana, lai baitus pārvērstu GigaByte def baitos_to_GB (baiti): gb = baiti / (1024 * 1024 * 1024) gb = apaļa (gb, 2) atgriešanās gb # Izmantojot funkciju virtual_memory (), tiks atgriezta virtuālā atmiņa. = psutils.virtual_memory () print ("\ n \ t \ t \ t Atmiņas informācija \ n") # Tas izdrukās primārās atmiņas detaļas print ("[+] Kopējā atmiņa:", baiti_to_GB (virtual_memory).total), "Gb") print ("[+] Kopējā pieejamā atmiņa:", bytes_to_GB (virtual_memory.pieejams), "Gb") druka ("[+] Kopējā izmantotā atmiņa:", baiti_to_GB (virtuālā_atmiņa).izmantots), "Gb") print ("[+] Izmantotā procentuālā daļa:", virtuālā_atmiņa.procenti, "%") print ("\ n") # Tas izdrukās informāciju par mijmaiņas atmiņu, ja pieejama swap = psutil.swap_memory () print (f "[+] Kopējā atmiņa: bytes_to_GB (swap.kopā) ") print (f" [+] Bezmaksas mijmaiņas atmiņa: bytes_to_GB (mijmaiņa.bezmaksas) ") print (f" [+] Izmantotā mijmaiņas atmiņa: bytes_to_GB (swap.lietota) ") print (f" [+] Izmantotā procentuālā daļa: apmainīt.procents% ") # Atmiņas informācijas apkopošana no meminfo faila drukas (" \ nLasot / proc / meminfo failu: \ n ") ar atvērtu (" / proc / meminfo "," r ") kā f: lines = f.readlines () print ("[+]" + līnijas [0].sloksne ()) druka ("[+]" + līnijas [1].strip ()) # piekļuve visiem diska nodalījumiem disk_partitions = psutil.disk_partitions () print ("\ n \ t \ t \ t Diska informācija \ n") # parāda nodalījuma un nodalījuma lietošanas informāciju disk_partitions: print ("[+] Partition Device:", nodalījums.ierīce) print ("[+] File System:", nodalījums.fstype) print ("[+] Mountpoint:", nodalījums.mountpoint) disk_usage = psutil.disk_usage (nodalījums.mountpoint) print ("[+] Kopējā diska vieta:", baiti_to_GB (diska_lietojums.kopā), "GB") izdruka ("[+] brīva vieta diskā:", baiti_to_GB (diska_lietojums).bezmaksas), "GB") druka ("[+] Izmantotā diska vieta:", baiti_to_GB (diska_lietojums).lietota), "GB") print ("[+] Izmantotā procentuālā daļa:", diska_lietojums.procenti, "%") # iegūt lasīšanas / rakstīšanas statistiku kopš sāknēšanas diska_rw = psutil.disk_io_counters () print (f "[+] Kopā lasīts kopš sāknēšanas: bytes_to_GB (disk_rw.read_bytes) GB ") print (f" [+] Kopējā rakstīšanas sāknēšanas summa: bytes_to_GB (disk_rw.write_bytes) GB ") # visu tīkla interfeisu (virtuālo un fizisko) apkopošana no sistēmas if_addrs = psutil.net_if_addrs () print ("\ n \ t \ t \ t Tīkla informācija \ n") # drukā eah tīkla interfeisu informāciju par interface_name, interfeisa_adreses if_addrs.vienumi (): adresei interfeisa adresēs: drukāt (f "Interfeiss:", saskarnes_nosaukums) if str (adrese.ģimene) == 'AddressFamily.AF_INET ': print ("[+] IP adrese:", adrese.adrese) print ("[+] Netmask:", adrese.netmask) print ("[+] Broadcast IP:", adrese.apraide) elif str (adrese.ģimene) == 'AddressFamily.AF_PACKET ': print ("[+] MAC adrese:", adrese.adrese) print ("[+] Netmask:", adrese.netmask) print ("[+] Broadcast MAC:", adrese.apraide) # iegūt tīkla lasīšanas / rakstīšanas statistiku kopš sāknēšanas net_io = psutil.net_io_counters () print ("[+] Kopējais nosūtīto baitu skaits:", baiti_to_GB (net_io.bytes_sent)) print ("[+] Kopējais saņemto baitu skaits:", baiti_to_GB (net_io.bytes_recv)) # Informācijas par akumulatoru iegūšana akumulators = psutil.sensors_battery () print ("\ n \ t \ t \ t Informācija par akumulatoriem \ n") print ("[+] Akumulatora procentuālais daudzums:", apaļa (akumulators.procenti, 1), "%") izdruka ("[+] Baterijas atlikušais laiks:", apaļa (akumulators.secsleft / 3600, 2), "hr") print ("[+] Strāvas padeve:", akumulators.strāvas avots) Palaižot šo kodu, mēs iegūsim šādu izvadi.
Ja vēlaties uzlabot programmu vai vēlaties lejupielādēt kodu, to varat izdarīt no manas Github lapas.
Secinājums
Šī ir pilna apmācība par interesantas informācijas apkopošanu par sistēmu un aparatūru, izmantojot pitonu. Ja jums ir kādas problēmas ar koda kopēšanu, pilnu pirmkodu varat atrast arī manā Github repo. Iespējams, vēlēsities redzēt arī mūsu ceļvedi par darbu ar operētājsistēmu pitonā, lai iegūtu dažus interesantākus python pielāgojumus.
