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命令下面也能找到你要的更多參數。