Phenquestions
Att hitta maskinvara och systeminformation i Linux är en praktisk och intressant uppgift. Vi kan extrahera operativsystemdetaljer, användardetaljer, minnesinformation, CPU-detaljer och mycket mer med enkla pythonkoder på Linux. Även om vi kan utföra många av dessa saker med terminal- och bash-skript, är python mycket mer intressant.
Som en pythonälskare vill vi att varje uppgift ska göras med det språket, så att extrahera system- och hårdvaruinformation med python är en fantastisk uppgift. Vi kan också lära oss både Linux och python samtidigt. Den här artikeln kommer att vara ganska lång, så ta dig tid att läsa hela artikeln och köra varje kod för bättre förståelse.
Du kan kopiera var och en av koderna i en python IDE och köra den. Om du inte har en python IDE eller vill jämföra mellan IDE, se vår guide på topp 10 IDE för Linux. Förresten använder jag VS-koden som IDE för att skriva kod. Det är öppen källkod och lätt att använda. Om du vill använda Visual Studio-kod, se vår guide om installation av VS-kod på Linux.
Extrahera systeminformation med Python
I den här artikeln kommer vi att utveckla ett program som extraherar följande detaljer:
- Grundläggande systemdetaljer
- CPU-detaljer
- Minnesinformation
- Diskanvändning
- Nätverksinformation
- Övrig hårdvaruinformation
För att få dessa detaljer ska vi använda modulerna i Python-standardbiblioteket. Några av de moduler vi kommer att använda är OS, plattform osv. Jag har också lagt källkoden i Github; Du kan se en demo av programmet genom att ladda ner från mitt Github-arkiv och köra det.
För att följa denna handledning rekommenderas att den senaste pythonversionen är installerad i ditt system. Du kan följa vår guide för installation av python på Linux.
Krav
Många av de bibliotek vi använder i den här självstudien finns i python-standardbiblioteket. Vi behöver bara installera paketet psutil. Du kan kontrollera det genom att importera det. Om du inte har installerat psutil kan du enkelt installera det med pip-verktyget. För att installera pip i vårt system måste vi köra följande kommando i terminalen.
pip installera psutil
Få grundläggande systeminformation
Nu när du har installerat psutil, låt oss se hur man använder den för att samla operativsystem med python. Vi använde plattform modul som finns i pythons standardbibliotek för att samla in denna grundläggande systeminformation. Du måste kopiera följande kod i din favorit python IDE och köra den.
# importera de nödvändiga modulerna importplattform # skriva ut arkitekturen för OS-utskriften ("[+] Architecture:", plattform.arkitektur () [0]) # Visar maskinutskrift ("[+] Maskin:", plattform.maskin ()) # utskrift av operativsystemets utgivningsinformation ("[+] Operativsystemutgåva:", plattform.release ()) # skriver ut det systemnamn som för närvarande skrivs ut ("[+] Systemnamn:", plattform.system ()) # Denna rad skriver ut versionen av ditt operativsystems utskrift ("[+] Version av operativsystem:", plattform.version ()) # Detta skriver ut noden eller värdnamnet för ditt operativsystems utskrift ("[+] nod:" + plattform.node ()) # Detta skriver ut din systemplattformsutskrift ("[+] Platform:", platform.platform ()) # Detta skriver ut processorinformationsutskriften ("[+] Processor:", plattform.processor ())I ovanstående kod importerade vi först plattformsmodulen som finns i python-standardbiblioteket. Efter att ha importerat modulen använder vi plattformsmodulens funktioner för att få den information som krävs. När jag körde koden på min enhet fick jag följande utdata.
Som vi kan se i utdata visar programmet många viktiga detaljer om operativsystemet som systemarkitektur, plattform och mycket mer.
System Uptime
Vi kan också få systemstarttiden och systemets driftstid i python. Vi måste använda psutil bibliotek som vi har installerat tidigare. Vi kan få systemets driftstid genom att läsa upptidstiden i proc-katalogen i Linux.
Kopiera följande kod i din favorit python IDE och kör den.
från datetime-import datetime-import psutil # Använda psutil-biblioteket för att få starttiden för systemets starttid = datetime.fromtimestamp (psutil.starttid ()) utskrift ("[+] Systemstarttid:", starttid) Den här koden skriver ut starttiden, vilket betyder den tid då systemet startades. När jag körde programmet på min dator fick jag följande utdata.
Vi kan också se systemets driftstid, vilket är den tid som systemet körs. Vi måste läsa proc-katalogens drifttidsfil, som visas i koden nedan.
# få systemet upp tid från uptime-filen i proc-katalogen med open ("/ proc / uptime", "r") som f: uptime = f.läsa().split ("") [0].strip () uptime = int (float (uptime)) uptime_hours = uptime // 3600 uptime_minutes = (uptime% 3600) // 60 print ("[+] System Uptime:" + str (uptime_hours) + ":" + str ( upptid_minuter) + "timmar")Jag har följande utdata när jag kör koden.
Processer
Vi kan också använda python för att få en lista över processer som körs, totalt antal processer. Vi måste köra följande kod.
importera os pids = [] för undermapp i os.listdir ('/ proc'): om subdir.isdigit (): pids.lägg till (underkatalog) utskrift ('Totalt antal processer: 0'.format (len (pids))) När jag körde koden fick jag utdata, som visas i bilden nedan.
användar information
Vi kan också få en lista över alla användare som finns i vår Linux-enhet med hjälp av pwd-biblioteket som finns i python-standardbiblioteket. För att göra detta måste du kopiera följande kod i din python IDE och köra den.
importera pwd-användare = pwd.getpwall () för användare i användare: skriv ut (användare.pw_name, användare.pw_shell)
När du kör ovanstående kod får du alla användare närvarande i din enhet och deras skal.
CPU-information
Vi har samlat in systemdetaljerna nu för att samla in lite information om CPU: n som används av vår maskin. Vi kan samla in CPU-information från vår Linux-maskin på två sätt. Det första och enklaste sättet är att använda psutil modul och det andra sättet är att läsa filen / proc / cpuinfo.
Låt oss se hur vi kan använda psutil-biblioteket för att få CPU-information. Du måste kopiera följande kod till din favorit python IDE och köra den.
# importera de nödvändiga paketen importera psutil # Den här koden kommer att skriva ut antalet CPU-kärnor som är närvarande ("[+] Antal fysiska kärnor:", psutil.cpu_count (logical = False)) print ("[+] Antal kärnor totalt:", psutil.cpu_count (logical = True)) print ("\ n") # Detta skriver ut den maximala, minimala och nuvarande CPU-frekvensen cpu_frequency = psutil.cpu_freq () tryck (f "[+] Max frekvens: cpu_frequency.max:.2f Mhz ") utskrift (f" [+] Min frekvens: cpu_frequency.min:.2f Mhz ") tryck (f" [+] Aktuell frekvens: cpu_frequency.nuvarande:.2f Mhz ") utskrift (" \ n ") # Detta skriver ut användningen av CPU per kärna för i, procent i räknat (psutil.cpu_percent (percpu = True, interval = 1)): print (f "[+] CPU-användning av Core i: percentage%") print (f "[+] Total CPU-användning: psutil.cpu_percent ()% ")Låt oss se vad som händer i ovanstående program. I första raden importerade vi psutil modul som hjälper till att samla in CPU-detaljerna. I andra och tredje raden använder vi cpu_count () funktion av psutil modul för att räkna antalet CPU-kärnor. Sedan använde vi cpu_freq () -funktionen för att få max-, min- och strömfrekvensen. Äntligen använder vi cpu_percent-funktionen fo psutil för att hitta CPU-användningen. När jag körde koden i min maskin fick jag följande utdata.
Som vi kan se i utgången att alla CPU-detaljer har skickats ut av programmet i terminalen. Vi kan också få namnet på CPU: n genom att läsa filen / proc / cpuinfo med hjälp av python. För att göra detta måste vi köra följande kod.
# läser cpuinfo-filen för att skriva ut namnet på den CPU som finns med öppen ("/ proc / cpuinfo", "r") som f: file_info = f.readlines () cpuinfo = [x.remsa().split (":") [1] för x i file_info om "modellnamn" i x] för index, objekt i enumerate (cpuinfo): print ("[+] Processor" + str (index) + ":" + item )Vi kan också samla in annan CPU-information med filen / proc / cpuinfo. Jag läste bara CPU-modellnamnet, men du kan öppna filen och se den andra informationen som finns i filen och kan använda dem i programmet. Här är resultatet.
Låt oss samla in lite information om minne med python.
Minnesinformation
Liksom CPU-informationen kan vi också få minnesinformation från två platser. En använder psutil-verktyget, och den andra är genom att läsa proc / meminfo-filen. Till att börja med, låt oss börja samla in minnesinformation med psutil-biblioteket. Kopiera följande kod till din favorit python IDE och kör den.
# importera de nödvändiga modulerna importera psutil # skriva en funktion för att konvertera byte till GigaByte def bytes_to_GB (bytes): gb = bytes / (1024 * 1024 * 1024) gb = rund (gb, 2) returnera gb # Använda funktionen virtual_memory () det returnerar en tuple virtual_memory = psutil.virtual_memory () # Detta kommer att skriva ut den primära minnesinformationens utskrift ("[+] Totalt minne närvarande:", bytes_to_GB (virtual_memory.totalt), "Gb") print ("[+] Totalt tillgängligt minne:", bytes_to_GB (virtual_memory.tillgängligt), "Gb") print ("[+] Totalt minne som används:", bytes_to_GB (virtual_memory.used), "Gb") print ("[+] Procentandel som används:", virtual_memory.procent, "%") utskrift ("\ n") # Detta kommer att skriva ut bytesminnesinformation om tillgänglig swap = psutil.swap_memory () print (f "[+] Totalt swap-minne: bytes_to_GB (swap).totalt) ") skriv ut (f" [+] Gratis swap-minne: bytes_to_GB (swap.gratis) ") print (f" [+] Användt bytminne: bytes_to_GB (swap.används) ") print (f" [+] Procentandel som används: swap.procent%")Låt oss se vad som händer i ovanstående kod. På första raden importerade vi psutil-biblioteket och använde sedan dess virtual_memory () -funktion, som returnerar en tupel med information om virtuellt minne. Sedan använder vi swap_memory () -funktionen för att få information om swap-minnet. Vi byggde också ett funktionsnamn bytes_to_GB (), som kommer att konvertera bytes till GigaBytes för bättre läsbarhet. Jag fick följande resultat.
Vi kan också använda meminfo-filen som finns i Linux proc-katalog för att hämta minnesinformation som totalt minne, använt minne osv. För att göra detta, kör följande kod.
# Samla in minnesinformation från meminfo-filutskrift ("\ nLäs / proc / meminfo-filen: \ n") med öppen ("/ proc / meminfo", "r") som f: linjer = f.readlines () print ("[+]" + rader [0].strip ()) print ("[+]" + rader [1].remsa())Och här är resultatet:
Diskinformation
Hittills har vi sett några grundläggande systemdetaljer, CPU-detaljer, minnesdetaljer. Låt oss nu se informationen om disken som finns i vår maskin. För att extrahera diskinformation använder vi psutil-modulen för att göra vår uppgift enkel och vi behöver inte uppfinna hjulet på nytt. Titta på koden nedan för att se ett fungerande exempel på koden. Du kan kopiera koden och köra i din favorit pythons IDE.
# importera obligatoriska moduler importera psutil # åtkomst till alla diskpartitioner disk_partitions = psutil.disk_partitions () # skriver en funktion för att konvertera byte till Giga byte def bytes_to_GB (bytes): gb = bytes / (1024 * 1024 * 1024) gb = rund (gb, 2) returnera gb # som visar partitions- och användningsinformation för partition i disk_partitions: print ("[+] Partition Device:", partition.enhet) skriv ut ("[+] File System:", partition.fstype) print ("[+] Mountpoint:", partition.mountpoint) disk_usage = psutil.disk_usage (partition.mountpoint) print ("[+] Total Disk Space:", bytes_to_GB (disk_användning).totalt), "GB") utskrift ("[+] Ledigt diskutrymme:", bytes_to_GB (disk_användning).gratis), "GB") utskrift ("[+] Användt diskutrymme:", bytes_to_GB (disk_användning).används), "GB") tryck ("[+] Procentandel som används:", disk_användning.procent, "%") # få läs / skriv-statistik sedan start disk_rw = psutil.disk_io_counters () skriv ut (f "[+] Totalt läst sedan start: bytes_to_GB (disk_rw.read_bytes) GB ") utskrift (f" [+] Totalt skrivstartsstart: bytes_to_GB (disk_rw.skriv_bytes) GB ") I koden har vi först importerat psutil-biblioteket, vilket krävs för att samla in diskinformation. Sedan använde vi dess disk_partitions () funktion för att få listan över diskpartitioner tillgängliga med deras information. Vi använder också funktionen disk_usage () för att få användning av dessa partitioner. Slutligen använder vi disk_io_counters () funktion för att få skivans totala läsning / skrivning sedan start. Här är ett exempel på utdata.
Du kan få lite annan utdata beroende på din disk och partitioner.
Nätverksinformation
Vi kan också samla in nätverksinformation för systemet med psutil-biblioteket. För att göra det, kopiera följande kod till din python IDE och kör den.
# importera nödvändiga moduler importera psutil # skriva en funktion för att konvertera bytes till gigabyte def bytes_to_GB (bytes): gb = bytes / (1024 * 1024 * 1024) gb = rund (gb, 2) returnera gb # samla alla nätverksgränssnitt virtuellt och fysiskt) från systemet if_addrs = psutil.net_if_addrs () # skriver ut informationen för varje nätverksgränssnitt för gränssnittsnamn, gränssnittsadresser i if_addrs.objekt (): för adress i gränssnittsadresser: skriv ut ("\ n") skriv ut (f "Gränssnitt:", gränssnittsnamn) om str (adress.familj) == 'Adressfamilj.AF_INET ': skriv ut ("[+] IP-adress:", adress.adress) skriv ut ("[+] nätmask:", adress.netmask) print ("[+] Broadcast IP:", adress.sändning) elif str (adress.familj) == 'Adressfamilj.AF_PACKET ': skriv ut ("[+] MAC-adress:", adress.adress) skriv ut ("[+] nätmask:", adress.netmask) print ("[+] Broadcast MAC:", adress.sändning) # få läs- / skrivstatistik för nätverket sedan startutskrift ("\ n") net_io = psutil.net_io_counters () skriver ut ("[+] Totalt antal byten skickade:", bytes_to_GB (net_io.bytes_sent)) print ("[+] Totalt antal mottagna byte:", bytes_to_GB (net_io.bytes_recv))Här är ett exempel på min testdator.
Annan hårdvaruinformation
Vi kan också använda psutil bibliotek för att få annan hårdvaruinformation som batteriinformation, fläkters rotationshastighet, olika enhets temperaturinformation, etc. Låt oss se hur vi kan göra detta en efter en.
Om du använder en bärbar dator kan du använda psutil.sensors_battery () för att få information om batteriet. För att göra det, kopiera och kör följande kod i din Python IDE.
importera psutil-batteri = psutil.sensors_battery () print ("[+] Batteriprocent:", rund (batteri.procent, 1), "%") utskrift ("[+] Batteritid kvar:", rund (batteri.secsleft / 3600, 2), "hr") print ("[+] Power Plugged:", batteri.power_plugged) I ovanstående kod använder vi sensors_battery () funktion för att få information om batteriet, t.ex. batteriprocent, återstående tid, strömförsörjning eller inte. När jag körde koden i min maskin fick jag följande utdata.
Vi kan också använda psutil-biblioteket för att få fläktens varvtal (varv per minut) med funktionen sensors_fan () medan fläkten är igång. Psutilen kan också användas för att få temperaturen på olika enheter. Vi kan göra det med hjälp av sensor_temperatures () -funktionen i psutil. Jag låter detta göras av dig för träning.
Sista skriptet
Låt oss nu kombinera alla koder med att bygga ett slutligt program för att samla alla system- och hårdvaruuppgifter som vi diskuterade. Du kan kopiera följande program och köra det i din python IDE.
# importera de nödvändiga modulerna importplattform från datetime import datetime import psutil import os # Först kommer vi att skriva ut den grundläggande systeminformationen # med plattformsmodulen skriva ut ("\ n \ t \ t \ t Grundläggande systeminformation \ n") utskrift (" [+] Arkitektur: ", plattform.arkitektur () [0]) tryck ("[+] Maskin:", plattform.maskin ()) print ("[+] Operativsystem Release:", plattform.release ()) print ("[+] Systemnamn:", plattform.system ()) print ("[+] Version av operativsystem:", plattform.version ()) print ("[+] Nod:" + plattform.node ()) print ("[+] Platform:", platform.plattform ()) print ("[+] Processor:", plattform.processor ()) # Använda psutil-biblioteket för att få starttiden för systemet boot_time = datetime.fromtimestamp (psutil.boot_time ()) print ("[+] System Boot Time:", boot_time) # får systemet upp tid från uptime-filen i proc-katalogen med öppen ("/ proc / uptime", "r") som f: uptime = f.läsa().split ("") [0].strip () uptime = int (float (uptime)) uptime_hours = uptime // 3600 uptime_minutes = (uptime% 3600) // 60 print ("[+] System Uptime:" + str (uptime_hours) + ":" + str ( uptime_minutes) + "timmar") # får det totala antalet processer som för närvarande kör pids = [] för subdir in OS.listdir ('/ proc'): om subdir.isdigit (): pids.lägg till (underkatalog) utskrift ('Totalt antal processer: 0'.format (len (pids))) # Visar CPU-informationsutskrift ("\ n \ t \ t \ t CPU-information \ n") # Den här koden kommer att skriva ut antalet CPU-kärnor som skrivs ut ("[+] Antal fysiska kärnor: ", psutil.cpu_count (logical = False)) print ("[+] Antal kärnor totalt:", psutil.cpu_count (logical = True)) print ("\ n") # Detta skriver ut den maximala, minimala och nuvarande CPU-frekvensen cpu_frequency = psutil.cpu_freq () tryck (f "[+] Max frekvens: cpu_frequency.max:.2f Mhz ") utskrift (f" [+] Min frekvens: cpu_frequency.min:.2f Mhz ") tryck (f" [+] Aktuell frekvens: cpu_frequency.nuvarande:.2f Mhz ") utskrift (" \ n ") # Detta skriver ut användningen av CPU per kärna för i, procent i räknat (psutil.cpu_percent (percpu = True, interval = 1)): print (f "[+] CPU-användning av kärna i: percentage%") print (f "[+] Total CPU-användning: psutil.cpu_percent ()% ") # läser cpuinfo-filen för att skriva ut namnet på den CPU som finns med öppen (" / proc / cpuinfo "," r ") som f: file_info = f.readlines () cpuinfo = [x.remsa().split (":") [1] för x i file_info om "modellnamn" i x] för index, objekt i enumerate (cpuinfo): print ("[+] Processor" + str (index) + ":" + item ) # att skriva en funktion för att konvertera byte till GigaByte def bytes_to_GB (bytes): gb = bytes / (1024 * 1024 * 1024) gb = rund (gb, 2) returnera gb # Med funktionen virtual_memory () kommer den att returnera en virtuell minnesupplösning = psutil.virtual_memory () print ("\ n \ t \ t \ t Memory Information \ n") # Detta kommer att skriva ut den primära minnesinformationens utskrift ("[+] Totalt minne närvarande:", bytes_to_GB (virtual_memory.totalt), "Gb") print ("[+] Totalt tillgängligt minne:", bytes_to_GB (virtual_memory.tillgängligt), "Gb") print ("[+] Totalt minne som används:", bytes_to_GB (virtual_memory.used), "Gb") print ("[+] Procentandel som används:", virtual_memory.procent, "%") utskrift ("\ n") # Detta kommer att skriva ut bytesminnesinformation om tillgänglig swap = psutil.swap_memory () print (f "[+] Totalt swap-minne: bytes_to_GB (swap).totalt) ") skriv ut (f" [+] Gratis swap-minne: bytes_to_GB (swap.gratis) ") print (f" [+] Användt bytminne: bytes_to_GB (swap.används) ") print (f" [+] Procentandel som används: swap.procent% ") # Samla in minnesinformation från meminfo-filutskrift (" \ nLäs / proc / meminfo-filen: \ n ") med öppen (" / proc / meminfo "," r ") som f: linjer = f.readlines () print ("[+]" + rader [0].strip ()) print ("[+]" + rader [1].strip ()) # åtkomst till alla diskpartitioner disk_partitions = psutil.disk_partitions () print ("\ n \ t \ t \ t Diskinformation \ n") # visar partitions- och användningsinformation för partition i disk_partitions: print ("[+] Partition Device:", partition.enhet) skriv ut ("[+] File System:", partition.fstype) print ("[+] Mountpoint:", partition.mountpoint) disk_usage = psutil.disk_usage (partition.mountpoint) print ("[+] Total Disk Space:", bytes_to_GB (disk_användning).totalt), "GB") utskrift ("[+] Ledigt diskutrymme:", bytes_to_GB (disk_användning).gratis), "GB") utskrift ("[+] Användt diskutrymme:", bytes_to_GB (disk_användning).används), "GB") utskrift ("[+] Användningsprocent:", disk_användning.procent, "%") # få läs / skriv-statistik sedan start disk_rw = psutil.disk_io_counters () skriv ut (f "[+] Totalt läst sedan start: bytes_to_GB (disk_rw.read_bytes) GB ") utskrift (f" [+] Totalt skrivstartsstart: bytes_to_GB (disk_rw.write_bytes) GB ") # samlar alla nätverksgränssnitt (virtuella och fysiska) från systemet if_addrs = psutil.net_if_addrs () print ("\ n \ t \ t \ t Network Information \ n") # utskrift av information om eah-nätverksgränssnitt för gränssnittsnamn, gränssnittsadresser i if_addrs.objekt (): för adress i gränssnittsadresser: skriv ut (f "Gränssnitt:", gränssnittsnamn) om str (adress.familj) == 'Adressfamilj.AF_INET ': skriv ut ("[+] IP-adress:", adress.adress) skriv ut ("[+] nätmask:", adress.netmask) print ("[+] Broadcast IP:", adress.sändning) elif str (adress.familj) == 'Adressfamilj.AF_PACKET ': skriv ut ("[+] MAC-adress:", adress.adress) skriv ut ("[+] nätmask:", adress.netmask) print ("[+] Broadcast MAC:", adress.sändning) # får läs / skriv-statistiken för nätverket sedan start net_io = psutil.net_io_counters () skriver ut ("[+] Totalt antal byten skickade:", bytes_to_GB (net_io.bytes_sent)) print ("[+] Totalt antal mottagna byte:", bytes_to_GB (net_io.bytes_recv)) # Få batteriet Information batteri = psutil.sensors_battery () print ("\ n \ t \ t \ t Battery Information \ n") print ("[+] Battery Procent:", rund (batteri.procent, 1), "%") utskrift ("[+] Batteritid kvar:", rund (batteri.secsleft / 3600, 2), "hr") print ("[+] Power Plugged:", batteri.power_plugged) När vi kör den här koden får vi följande utdata.
Om du vill förbättra programmet eller vill ladda ner koden kan du göra det från min Github-sida.
Slutsats
Det här är den fullständiga guiden för att samla in intressant system- och hårdvaruinformation med python. Om du har några problem med att kopiera koden kan du också hitta hela källkoden i min Github-repo. Du kanske också vill se vår guide om att arbeta med operativsystem i python för några mer intressanta python-tweaks.
