„Linux“ sistemos ir aparatinės įrangos informacijos išskleidimas naudojant „Python“

„Linux“ aparatūros ir sistemos informacijos paieška yra patogi ir įdomi užduotis. Mes galime išgauti išsamią informaciją apie operacinę sistemą, vartotojo duomenis, atminties duomenis, procesoriaus duomenis ir daug daugiau naudodami paprastus „python“ kodus „Linux“. Nors daugelį šių dalykų galime atlikti naudodami terminalo ir „bash“ scenarijus, „python“ yra daug įdomesnis.

Kaip pitonų mėgėjas, norime, kad kiekviena užduotis būtų atlikta naudojant tą kalbą, todėl sistemos ir aparatinės įrangos informacijos išskleidimas naudojant pitoną yra puiki užduotis. Be to, vienu metu galime išmokti tiek „Linux“, tiek „python“. Šis straipsnis bus gana ilgas, todėl neskubėkite perskaityti visą straipsnį ir paleiskite kiekvieną kodą, kad geriau suprastumėte.

Kiekvieną kodą galite nukopijuoti į python IDE ir paleisti. Jei neturite „python IDE“ arba norite palyginti IDE, žiūrėkite mūsų vadovą, pateiktą 10 geriausių „Linux“ skirtų IDE. Beje, aš naudoju VS kodą kaip IDE kodui rašyti. Tai yra atviro kodo ir paprasta naudoti. Jei norite naudoti „Visual Studio Code“, peržiūrėkite mūsų VS kodo diegimo „Linux“ vadove.

Išskleisti sistemos informaciją naudojant „Python“

Šiame straipsnyje sukursime programą, kurioje bus pateikta ši išsami informacija:

• Pagrindinė sistemos informacija
• Išsami procesoriaus informacija
• Informacija apie atmintį
• Disko naudojimas
• Tinklo informacija
• Kita aparatinės įrangos informacija

Norėdami gauti šią informaciją, naudosime modulius, esančius „Python“ standartinėje bibliotekoje. Kai kurie moduliai, kuriuos naudosime, yra OS, platforma ir kt. Aš taip pat įdėjau šaltinio kodą į „Github“; galite pamatyti programos demonstracinę versiją atsisiųsdami iš mano „Github“ saugyklos ir paleisdami ją.

Jei norite laikytis šios mokymo programos, rekomenduojama, kad jūsų sistemoje būtų įdiegta naujausia „python“ versija. Galite sekti mūsų „python“ diegimo „Linux“ vadove.

Reikalavimai

Daugelis bibliotekų, kurias naudojame šioje mokymo programoje, yra standartinėje python bibliotekoje. Mums reikia įdiegti tik paketą psutilas. Galite patikrinti importuodami. Jei neturite įdiegę „psutil“, galite lengvai jį įdiegti naudodami „pip“ įrankį. Norėdami įdiegti „pip“ į savo sistemą, mes turime paleisti šią komandą terminale.

pip įdiegti psutil

Kaip gauti pagrindinę sistemos informaciją

Dabar, kai įdiegėte „psutil“, pažiūrėkime, kaip jį naudoti norint surinkti OS naudojant „python“. Mes naudojome platforma modulis, esantis python standartinėje bibliotekoje, norint surinkti šią pagrindinę sistemos informaciją. Turite nukopijuoti šį kodą į savo mėgstamą „python IDE“ ir paleisti.

# reikalingų modulių importavimas importavimo platforma # OS spausdinimo architektūros spausdinimas ("[+] Architektūra:", platforma.architektūra () [0]) # Mašinos spausdinimo rodymas („[+] Mašina:“, platforma.mašina ()) # operacinės sistemos leidimo informacijos spausdinimas („[+] Operacinės sistemos leidimas:“, platforma).release ()) # spausdina šiuo metu naudojamą sistemos pavadinimo spausdinimą („[+] Sistemos pavadinimas:“, platforma.system ()) # Ši eilutė atspausdins jūsų operacinės sistemos spausdinimo versiją („[+] Operacinės sistemos versija:“, platforma.version ()) # Tai atspausdins jūsų operacinės sistemos spausdinimo mazgą arba pagrindinio kompiuterio pavadinimą ("[+] mazgas:" + platforma.node ()) # Tai atspausdins jūsų sistemos platformos spausdinimą ("[+] Platforma:", platforma.platforma ()) # Tai atspausdins procesoriaus informacijos spausdinimą ("[+] Procesorius:", platforma.procesorius ())

Pirmiau pateiktame kode pirmiausia importavome platformos modulį, esantį python standartinėje bibliotekoje. Importavę modulį, mes naudojame platformos modulio funkcijas norimai informacijai gauti. Vykdydamas kodą savo įrenginyje, gavau šią išvestį.

Kaip matome išvestyje, programa pateikia daug svarbių detalių apie operacinę sistemą, pvz., Sistemos architektūrą, platformą ir daug daugiau.

Sistemos veikimo laikas

Taip pat galime gauti sistemos įkrovos laiką ir sistemos veikimo laiką „python“. Turime naudoti psutilas biblioteką, kurią įdiegėme anksčiau. Sistemos veikimo laiką galime gauti perskaitę „uptime“ failą, esantį „Linux“ proc kataloge.

Nukopijuokite šį kodą į savo mėgstamą python IDE ir paleiskite jį.

from datetime importuoti datetime importuoti psutil # psutil bibliotekos naudojimas norint gauti sistemos paleidimo laiką boot_time = datetime.fromtimestamp (psutil.boot_time ()) print ("[+] System Boot Time:", įkrovos laikas)

Šis kodas atspausdins įkrovos laiką, ty laiką, kai sistema buvo paleista. Vykdydamas programą savo kompiuteryje, gavau tokį išvestį.

Taip pat galime pamatyti sistemos veikimo laiką, tai yra laikas, kurį sistema veikia. Turime perskaityti „proc“ katalogo veikimo laiko failą, kaip parodyta žemiau esančiame kode.

# gauti sistemos veikimo laiką iš „uptime“ failo „Proc“ kataloge su „open“ („/ proc / uptime“, „r“) kaip f: uptime = f.skaityti ().padalinti ("") [0].strip () uptime = int (float (uptime)) uptime_hours = uptime // 3600 uptime_minutes = (uptime% 3600) // 60 print ("[+] Sistemos veikimo laikas:" + str (uptime_hours) + ":" + str ( uptime_minutes) + "valandos")

Vykdydamas kodą gavau šią išvestį.

Procesai

Mes taip pat galime naudoti python, kad gautume šiuo metu vykdomų procesų sąrašą, iš viso procesų. Turime paleisti šį kodą.

importuoti os pids = [] pakatalogiui OS.listdir ('/ proc'): jei pakatalogis.isdigit (): pids.pridėti (pakatalogį) spausdinti („Bendras procesų skaičius: 0“.formatas (len (pids)))

Vykdydamas kodą, aš gavau išvestį, kaip parodyta žemiau esančiame paveikslėlyje.

Vartotojo informacija

Mes taip pat galime gauti visų mūsų „Linux“ įrenginyje esančių vartotojų sąrašą naudodami „pwd“ biblioteką, esančią standartinėje „Python“ bibliotekoje. Norėdami tai padaryti, turite nukopijuoti šį kodą į savo python IDE ir paleisti jį.

importuoti pwd vartotojus = pwd.vartotojas vartotojas: spausdinti (vartotojas.pw_name, vartotojas.pw_shell)

Paleisdami pirmiau nurodytą kodą, gausite visus įrenginyje esančius vartotojus ir jų apvalkalus.

Informacija apie procesorių

Dabar mes surinkome išsamią informaciją apie sistemą, kad surinktume šiek tiek informacijos apie mūsų mašinos naudojamą procesorių. Mes galime rinkti procesoriaus informaciją iš savo „Linux“ kompiuterio dviem būdais. Pirmasis ir paprasčiausias būdas yra naudoti psutilas modulis, o antrasis būdas yra skaityti failą / proc / cpuinfo.

Pažiūrėkime, kaip mes galime naudoti „psutil“ biblioteką, kad gautume informaciją apie procesorių. Turite nukopijuoti šį kodą į savo mėgstamą „python IDE“ ir paleisti.

# importuoti reikiamus paketus importuoti psutil # Šis kodas atspausdins spausdintų procesoriaus branduolių skaičių ("[+] Fizinių branduolių skaičius:", psutil.cpu_count (loginis = klaidingas)) print ("[+] Viso branduoliu skaicius:", psutil.cpu_count (logiškas = True)) print ("\ n") # Tai atspausdins maksimalų, mažiausią ir dabartinį procesoriaus dažnį cpu_frequency = psutil.cpu_freq () print (f "[+] Maksimalus dažnis: cpu_frequency.maks .:.2f Mhz ") spausdinimas (f" [+] Min dažnis: cpu_frequency.min .:.2f Mhz ") spausdinimas (f" [+] Dabartinis dažnis: cpu_frequency.srovė:.2f Mhz ") print (" \ n ") # Tai atspausdins procesoriaus naudojimą vienam branduoliui i, procentais suskaičiuota (psutil.cpu_percent (percpu = True, intervalas = 1)): spausdinti (f "[+] Centrinio procesoriaus naudojimas i: percent%") spausdinti (f "[+] Bendras procesoriaus naudojimas: psutil.cpu_percent ()% ")

Pažiūrėkime, kas vyksta pirmiau pateiktoje programoje. Pirmoje eilutėje mes importavome psutilas modulis, kuris padės surinkti procesoriaus duomenis. Antroje ir trečioje eilutėse mes naudojame cpu_count () funkcija psutilas modulis, skirtas skaičiuoti procesoriaus branduolių skaičių. Tada mes naudojome cpu_freq () funkciją, kad gautume maksimalų, minų ir srovės dažnį. Pagaliau mes naudojame „cpu_percent“ funkciją „psutil“, kad surastume procesoriaus naudojimą. Vykdydamas kodą savo mašinoje, gavau šią išvestį.

Kaip matome išvestyje, kad visas procesoriaus detales programoje išvedė terminalas. Procesoriaus pavadinimą taip pat galime gauti perskaitę failą / proc / cpuinfo naudodamiesi python. Norėdami tai padaryti, turime paleisti šį kodą.

# skaitant cpuinfo failą, norint atsispausdinti # esamo procesoriaus pavadinimą su open ("/ proc / cpuinfo", "r") kaip f: file_info = f.readlines () cpuinfo = [x.juosta ().split (":") [1] x failo informaciniame faile, jei indekso "modelio pavadinimas" x], elementas išvardytame (cpuinfo): print ("[+] Procesorius" + str (rodyklė) + ":" + elementas )

Mes taip pat galime rinkti kitą procesoriaus informaciją naudodami / proc / cpuinfo failą. Aš skaitau tik procesoriaus modelio pavadinimą, bet jūs galite atidaryti failą, pamatyti kitą faile esančią informaciją ir juos naudoti programoje. Štai išvestis.

Surinkime šiek tiek informacijos apie atmintį naudodami pitoną.

Informacija apie atmintį

Kaip ir procesoriaus informaciją, atminties informaciją taip pat galime gauti iš dviejų vietų. Vienas naudoja „psutil“ įrankį, o antrasis - skaitydamas proc / meminfo failą. Pirmiausia pradėkime rinkti informaciją apie atmintį naudodami „psutil“ biblioteką. Nukopijuokite šį kodą į savo mėgstamą python IDE ir paleiskite jį.

# importuodami reikiamus modulius importuokite psutil # rašydami funkciją, kad baitai būtų konvertuojami į GigaByte def bytes_to_GB (baitai): gb = baitai / (1024 * 1024 * 1024) gb = apvalūs (gb, 2) grąžinti gb # Naudojant funkciją virtual_memory () tai grąžins virtualų atmintį = psutil.virtual_memory () # Tai išspausdins išsamią informaciją apie pagrindinę atmintį ("[+] Iš viso atminties:", baitų_į_GB (virtuali_memorija).viso), "Gb") spausdinti ("[+] Iš viso laisvos atminties:", baitų_į_GB (virtualioji atmintis).galimas), „Gb“) spausdinimas („[+] Iš viso naudojama atmintis:“, baitų_į_GB (virtualioji atmintis).naudotas), „Gb“) spausdinti („[+] naudojama procentinė dalis:“, virtualioji atmintis.procentai, "%") print ("\ n") # Tai išspausdins išsamią apsikeitimo atminties informaciją, jei bus swap = psutil.swap_memory () print (f "[+] Visa apsikeitimo atmintis: bytes_to_GB (swap.viso) ") print (f" [+] Nemokama atminties keitimas: bytes_to_GB (swap.nemokamai) ") print (f" [+] Naudota keitimo atmintis: bytes_to_GB (swap.naudota) ") spausdinti (f" [+] Naudota procentinė dalis: sukeisti.procentai% ")

Pažiūrėkime, kas vyksta aukščiau pateiktame kode. Pirmoje eilutėje mes importavome „psutil“ biblioteką, tada naudojome jos virtual_memory () funkciją, kuri grąžina atkarpą su virtualios atminties informacija. Tada mes naudojame funkciją swap_memory (), kad gautume informaciją apie apsikeitimo atmintį. Mes taip pat sukūrėme funkcijos pavadinimą bytes_to_GB (), kuris konvertuos baitus į „GigaBytes“, kad būtų lengviau skaityti. Aš gavau tokią išvestį.

Mes taip pat galime naudoti „meminfo“ failą, esantį „Linux“ proc kataloge, kad gautume atminties informaciją, pvz., Bendrą atmintį, naudojamą atmintį ir kt. Norėdami tai padaryti, paleiskite šį kodą.

# Atminties informacijos rinkimas iš „meminfo“ failo spausdinimo ("\ nSkaitydamas / proc / meminfo failą: \ n") su atidarytu ("/ proc / meminfo", "r") kaip f: lines = f.readlines () spausdinti ("[+]" + eilutės [0].juosta ()) spausdinti ("[+]" + eilutės [1].juosta ())

Ir čia yra išvestis:

Disko informacija

Iki šiol mes matėme keletą pagrindinių sistemos duomenų, centrinio procesoriaus ir atminties informacijos. Dabar pažiūrėkime informaciją apie diską, esantį mūsų mašinoje. Norėdami išgauti informaciją apie diską, naudosime „psutil“ modulį, kad palengvintume savo užduotį, ir mums nereikia išradinėti dviračio. Pažvelkite į žemiau pateiktą kodą, kad pamatytumėte veikiantį kodo pavyzdį. Galite nukopijuoti kodą ir paleisti savo mėgstamo pitono IDE.

# importuojant reikiamus modulius importuokite psutil # prieigą prie visų disko skaidinių disk_partitions = psutil.disk_partitions () # rašyti funkciją, kad baitai būtų konvertuojami į Giga baitus def bytes_to_GB (baitai): gb = bytes / (1024 * 1024 * 1024) gb = apvalus (gb, 2) grąžina gb #, rodantį skaidinį ir naudojimo informaciją apie skaidinį disk_partitions: print ("[+] Partition Device:", skaidinys.įrenginys) spausdinti ("[+] Failų sistema:", skaidinys.fstype) print ("[+] Mountpoint:", skaidinys.mountpoint) disk_usage = psutil.disk_usage (skaidinys.prijungimo taškas) print ("[+] Bendra vietos diske:", baitų_į_GB (disko_naudojimas.viso), "GB") spausdinimas ("[+] laisvos vietos diske:", baitų_į_GB (disko_naudojimas.nemokamai), "GB") spausdinimas ("[+] panaudota vietos diske:", baitų_į_GB (disko_naudojimas.naudota), "GB") spausdinti ("[+] Naudota procentinė dalis:", disko_naudojimas.procentai, "%") # gauti skaitymo / rašymo statistiką, nes įkrovos disk_rw = psutil.disk_io_counters () print (f "[+] Iš viso perskaityta nuo įkrovos: bytes_to_GB (disk_rw.read_bytes) GB ") print (f" [+] Total Write sice boot: bytes_to_GB (disk_rw.write_bytes) GB ")

Kode pirmiausia importavome „psutil“ biblioteką, reikalingą disko informacijai rinkti. Tada mes jį panaudojome disk_partitions () funkciją, kad gautumėte galimų disko skaidinių sąrašą su jų informacija. Mes taip pat naudojame disk_usage () funkciją, kad gautume šių skaidinių naudojimą. Galiausiai mes naudojame disk_io_counters () funkciją, kad gautumėte bendrą disko skaitymo / rašymo laiką nuo įkrovos.  Čia yra išvesties pavyzdys.

Galite gauti kitą išvestį, priklausomai nuo disko ir skaidinių.

Tinklo informacija

Mes taip pat galime surinkti sistemos tinklo informaciją naudodamiesi „psutil“ biblioteka. Norėdami tai padaryti, nukopijuokite šį kodą į savo python IDE ir paleiskite jį.

# importuojant reikiamus modulius importuokite „psutil“ # rašydami funkciją, kad baitai būtų konvertuojami į gigabaitus def bytes_to_GB (baitai): gb = baitai / (1024 * 1024 * 1024) gb = apvalūs (gb, 2) grąžina gb # surenkant visas tinklo sąsajas ( virtualus ir fizinis) iš sistemos if_addrs = psutil.net_if_addrs () # spausdina kiekvienos tinklo sąsajos informaciją sąsajai_pavadinimas, sąsajos_adresai if_addrs.elementai (): adresui sąsajos_adresuose: spausdinti ("\ n") spausdinti (f "Sąsaja:", sąsajos_pavadinimas) if str (adresas.šeima) == 'AdresasŠeima.AF_INET ': spausdinti ("[+] IP adresas:", adresas.adresas) spausdinti ("[+] Netmask:", adresas.netmask) print ("[+] Broadcast IP:", adresas.transliacija) elif str (adresas.šeima) == 'AdresasŠeima.AF_PACKET ': spausdinti ("[+] MAC adresas:", adresas.adresas) spausdinti ("[+] Netmask:", adresas.netmask) print ("[+] Broadcast MAC:", adresas.# gauti tinklo skaitymo / rašymo statistiką nuo įkrovos spausdinimo ("\ n") net_io = psutil.net_io_counters () print ("[+] Iš viso išsiųstų baitų:", baitų_to_GB (net_io.bytes_sent)) print ("[+] Iš viso gautų baitų:", bytes_to_GB (net_io.bytes_recv))

Štai pavyzdys iš mano bandomojo kompiuterio.

Kita aparatinės įrangos informacija

Mes taip pat galime naudoti psutilas biblioteką, kad gautumėte kitos informacijos apie aparatinę įrangą, pvz akumuliatoriaus informacija, ventiliatorių sukimosi greitis, informacija apie įvairių prietaisų temperatūrą, ir pan. Pažiūrėkime, kaip tai galime padaryti po vieną.

Jei naudojate nešiojamąjį kompiuterį, galite naudoti psutilas.jutikliai_baterija () funkcija gauti informaciją apie akumuliatorių. Norėdami tai padaryti, nukopijuokite ir paleiskite šį kodą savo „Python IDE“.

importuoti psutil baterija = psutil.sensor_battery () print ("[+] Baterijos procentas:", apvalus (baterija.procentų, 1), "%") spausdinimo ("[+] Baterijos laikas liko:", apvalus (baterija.secsleft / 3600, 2), "hr") spausdinimas ("[+] Maitinimo kištukas:", akumuliatorius.maitinimas prijungtas)

Aukščiau pateiktame kode mes naudojame jutikliai_baterija () funkciją, kad gautumėte informaciją apie akumuliatorių, pvz., apie akumuliatoriaus procentą, likusį laiką, maitinimą išjungtą ar ne. Vykdydamas kodą savo mašinoje, gavau šį išvestį.

Mes taip pat galime naudoti „psutil“ biblioteką, kad gautume ventiliatoriaus RPM (apsisukimus per minutę), naudodami funkciją sensor_fan (), kol ventiliatorius veikia. Psutilį taip pat galima naudoti norint gauti įvairių prietaisų temperatūrą. Tai galime padaryti naudodami psutil funkciją sensor_temperatures (). Palieku tai padaryti jums praktikai.

Galutinis scenarijus

Dabar sujungkime visus kodus su galutinės programos kūrimu, kad surinktume visas sistemos ir aparatinės įrangos detales, kurias aptarėme. Galite nukopijuoti šią programą ir paleisti ją savo python IDE.

# reikalingų modulių importavimo platformos importavimas iš datos laiko importo datos laiko importo psutil import os # Pirmiausia išspausdinsime pagrindinę sistemos informaciją # naudodami platformos modulio spausdinimo ("\ n \ t \ t \ t Pagrindinės sistemos informacijos \ n") spausdinimo (" [+] Architektūra: ", platforma.architektūra () [0]) spausdinti ("[+] Mašina:", platforma.mašina ()) spausdinti ("[+] Operacinės sistemos leidimas:", platforma.release ()) print ("[+] Sistemos pavadinimas:", platforma.system ()) print ("[+] Operacinės sistemos versija:", platforma.version ()) print ("[+] Node:" + platforma.node ()) print ("[+] Platforma:", platforma.platforma ()) print ("[+] Procesorius:", platforma.procesorius ()) # „psutil“ bibliotekos naudojimas norint gauti sistemos įkrovos laiką boot_time = datetime.fromtimestamp (psutil.boot_time ()) print ("[+] System Boot Time:", boot_time) # gauti sistemos veikimo laiką iš "uptime" failo proc kataloge su atidarytu ("/ proc / uptime", "r") kaip f: uptime = f.skaityti ().padalinti ("") [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") # gauti visą šiuo metu vykdomų procesų skaičių pids = [] pakatalogiui OS.listdir ('/ proc'): jei pakatalogis.isdigit (): pids.pridėti (pakatalogį) spausdinti („Bendras procesų skaičius: 0“.formatas (len (pids))) # Parodomas procesoriaus informacijos spausdinimas ("\ n \ t \ t \ t procesoriaus informacija \ n") # Šis kodas išspausdins spausdintų procesoriaus branduolių skaičių ("[+] Fizinių duomenų skaičius šerdys: ", psutil.cpu_count (loginis = klaidingas)) print ("[+] Viso branduoliu skaicius:", psutil.cpu_count (logiškas = True)) print ("\ n") # Tai atspausdins maksimalų, mažiausią ir dabartinį procesoriaus dažnį cpu_frequency = psutil.cpu_freq () print (f "[+] Maksimalus dažnis: cpu_frequency.maks .:.2f Mhz ") spausdinimas (f" [+] Min dažnis: cpu_frequency.min .:.2f Mhz ") spausdinimas (f" [+] Dabartinis dažnis: cpu_frequency.srovė:.2f Mhz ") print (" \ n ") # Tai atspausdins procesoriaus naudojimą vienam branduoliui i, procentais suskaičiuota (psutil.cpu_percent (percpu = True, intervalas = 1)): spausdinti (f "[+] Centrinio procesoriaus naudojimas i: percent%") spausdinti (f "[+] Bendras procesoriaus naudojimas: psutil.cpu_percent ()% ") # skaitant cpuinfo failą, norint atspausdinti # esamo procesoriaus pavadinimą su open (" / proc / cpuinfo "," r ") kaip f: file_info = f.readlines () cpuinfo = [x.juosta ().split (":") [1] x failo informaciniame faile, jei indekso "modelio pavadinimas" x], elementas išvardytame (cpuinfo): print ("[+] Procesorius" + str (rodyklė) + ":" + elementas ) # rašyti funkciją, kad baitai būtų konvertuojami į GigaByte def bytes_to_GB (baitai): gb = baitai / (1024 * 1024 * 1024) gb = apvalus (gb, 2) grąžinti gb = psutilas.virtual_memory () print ("\ n \ t \ t \ t Atminties informacija \ n") #Tai išspausdins išsamią informaciją apie pagrindinę atmintį ("[+] Iš viso atminties:", baitų_to_GB (virtual_memory).iš viso), „Gb“) spausdinti („[+] Iš viso laisvos atminties:“, baitų_į_GB (virtualioji atmintis).galimas), „Gb“) spausdinimas („[+] Iš viso naudojama atmintis:“, baitų_į_GB (virtualioji atmintis.naudotas), „Gb“) spausdinti („[+] Naudota procentinė dalis:“, virtualioji atmintis.procentai, "%") print ("\ n") # Tai išspausdins išsamią apsikeitimo atminties informaciją, jei bus swap = psutil.swap_memory () print (f "[+] Visa apsikeitimo atmintis: bytes_to_GB (swap.viso) ") print (f" [+] Nemokama atminties keitimas: bytes_to_GB (swap.nemokamai) ") print (f" [+] Naudota keitimo atmintis: bytes_to_GB (swap.naudota) ") spausdinti (f" [+] Naudota procentinė dalis: sukeisti.procentai% ") # Atminties informacijos rinkimas iš spausdinimo iš meminfo failo (" \ nSkaitydamas / proc / meminfo failą: \ n ") su atidarytu (" / proc / meminfo "," r ") kaip f: lines = f.readlines () spausdinti ("[+]" + eilutės [0].juosta ()) spausdinti ("[+]" + eilutės [1].strip ()) # prieiga prie visų disko skaidinių disk_partitions = psutil.disk_partitions () print ("\ n \ t \ t \ t Disko informacija \ n") # rodanti skaidinio ir disko naudojimo informaciją disk_partitions: print ("[+] Partition Device:", skaidinys.įrenginys) spausdinti ("[+] Failų sistema:", skaidinys.fstype) print ("[+] Mountpoint:", skaidinys.mountpoint) disk_usage = psutil.disk_usage (skaidinys.prijungimo taškas) print ("[+] Bendra vietos diske:", baitų_į_GB (disko_naudojimas.viso), "GB") spausdinimas ("[+] laisvos vietos diske:", baitų_į_GB (disko_naudojimas.nemokamai), „GB“) spausdinti („[+] panaudota vietos diske:“, baitų_į_GB (disko_naudojimas).naudota), "GB") spausdinti ("[+] Naudota procentinė dalis:", disko_naudojimas.procentai, "%") # gauti skaitymo / rašymo statistiką, nes įkrovos disk_rw = psutil.disk_io_counters () print (f "[+] Iš viso perskaityta nuo įkrovos: bytes_to_GB (disk_rw.read_bytes) GB ") print (f" [+] Total Write sice boot: bytes_to_GB (disk_rw.write_bytes) GB ") # surinkti visas tinklo sąsajas (virtualias ir fizines) iš sistemos if_addrs = psutil.net_if_addrs () print ("\ n \ t \ t \ t Tinklo informacija \ n") # spausdina eah tinklo sąsajų informaciją sąsajai_pavadinimas, sąsajos_adresai if_addrs.elementai (): adresui sąsajos_adresuose: spausdinti (f „Sąsaja:“, sąsajos_vardas) if str (adresas.šeima) == 'AdresasŠeima.AF_INET ': spausdinti ("[+] IP adresas:", adresas.adresas) spausdinti ("[+] Netmask:", adresas.netmask) print ("[+] Broadcast IP:", adresas.transliacija) elif str (adresas.šeima) == 'AdresasŠeima.AF_PACKET ': spausdinti ("[+] MAC adresas:", adresas.adresas) spausdinti ("[+] Netmask:", adresas.netmask) print ("[+] Broadcast MAC:", adresas.# gauti tinklo skaitymo / rašymo statistiką nuo įkrovos net_io = psutil.net_io_counters () print ("[+] Iš viso išsiųstų baitų:", baitų_to_GB (net_io.bytes_sent)) print ("[+] Iš viso gautų baitų:", baitų_to_GB (net_io.bytes_recv)) # Informacijos apie akumuliatorių gavimas baterija = psutil.sensors_battery () print ("\ n \ t \ t \ t Baterijos informacija \ n") print ("[+] Baterijos procentas:", apvalus (baterija.procentų, 1), "%") spausdinimo ("[+] Baterijos laikas liko:", apvalus (baterija.secsleft / 3600, 2), "hr") spausdinimas ("[+] Maitinimo kištukas:", akumuliatorius.maitinimas prijungtas)

Vykdydami šį kodą gausime šią išvestį.

Jei norite patobulinti programą arba atsisiųsti kodą, galite tai padaryti iš mano „Github“ puslapio.

Išvada

Tai yra visa pamoka apie įdomios sistemos ir aparatinės įrangos informacijos rinkimą naudojant pitoną. Jei turite kokių nors problemų su kodo kopijavimu, visą šaltinio kodą taip pat galite rasti mano „Github“ repo. Taip pat galite pamatyti mūsų darbo su „Python“ operacine sistema vadovą, norėdami sužinoti daugiau įdomių „python“ patobulinimų.