當我提及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模塊在標準庫中，它有很多運行我們獲得眾多系統信息的函數。讓我們運行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')在32位的系統上，你將會看到：
>>> platform.architecture()
('32bit', 'ELF')如果你指定了系統上其他任何可執行的，你都將會獲得相似的結果，如同這樣：
>>> platform.architecture(executable='/usr/bin/ls')
('64bit', 'ELF')鼓勵探索platform模塊的除了這些的其它函數，找出你現在運行的Python版本。如果你想知道這個模塊是如何獲取這些信息的，你可以深入查看PYthon源碼目錄下的Lib/platform.py文件。
os和sys模塊也可以獲得一些系統屬性，例如原生的字節序。接下來，我們超越Python標準庫模塊，去探索一些在linux系統通過proc和sysfs文件系統使之訪問信息成為可能。注意的是通過文件系統來訪問信息將會在不同的硬件架構有所不同。所以在讀本文或是寫腳本時要時刻記住可以試圖從這些文件獲取信息。
/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('
'))當你使用Python 2 或者 Python 3執行這個程序時，你會在屏幕上看到所有/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('
').startswith('model name'):
model_name = line.rstrip('
').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('
').startswith('flags')
or line.rstrip('
').startswith('Features'):
if 'lm' in line.rstrip('
').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('
')
sect_size = open(device+'/queue/hw_sector_size').read().rstrip('
')
# 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
聲明：本網頁內容旨在傳播知識，若有侵權等問題請及時與本網聯系，我們將在第一時間刪除處理。TEL:177 7030 7066 E-MAIL:11247931@qq.com
Copyright ? 2019-2025 51dongshi.com 版權所有
違法及侵權請聯系：TEL:177 7030 7066 E-MAIL:11247931@qq.com 本站由北京市萬商天勤律師事務所王興未律師提供法律服務
