In diesem Artikel untersuchen wir die Verwendung von Python-Programmiersprachentools zum Abrufen verschiedener Informationen auf Linux-Systemen. Lass uns gehen.
Wenn ich mich auf Python beziehe, beziehe ich mich auf CPython 2 (genauer gesagt auf 2.7). Ich werde ausdrücklich darauf hinweisen, dass derselbe Code nicht auf CPython 3 (3.3) funktioniert, und einen Hinweis geben, in dem der Unterschied erläutert wird. Bitte stellen Sie sicher, dass Sie CPython installiert haben, geben Sie python oder python3 auf dem Terminal ein und drücken Sie die Eingabetaste. Anschließend sollte die Python-Eingabeaufforderung (Eingabeaufforderung) auf dem Terminal angezeigt werden.
Bitte beachten Sie, dass alle Programme #!/usr/bin/env/python in der ersten Zeile haben, das heißt, wir möchten, dass der Python-Interpreter diese Skripte ausführt. Wenn Sie also möchten, dass Ihr Skript ausführbar ist, verwenden Sie chmod +x your-script.py und Sie können es mit ./your-script.py ausführen (Sie werden dies in diesem Artikel sehen)
Das Plattformmodul befindet sich in der Standardbibliothek und verfügt über viele Funktionen, die es uns ermöglichen, zahlreiche Systeminformationen zu erhalten. Lassen Sie uns den Python-Interpreter ausführen, um einige davon zu erkunden, beginnend mit der Funktion platform.uname():
>>> import platform >>> platform.uname() ('Linux', 'fedora.echorand', '3.7.4-204.fc18.x86_64', '#1 SMP Wed Jan 23 16:44:29 UTC 2013', 'x86_64')
Wenn Sie den Befehl uname unter Linux bereits kennen, werden Sie erkennen, dass es sich bei dieser Funktion um eine Schnittstelle zu diesem Befehl handelt. Unter Python 2 wird ein Tupel zurückgegeben, das Systemtyp (oder Kernelversion), Hostnamen, Version, Release-Version, Maschinenhardware und Prozessorinformationen enthält. Sie können über Indizes auf einzelne Eigenschaften zugreifen, etwa so:
>>> platform.uname()[0] 'Linux'
Unter Python 3 gibt diese Funktion ein benanntes Tupel zurück:
>>> platform.uname() uname_result(system='Linux', node='fedora.echorand', release='3.7.4-204.fc18.x86_64', version='#1 SMP Wed Jan 23 16:44:29 UTC 2013', machine='x86_64', processor='x86_64')
Da das zurückgegebene Ergebnis ein benanntes Tupel ist, ist es möglich, bestimmte Eigenschaften einfach anhand des Namens anzugeben, anstatt sich den Index merken zu müssen, wie folgt:
>>> platform.uname().system 'Linux'
Das Plattformmodul verfügt auch über direkte Schnittstellen zu einigen der oben genannten Attribute, wie zum Beispiel:
>>> platform.system() 'Linux' >>> platform.release() '3.7.4-204.fc18.x86_64'
Die Funktion linux_distribution() gibt detaillierte Informationen über die Version der Linux-Distribution zurück, in der Sie sich befinden. Auf einem Fedora 18-System gibt dieser Befehl beispielsweise die folgenden Informationen zurück:
>>> platform.linux_distribution() ('Fedora', '18', 'Spherical Cow')
Dieses Rückgabeergebnis enthält Tupel aus Versionsfreigabename, Version und Codename. Unterstützte Distributionen für eine bestimmte Python-Version können über den in _supported_dists angezeigten Wert abgerufen werden.
>>> platform._supported_dists ('SuSE', 'debian', 'fedora', 'redhat', 'centos', 'mandrake', 'mandriva', 'rocks', 'slackware', 'yellowdog', 'gentoo', 'UnitedLinux', 'turbolinux')
Wenn Ihre Linux-Distribution nicht darunter ist (oder eines ihrer Derivate). Dann rufen Sie wahrscheinlich die obige Funktion auf und sehen keine nützlichen Informationen.
Als letzte Funktion des Plattformmoduls werden wir uns die Funktion architect() ansehen. Wenn Sie diese Funktion ohne Argumente aufrufen, gibt sie ein Tupel zurück, das die Architekturbits und das ausführbare Python-Format enthält, etwa so:
>>> platform.architecture() ('64bit', 'ELF')
Auf einem 32-Bit-System sehen Sie:
>>> platform.architecture() ('32bit', 'ELF')
Wenn Sie eine andere ausführbare Datei auf dem System angeben, erhalten Sie ähnliche Ergebnisse wie dieses:
>>> platform.architecture(executable='/usr/bin/ls') ('64bit', 'ELF')
Wir empfehlen Ihnen, neben diesen auch die anderen Funktionen des Plattformmoduls zu erkunden, um herauszufinden, welche Version von Python Sie derzeit verwenden. Wenn Sie wissen möchten, wie dieses Modul diese Informationen erhält, können Sie sich die Datei Lib/platform.py im Python-Quellverzeichnis ansehen.
Die Module os und sys können auch einige Systemeigenschaften erhalten, z. B. natives Endianness. Als nächstes gehen wir über die Python-Standardbibliotheksmodule hinaus und untersuchen einige Dinge, die den Zugriff auf Informationen in Linux-Systemen über die Dateisysteme proc und sysfs ermöglichen. Beachten Sie, dass der Zugriff auf Informationen über das Dateisystem je nach Hardwarearchitektur unterschiedlich ist. Denken Sie also beim Lesen dieses Artikels oder beim Schreiben von Skripten immer daran, dass Sie versuchen können, Informationen aus diesen Dateien abzurufen.
Die Datei /proc/cpuinfo enthält Informationen über die Prozessoreinheiten Ihres Systems. Hier ist zum Beispiel, was die Python-Version des Linux-Befehls cat /proc/cpuinfo tut:
#! /usr/bin/env python
""" print out the /proc/cpuinfo
file
"""
from __future__ import print_function
with open('/proc/cpuinfo') as f:
for line in f:
print(line.rstrip('\n'))Wenn Sie dieses Programm mit Python 2 oder Python 3 ausführen, sehen Sie den gesamten Inhalt von /proc/cpuinfo auf dem Bildschirm (im obigen Programm wird die Methode rstrip() verwendet, um das Zeilenumbruchzeichen am Ende jeder Zeile zu entfernen). )
Der folgende Code veranschaulicht, wie Sie mit der String-Methode startwith() den Modus Ihrer Prozessoreinheit anzeigen.
#! /usr/bin/env python
""" Print the model of your
processing units
"""
from __future__ import print_function
with open('/proc/cpuinfo') as f:
for line in f:
# Ignore the blank line separating the information between
# details about two processing units
if line.strip():
if line.rstrip('\n').startswith('model name'):
model_name = line.rstrip('\n').split(':')[1]
print(model_name)Wenn Sie dieses Programm ausführen, sollten Sie den Modusnamen für jede Ihrer Prozessoreinheiten sehen. Folgendes sehe ich zum Beispiel auf meinem Computer.
Intel(R) Core(TM) i7-3520M CPU @ 2.90GHz Intel(R) Core(TM) i7-3520M CPU @ 2.90GHz Intel(R) Core(TM) i7-3520M CPU @ 2.90GHz Intel(R) Core(TM) i7-3520M CPU @ 2.90GHz
Bisher hatten wir zwei Möglichkeiten, die Architektur des von uns verwendeten Systems herauszufinden. Technisch gesehen korrekt, melden beide Methoden tatsächlich die Kernel-Architektur, auf der Ihr System läuft. Wenn Ihr Computer also 64-Bit ist, aber einen 32-Bit-Kernel ausführt, wird bei der oben genannten Methode immer noch „Für 32-Bit-Architektur“ angezeigt. Sie können die tatsächliche Architektur Ihres Computers ermitteln, indem Sie unter den in /proc/cpuinfo aufgeführten Flags nach dem lm-Flag suchen. Das lm-Flag stellt den Langmodus dar und wird nur auf 64-Bit-Architekturen angezeigt. Das folgende Verfahren zeigt Ihnen, wie es geht:
#! /usr/bin/env python
""" Find the real bit architecture
"""
from __future__ import print_function
with open('/proc/cpuinfo') as f:
for line in f:
# Ignore the blank line separating the information between
# details about two processing units
if line.strip():
if line.rstrip('\n').startswith('flags') \
or line.rstrip('\n').startswith('Features'):
if 'lm' in line.rstrip('\n').split():
print('64-bit')
else:
print('32-bit')如我们所看到那样，读取/proc/cpuinfo文件以及使用简单文本处理技术就可以获得我们要查找的数据是可能的。为了给其他程序更好的使用这些数据，一个更好的主意就是使/proc/cpuinfo的内容成为标准的数据结构，譬如字典(dictionary)。这个注意很简单：如果你查看这个文件的内容，你就会发现对于每个处理器单元，都有好些键值对(在先前的例子中，我们打印了每个处理器的模型名，即模型名就是关键字)。不同的处理器 单元的信息可以使用空白行隔开。构造一个字典数据结构包含每个处理器单元的关键字是很简单的。对于每个关键字，对于处理器单元的值都在/proc/cpuinfo文件中。下面的代码将会指导你怎么做。
#!/usr/bin/env/ python
"""
/proc/cpuinfo as a Python dict
"""
from __future__ import print_function
from collections import OrderedDict
import pprint
def cpuinfo():
''' Return the information in /proc/cpuinfo
as a dictionary in the following format:
cpu_info['proc0']={...}
cpu_info['proc1']={...}
'''
cpuinfo=OrderedDict()
procinfo=OrderedDict()
nprocs = 0
with open('/proc/cpuinfo') as f:
for line in f:
if not line.strip():
# end of one processor
cpuinfo['proc%s' % nprocs] = procinfo
nprocs=nprocs+1
# Reset
procinfo=OrderedDict()
else:
if len(line.split(':')) == 2:
procinfo[line.split(':')[0].strip()] = line.split(':')[1].strip()
else:
procinfo[line.split(':')[0].strip()] = ''
return cpuinfo
if __name__=='__main__':
cpuinfo = cpuinfo()
for processor in cpuinfo.keys():
print(cpuinfo[processor]['model name'])这段代码中使用了OrderedDict(有序字典)而不是常规的字典，能够使用键值有序的存储在文件里。所以，第一个处理器单元的数据之后就是第二个处理器单元的数据，以此类推。你可以使用过滤器来过滤你所查找的信息（如同在if __name__ == '__main__'块中演示的那样）。上面的程序每次执行后都会打印每个处理器单元的模型名（如通过cpuinfo[processor]['model name']语句表明的那样）
Intel(R) Core(TM) i7-3520M CPU @ 2.90GHz Intel(R) Core(TM) i7-3520M CPU @ 2.90GHz Intel(R) Core(TM) i7-3520M CPU @ 2.90GHz Intel(R) Core(TM) i7-3520M CPU @ 2.90GHz
和/proc/cpuinfo相似，文件/proc/meminfo包含了你电脑的主存的信息。下面的这个程序创建了一个使用这个文件的内容填充的字典。
#!/usr/bin/env python
from __future__ import print_function
from collections import OrderedDict
def meminfo():
''' Return the information in /proc/meminfo
as a dictionary '''
meminfo=OrderedDict()
with open('/proc/meminfo') as f:
for line in f:
meminfo[line.split(':')[0]] = line.split(':')[1].strip()
return meminfo
if __name__=='__main__':
#print(meminfo())
meminfo = meminfo()
print('Total memory: {0}'.format(meminfo['MemTotal']))
print('Free memory: {0}'.format(meminfo['MemFree']))像先前的，通过它的关键字，你可以访问任何你查询的指定信息(在if __name__==__main__块中有所表示)。当你执行这个程序，你该会看到像下面类似的输出：
Total memory: 7897012 kB Free memory: 249508 kB
接下来，我们会探索我们电脑系统的网络设备。我们将会获得系统的网络接口，以及当系统重启之后通过它们数据发送和接受数据的信息。 /proc/net/dev文件让这些信息可用。如果你检查了这个文件的内容，你就会注意到头一两行包含了头信息等等，这个文件第一列是网络接口名，第二和第三列显示了接收和发送的字节数信息（例如总发送字节数，包数，错误等等）。这里我们所感兴趣的就是他哦难过不同的网络设备提取出总发送数据和接收数据。下面的代码展示了怎么从/proc/net/dev文件中提取出这些信息。
#!/usr/bin/env python
from __future__ import print_function
from collections import namedtuple
def netdevs():
''' RX and TX bytes for each of the network devices '''
with open('/proc/net/dev') as f:
net_dump = f.readlines()
device_data={}
data = namedtuple('data',['rx','tx'])
for line in net_dump[2:]:
line = line.split(':')
if line[0].strip() != 'lo':
device_data[line[0].strip()] = data(float(line[1].split()[0])/(1024.0*1024.0),
float(line[1].split()[8])/(1024.0*1024.0))
return device_data
if __name__=='__main__':
netdevs = netdevs()
for dev in netdevs.keys():
print('{0}: {1} MiB {2} MiB'.format(dev, netdevs[dev].rx, netdevs[dev].tx))当你运行上面的程序，下面这个输出就会显示从你最近重启之后网络设备总接收和发送的数据，单位为兆。
em1: 0.0 MiB 0.0 MiB wlan0: 2651.40951061 MiB 183.173976898 MiB
你可以使用持久的数据存储机制来连接，来写出自己的数据使用监控程序。
/proc目录包含了所有正运行的进程目录。这些目录的名字和进程的标识符是一样的。所以，如果你遍历/proc目录下那些使用数字作为它们的名字的目录，你就会获得所有现在正在运行的进程列表。在下面的代码中process_list()函数返回所有现在正在运行的进程的标识符列表。当你执行这个程序后，这个列表的长度就是在系统上运行的总进程数。
#!/usr/bin/env python
"""
List of all process IDs currently active
"""
from __future__ import print_function
import os
def process_list():
pids = []
for subdir in os.listdir('/proc'):
if subdir.isdigit():
pids.append(subdir)
return pids
if __name__=='__main__':
pids = process_list()
print('Total number of running processes:: {0}'.format(len(pids)))上面的程序当执行后会显示和下面类似的输出：
Total number of running processes:: 229
每个进程目录包含了一些其他文件和目录，如进程命令的调用，它正使用的共享库以及其它的。
下一个程序通过读sysfs虚拟文件系统列出所有块设备。你系统中的块设备可以从/sys/block目录中找到。因此可能会有/sys/block/sda、/sys/block/sdb等这样的目录。为了获取所有这些设备，我们使用正则表达式对/sys/block目录进行扫描提取感兴趣的块设备。
#!/usr/bin/env python
"""
Read block device data from sysfs
"""
from __future__ import print_function
import glob
import re
import os
# Add any other device pattern to read from
dev_pattern = ['sd.*','mmcblk*']
def size(device):
nr_sectors = open(device+'/size').read().rstrip('\n')
sect_size = open(device+'/queue/hw_sector_size').read().rstrip('\n')
# The sect_size is in bytes, so we convert it to GiB and then send it back
return (float(nr_sectors)*float(sect_size))/(1024.0*1024.0*1024.0)
def detect_devs():
for device in glob.glob('/sys/block/*'):
for pattern in dev_pattern:
if re.compile(pattern).match(os.path.basename(device)):
print('Device:: {0}, Size:: {1} GiB'.format(device, size(device)))
if __name__=='__main__':
detect_devs()如果你运行该程序，你将会看到下述类似的输出：
Device:: /sys/block/sda, Size:: 465.761741638 GiB Device:: /sys/block/mmcblk0, Size:: 3.70703125 GiB
当我运行该程序的时候，有个SD内存卡插在电脑上，因此你会看到程序检测到了它。你也可以扩展该程序识别其它块设备（比如虚拟硬盘）。
linux中命令行使用工具是无所不在的[@Lesus 注：曾有人说过：linux没有了命令行就是个渣。]，它允许人么指定命令行参数来定制程序的默认行为。argparse模块就提供了和linux命令行实用工具类似的接口。下面的代码展示了程序如何获得系统上的所有用户以及打印它们的登录shell(使用了pwd标准库模块)：
#!/usr/bin/env python
"""
Print all the users and their login shells
"""
from __future__ import print_function
import pwd
# Get the users from /etc/passwd
def getusers():
users = pwd.getpwall()
for user in users:
print('{0}:{1}'.format(user.pw_name, user.pw_shell))
if __name__=='__main__':
getusers()当运行这个程序之后，它会打印系统上所有的用户以及他们登录shell名。
现在，你想要程序的用户能够选择是否想看系统用户(像daemon, apache)。我们扩展前面的代码，第一次使用argparse模块来实现这个特性，如下。
#!/usr/bin/env python
"""
Utility to play around with users and passwords on a Linux system
"""
from __future__ import print_function
import pwd
import argparse
import os
def read_login_defs():
uid_min = None
uid_max = None
if os.path.exists('/etc/login.defs'):
with open('/etc/login.defs') as f:
login_data = f.readlines()
for line in login_data:
if line.startswith('UID_MIN'):
uid_min = int(line.split()[1].strip())
if line.startswith('UID_MAX'):
uid_max = int(line.split()[1].strip())
return uid_min, uid_max
# Get the users from /etc/passwd
def getusers(no_system=False):
uid_min, uid_max = read_login_defs()
if uid_min is None:
uid_min = 1000
if uid_max is None:
uid_max = 60000
users = pwd.getpwall()
for user in users:
if no_system:
if user.pw_uid >= uid_min and user.pw_uid <= uid_max:
print('{0}:{1}'.format(user.pw_name, user.pw_shell))
else:
print('{0}:{1}'.format(user.pw_name, user.pw_shell))
if __name__=='__main__':
parser = argparse.ArgumentParser(description='User/Password Utility')
parser.add_argument('--no-system', action='store_true',dest='no_system',
default = False, help='Specify to omit system users')
args = parser.parse_args()
getusers(args.no_system)使用--help选项执行上面的程序，你会看到友好的帮助信息：可选项以及它们的作用。
$ ./getusers.py --help usage: getusers.py [-h] [--no-system] User/Password Utility optional arguments: -h, --help show this help message and exit --no-system Specify to omit system users
上面程序使用的一个例子，如下所示：
$ ./getusers.py --no-system gene:/bin/bash
当你传入一个非法的参数，这个程序就会发牢骚(报错)
$ ./getusers.py --param usage: getusers.py [-h] [--no-system] getusers.py: error: unrecognized arguments: --param
在上面的程序中，我们简单的理解了如何使用argparse模块。parser = argparse.ArgumentParser(description="User/Password Utility")语句创建了一个带说明程序是做什么的可选描述的ArgumentParser对象，
然后,我们添加参数。我们想要程序能够识别接下来这条语句 add_argument()。parser.add_argument('--no-system', action='store_true', dest='no_system', default = False, help='Specify to omit system users')。第一个方法的参数是当系统调用这个程序,程序使用着将要提供这个参数的名称,接下来的参数acton=store_true表明它是一个布尔选择。那就是说,它真或假影响程序的某些行为。dest为可定制化参数,它的值可以提供给程序使用。假如这个值用户不提供,这个值默认false。最后的参数程序显示的帮助信息。最后,参数被解析通过args=parser.parse_args()方法。一旦解析方法被做,用户选项的值能够被抓取到通过相应的语法参数option_dest,当你配置参数的时候,option_dest是一个你指定的目的变量。getusers(args.no_system)这条语句使用用户提供参数的值将会回调getusers()方法。
下面的程序展示了如何指定非布尔类型的选项。该程序是对第6个程序的重写，附加了一个选项用于指定你感兴趣的网络设备。
#!/usr/bin/env python
from __future__ import print_function
from collections import namedtuple
import argparse
def netdevs(iface=None):
''' RX and TX bytes for each of the network devices '''
with open('/proc/net/dev') as f:
net_dump = f.readlines()
device_data={}
data = namedtuple('data',['rx','tx'])
for line in net_dump[2:]:
line = line.split(':')
if not iface:
if line[0].strip() != 'lo':
device_data[line[0].strip()] = data(float(line[1].split()[0])/(1024.0*1024.0),
float(line[1].split()[8])/(1024.0*1024.0))
else:
if line[0].strip() == iface:
device_data[line[0].strip()] = data(float(line[1].split()[0])/(1024.0*1024.0),
float(line[1].split()[8])/(1024.0*1024.0))
return device_data
if __name__=='__main__':
parser = argparse.ArgumentParser(description='Network Interface Usage Monitor')
parser.add_argument('-i','--interface', dest='iface',
help='Network interface')
args = parser.parse_args()
netdevs = netdevs(iface = args.iface)
for dev in netdevs.keys():
print('{0}: {1} MiB {2} MiB'.format(dev, netdevs[dev].rx, netdevs[dev].tx))当你不带任何参数执行程序的时候，程序的行为与之前的版本完全一致。然后，你也可以指定感兴趣的网络设备。例如：
$ ./net_devs_2.py
em1: 0.0 MiB 0.0 MiB
wlan0: 146.099492073 MiB 12.9737148285 MiB
virbr1: 0.0 MiB 0.0 MiB
virbr1-nic: 0.0 MiB 0.0 MiB
$ ./net_devs_2.py --help
usage: net_devs_2.py [-h] [-i IFACE]
Network Interface Usage Monitor
optional arguments:
-h, --help show this help message and exit
-i IFACE, --interface IFACE
Network interface
$ ./net_devs_2.py -i wlan0
wlan0: 146.100307465 MiB 12.9777050018 MiB在本文的帮助下，你可能已经可以写一个或多个有用的脚本，就像其它linux命令一样，你想要每天都使用它们。最简单的方式是将脚本设置为可执行的，然后为脚本设置一个BASH别名。你也可以移除.py扩展名，然后将脚本放在诸如/usr/local/sbin这样的标准位置。
除了本文中已经提到的标准库模组，还有很多其它有用的标准模组：subprocess、ConfigParser、readline和curses。
在这个阶段，依靠你自己使用Python的经验，探索Linux内部，你可以参考下面的任一方式。如果你曾经需要写很多shell脚本/命令流水线来探索Linux内部，那么试一下Python。如果你想要一个更简单的方式来编写执行很多任务的实用程序脚本，那么试一下Python。最后，如果你已经使用Python在Linux上别写其它目的的程序，那么试一下用Python探索Linux内部。
Lists
Tuples
Namedtuples
OrderedDict
split()
strip() rstrip() and other string methods
Reading and writing files
os module
platform module
pwd module
spwd module
grp module
subprocess module
ConfigParser module
readline module
Long Mode
/proc file system
sysfs
原文地址：http://amitsaha.github.io/site/notes/articles/python_linux/article.html
Das obige ist der detaillierte Inhalt vonSo erhalten Sie Systeminformationen von Linux mit Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
