Python自动化：系统基础信息收集

系统性能信息模块psutil

 psutil能够轻松实现获取系统运行的进程和系统利用率包括（CPU，内存，磁盘 和网络）等。主要用于系统监控。对于系统维护来说是个不错的模块。

wget https://files.pythonhosted.org/packages/14/a2/8ac7dda36eac03950ec2668ab1b466314403031c83a95c5efc81d2acf163/psutil-5.4.5.tar.gz

yum install -y gcc readline-devel* zlib*

tar -xzvf psutil-5.4.5.tar.gz
cd psutil-5.4.5
python setup.py install

获取系统性能信息

（1）获取CPU信息

Linux操作系统的CPU利用率有以下几个部分：

• User Time　　  #执行用户进程的时间百分比
• System Time　 #执行内核进程和总段的时间百分比
• Wait IO　　      #由于IO等待而使CPU处于idle(空闲状态的时间百分比)
• Idle                    #CPU处于Idle状态的时间百分比

使用psutil.cpu_times()函数取出CPU简要信息,如需要完整信息使用psutil.cpu_times(True)即可

>>> import psutil
>>> 
>>> psutil.cpu_times()
scputimes(user=52745.65625, system=26600.859375, idle=384777.265625, interrupt=1410.8125, dpc=1468.984375)
>>> psutil.cpu_times(True)
[scputimes(user=12148.0, system=7542.421875, idle=96366.203125, interrupt=1105.546875, dpc=1091.84375), scputimes(user=13037.046875, system=6173.28125, idle=96845.85937499999, interrupt=137.734375, dpc=151.171875), scputimes(user=13006.953125, system=6257.390625, idle=96791.84374999999, interrupt=87.5, dpc=137.671875), scputimes(user=14555.515624999998, system=6629.703124999985, idle=94870.9375, interrupt=80.0625, dpc=88.4375)]
>>> 

获取单项数据信息,如以下获取user的CPU时间比

>>> psutil.cpu_times().user
52766.546875
>>> 

获取CPU逻辑个数，默认logical=True4

>>> psutil.cpu_count()
4
>>> 

获取CPU物理个数

>>> psutil.cpu_count(logical=False)
4
>>> 

（2）获取内存信息

Linux操作系统对内存的统计有以下几个部分：

• Total　　           #内存总数
• User　              #已使用内存
• Free　　          #空闲内存数
• Buffers             #缓冲使用数
• Cache              #缓存使用数
• Swap               #交换分区

 获取内存完整信息

>>> import psutil
>>> 
>>> mem=psutil.virtual_memory()
>>> 
>>> mem                   #获取到的内存数据
svmem(total=8457035776, available=5508038656, percent=34.9, used=2948997120, free=5508038656)
>>> 
>>> mem.total             #获取内存总数
8457035776
>>> 
>>> mem.free              #获取内存剩余
5508038656
>>> 
>>> psutil.swap_memory()  #获取swap交换内存
sswap(total=9799213056, used=3736629248, free=6062583808, percent=38.1, sin=0, sout=0)
>>> 
>>> 

（3）获取磁盘信息

• Read_count     #读IO数
• Write_count     #写IO数
• Read_byte       #IO读字节数
• Write_byte        #IO写字节数
• Read_time        #磁盘读时间
• Write_time        #磁盘写时间

>>> import psutil
>>> 
>>> psutil.disk_partitions()                #获取当前磁盘完整信息
[sdiskpart(device='C:\', mountpoint='C:\', fstype='NTFS', opts='rw,fixed'), sdiskpart(device='D:\', mountpoint='D:\', fstype='NTFS', opts='rw,fixed')]
>>> 
>>> psutil.disk_usage("C:\")               #获取指定分区（参数）的使用情况
sdiskusage(total=115865546752, used=31459299328, free=84406247424, percent=27.2)
>>> >>> 
>>> psutil.disk_io_counters()                #获取硬盘总的IO个数,与读写信息
sdiskio(read_count=1577844, write_count=1529528, read_bytes=71110199808, write_bytes=103924939776, read_time=6624, write_time=8764)
>>> 
>>> psutil.disk_io_counters(perdisk=True)     #获取单个分区IO个数，与读写信息
{'PhysicalDrive0': sdiskio(read_count=837428, write_count=944450, read_bytes=37869357056, write_bytes=32956311040, read_time=1928, write_time=2476), 'PhysicalDrive1': sdiskio(read_count=740416, write_count=585185, read_bytes=33240842752, write_bytes=70969325056, read_time=4696, write_time=6288)}
>>> 
>>> 

（4）获取网络信息

• Bytes_sent       #发送字节数
• Bytes_recv       #接收字节数
• Packets_sent   #发送数据包
• Packets_recv    #接收数据包

>>> import psutil
>>> 
>>> psutil.net_io_counters()           #获取网络IO信息，默认pernic=False
snetio(bytes_sent=1137465964, bytes_recv=1533965380, packets_sent=18466211, packets_recv=4429783, errin=0, errout=0, dropin=0, dropout=0)
>>> 
>>> psutil.net_io_counters(pernic=True) #输出每个网络接口的IO信息
{'eth0': snetio(bytes_sent=1137468550, bytes_recv=1533958095, packets_sent=18466313, packets_recv=4429706, errin=0, errout=0, dropin=0, dropout=0), 'lo': snetio(bytes_sent=33796, bytes_recv=33796, packets_sent=455, packets_recv=455, errin=0, errout=0, dropin=0, dropout=0)}
>>> 

 （5）其他系统信息

>>> import psutil
>>> 
>>> psutil.users()                #返回当前登录系统用户信息
[suser(name='root', terminal='pts/0', host='27.201.232.42', started=1528273152.0, pid=18905)]
>>> 
>>> import psutil,datetime
>>> 
>>> psutil.boot_time()             #获取开启时间
1527585242.0
>>> 
>>> datetime.datetime.fromtimestamp(psutil.boot_time()).strftime("%Y-%m-%d %H:%M:%S")
'2018-05-29 17:14:02'              #获取开机时间，以linux时间戳显示
>>> 

系统进程管理方法

常用方法：

• psutil.pids()                      #列出所有进程PID
• psutil.Process(2714)        #实例化
• p.name()                            #取进程名
• p.exe()                               #取bin路径
• p.cwd()                              #进程工作目录绝对路径
• p.status()                          #进程状态
• p.create_time()                 #进程创建时间,时间戳格式
• p.uids()                             #取进程UID信息
• p.gids()                             #取进程GID信息
• p.cpu_times()                   #进程CPU时间信息，包括user,system两个CPU时间
• p.cpu_affinity()                #get进程CPU亲和度,如果设置进程CPU亲和度将CPU号作为参数即可
• p.memory_percent()        #取进程利用率
• p.memory_info()              #进程内存rss.vms信息
• p.io_counters()                #进程IO信息,包括读写IO数及字节数
• p.connections()               #返回打开进程socket的namedutples列表,包括fs.family.laddr等信息
• p.num_threads()              #进程开启的线程数

>>> import psutil
>>> 
>>> psutil.pids()                      #列出所有进程号
[0, 4, 360, 544, 636, 708, 716, 808, 880, 304, 384, 1028, 1120, 1236, 1420, 1480, 1688, 1788, 1900, 1956, 1848, 2064]
>>> 
>>> p=psutil.Process(1956)             #实例化一个Process对象,参数为一进程PID
>>> 
>>> p.name()                           #取进程名字
'RtkAudioService64.exe'
>>> 
>>> 
>>> p.num_threads()                    #取进程线程数
4
>>> 

IP地址处理模块IPy

 作用：计算大量的IP地址，包括网段，网络掩码，广播地址，子网个数，IP类型等。可以很好的辅助我们高效完成IP地址的规划工作。

1：IP地址与网段的基本处理

#辨别IPv4与IPv6

>>> import IPy
>>> from IPy import IP
>>> 
>>> IP("192.168.0.0/24").version()       #判断类型为IPv4
4
>>> 
>>> IP("::1").version()                  #判断类型为IPv6
6
>>> 

#通过指定网段输出该网段的IP个数以及所有IP地址清单

>>> import IPy
>>> from IPy import IP
>>> 
>>> ip_address=IP("192.168.1.0/24")       #指定IP地址范围
>>> 
>>> print(ip_address.len())               #输出该网段的IP个数
256
>>> 
>>> for i in ip_address:                  #输出该网段的所有IP清单
...     print(i)
... 
192.168.1.0
192.168.1.1
192.168.1.2
192.168.1.3
192.168.1.4
192.168.1.5
192.168.1.6
........

#IP地址的反向解析名称，IP类型与转换

>>> import IPy
>>> from IPy import IP
>>> 
>>> ip_address=IP("192.168.1.10")
>>> 
>>> ip_address.reverseNames()              #输出反向解析地址格式
['10.1.168.192.in-addr.arpa.']
>>> 
>>> ip_address.iptype()                    #查看IP类型，此处为私网类型
'PRIVATE'
>>> 
>>> IP("8.8.8.8").iptype()                 #查看IP类型，此处为公网类型
'PUBLIC'
>>> 
>>> 
>>> IP("8.8.8.8").int()                    #转换成整形格式
134744072
>>> 
>>> IP("8.8.8.8").strHex()                 #转换成十六进制格式
'0x8080808'
>>> 
>>> IP("8.8.8.8").strBin()                 #转换成二进制格式
'00001000000010000000100000001000'
>>> 
>>> print(IP(0x8080808))                   #十六进制转换成IP格式
8.8.8.8
>>> 

#根据IP与子网掩码生成网段格式

>>> import IPy
>>> from IPy import IP
>>> 
>>> IP("192.168.1.0").make_net("255.255.255.0")
IP('192.168.1.0/24')
>>> 
>>> IP("192.168.1.0/255.255.255.0",make_net=True)
IP('192.168.1.0/24')
>>> 
>>> IP("192.168.1.0-192.168.1.255",make_net=True)
IP('192.168.1.0/24')

#通过strNormal方法指定不同wantprefixlen参数值，定制输出不同类型的网段

>>> import IPy
>>> from IPy import IP
>>> 
>>> IP("192.168.1.0/24").strNormal(0)
'192.168.1.0'
>>> 
>>> IP("192.168.1.0/24").strNormal(1)
'192.168.1.0/24'
>>> 
>>> IP("192.168.1.0/24").strNormal(2)
'192.168.1.0/255.255.255.0'
>>> 
>>> IP("192.168.1.0/24").strNormal(3)
'192.168.1.0-192.168.1.255'
>>> 

wantprefixlen取值范围：

• wantprefixlen=0         #无返回值，如192.168.1.0;
• wantprefixlen=1         #perfix格式，如192.168.1.0/2;
• wantprefixlen=2         #decimalnetmask格式，如192.168.1.0/255.255.255.0；
• wantprefixlen=3         #lastIP格式，如192.168.1.0-192.168.1.255

2：多网络的计算比对方法

作用：用于比对两个网段是否存在，包含，重叠等关系

#进行数据比对，判断两个网段是否相等（或者说是否在同一个广播域）

>>> import IPy
>>> from IPy import IP
>>> 
>>> IP("10.0.0.0/24") < IP("20.0.0.0/24")
True

#判断IP地址和网段是否包含于另一个网段中

>>> import IPy
>>> from IPy import IP
>>> 
>>> "192.168.1.10" in IP("192.168.1.0/24")         #1.10是否在0/24这个网段中
True
>>> 
>>> IP("192.168.1.0/24") in IP("192.168.0.0/16")   #前面的与后面的是否有交叉
True
>>> 

#判断两个网段是否有重叠，采用IPy提供的overlaps方法

>>> import IPy
>>> from IPy import IP
>>> 
>>> IP("192.168.0.0/23").overlaps("192.168.1.0/24")     #返回1代表存在重叠
1
>>> 
>>> IP("192.168.1.0/24").overlaps("192.168.2.0")        #返回0代表不存在重叠
0
>>> 

#输入IP或子网，返回网络，掩码，广播，反向解析，子网个数，IP类型等信息

import IPy
from IPy import IP

ip_s =input("输入IP地址或网段地址：")             #例如：192.168.1.0/24

ips=IP(ip_s)

if len(ips) > 1:                               #为一个网络地址时执行
    
    print("网络地址：%s" %ips.net())
    print("子网掩码：%s" %ips.netmask())
    print("广播地址：%s" %ips.broadcast())
    print("反向解析：%s" %ips.reverseNames()[0])
    print("网络子网数：%s" %len(ips))

else:                                           #为单个IP时执行

    print("反向解析：%s" %ips.reverseNames()[0])
    print("十六进制地址：%s" %ips.strHex())
    print("二进制地址：%s" %ips.strBin())
    print("地址类型：%s" %sips.iptype())

DNS处理模块dnspython

目录：

• 利用模块解析域名的方法
• 常见的解析类型实例
• 实践：DNS域名轮询业务监控

dnspython是python实现的一个DNS工具包，它支持几乎所有的记录类型，可用于查询，传输并动态更新ZONE信息，同时支持TSIG（事务签名），验证消息和EDNS0（扩展DNS）。

 #实现A记录的查询

import dns.resolver

domain=input("输入一个域名：")          #输入域名，例如：www.baidu.com

A=dns.resolver.query(domain,"A")     #指定查询A记录

for i in A.response.answer:          #通过response.answer方法获取查询回应信息
    for j in i.items:                #遍历回应信息
        print(j)

 #实现MX邮件交换记录的查询

import dns.resolver

domain=input("输入一个域名：")        #输入域名，例如:163.com

MX=dns.resolver.query(domain,"MX")  #指定查询MX记录
for i in MX:
    print("MX preference=",i.preference,"main exchanger=",i.exchange)

 #实现NS记录的查询

import dns.resolver

domain=input("输入一个域名：")         #输入域名，例如：qq.com

NS=dns.resolver.query(domain,"NS")   #制定查询NS
for i in NS.response.answer:
    for j in i.items:
        print(j.to_text())

#实现CNAME别名的查询

import dns.resolver

domain=input("输入一个域名：")        #输入域名，例如：www.baidu.com

cname=dns.resolver.query(domain,"CNAME")

for i in cname.response.answer:
    for j in i.items:
        print(j.to_text())

#实践：DNS域名轮询业务监控（实现监控指定域名的后端主机）

import dns.resolver
import os
import http.client

iplist=[]                                    #定义域名IP列表变量
appdomain="www.baidu.com"                    #定义业务域名

def get_iplist(domain=""):                   #域名解析函数，解析成功IP将追加到iplist
    try:
        A = dns.resolver.query(domain, 'A')  #解析A记录类型
    except Exception (e):
        print ("DNS记录解析错误:"+str(e))
        return
    for i in A.response.answer:
        for j in i.items:
            iplist.append(j.address)          #追加到iplist
    return True

def checkip(ip):
    checkurl=ip+":80"
    getcontent=""
    http.client.socket.setdefaulttimeout(5)   #定义http连接超时时间(5秒)
    conn=http.client.HTTPConnection(checkurl) #创建http连接对象

    try:
        conn.request("GET", "/",headers = {"Host": appdomain})  #发起URL请求，添加host主机头
        r=conn.getresponse()
        getcontent =r.read(15)                                  #获取URL页面前15个字符，以便做可用性校验
    finally:
        if getcontent=="<!doctype html>":                       #监控URL页的内容一般是事先定义好，比如“HTTP200”等
            print (ip+" [OK]")
        else:
            print (ip+" [Error]")    #此处可放告警程序，可以是邮件、短信通知

if __name__=="__main__":
    if get_iplist(appdomain) and len(iplist)>0:    #条件：域名解析正确且至少要返回一个IP
        for ip in iplist:
            checkip(ip)
    else:
        print ("DNS解析错误.")

psutil是个跨平台库，能够轻松实现获取系统运行的进程和系统利用率，包括CPU、内存、磁盘、网络等信息。

它主要应用于信息监控，分析和限制系统资源及进程的管理。它实现了同等命令命令行工具提供的功能，如：ps、top、lsof、netstat、ifconfig、who、df、kill、free、nice、ionice、iostat、iotop、uptime、pidof、tty、taskset、pmap等。目前支持32位和64位的linux、windows、OS X、FreeBSD和Sun Solaris等操作系统。

资料来自： https://www.cnblogs.com/zhangxinqi/p/9106265.html

1、psutil模块安装

（1）源码安装psutil

git clone https://github.com/giampaolo/psutil.git
cd psutil
python3 setup.py install

（2）pip安装

pip3 install psutil

（3）windows上安装

C:python35python.exe -m pip install psutil

或者源码编译安装：
make.bat build
make.bat install

2、获取CPU信息

In [10]: psutil.cpu_times(percpu=False)  #查看CPU所有信息
Out[10]: scputimes(user=306.98, nice=2.01, system=337.34, idle=410414.39, iowait=78.37, irq=0.0, softirq=17.42, steal=0.0, guest=0.0, guest_nice=0.0)

#user:用户进程花费的时间
#nice：用户模式执行Niced优先级进程花费的时间
#system：内核模式进程花费的时间
#idle：闲置时间
#iowait:等待I/O完成的时间
#irq：处理硬件中断的时间
#softirq：处理软件中断的时间
#steal：虚拟化环境中运行的其他操作系统花费的时间
#guest：在linux内核的控制下为客户端操作系统运行虚拟CPU所花费的时间
#guest_nice：虚拟机运行niced所花费的时间

#显示CPU所有逻辑信息

In [7]: psutil.cpu_times(percpu=True)  #显示所有CPU逻辑信息
Out[7]: 
[scputimes(user=45.48, nice=0.31, system=69.41, idle=101285.67, iowait=19.67, irq=0.0, softirq=3.06, steal=0.0, guest=0.0, guest_nice=0.0),
 scputimes(user=110.04, nice=0.46, system=70.63, idle=101210.2, iowait=22.99, irq=0.0, softirq=5.0, steal=0.0, guest=0.0, guest_nice=0.0),
 scputimes(user=58.5, nice=0.5, system=126.64, idle=100934.59, iowait=14.47, irq=0.0, softirq=4.36, steal=0.0, guest=0.0, guest_nice=0.0),
 scputimes(user=92.1, nice=0.72, system=68.3, idle=101146.96, iowait=21.12, irq=0.0, softirq=4.79, steal=0.0, guest=0.0, guest_nice=0.0)]

#显示用户占CPU的时间比

In [11]: psutil.cpu_times().user  #显示用户占CPU的时间比
Out[11]: 307.11

#显示CPU逻辑个数和物理个数

In [8]: psutil.cpu_count(logical=True)  #显示CPU逻辑个数
Out[8]: 4

In [9]: psutil.cpu_count(logical=False)  #显示CPU物理个数
Out[9]: 4

#将各种CPU统计信息作为命名元组返回

In [15]: psutil.cpu_stats()   #CPU统计信息
Out[15]: scpustats(ctx_switches=9838934, interrupts=10572621, soft_interrupts=5582125, syscalls=0)

#ctx_switches：启动后的上下问切换次数
#interrupts：自启动以来的中断次数
#soft_interrupts：启动后的软件中断数量
#syscalls：启动以来的系统调用次数，在linux上始终为0

3、内存信息

psutil.virtual_memory()以字节返回内存使用情况的统计信息

In [20]: mem = psutil.virtual_memory()  #获取内存完整信息
In [21]: mem
Out[21]: svmem(total=2078892032, available=1508818944, percent=27.4, used=367063040, free=135192576, active=874614784, inactive=694231040, buffers=122880, cached=1576513536, shared=10444800, slab=255148032)

#total:总物理内存
#available:可用的内存
#used:使用的内存
#free：完全没有使用的内存
#active：当前正在使用的内存
#inactive：标记为未使用的内存
#buffers：缓存文件系统元数据使用的内存
#cached:缓存各种文件的内存
#shared:可以被多个进程同时访问的内存
#slab:内核数据结构缓存的内存


In [22]: mem.total  #获取内存总数
Out[22]: 2078892032

In [23]: mem.used  #获取已使用内存
Out[23]: 367063040

In [24]: mem.free  #获取空闲内存
Out[24]: 135192576

In [25]: psutil.swap_memory()  #获取swap内存信息
Out[25]: sswap(total=2148528128, used=270336, free=2148257792, percent=0.0, sin=0, sout=12288)

#total：以字节为单位的总交换内存
#used：以字节为单位使用交换内存
#free：以字节为单位的可用交换内存
#percent：使用百分比
#sin：系统从磁盘交换的字节数
#sout：系统从磁盘换出的字节数

4、磁盘信息

psutil.disk_partitions(all=False)：返回所有安装的磁盘分区作为名称元组的列表，包括设备，安装点和文件系统类型，类似于Unix上的‘df’命令.

In [25]: import psutil
In [26]: psutil.disk_partitions(all=False) #获取磁盘完整信息
Out[26]: 
[sdiskpart(device='/dev/sda3', mountpoint='/', fstype='xfs', opts='rw,seclabel,relatime,attr2,inode64,noquota'),
 sdiskpart(device='/dev/sda5', mountpoint='/home', fstype='xfs', opts='rw,seclabel,relatime,attr2,inode64,noquota'),
 sdiskpart(device='/dev/sda1', mountpoint='/boot', fstype='xfs', opts='rw,seclabel,relatime,attr2,inode64,noquota')]

psutil.disk_usage(path)：将有关包含给定路径的分区的磁盘使用情况统计信息返回为指定元组，包括以字节表示的，总共，已使用和空闲的空间以及百分比使用率，如果路径存在则引发OSError.

In [30]: psutil.disk_usage('/')  #获取分区使用情况
Out[30]: sdiskusage(total=53660876800, used=3662462976, free=49998413824, percent=6.8)

#total：总的大小（字节）
#used：已使用的大小（字节）
#free：空闲的大小（字节）
#percent：使用百分比

psutil.disk_io_counters(perdisk=False,nowrap=True)  #将系统范围的磁盘I/0统计作为命名元组返回，包括以下字段：

• read_count：读取次数
• write_count：写入次数
• read_bytes：读取的字节数
• write_bytes：写入的字节数
• read_time：从磁盘读取的时间（以毫秒为单位）
• write_time：写入磁盘的时间（毫秒为单位）
• busy_time：花费在实际I/O上的时间
• read_merged_count：合并读取的数量
• write_merged_count：合并写入次数

perdisk为True时返回物理磁盘相同的信息；nowrap为True它将检测并调整函数调用中的新值。

In [32]: psutil.disk_io_counters(perdisk=True)  #获取单个分区的IO信息
Out[32]: 
{'fd0': sdiskio(read_count=0, write_count=0, read_bytes=0, write_bytes=0, read_time=0, write_time=0, read_merged_count=0, write_merged_count=0, busy_time=0),
 'sda1': sdiskio(read_count=1003, write_count=25, read_bytes=5893632, write_bytes=2226176, read_time=1143, write_time=11298, read_merged_count=0, write_merged_count=1, busy_time=3976),
 'sda2': sdiskio(read_count=51, write_count=2, read_bytes=2260992, write_bytes=12288, read_time=246, write_time=391, read_merged_count=0, write_merged_count=1, busy_time=545),
 'sda3': sdiskio(read_count=15216, write_count=34370, read_bytes=456854528, write_bytes=2394566656, read_time=186146, write_time=3937459, read_merged_count=17, write_merged_count=37260, busy_time=156705),

5、网络信息

psutil.net_io_counters(pernic=False,nowrap=True)：将系统范围的网络I/O统计信息作为命名元组返回，包括以下属性：

• bytes_sent：发送的字节数
• bytes_recv：收到的字节数
• packets_sent：发送的数据包数量
• packets_recv：接收的数据包数量
• errin：接收时的错误总数
• errout：发送时的错误总数
• dropin：丢弃的传入数据包总数

• dripout：丢弃的传出数据包总数（在OSX和BSD上始终为0）

如果pernic为True网络接口上安装的每个网络接口返回相同的信息，nowrap为True时将检测并调整函数调用中的这些数字，将旧值添加到新值，保证返回的数字将增加或不变，但不减少，net_io_counters.cache_clear()可用于使nowrap缓存失效。

In [79]: psutil.net_io_counters(pernic=False,nowrap=True)
Out[79]: snetio(bytes_sent=19487039, bytes_recv=301660567, packets_sent=123489, packets_recv=337983, errin=0, errout=0, dropin=0, dropout=0)

In [81]: psutil.net_io_counters(pernic=True,nowrap=True)
Out[81]: 
{'ens32': snetio(bytes_sent=17684066, bytes_recv=299856862, packets_sent=121275, packets_recv=335825, errin=0, errout=0, dropin=0, dropout=0),
 'lo': snetio(bytes_sent=1812739, bytes_recv=1812739, packets_sent=2270, packets_recv=2270, errin=0, errout=0, dropin=0, dropout=0)}

psutil.net_connections(kind='inet')：返回系统范围的套接字链接，命令元组列表返回，每个命名元组提供了7个属性：

• fd：套接字文件描述符。
• family：地址系列，AF_INET， AF_INET6 或AF_UNIX。
• type：地址类型，SOCK_STREAM或 SOCK_DGRAM。
• laddr：本地地址作为命名元组或 AF_UNIX套接字的情况。对于UNIX套接字，请参阅下面的注释。(ip, port)path
• raddr：远程地址是指定的元组，或者是UNIX套接字的绝对地址。当远程端点未连接时，您将获得一个空元组（AF_INET *）或（AF_UNIX）。对于UNIX套接字，请参阅下面的注释。(ip, port)path""
• status：表示TCP连接的状态。
• pid：打开套接字的进程的PID，如果是可检索的，否则None。在某些平台（例如Linux）上，此字段的可用性根据进程权限而变化（需要root）。

kind参数的值包括：

inet：ipv4和ipv6

inet4：ipv4

inet6：ipv6

tcp：TCP

tcp4：TCP over ipv4

tcp6：TCP over ipv6

udp：UDP

dup4：基于ipv4的udp

cpu6：基于ipv6的udp

Unix：UNIX套接字（udp和TCP协议）

all：所有可能的家庭和协议的总和

In [86]: psutil.net_connections(kind='tcp')
Out[86]: 
[sconn(fd=3, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='127.0.0.1', port=9090), raddr=(), status='LISTEN', pid=103599),
 sconn(fd=4, family=<AddressFamily.AF_INET6: 10>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='::', port=22), raddr=(), status='LISTEN', pid=1179),
 sconn(fd=13, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='127.0.0.1', port=25), raddr=(), status='LISTEN', pid=1279),
 sconn(fd=10, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='0.0.0.0', port=3306), raddr=(), status='LISTEN', pid=70099),
 sconn(fd=3, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='0.0.0.0', port=22), raddr=(), status='LISTEN', pid=1179),
 sconn(fd=3, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='192.168.146.139', port=22), raddr=addr(ip='192.168.146.1', port=4238), status='ESTABLISHED', pid=122738),
 sconn(fd=12, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='127.0.0.1', port=9001), raddr=(), status='LISTEN', pid=103596),
 sconn(fd=14, family=<AddressFamily.AF_INET6: 10>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='::1', port=25), raddr=(), status='LISTEN', pid=1279)]

In [87]: psutil.net_connections(kind='inet4')
Out[87]: 
[sconn(fd=3, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='127.0.0.1', port=9090), raddr=(), status='LISTEN', pid=103599),
 sconn(fd=13, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='127.0.0.1', port=25), raddr=(), status='LISTEN', pid=1279),
 sconn(fd=10, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='0.0.0.0', port=3306), raddr=(), status='LISTEN', pid=70099),
 sconn(fd=3, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='0.0.0.0', port=22), raddr=(), status='LISTEN', pid=1179),
 sconn(fd=3, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='192.168.146.139', port=22), raddr=addr(ip='192.168.146.1', port=4238), status='ESTABLISHED', pid=122738),
 sconn(fd=6, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_DGRAM: 2>, laddr=addr(ip='0.0.0.0', port=68), raddr=(), status='NONE', pid=119605),
 sconn(fd=12, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='127.0.0.1', port=9001), raddr=(), status='LISTEN', pid=103596),
 sconn(fd=1, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_DGRAM: 2>, laddr=addr(ip='127.0.0.1', port=323), raddr=(), status='NONE', pid=741)]

psutil.net_if_addrs()：以字典的方式返回系统上的每个网络接口的关联地址。

In [88]: psutil.net_if_addrs()
Out[88]: 
{'lo': [snic(family=<AddressFamily.AF_INET: 2>, address='127.0.0.1', netmask='255.0.0.0', broadcast=None, ptp=None),
  snic(family=<AddressFamily.AF_INET6: 10>, address='::1', netmask='ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', broadcast=None, ptp=None),
  snic(family=<AddressFamily.AF_PACKET: 17>, address='00:00:00:00:00:00', netmask=None, broadcast=None, ptp=None)],
 'ens32': [snic(family=<AddressFamily.AF_INET: 2>, address='192.168.146.139', netmask='255.255.255.0', broadcast='192.168.146.255', ptp=None),
  snic(family=<AddressFamily.AF_INET6: 10>, address='fe80::9853:19bb:b07b:89d4%ens32', netmask='ffff:ffff:ffff:ffff::', broadcast=None, ptp=None),
  snic(family=<AddressFamily.AF_PACKET: 17>, address='00:50:56:31:d8:11', netmask=None, broadcast='ff:ff:ff:ff:ff:ff', ptp=None)]}

psutil.net_if_stats()：将安装在系统上的网络接口的信息作为字典返回，其中包括isup是否启动，duplex双工模式，speed速率，mtu最大传输单位，以字节表示

In [89]: psutil.net_if_stats()
Out[89]: 
{'ens32': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=1000, mtu=1500),
 'lo': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_UNKNOWN: 0>, speed=0, mtu=65536)}

6、其他系统信息

IN[93]：import psutil,time
In [94]: psutil.boot_time()  #系统启动时间戳
Out[94]: 1527457908.0
In [96]: time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(psutil.boot_time
    ...: ()))    #格式化时间
Out[96]: '2018-05-28 05:51:48'

In [97]: psutil.users()   #返回当前链接的系统用户
Out[97]: 
[suser(name='root', terminal='tty1', host='', started=1527050368.0, pid=769),
 suser(name='root', terminal='pts/0', host='192.168.146.1', started=1527559040.0, pid=122742),
 suser(name='root', terminal='pts/1', host='192.168.146.1', started=1527559040.0, pid=122761)]

7、系统进程管理

In [1]: import psutil

In [2]: psutil.pids()   #列出所有进程PID
Out[2]: 
[1,2,3,5,6,7,8,]

In [3]: p = psutil.Process(1265)  #实例化一个Process对象，参数为进程PID

In [4]: p.name()  #进程名
Out[4]: 'mysqld'

In [5]: p.exe()  #进程bin路径
Out[5]: '/usr/local/mysql-5.5.32/bin/mysqld'

In [6]: p.cwd()  #进程工作目录绝对路径
Out[6]: '/mysql/data'

In [7]: p.status()  #进程状态
Out[7]: 'sleeping'

In [8]: p.create_time()  #进程创建时间，时间戳格式
Out[8]: 1527642963.22

In [9]: p.uids()  #进程UID信息
Out[9]: puids(real=1001, effective=1001, saved=1001)

In [10]: p.gids()  #进程GID信息
Out[10]: pgids(real=1001, effective=1001, saved=1001)

In [11]: p.cpu_times()  #进程CPU时间信息，包括user、system的CPU时间
Out[11]: pcputimes(user=1.53, system=6.06, children_user=0.0, children_system=0.0)

In [12]: p.cpu_affinity()  #get进程CPU亲和度，如果设置进程CPU亲和度，将CPU号作为参数即可
Out[12]: [0, 1, 2, 3]

In [13]: p.memory_info()  #进程内存rss、vms信息
Out[13]: pmem(rss=45268992, vms=460525568, shared=4399104, text=9420800, lib=0, data=425431040, dirty=0)

In [14]: p.io_counters()  #进程IO信息包括读写IO数及字节数
Out[14]: pio(read_count=594, write_count=27, read_bytes=15859712, write_bytes=32768, read_chars=6917150, write_chars=1555)

In [15]: p.connections()  #返回发开进程socket的namedutples列表，包括fs、family、laddr等信息
Out[15]: [pconn(fd=10, family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, laddr=addr(ip='0.0.0.0', port=3306), raddr=(), status='LISTEN')]

In [16]: p.num_threads()  #进程开启的线程数
Out[16]: 16

In [17]: p.memory_percent()  #进程内存利用率
Out[17]: 2.177553778800572

psutil.process_iter(attrs=None,ad_value=None)：返回一个迭代器process，为本地机器上的所有正在运行的进程生成一个类实例。

psutil.pid_exists(pid)：检查给定的PID是否存在于当前进程列表中。

psutil.wait_procs(procs,timeout=None,callback=None)：等待process终止实例列表的便捷函数，返回一个元组，指示哪些进程已经消失，哪些进程还活着。

class psutil.Popen(*args,**kwargs)：它启动一个子进程，并完全像使用subprocess.Popen一样处理，它还提供了所有psutil.Process类的方法。Popen类的作用是获取用户启动的应用程序进程信息，以便跟踪程序进程的运行状态。

In [18]: import psutil

In [19]: from subprocess import PIPE

In [20]: p = psutil.Popen(["/usr/bin/python","-c","print('hello world')"],stdout=
    ...: PIPE)

In [21]: p.name()
Out[21]: 'python'

In [22]: p.username()
Out[22]: 'root'

In [23]: p.communicate()
Out[23]: (b'hello world
', None)

进程过滤实例：

In [25]: import psutil

In [26]: from pprint import pprint as pp

#根据进程名查看系统中的进程名与pid
In [27]: pp([p.info for p in psutil.process_iter(attrs=['pid','name']) if 'python
    ...: ' in p.info['name']])
[{'name': 'ipython3', 'pid': 2429}]

In [28]: pp([p.info for p in psutil.process_iter(attrs=['pid','name']) if 'mysql'
    ...:  in p.info['name']])
[{'name': 'mysqld_safe', 'pid': 987}, {'name': 'mysqld', 'pid': 1265}]

#所有用户进程
In [32]: import getpass

In [33]: pp([(p.pid,p.info['name']) for p in psutil.process_iter(attrs=['name','u
    ...: sername']) if p.info['username'] == getpass.getuser()])
[(1, 'systemd'),
 (2, 'kthreadd'),
 (3, 'ksoftirqd/0'),
 (5, 'kworker/0:0H'),
 (6, 'kworker/u256:0'),
...
 (5004, 'kworker/0:0')]

#查看积极运行的进程：
In [37]: pp([(p.pid,p.info) for p in psutil.process_iter(attrs=['name','status'])
    ...:  if p.info['status'] == psutil.STATUS_RUNNING])
[(2429, {'name': 'ipython3', 'status': 'running'})]

#使用日志文件的进程
In [38]: import os,psutil

In [39]: for p in psutil.process_iter(attrs=['name','open_files']):
    ...:     for file in p.info['open_files'] or []:
    ...:         if os.path.splitext(file.path)[1] == '.log':
    ...:             print("%-5s %-10s %s" % (p.pid,p.info['name'][:10],file.path
    ...: ))
    ...:             
689   auditd     /var/log/audit/audit.log
725   vmtoolsd   /var/log/vmware-vmsvc.log
974   tuned      /var/log/tuned/tuned.log

#消耗超过5M内存的进程：
In [42]: pp([(p.pid,p.info['name'],p.info['memory_info'].rss) for p in psutil.pro
    ...: cess_iter(attrs=['name','memory_info']) if p.info['memory_info'].rss > 5
    ...:  * 1024 * 1024])
[(1, 'systemd', 7118848),
 (411, 'systemd-udevd', 6254592),
 (712, 'polkitd', 13553664),
 (716, 'abrtd', 5734400),
 (724, 'VGAuthService', 6262784),
 (725, 'vmtoolsd', 6426624),
 (974, 'tuned', 19648512),
 (1265, 'mysqld', 45268992),
 (2204, 'sshd', 5726208),
 (2429, 'ipython3', 37232640)]


#消耗量最大的3个进程
In [43]: pp([(p.pid, p.info) for p in sorted(psutil.process_iter(attrs=['name', '
    ...: memory_percent']), key=lambda p: p.info['memory_percent'])][-3:])
[(974, {'memory_percent': 0.9451434561080659, 'name': 'tuned'}),
 (2429, {'memory_percent': 1.7909847854955845, 'name': 'ipython3'}),
 (1265, {'memory_percent': 2.177553778800572, 'name': 'mysqld'})]

#消耗最多CPU时间的前3个进程
In [44]: pp([(p.pid, p.info['name'], sum(p.info['cpu_times'])) for p in sorted(ps
    ...: util.process_iter(attrs=['name', 'cpu_times']), key=lambda p: sum(p.info
    ...: ['cpu_times'][:2]))][-3:])
[(1265, 'mysqld', 13.93),
 (2429, 'ipython3', 14.809999999999999),
 (725, 'vmtoolsd', 16.74)]

#导致最多I/O的前3个进程
In [45]: pp([(p.pid, p.info['name']) for p in sorted(psutil.process_iter(attrs=['
    ...: name', 'io_counters']), key=lambda p: p.info['io_counters'] and p.info['
    ...: io_counters'][:2])][-3:])
[(2429, 'ipython3'), (725, 'vmtoolsd'), (1, 'systemd')]


#前3个进程打开最多的文件描述符：
In [46]: pp([(p.pid, p.info) for p in sorted(psutil.process_iter(attrs=['name', '
    ...: num_fds']), key=lambda p: p.info['num_fds'])][-3:])
[(377, {'name': 'systemd-journald', 'num_fds': 24}),
 (1, {'name': 'systemd', 'num_fds': 43}),
 (1307, {'name': 'master', 'num_fds': 91})]