python多网卡

① 在linux下，python怎么才能抓到网卡上的所有TCP数据包

Ethereal 自带许多协议的 decoder,简单,易用,基于winpcap的一个开源的软件.但是它的架构并不灵活,如何你要加入一个自己定义的的解码器,得去修改 Ethereal的代码,再重新编译,很烦琐.对于一般的明文 协议,没有什么问题,但是对于加密协议,比如网络游戏,客户端程序一般会在刚连接上的时候,发送一个随机密钥,而后的报文都会用这个密钥进行加密,如此. 要想破解,得要有一个可编程的抓包器.
libpcap是一个不错的选择,但是对于抓包这样需要反复进行”试 验->修改”这个过程的操作,c 语言显然不是明智的选择.
Python提供了几个libpcapbind。在windows平台上,你需要先安装winpcap,如果你已经安装了Ethereal非常好用
一个规范的抓包过程
import pcap
import dpkt
pc=pcap.pcap() #注，参数可为网卡名，如eth0
pc.setfilter('tcp port 80') #设置监听过滤器
for ptime,pdata in pc: #ptime为收到时间，pdata为收到数据
print ptime,pdata #...
对抓到的以太网V2数据包(raw packet)进行解包
p=dpkt.ethernet.Ethernet(pdata)
if p.data.__class__.__name__=='IP':
ip='%d.%d.%d.%d'%tuple(map(ord,list(p.data.dst)))
if p.data.data.__class__.__name__=='TCP':
if data.dport==80:
print p.data.data.data # by gashero
一些显示参数
nrecv,ndrop,nifdrop=pc.stats()
返回的元组中，第一个参数为接收到的数据包，(by gashero)第二个参数为被核心丢弃的数据包。

② 如何用python获取linux系统的网卡信息

1．下载源代码
2． 安装，过程如下。

$ tar –jxvf Python-2.5.2.tar.bz2
$ cd Python-2.5.2
$ ./configure
$ make
$ make install

3. 测试。
在命令行下输入python，出现python解释器即表示已经正确安装。
在suse10或rhel5（es5）下系统默认已经装了python但版本是2.4.x；本次安装后在shell中输入#python

会发现显示结果：
# python

Python 2.4.3 (#1, Dec 11 2006, 11:38:52)

[GCC 4.1.1 20061130 (Red Hat 4.1.1-43)] on linux2

Type “help”, “right”, “credits” or “license” for more information.

>>>

③ 已经获取虚拟机的所有信息，怎么用python提取网卡信息

KVM(Kernel-based Virtual Machine)作为一个开源的系统虚拟化模块，已经成为虚拟机虚拟化技术的主流，在越来越多的Cloud环境中使用。为了保证Cloud环境的正常运行，需要在运维过程中对Cloud环境中的VM状态进行监控，比如CPU，内存，Disk，Disk I/O，Network I/O等信息，可以利用这些信息及时的调整分配Cloud环境的资源，保证VM的正常运行。Libvirt是基于KVM的上层封装，提供了操作KVM的原生层接口，可以实现对虚拟机的日常管理操作，如虚拟机的生命周期(创建，删除，查看，管理)，开机，关机，重启，网络管理，存储管理等。本文以查看hypervisor的instance为例，讲述通过Libvirt-python模块，查看当前HOST的KVM虚拟机常用监控信息。文章主要包括如下几个方面的内容：
1、 Libvirt-python模块的简单介绍与环境安装配置;
2、 利用Python调用API获取 VM相关监控信息;
1. Libvirt-python模块的简单介绍与安装配置
Libvirt提供一种虚拟机监控程序不可知的 API 来安全管理运行于主机上的客户操作系统，是一种可以建立工具来管理客户操作系统的 API。Libvirt 本身构建于一种抽象的概念之上。它为受支持的虚拟机监控程序实现的常用功能提供通用的API，适用于包括基于KVM/QEMU, Xen, LXC, OpenVZ, Virtualbox, VMware, PowerVM等多种虚拟机化技术的虚拟机。Libvirt-python是基于libvirt API的python语言绑定工具包，通过该包，可以使用python对VM进行日常管理操作和监控数据获取。需要运行的Python监控程序可以在KVM的HOST中运行，也可以在基于KVM虚拟机化的任意环境运行，需要做的配置如下：
1) 环境准备：
安装python 2.6及以上
安装libvirt 1.2及以上
安装libvirt-client 1.2及以上
安装libvirt-python1.2及以上
以上环境如果已经在操作系统中存在并且满足要求，不需要进行重复安装，可以在libvirt的官方网站选择不同的站点和适合自己操作系统的安装包进行下载安装。

2) 验证安装环境：

安装完上述安装包后，在命令行运行rpm -qa | grep libvirt 查看相关安装信息是否正确如图：

在命令行运行python命令查看python环境

在命令行运行virsh进入virsh命令行窗口

执行list –all,列出所有虚拟机，执行dommemstat domainID验证windows虚拟机内存信息

unused代表虚机内部未使用的内存量，available代表虚机内部识别出的总内存量，那么虚机内部的内存使用量则是(available-unused)。
如果windows虚拟机中没有unused值，

按下一步安装virtio-win驱动和balloon service，并且启动balloon service
3) windows虚拟机Windows Virtio Drivers安装。
1、下载地址，根据自己需求下载相应版本，这里以下载Stable virtio-win iso为例。
2、安装驱动
3、安装Balloon Services，
在python应用运行环境验证servie，查看该VM 内存信息。

2. 利用Python调用API获取 VM相关监控信息
2.1创建连接
Python的管理应用程序可以和域位于同一节点上，管理应用程序通过libvirt工作，以控制本地域，如下图：

也可以运行在远端，通过本地libvirt连接远端libvirt，以控制本地域，该模式使用一种运行于远程节点上的libvirtd守护进程。当在新节点上安装libvirt时该程序会自动启动，且可自动确定本地虚拟机监控程序并为其安装驱动程序。该管理应用程序通过一种通用协议从本地libvirt连接到远程libvirtd。

提供不同的连接方式，注意连接使用过后需要关闭。
from __future__ import print_function
import sys
import libvirt
# conn = libvirt.open('qemu+ssh://IP/system'
conn = libvirt.open('qemu:///system')
if conn == None:
print('Failed to open connection to qemu:///system', file=sys.stderr)
exit(1)
conn.close()
2.2 列出Domains
conn.listAllDomains(type)方法返回指定类型的domains列表，type参数可以设置以下类型
VIR_CONNECT_LIST_DOMAINS_ACTIVE
VIR_CONNECT_LIST_DOMAINS_INACTIVE
VIR_CONNECT_LIST_DOMAINS_PERSISTENT
VIR_CONNECT_LIST_DOMAINS_TRANSIENT
VIR_CONNECT_LIST_DOMAINS_RUNNING
VIR_CONNECT_LIST_DOMAINS_PAUSED
VIR_CONNECT_LIST_DOMAINS_SHUTOFF
VIR_CONNECT_LIST_DOMAINS_OTHER
VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE
VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE
VIR_CONNECT_LIST_DOMAINS_AUTOSTART
VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART
VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT
VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHO
如果设置为0，则返回所有活动和关机的domain
2.2 获取监控数据
VM的监控信息主要是CPU使用率，内存使用率，Disk使用率，Disk I/O，Network I/O。其中，CPU的使用率，Disk I/O，Network I/O并不能直接获取，需要经过计算获得。
2.2.1 CPU使用率
libvirt中并不能直接获取到虚拟机的CPU使用率，但是可以通过CPUTIME来计算出实际使用率。计算的公式为：
首先得到一个周期差：cpu_time_diff = cpuTimenow — cpuTimet seconds ago
然后根据这个差值计算实际使用率：%CPU = 100 × cpu_time_diff / ((now- seconds ago) × vcpus × 109).CPUtime可以使用domain的info函数获得，如下：
from __future__ import print_function
import sys
import libvirt
from xml.dom import minidom
conn = libvirt.open('qemu:///system')
dom = conn.lookupByName(domName)
dominfo = dom.info()
print('The state is ' + str(dominfo[0]))
print('The max memory is ' + str(dominfo[1]))
print('The memory is ' + str(dominfo[2]))
print('The number of cpus is ' + str(dominfo[3]))
print('The cpu time is ' + str(dominfo[4]))
conn.close()
info()函数返回一个数组，下标为4的值即为CPUTime。
2.2.2 内存使用率
内存的使用情况可以函数dom.memoryStats()获得，如下：
from __future__ import print_function
import sys
import libvirt
domName = 'Fedora22-x86_64-1'
conn = libvirt.open('qemu:///system')
if conn == None:
print('Failed to open connection to qemu:///system', file=sys.stderr)
exit(1)
dom = conn.lookupByID(5)
if dom == None:
print('Failed to find the domain '+domName, file=sys.stderr)
exit(1)
stats = dom.memoryStats()
print('memory used:')
for name in stats:
print(' '+str(stats[name])+' ('+name+')')
conn.close()
exit(0)
可以在Virsh命令行中验证获取的值是否正确。
2.2.3 Disk使用率
对于一个VM的DISK，在DOMAIN XML的device根据标示获取，有关Disk部分的XML如下所示。
<devices>
<disk type='file' snapshot='external'>
<driver name="tap" type="aio" cache="default"/>
<source file='/var/lib/xen/images/fv0' startupPolicy='optional'>
<seclabel relabel='no'/>
</source>
<target dev='hda' bus='ide'/>
/*这个'hda'就是需要的参数 */
<iotune>
<total_bytes_sec>10000000</total_bytes_sec>
<read_iops_sec>400000</read_iops_sec>
<write_iops_sec>100000</write_iops_sec>
</iotune>
<boot order='2'/>
<encryption type='...'>
...
</encryption>
<shareable/>
<serial>
...
</serial>
</disk>
...
</devices>
使用函数domain.blockInfo(disk,0)获得磁盘的总量和已使用量
2.2.4 Disk I/O
可以使用 domain. blockStats ()方法，该方法需要传递一个Disk的参数，这个参数可以通过XML文件取得：
<devices>
<disk type='file' snapshot='external'>
<driver name="tap" type="aio" cache="default"/>
<source file='/var/lib/xen/images/fv0' startupPolicy='optional'>
<seclabel relabel='no'/>
</source>
<target dev='hda' bus='ide'/>
/*这个'hda'就是需要的参数 */
<iotune>
<total_bytes_sec>10000000</total_bytes_sec>
<read_iops_sec>400000</read_iops_sec>
<write_iops_sec>100000</write_iops_sec>
</iotune>
<boot order='2'/>
<encryption type='...'>
...
</encryption>
<shareable/>
<serial>
...
</serial>
</disk>
...
</devices>
2.2.5 Network I/O
可以使用 domain.interfaceStats()方法，该方法需要传递一个虚拟网卡接口的参数，这个参数可以通过XML文件取得：
<interface type='bridge'>
<mac address='00:16:3e:74:03:53'/>
<source bridge='xenbr0'/>
<script path='vif-bridge'/>
<target dev='vif1.0 '/>
/*这个vif1.0就是需要的参数 */
</interface>
网卡的I/O值返回是一个数组，根据自己需要获取对应的值。
3. 总结
通过对VM监控信息的获取，可以实时的了解Cloud环境中各个VM的负载和使用情况，合理的调配计算资源，或者关闭长时间没有使用的VM，做到Cloud资源的合理利用和运行环境的健康可靠性。

④ 如何用python实现《多社交网络的影响力最大化问题分析》中的算法

经过一周，现已初步完成，其中多出代码不够美观以及效率不高，还请指点
# _*_ coding:utf-8 _*_
# ==================================================================================
#
# Description: Influence Maximization on Multiple Social Networks
#
# ==================================================================================
import matplotlib.pyplot as plt
import networkx as nx
import heapq

#总图
G = nx.DiGraph()

def load_graph(file):
'''
加载文件为列表格式,并得到G,画出图结构
'''

#将总列表设成全局格式
global gllist

#迭代文件中每个元素
with open(file) as f:
lines = f.readlines()
mylist = [line.strip().split() for line in lines]

gllist = []
#将字符串型转换为整型
for i in mylist:
gllist.append(i[:-2]+map(lambda x: float(x), i[-2:]))
print '初始全局列表:'
print gllist

drawlist=[]
#提取二维列表mylist每行前三个元素,赋给新的列表drawlist
for i in range(len(mylist)):
drawlist.append([])
for j in range(3):
drawlist[i].append(mylist[i][j])
#将列表drawlist加载为有向加权图
G.add_weighted_edges_from(drawlist)
nx.draw(G, with_labels=True, width=1, node_color='y', edge_color='b')
plt.show()
print 'G图中所有节点:',G.nodes()
print 'G图中所有边:',G.edges()
print '\n'

def get_self_node(gllist, target=None):
'''
获取目标节点的自传播节点,返回selflist并包含含晌目标节点
'''
#初始化自传播节点列表
selflist = [target]

#存放已传播节点列表
haslist = []

flag = 0

while (flag != 0):
flag = 0
for target in selflist:
if target not in haslist:
for i in range(len(gllist)):
#判断二维列表中,每行第三个元素是否为1,若为1，则为自传播节点
if ((gllist[i][0] == target)or(gllist[i][1]==target))and(gllist[i][3]==1.0):
if gllist[i][0] == target:
if gllist[i][1] not in haslist:
selflist.append(gllist[i][1])
haslist.append(gllist[i][1])
flag += 1
else:
if gllist[i][0] not in haslist:
selflist.append(gllist[i][0])
haslist.append(gllist[i][0])
flag += 1
#去除重复元素
haslist = set(haslist)
selflist = set(selflist)

#去除重复元素
selflist = set(selflist)
return selflist

def longest_path(gllist,source=None,target=None):
'''
获取起始点到实体的最大谈配锋路径集合,返回卖悉为longestpath列表
'''
longestpath = []
newlist = []
for i in range(len(gllist)):
newlist.append([])
for j in range(3):
newlist[i].append(gllist[i][j])
#构建图结构
G1 = nx.DiGraph()
#添加带权有向边
G1.add_weighted_edges_from(newlist)
#获取目标节点的所有自传播街边,并存入selflist中
selflist = get_self_node(gllist, target)
max_path = 0
val_path = 1
#获取初始节点到目标节点及目标节点的自传播节点的最大路径
for v in selflist:
if v != source:
#遍历两点之间所有路径,并进行比对
for path in nx.all_simple_paths(G1,source=source,target=v):
#判断路径后两个元素是否为相同实体（如：b1->b2）
if is_self_transmit_node(path[-2], v) == 0:
for i in range(0, len(path)-1):
val_path *= G1.get_edge_data(path[i], path[i+1])['weight']
if max_path < val_path:
max_path = val_path
val_path = 1
#若目标节点为起始节点则直接跳出
else: continue ############ 有待商榷 ##############
longestpath.append(max_path)
#返回初始节点到实体的最大路径
return longestpath

def is_self_transmit_node(u, v):
'''
判断目标节点不为起始节点的自传播点
'''
flag = 0
#获得起始节点的所有自传播点
selflist = get_self_node(gllist, v)
for x in selflist:
if u == x:
flag = 1
return flag

def single_strong_infl(longestpath):
'''
计算起始点到实体的传播概率（影响强度）,返回影响强度stronginfl
'''
temp = 1
for x in longestpath:
temp *= 1-x
stronginfl = 1-temp
return stronginfl

def all_strong_infl(G):
'''
获得每个节点对实体的影响概率
'''
allstrong = [] #初始化所有节点的加权影响范围列表
gnodes = [] #初始化节点列表
tempnodes = [] #初始化临时节点列表

gnodes = G.nodes()

for u in gnodes:
strong = 0 #存储初始节点对每个实体的影响范围加权，初始化为0
#重置临时节点列表
tempnodes = G.nodes()
for v in tempnodes:
#非自身节点
if u != v:
#判断目标节点不为起始节点的自传播点
if is_self_transmit_node(v, u) == 0:
#获取起始节点到实体间最大加权路径，并存入longestpath
longestpath = longest_path(gllist, u, v)

#去除已遍历目标节点的所有自传播节点
renode = get_self_node(gllist, v)
for x in renode:
if x != v:
tempnodes.remove(x)

#计算起始节点到实体间传播概率（影响强度）
stronginfl = single_strong_infl(longestpath)
strong += stronginfl

#添加单个节点到所有实体的加权影响范围
allstrong.append([u, round(strong, 2)])

#返回每个节点到所有实体的加权影响范围
return allstrong
#output allstrong : [['a1', 2.48], ['a2', 1.6880000000000002], ['b1', 0.7], ['b2', 0], ['c1', 0], ['d2', 0.6]]

def uS_e_uppergain(u, ev, S):
'''
获取节点u在集合S的基础上对实体ev的影响增益, 传入候选节点,上界gain(u|S, ev)
'''

#获取目前实体的所有自传播节点
selflist = get_self_node(gllist, ev)
stronglist = []
#遍历自传遍节点
for v in selflist:
'''
判断节点v是否存在种子集合S中
其中v为单个节点,如v(ev, Gi)
S为种子节点集合,如['a1','a2','b1','b2','c1','d2']
'''
if v in S:
ppSv = 1
else:
longestpath = []
#遍历种子集合
for s in S:

#初始化路径权值与最大路径权值
val_path = 1
max_path = 0

#遍历两点之间所有路径，并进行比对
for path in nx.all_simple_paths(G,source=s,target=v):
#判断路径后两个元素是否为相同实体（如：b1->b2）
if is_self_transmit_node(path[-2], v) == 0:
for i in range(0, len(path)-1):
val_path *= G.get_edge_data(path[i], path[i+1])['weight']
if max_path < val_path:
max_path = val_path
#重置路径权值为1
val_path = 1
#将最大加权路径存入longestpath列表
longestpath.append(max_path)
#得到上界pp(S,v)的影响概率,上界pp(S,v)
ppSv = single_strong_infl(longestpath)

stronglist.append(ppSv)
#得到上界pp(S,ev)的影响概率,上界pp(S,ev)
ppSev = single_strong_infl(stronglist)

#获取pp(u,ev)
ppuev = single_strong_infl(longest_path(gllist, u, ev))

#计算上界gain(u|S，ev)
uSevgain = (1 - ppSev) * ppuev
return uSevgain

def uppergain(u, emu, ems, S):
'''
在已有种子集合S的基础上,求得节点u的影响增益上界,
其中传进参数ems为二维列表,如[['a1',2.48],['a2',1.688]],S则为['a1','a2']
'''
uSgain = 0.0
#遍历emu得到列表形式,得到如['a1',2.48]形式
for ev in emu:
#判断节点是否存在种子集合中
if ev[0] in S:
uSgain += uS_e_uppergain(u, ev[0], S)
else:
uSgain += ev[1]

#返回上界gain(u|S)
return uSgain

def bound_base_imms(G, k):
'''
完全使用影响增益上界的方式选择top-k个种子节点的过程
'''
#初始化emu,H,初始化ems=空集,S=空集

Htemp = []
Htemp = all_strong_infl(G)
H = []
#遍历Htemp=[['a1',2.48],['a2',1.688]],得到如['a1',2.48]形式
for x in Htemp:
#逐个获取二维列表中每一行，形式为['a1',2.48,0]
H.append([x[0],x[1],0])

emu = []
emu = all_strong_infl(G)

ems = []
S = []

for i in range(k):

#提取堆顶元素,tnode的形式为['a1',2.48,0]
tnode = heapq.nlargest(1, H, key=lambda x: x[1])
#将[['b2', 3.1, 0]]格式改为['b2', 3.1, 0]格式
tnode = sum(tnode, [])

while (tnode[2] != i):
gain = 0.0
#获取节点u的影响增益上界
gain = uppergain(tnode, emu, ems, S)
#赋值影响范围
tnode[1] = gain
#修改status
tnode[2] = i

#对堆进行排序
H = heapq.nlargest(len(H), H, key=lambda x: x[1])

#获取堆顶元素
tnode = heapq.nlargest(1, H, key=lambda x: x[1])
tnode = sum(tnode, [])

#添加node到种子集合
S.append([tnode[0]])
#更新ems,添加新节点及节点对每个实体的影响范围加权
ems.append([tnode[0], tnode[1]])

#删除堆顶元素
H.remove(tnode)
print ems
return sum(S, [])

if __name__=='__main__':

#大小为k的种子集合S
k = 60

#加载文件数据,得到图G和初始列表gllist
load_graph('test.txt')

#完全使用影响增益上界值的计算过程函数,打印种子集合S
print '种子集合:',bound_base_imms(G, k)

test.txt
a1 b1 0.2 0
a1 c1 0.8 0
a2 b2 0.4 0
a2 d2 1 0
b1 c1 0.7 0
c2 a2 0.8 0
d2 b2 0.6 0
a1 a2 1 1
a2 a1 0.1 1
....
a1 l1 0.5 0
a1 m1 0.5 0
a1 q1 0.5 0
a1 v1 0.5 0
a1 z1 0.5 0
a1 s1 0.5 0
a1 w1 0.5 0
a1 u1 0.5 0
其中前两列为传播实体，第三列为实体间传播概率，最后一列为0代表同一网络传播，为1代表网络间自传播。
下来要进行优化：
1.采用独立级联模型，设置阈值
2.将最大路径改为最短路径，利用log

⑤ python pywifi 模块 如何识别(获取外置网卡)多张网卡(python的其他模块也可以)

不知道你是windows还是linux系统，用系统的网络配置命令查看，然后从结果里正则提取即可。
例如windows的 ipconfig /all 里面就有你要的信息。netsh命令下面也能找到你要的更多参数。