這篇文章主要介紹了使用python獲取linux系統的各種信息,例如系統類型、cpu信息、內存信息、塊設備等,需要的朋友可以參考下。
    在本文中，我們將會探索使用python編程語言工具來檢索linux系統各種信息。走你。
    哪個python版本?
    當我提及python，所指的就是cpython 2(準確的是2.7).我會顯式提醒那些相同的代碼在cpython 3 (3.3)上是不工作的，以及提供一份解釋不同之處的備選代碼。請確保你已經安裝了cpython,在終端上輸入python或者python3回車，然后你在終端上應該能看到python的提示符(prompt)。
    請注意，所有的程序在它們第一行都是#!/usr/bin/env/python，也就是說，我們想要python的解釋器來執(zhí)行這些腳本。因此，如果你想你的腳本具有執(zhí)行性，請使用chmod +x your-script.py， 那么你就可以使用./your-script.py來執(zhí)行它了（在本文中你將會看到這種方式）
    探索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上，它會返回一個包含系統類型(或者內核版本)，主機名，版本，發(fā)布版本，機器的硬件以及處理器信息元組(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發(fā)布版本的詳細信息。例如，在fedora 18系統上，這個命令會返回如下信息：
    代碼如下:
    >>> platform.linux_distribution()
    ('fedora', '18', 'spherical cow')
    這個返回結果中包含了版本發(fā)布名，版本以及代號元組。特定的python版本支持的發(fā)布版本上可以通過_supported_dists顯示的值獲得。
    代碼如下:
    >>> platform._supported_dists
    ('suse', 'debian', 'fedora', 'redhat', 'centos', 'mandrake',
    'mandriva', 'rocks', 'slackware', 'yellowdog', 'gentoo',
    'unitedlinux', 'turbolinux')
    如果你的linux發(fā)布版本不在其中（或者其中之一的衍生發(fā)行版）。那么你很可能調用了上面這個函數而看不到任何有用的信息。
    platform模塊的最后一個函數，我們將會看看architecture()函數。當你無參的調用這個函數，它會返回包含架構位數以及python可執(zhí)行的格式的元組，像這樣：
    代碼如下:
    >>> platform.architecture()
    ('64bit', 'elf')
    在32位的系統上，你將會看到：
    代碼如下:
    >>> platform.architecture()
    ('32bit', 'elf')
    如果你指定了系統上其他任何可執(zhí)行的，你都將會獲得相似的結果，如同這樣：
    代碼如下:
    >>> platform.architecture(executable='/usr/bin/ls')
    ('64bit', 'elf')
    鼓勵探索platform模塊的除了這些的其它函數，找出你現在運行的python版本。如果你想知道這個模塊是如何獲取這些信息的，你可以深入查看python源碼目錄下的lib/platform.py文件。
    os和sys模塊也可以獲得一些系統屬性，例如原生的字節(jié)序。接下來，我們超越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執(zhí)行這個程序時，你會在屏幕上看到所有/proc/cpuinfo的內容（在上面的程序里，rstrip()方法用來刪除每行末尾的換行符）
    在下面的代碼里列舉了使用startwith()字符串方法來顯示你的處理器單元的模式。
    代碼如下:
    #! /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位的，但是運行的是32位的內核，然后上面的方法還是將會顯示為32位的架構。你可以通過從/proc/cpuinfo所列舉的標志中查找lm標志，來找到你的電腦的真實的架構。lm標志代表了長模式，只有64位架構的才會顯示它。下面的程序將會指導你怎樣做：
    代碼如下:
    #! /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)。這個注意很簡單：如果你查看這個文件的內容，你就會發(fā)現對于每個處理器單元，都有好些鍵值對(在先前的例子中，我們打印了每個處理器的模型名，即模型名就是關鍵字)。不同的處理器單元的信息可以使用空白行隔開。構造一個字典數據結構包含每個處理器單元的關鍵字是很簡單的。對于每個關鍵字，對于處理器單元的值都在/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(有序字典)而不是常規(guī)的字典，能夠使用鍵值有序的存儲在文件里。所以，第一個處理器單元的數據之后就是第二個處理器單元的數據，以此類推。你可以使用過濾器來過濾你所查找的信息（如同在if __name__ == '__main__'塊中演示的那樣）。上面的程序每次執(zhí)行后都會打印每個處理器單元的模型名（如通過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包含了你電腦的主存的信息。下面的這個程序創(chuàng)建了一個使用這個文件的內容填充的字典。
    代碼如下:
    #!/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__塊中有所表示)。當你執(zhí)行這個程序，你該會看到像下面類似的輸出：
    代碼如下:
    total memory: 7897012 kb
    free memory: 249508 kb
    網絡統計信息
    接下來，我們會探索我們電腦系統的網絡設備。我們將會獲得系統的網絡接口，以及當系統重啟之后通過它們數據發(fā)送和接受數據的信息。 /proc/net/dev文件讓這些信息可用。如果你檢查了這個文件的內容，你就會注意到頭一兩行包含了頭信息等等，這個文件第一列是網絡接口名，第二和第三列顯示了接收和發(fā)送的字節(jié)數信息（例如總發(fā)送字節(jié)數，包數，錯誤等等）。這里我們所感興趣的就是他哦難過不同的網絡設備提取出總發(fā)送數據和接收數據。下面的代碼展示了怎么從/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))
    當你運行上面的程序，下面這個輸出就會顯示從你最近重啟之后網絡設備總接收和發(fā)送的數據，單位為兆。
    代碼如下:
    em1: 0.0 mib 0.0 mib
    wlan0: 2651.40951061 mib 183.173976898 mib
    你可以使用持久的數據存儲機制來連接，來寫出自己的數據使用監(jiān)控程序。
    進程信息
    /proc目錄包含了所有正運行的進程目錄。這些目錄的名字和進程的標識符是一樣的。所以，如果你遍歷/proc目錄下那些使用數字作為它們的名字的目錄，你就會獲得所有現在正在運行的進程列表。在下面的代碼中process_list()函數返回所有現在正在運行的進程的標識符列表。當你執(zhí)行這個程序后，這個列表的長度就是在系統上運行的總進程數。
    代碼如下:
    #!/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)))
    上面的程序當執(zhí)行后會顯示和下面類似的輸出：
    代碼如下:
    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選項執(zhí)行上面的程序，你會看到友好的幫助信息：可選項以及它們的作用。
    代碼如下:
    $ ./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
    當你傳入一個非法的參數，這個程序就會發(fā)牢騷(報錯)
    代碼如下:
    $ ./getusers.py --param
    usage: getusers.py [-h] [--no-system]
    getusers.py: error: unrecognized arguments: --param
    在上面的程序中，我們簡單的理解了如何使用argparse模塊。parser = argparse.argumentparser(description=user/password utility)語句創(chuàng)建了一個帶說明程序是做什么的可選描述的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))
    當你不帶任何參數執(zhí)行程序的時候，程序的行為與之前的版本完全一致。然后，你也可以指定感興趣的網絡設備。例如：
    代碼如下:
    $ ./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命令一樣，你想要每天都使用它們。最簡單的方式是將腳本設置為可執(zhí)行的，然后為腳本設置一個bash別名。你也可以移除.py擴展名，然后將腳本放在諸如/usr/local/sbin這樣的標準位置。
    其它有用的標準庫模組
    除了本文中已經提到的標準庫模組，還有很多其它有用的標準模組：subprocess、configparser、readline和curses。
    接下來做什么？
    在這個階段，依靠你自己使用python的經驗，探索linux內部，你可以參考下面的任一方式。如果你曾經需要寫很多shell腳本/命令流水線來探索linux內部，那么試一下python。如果你想要一個更簡單的方式來編寫執(zhí)行很多任務的實用程序腳本，那么試一下python。最后，如果你已經使用python在linux上別寫其它目的的程序，那么試一下用python探索linux內部。