如何用python網路分析

㈠ 如何用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 分析網站日誌

日誌的記錄

Python有一個logging模塊，可以用來產生日誌。
（1）學習資料
http://blog.sina.com.cn/s/blog_4b5039210100f1wv.html

http://blog.donews.com/limodou/archive/2005/02/16/278699.aspx
http://kenby.iteye.com/blog/1162698
http://blog.csdn.NET/fxjtoday/article/details/6307285
前邊幾篇文章僅僅是其它人的簡單學習經驗，下邊這個鏈接中的內容比較全面。

http://www.red-dove.com/logging/index.html

（2）我需要關注內容
日誌信息輸出級別
logging模塊提供了多種日誌級別，如：NOTSET（0），DEBUG（10），
INFO（20），WARNING（30），WARNING（40），CRITICAL（50）。
設置方法：
logger = getLogger()
logger.serLevel(logging.DEBUG)

日誌數據格式
使用Formatter設置日誌的輸出格式。
設置方法：
logger = getLogger()
handler = loggingFileHandler(XXX)
formatter = logging.Formatter("%(asctime)s %(levelname) %(message)s","%Y-%m-%d,%H:%M:%S")

%(asctime)s表示記錄日誌寫入時間，"%Y-%m-%d,%H:%M:%S「設定了時間的具體寫入格式。
%(levelname)s表示記錄日誌的級別。
%(message)s表示記錄日誌的具體內容。

日誌對象初始化
def initLog():
logger = logging.getLogger()
handler = logging.FileHandler("日誌保存路徑")
formatter = logging.Formatter("%(asctime)s %(levelname) %(message)s","%Y-%m-%d,%H:%M:%S")
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel

寫日誌
logging.getLogger().info(), logging.getLogger().debug()......

2. 日誌的分析。
（1）我的日誌的內容。(log.txt)
2011-12-12,12:11:31 INFO Client1: 4356175.0 1.32366309133e+12 1.32366309134e+12
2011-12-12,12:11:33 INFO Client1: 4361320.0 1.32366309334e+12 1.32366309336e+12
2011-12-12,12:11:33 INFO Client0: 4361320.0 1.32366309389e+12 1.32366309391e+12
2011-12-12,12:11:39 INFO Client1: 4366364.0 1.32366309934e+12 1.32366309936e+12
2011-12-12,12:11:39 INFO Client0: 4366364.0 1.32366309989e+12 1.32366309991e+12
2011-12-12,12:11:43 INFO Client1: 4371416.0 1.32366310334e+12 1.32366310336e+12
2011-12-12,12:11:43 INFO Client0: 4371416.0 1.32366310389e+12 1.32366310391e+12
2011-12-12,12:11:49 INFO Client1: 4376450.0 1.32366310934e+12 1.32366310936e+12
我需要將上述內容逐行讀出，並將三個時間戳提取出來，然後將其圖形化。

(2) 文件操作以及字元串的分析。
打開文件，讀取出一行日誌。
file = file("日誌路徑"，「r」)
while True:
line = file.readline()
if len(len) == 0:
break;
print line
file.close()

從字元串中提取數據。
字元串操作學習資料：

http://reader.you.com/sharelite?itemId=-4646262544179865983&method=viewSharedItemThroughLink&sharedBy=-1137845767117085734
從上面展示出來的日誌內容可見，主要數據都是用空格分隔，所以需要使用字元串的
split函數對字元串進行分割：
paraList = line.split(),該函數默認的分割符是空格,返回值為一個list。
paraList[3], paraList[4], paraList[5]中分別以字元串形式存儲著我需要的時間戳。

使用float(paraList[3])將字元串轉化為浮點數。
（3）將日誌圖形化。
matplotlib是python的一個繪圖庫。我打算用它來將日誌圖形化。
matplotlib學習資料。
matplotlib的下載與安裝：
http://yexin218.iteye.com/blog/645894
http://blog.csdn.Net/sharkw/article/details/1924949

對matplotlib的宏觀介紹：
http://apps.hi..com/share/detail/21928578
對matplotlib具體使用的詳細介紹：

http://blog.sina.com.cn/s/blog_4b5039210100ie6a.html
在matplotlib中設置線條的顏色和形狀：
http://blog.csdn.net/kkxgx/article/details/python

如果想對matplotlib有一個全面的了解，就需要閱讀教程《Matplotlib for Python developers》,教程下載地址:
http://download.csdn.net/detail/nmgfrank/4006691

使用實例
import matplotlib.pyplot as plt

listX = [] #保存X軸數據
listY = [] #保存Y軸數據
listY1 = [] #保存Y軸數據

file = file("../log.txt","r")#打開日誌文件

while True:
line = file.readline()#讀取一行日誌
if len(line) == 0:#如果到達日誌末尾，退出
break
paraList = line.split()
print paraList[2]
print paraList[3]
print paraList[4]
print paraList[5]
if paraList[2] == "Client0:": #在坐標圖中添加兩個點，它們的X軸數值是相同的
listX.append(float(paraList[3]))
listY.append(float(paraList[5]) - float(paraList[3]))
listY1.append(float(paraList[4]) - float(paraList[3]))

file.close()

plt.plot(listX,listY,'bo-',listX,listY1,'ro')#畫圖
plt.title('tile')#設置所繪圖像的標題
plt.xlabel('time in sec')#設置x軸名稱
plt.ylabel('delays in ms'')#設置y軸名稱

plt.show()

㈢ 怎樣用python實現深度學習

基於Python的深度學習庫、深度學習方向、機器學習方向、自然語言處理方向的一些網站基本都是通過Python來實現的。
機器學習，尤其是現在火爆的深度學習，其工具框架大都提供了Python介面。Python在科學計算領域一直有著較好的聲譽，其簡潔清晰的語法以及豐富的計算工具，深受此領域開發者喜愛。
早在深度學習以及Tensorflow等框架流行之前，Python中即有scikit-learn，能夠很方便地完成幾乎所有機器學習模型，從經典數據集下載到構建模型只需要簡單的幾行代碼。配合Pandas、matplotlib等工具，能很簡單地進行調整。
而Tensorflow、PyTorch、MXNet、Keras等深度學習框架更是極大地拓展了機器學習的可能。使用Keras編寫一個手寫數字識別的深度學習網路僅僅需要寥寥數十行代碼，即可藉助底層實現，方便地調用包括GPU在內的大量資源完成工作。
值得一提的是，無論什麼框架，Python只是作為前端描述用的語言，實際計算則是通過底層的C/C++實現。由於Python能很方便地引入和使用C/C++項目和庫，從而實現功能和性能上的擴展，這樣的大規模計算中，讓開發者更關注邏輯於數據本身，而從內存分配等繁雜工作中解放出來，是Python被廣泛應用到機器學習領域的重要原因。

㈣ 有大神會用python做網路評論文本的情感分析么有償

這個自學一會就會了，給你一個模型，自己研究一下，沒那麼難。

importjieba
importnltk.classify.util
fromnltk.
fromnltk.corpusimportnames

defword_feats(words):
returndict([(word,True)forwordinwords])

text1=open(r"積極.txt","r").read()
seg_list=jieba.cut(text1)
result1="".join(seg_list)

text2=open(r"消極.txt","r").read()
seg_list=jieba.cut(text2)
result2="".join(seg_list)


#數據准備
positive_vocab=result1
negative_vocab=result2
#特徵提取
positive_features=[(word_feats(pos),'pos')forposinpositive_vocab]
negative_features=[(word_feats(neg),'neg')forneginnegative_vocab]
train_set=negative_features+positive_features
#訓練模型
classifier=NaiveBayesClassifier.train(train_set)

#實戰測試
neg=0
pos=0
sentence=input("請輸入一句你喜歡的話：")
sentence=sentence.lower()
seg_list=jieba.cut(sentence)
result1="".join(seg_list)
words=result1.split("")

forwordinwords:
classResult=classifier.classify(word_feats(word))
ifclassResult=='neg':
neg=neg+1
ifclassResult=='pos':
pos=pos+1

print('積極：'+str(float(pos)/len(words)))
print('消極:'+str(float(neg)/len(words)))

㈤ python 怎樣進行社會網路分析

就目前來說python畢竟是一門腳本語言，很多企業不會直接招會Python的人。最多會說，招C++或者C#或者。。。然後最後補上一句，熟悉python為佳！

㈥ 如何使用python進行社交網路分析

建議在知乎上問，那裡高手多，而且可能會有n個大神很詳細地回答。

㈦ 想學習python中的networkx做復雜網路分析應該看那本啊 求介紹

跟樓主遇到的問題一樣，找了很多python的書，沒有詳細介紹networkx，只能看下networkx文檔了，http://networkx.github.io/documentation/latest/index.html。
另外這上面有一些networkx的學習筆記，可以借鑒。http://wenku..com/link?url=-vZ25Tkio_

㈧ 如何用python分析網站日誌

#coding:utf-8
#file: FileSplit.py

import os,os.path,time

def FileSplit(sourceFile, targetFolder):
sFile = open(sourceFile, 'r')
number = 100000 #每個小文件中保存100000條數據
dataLine = sFile.readline()
tempData = [] #緩存列表
fileNum = 1
if not os.path.isdir(targetFolder): #如果目標目錄不存在，則創建
os.mkdir(targetFolder)
while dataLine: #有數據
for row in range(number):
tempData.append(dataLine) #將一行數據添加到列表中
dataLine = sFile.readline()
if not dataLine :
break
tFilename = os.path.join(targetFolder,os.path.split(sourceFile)[1] + str(fileNum) + ".txt")
tFile = open(tFilename, 'a+') #創建小文件
tFile.writelines(tempData) #將列表保存到文件中
tFile.close()
tempData = [] #清空緩存列表
print(tFilename + " 創建於: " + str(time.ctime()))
fileNum += 1 #文件編號

sFile.close()

if __name__ == "__main__" :
FileSplit("access.log","access")
#coding:utf-8
#file: Map.py

import os,os.path,re

def Map(sourceFile, targetFolder):
sFile = open(sourceFile, 'r')
dataLine = sFile.readline()
tempData = {} #緩存列表
if not os.path.isdir(targetFolder): #如果目標目錄不存在，則創建
os.mkdir(targetFolder)
while dataLine: #有數據
p_re = re.compile(r'(GET|POST)\s(.*?)\sHTTP/1.[01]',re.IGNORECASE) #用正則表達式解析數據
match = p_re.findall(dataLine)
if match:
visitUrl = match[0][1]
if visitUrl in tempData:
tempData[visitUrl] += 1
else:
tempData[visitUrl] = 1
dataLine = sFile.readline() #讀入下一行數據

sFile.close()

tList = []
for key,value in sorted(tempData.items(),key = lambda k:k[1],reverse = True):
tList.append(key + " " + str(value) + '\n')

tFilename = os.path.join(targetFolder,os.path.split(sourceFile)[1] + "_map.txt")
tFile = open(tFilename, 'a+') #創建小文件
tFile.writelines(tList) #將列表保存到文件中
tFile.close()

if __name__ == "__main__" :
Map("access\\access.log1.txt","access")
Map("access\\access.log2.txt","access")
Map("access\\access.log3.txt","access")
#coding:utf-8
#file: Rece.py

import os,os.path,re

def Rece(sourceFolder, targetFile):
tempData = {} #緩存列表
p_re = re.compile(r'(.*?)(\d{1,}$)',re.IGNORECASE) #用正則表達式解析數據
for root,dirs,files in os.walk(sourceFolder):
for fil in files:
if fil.endswith('_map.txt'): #是rece文件
sFile = open(os.path.abspath(os.path.join(root,fil)), 'r')
dataLine = sFile.readline()

while dataLine: #有數據
subdata = p_re.findall(dataLine) #用空格分割數據
#print(subdata[0][0]," ",subdata[0][1])
if subdata[0][0] in tempData:
tempData[subdata[0][0]] += int(subdata[0][1])
else:
tempData[subdata[0][0]] = int(subdata[0][1])
dataLine = sFile.readline() #讀入下一行數據

sFile.close()

tList = []
for key,value in sorted(tempData.items(),key = lambda k:k[1],reverse = True):
tList.append(key + " " + str(value) + '\n')

tFilename = os.path.join(sourceFolder,targetFile + "_rece.txt")
tFile = open(tFilename, 'a+') #創建小文件
tFile.writelines(tList) #將列表保存到文件中
tFile.close()

if __name__ == "__main__" :
Rece("access","access")

㈨ 如何用python進行大數據挖掘和分析

毫不誇張地說，大數據已經成為任何商業交流中不可或缺的一部分。桌面和移動搜索向全世界的營銷人員和公司以空前的規模提供著數據，並且隨著物聯網的到來，大量用以消費的數據還會呈指數級增長。這種消費數據對於想要更好地定位目標客戶、弄懂人們怎樣使用他們的產品或服務，並且通過收集信息來提高利潤的公司來說無疑是個金礦。
篩查數據並找到企業真正可以使用的結果的角色落到了軟體開發者、數據科學家和統計學家身上。現在有很多工具輔助大數據分析，但最受歡迎的就是Python。
為什麼選擇Python?
Python最大的優點就是簡單易用。這個語言有著直觀的語法並且還是個強大的多用途語言。這一點在大數據分析環境中很重要，並且許多企業內部已經在使用Python了，比如Google，YouTube，迪士尼，和索尼夢工廠。還有，Python是開源的，並且有很多用於數據科學的類庫。所以，大數據市場急需Python開發者，不是Python開發者的專家也可以以相當塊速度學習這門語言，從而最大化用在分析數據上的時間，最小化學習這門語言的時間。
用Python進行數據分析之前，你需要從Continuum.io下載Anaconda。這個包有著在Python中研究數據科學時你可能需要的一切東西。它的缺點是下載和更新都是以一個單元進行的，所以更新單個庫很耗時。但這很值得，畢竟它給了你所需的所有工具，所以你不需要糾結。
現在，如果你真的要用Python進行大數據分析的話，毫無疑問你需要成為一個Python開發者。這並不意味著你需要成為這門語言的大師，但你需要了解Python的語法，理解正則表達式，知道什麼是元組、字元串、字典、字典推導式、列表和列表推導式——這只是開始。
各種類庫
當你掌握了Python的基本知識點後，你需要了解它的有關數據科學的類庫是怎樣工作的以及哪些是你需要的。其中的要點包括NumPy，一個提供高級數學運算功能的基礎類庫，SciPy，一個專注於工具和演算法的可靠類庫，Sci-kit-learn，面向機器學習，還有Pandas，一套提供操作DataFrame功能的工具。
除了類庫之外，你也有必要知道Python是沒有公認的最好的集成開發環境(IDE)的，R語言也一樣。所以說，你需要親手試試不同的IDE再看看哪個更能滿足你的要求。開始時建議使用IPython Notebook，Rodeo和Spyder。和各種各樣的IDE一樣，Python也提供各種各樣的數據可視化庫，比如說Pygal，Bokeh和Seaborn。這些數據可視化工具中最必不可少的就是Matplotlib，一個簡單且有效的數值繪圖類庫。
所有的這些庫都包括在了Anaconda裡面，所以下載了之後，你就可以研究一下看看哪些工具組合更能滿足你的需要。用Python進行數據分析時你會犯很多錯誤，所以得小心一點。一旦你熟悉了安裝設置和每種工具後，你會發現Python是目前市面上用於大數據分析的最棒的平台之一。
希望能幫到你！