动用Python获取Linux系统的各样消息

2019-09-24 04:08 来源:未知

在本文中,大家将会追究运用Python编制程序语言工具来检索Linux系统种种音信。走你。

动用Python获取Linux系统的各样新闻,python获取linux系统

在本文中,大家将会追究运用Python编制程序语言工具来检索Linux系统各样音讯。走你。

哪个Python版本?

当自个儿聊到Python,所指的便是CPython 2(正确的是2.7).小编会显式提示那多少个同样的代码在CPython 3 (3.3)上是不办事的,以及提供一份解释分歧之处的备选代码。请保管您已经设置了CPython,在终点上输入python恐怕python3回车,然后你在终端上应当能看到python的唤起符(prompt)。

请稳重,全体的顺序在它们第一行都以#!/usr/bin/env/python,相当于说,大家想要Python的解释器来进行那个本子。因而,要是您想你的脚本具备实行性,请使用chmod +x your-script.py, 那么您就足以使用./your-script.py来施行它了(在本文中你将会看出这种方法)

探索platform模块

platform模块在标准库中,它有大多运作大家获得众多系统消息的函数。让我们运转Python解释器来钻探它们中的一些函数,那就从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')

若果你已通晓linux上的uname命令,那么您就能够认出来这几个函数正是这么些命令的三个接口。在Python 2上,它会回到贰个带有系统项目(大概根本版本),主机名,版本,公布版本,机器的硬件以及Computer音讯元组(tuple)。你能够利用下标访问个别属性,像这么:

复制代码 代码如下:

>>> platform.uname()[0]
'Linux'

在Python 3上,那几个函数再次来到的是三个命名元组:

复制代码 代码如下:

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

因为再次回到结果是三个命名元组,那就足以简轻易单地通过名字来钦赐特定的习性,并不是必须牢记下标,像那样:

复制代码 代码如下:

>>> platform.uname().system
'Linux'

platform模块还应该有局地下面属性的直白接口,像这么:

复制代码 代码如下:

>>> platform.system()
'Linux'

>>> platform.release()
'3.7.4-204.fc18.x86_64'

linux_distribution()函数重返的有关您所在的linux发表版本的详细音讯。举个例子,在Fedora 18系统上,这么些命令会回到如下信息:

复制代码 代码如下:

>>> platform.linux_distribution()
('Fedora', '18', 'Spherical Cow')

那些重返结果中隐含了本子公布名,版本以及代号元组。特定的Python版本协助的发布版本上得以因而_supported_dists呈现的值获得。

复制代码 代码如下:

>>> platform._supported_dists
('SuSE', 'debian', 'fedora', 'redhat', 'centos', 'mandrake',
'mandriva', 'rocks', 'slackware', 'yellowdog', 'gentoo',
'UnitedLinux', 'turbolinux')

一经你的linux发布版本不在个中(也许当中之一的衍生发行版)。那么你很恐怕调用了地方这些函数而看不到任何有效的音信。
platform模块的终极贰个函数,大家将会看看architecture()函数。当您无参的调用那几个函数,它会再次回到包蕴架构位数以及python可实践的格式的元组,像这么:

复制代码 代码如下:

>>> platform.architecture()
('64bit', 'ELF')

在叁十一个人的系统上,你将会看到:

复制代码 代码如下:

>>> platform.architecture()
('32bit', 'ELF')

要是您钦命了系统上其余任何可实施的,你都将会获取相似的结果,就像那样:

复制代码 代码如下:

>>> platform.architecture(executable='/usr/bin/ls')
('64bit', 'ELF')

鞭挞探究platform模块的除了那么些的其余函数,搜索您今后运作的Python版本。若是你想精晓那一个模块是如何赢得那些音信的,你能够深刻查看PYthon源码目录下的Lib/platform.py文件。

os和sys模块也得以收获部分系统特性,举个例子原生的字节序。接下来,大家超越Python标准库模块,去搜求一些在linux系统通过proc和sysfs文件系统使之访谈消息成为大概。注意的是透过文件系统来访谈音信将会在分裂的硬件架构有所不一致。所以在读本文也许写脚本时要时刻牢记能够总括从这一个文件获取新闻。

获取CPU信息

/proc/cpuinfo文件富含了您的种类管理器单元的音信。比如,这里就是python版的linux命令cat /proc/cpuinfo所做的事:

复制代码 代码如下:

#! /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'))

当你利用Python 2 依然 Python 3实行那些顺序时,你会在荧屏上收看全数/proc/cpuinfo的内容(在上头的次第里,rstrip()方法用来删除每行末尾的换行符)
在底下的代码里列举了运用startwith()字符串方法来显示你的微型Computer单元的形式。

复制代码 代码如下:

#! /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)

当你运维那一个顺序后,你应当会看出您的各种管理器单元的方式名。比如,这里就是在自己电脑上所寓指标。

复制代码 代码如下:

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

迄今,大家已有二种艺术来找寻大家所使用的体系的架构。从本事上讲是没有错的,多少个方法实在报告了您系统运行的水源架构,所以,即便你的管理器是64人的,可是运转的是三16人的根本,然后上边的点子还是将会显得为三二十一人的框架结构。你能够透过从/proc/cpuinfo所列举的标记中查究lm标志,来找到您的管理器的真人真事的架构。lm标记代表了长格局,唯有陆十六位架构的才会来得它。下边包车型大巴次序将会指引你怎么着做:

复制代码 代码如下:

#! /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)。这些注意很简短:即使您查看那么些文件的原委,你就能够发觉对于种种处理器单元,皆有好些键值对(在原先的例子中,大家打字与印刷了各种处理器的模子名,即模型名正是十分重要字)。差异的Computer单元的新闻方可选择空白行隔断。构造叁个字典数据结构包罗种种管理器单元的要紧字是很简短的。对于每个主要字,对于Computer单元的值都在/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(有序字典)并不是健康的字典,能够选拔键值有序的存款和储蓄在文书里。所以,第多少个Computer单元的数据之后正是第四个Computer单元的数目,依此类推。你可以利用过滤器来过滤你所查找的音信(就像是在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满含了您Computer的主存的信息。上面包车型客车那几个顺序创制了二个使用那些文件的剧情填充的字典。

复制代码 代码如下:

#!/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内部。

哪个Python版本?

怎用python获取linux系统的网卡新闻?

一般是用os.popen()调用系统命令,获得重回消息,然后分析出结果。
python本身未有直接获取网卡消息的工具。  

当本身谈起Python,所指的就是CPython 2(正确的是2.7).小编会显式提示那几个同样的代码在CPython 3 (3.3)上是不做事的,以及提供一份解释差异之处的盘算代码。请保管您已经安装了CPython,在终极上输入python大概python3回车,然后你在终点上应有能观望python的唤醒符(prompt)。

在linux系统中 用shell 也许python 运营 grep 命令 但要搜索的内容是许五个 并想把结果放到贰个变量中

假使四个内容是与关系,能够四个grep用管道相连,是或涉嫌,可用正则式
如grep '(ab|cd)' a.txt 是查富含 ab或cd的行, grep 'ab' a.txt | grep 'cd' 是查包蕴ab和cd的行
要将结果赋到变量 a=`grep '(ab|cd)' a.txt ` 就行了
在python里就蛮好办了,用不着grep啦,字符串的find函数就行呐  

在本文中,我们将会追究使用Python编制程序语言工具来检索Linux系统各样新闻。走你。 哪...

请留意,全部的次序在它们第一行都是#!/usr/bin/env/python,也便是说,大家想要Python的解释器来试行这一个本子。由此,要是你想你的本子具备试行性,请使用chmod +x your-script.py, 那么你就能够使用./your-script.py来施行它了(在本文中您将拜访到这种艺术)

探索platform模块

platform模块在标准库中,它有众多运作大家获得过多连串音信的函数。让我们运转Python解释器来探寻它们中的一些函数,那就从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')

假使你已知道linux上的uname命令,那么您就能够认出来这一个函数正是以此命令的一个接口。在Python 2上,它会回到一个带有系统项目(只怕根本版本),主机名,版本,公布版本,机器的硬件以及计算机消息元组(tuple)。你可以采用下标访问个别属性,像这么:

复制代码 代码如下:

>>> platform.uname()[0]
'Linux'

在Python 3上,这几个函数重临的是叁个命名元组:

复制代码 代码如下:

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

因为重回结果是一个命名元组,那就能够大致地因而名字来钦赐特定的品质,并不是必需记住下标,像那样:

复制代码 代码如下:

>>> platform.uname().system
'Linux'

platform模块还恐怕有部分方面属性的直白接口,像这么:

复制代码 代码如下:

>>> platform.system()
'Linux'

>>> platform.release()
'3.7.4-204.fc18.x86_64'

linux_distribution()函数重临的有关您所在的linux公布版本的详细消息。举个例子,在Fedora 18系统上,那几个命令会回到如下消息:

复制代码 代码如下:

>>> platform.linux_distribution()
('Fedora', '18', 'Spherical Cow')

那个重回结果中带有了本子公布名,版本以及代号元组。特定的Python版本支持的公布版本上得以因此_supported_dists显示的值得到。

复制代码 代码如下:

>>> platform._supported_dists
('SuSE', 'debian', 'fedora', 'redhat', 'centos', 'mandrake',
'mandriva', 'rocks', 'slackware', 'yellowdog', 'gentoo',
'UnitedLinux', 'turbolinux')

假设你的linux发表版本不在个中(大概在那之中之一的衍生发行版)。那么你很大概调用了地点这么些函数而看不到任何有效的新闻。
platform模块的结尾多少个函数,大家将会看看architecture()函数。当您无参的调用这些函数,它会再次回到满含架构位数以及python可实行的格式的元组,像这么:

复制代码 代码如下:

>>> platform.architecture()
('64bit', 'ELF')

在叁拾三个人的系统上,你将会看出:

复制代码 代码如下:

>>> platform.architecture()
('32bit', 'ELF')

借让你钦命了系统上别样任何可实践的,你都将会获得相似的结果,就好像那样:

复制代码 代码如下:

>>> platform.architecture(executable='/usr/bin/ls')
('64bit', 'ELF')

鞭笞探求platform模块的除了那么些的别样函数,搜索您今后运营的Python版本。若是你想知道这一个模块是什么样收获那个消息的,你能够深入查看PYthon源码目录下的Lib/platform.py文件。

os和sys模块也能够博得部分连串质量,比如原生的字节序。接下来,大家凌驾Python规范库模块,去探寻一些在linux系统通过proc和sysfs文件系统使之访问新闻成为恐怕。注意的是透过文件系统来访谈音讯将会在差异的硬件架构有所分裂。所以在读本文可能写脚本时要时刻牢记能够计划从这个文件获撤消息。

获取CPU信息

/proc/cpuinfo文件富含了您的系统Computer单元的音讯。举例,这里就是python版的linux命令cat /proc/cpuinfo所做的事:

复制代码 代码如下:

#! /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'))

当您利用Python 2 依然 Python 3试行这几个程序时,你会在荧屏上看到有着/proc/cpuinfo的内容(在下边包车型客车先后里,rstrip()方法用来删除每行末尾的换行符)
在下边包车型客车代码里列举了选取startwith()字符串方法来展现你的Computer单元的形式。

复制代码 代码如下:

#! /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)

当您运维这一个顺序后,你应当会看出你的种种管理器单元的情势名。举个例子,这里正是在作者计算机上所寓指标。

复制代码 代码如下:

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

时至后天,大家已有二种方式来寻找大家所选择的系统的架构。从技能上讲是没有错的,多少个方式实在报告了你系统运维的基础架构,所以,若是您的微型计算机是陆拾陆个人的,不过运转的是叁13人的基石,然后上面包车型大巴法子照旧将会显得为31位的架构。你能够透过从/proc/cpuinfo所列举的注脚中搜索lm标识,来找到你的微型Computer的根据各州的具体情况制定方案的架构。lm标记代表了长格局,独有六十位架构的才会来得它。下边的程序将会引导你怎样做:

复制代码 代码如下:

#! /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)。这几个注意很轻便:假设您查看这些文件的剧情,你就能意识对于每一种管理器单元,皆有好些键值对(在过去的事情例中,大家打印了种种管理器的模型名,即模型名正是重视字)。分裂的微型Computer单元的新闻能够动用空白行隔开。构造一个字典数据结构富含各个管理器单元的重大字是不会细小略的。对于各种注重字,对于计算机单元的值都在/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闪存卡插在微型Computer上,因而你会看出程序检查测验到了它。你也足以扩大该程序识别另外块设备(举个例子虚构硬盘)。

创制命令行实用工具

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内部。

TAG标签:
版权声明:本文由990888藏宝阁发布于计算机网络,转载请注明出处:动用Python获取Linux系统的各样消息