⑴ python可以做數據分析，好處是什麼呢怎麼學習

Python做數據分析，肯定是因為Python更簡單，內置了很多庫，用簡單的代碼就可以實現強大的功專能，想學習屬Python數據分析，可以找一些Python培訓或者大數據培訓的視頻看看，裡面都包含這一部分內容的！

⑵ Python中做了相關性分析發現相關系數太低，接下來應該怎麼做

你這問題問得太簡略了啊，多給點細節看一下

⑶ python做數據分析怎麼樣

我使用python這門語言也有三年了，被其簡潔、易讀、強大的庫所折服，我已經深深愛上了python。其pythonic語言特性，對人極其友好，可以說，一個完全不懂編程語言的人，看懂python語言也不是難事。

在數據分析和交互、探索性計算以及數據可視化等方面，相對於R、MATLAB、SAS、Stata等工具，Python都有其優勢。近年來，由於Python庫的不斷發展（如pandas），使其在數據挖掘領域嶄露頭角。結合其在通用編程方面的強大實力，我們完全可以只使用Python這一種語言去構建以數據為中心的應用程序。

由於python是一種解釋性語言，大部分編譯型語言都要比python代碼運行速度快，有些同學就因此鄙視python。但是小編認為，python是一門高級語言，其生產效率更高，程序員的時間通常比CPU的時間值錢，因此為了權衡利弊，考慮用python是值得的。


Python強大的計算能力依賴於其豐富而強大的庫：

  • Numpy

Numerical Python的簡稱，是Python科學計算的基礎包。其功能：

1. 快速高效的多維數組對象ndarray。

2. 用於對數組執行元素級計算以及直接對數組執行數學運算的函數。

3. 線性代數運算、傅里葉變換，以及隨機數生成。

4. 用於將C、C++、Fortran代碼集成到Python的工具。


除了為Python提供快速的數組處理能力，NumPy在數據分析方面還有另外一個主要作用，即作為在演算法之間傳遞數據的容器。對於數值型數據，NumPy數組在存儲和處理數據時要比內置的Python數據結構高效得多。此外，由低級語言（比如C和Fortran）編寫的庫可以直接操作NumPy數組中的數據，無需進行任何數據復制工作。


  • SciPy

是一組專門解決科學計算中各種標准問題域的包的集合，主要包括下面這些包：

1. scipy.integrate：數值積分常式和微分方程求解器。

2. scipy.linalg：擴展了由numpy.linalg提供的線性代數常式和矩陣分解功能。

3. scipy.optimize：函數優化器（最小化器）以及根查找演算法。

4. scipy.signal：信號處理工具。

5. scipy.sparse：稀疏矩陣和稀疏線性系統求解器。

6. scipy.special：SPECFUN（這是一個實現了許多常用數學函數（如伽瑪函數）的Fortran庫）的包裝器。

7. scipy.stats：標准連續和離散概率分布（如密度函數、采樣器、連續分布函數等）、各種統計檢驗方法，以及更好的描述統計法。

8. scipy.weave：利用內聯C++代碼加速數組計算的工具。


註：NumPy跟SciPy的有機結合完全可以替代MATLAB的計算功能（包括其插件工具箱）。


  • SymPy

是python的數學符號計算庫，用它可以進行數學表達式的符號推導和演算。


  • pandas

提供了使我們能夠快速便捷地處理結構化數據的大量數據結構和函數。你很快就會發現，它是使Python成為強大而高效的數據分析環境的重要因素之一。

pandas兼具NumPy高性能的數組計算功能以及電子表格和關系型資料庫(如SQL)靈活的數據處理功能。它提供了復雜精細的索引功能，以便更為便捷地完成重塑、切片和切塊、聚合以及選取數據子集等操作。

對於使用R語言進行統計計算的用戶，肯定不會對DataFrame這個名字感到陌生，因為它源自於R的data.frame對象。但是這兩個對象並不相同。R的data.frame對象所提供的功能只是DataFrame對象所提供的功能的一個子集。也就是說pandas的DataFrame功能比R的data.frame功能更強大。


  • matplotlib

是最流行的用於繪制數據圖表的Python庫。它最初由John D. Hunter（JDH）創建，目前由一個龐大的開發人員團隊維護。它非常適合創建出版物上用的圖表。它跟IPython（馬上就會講到）結合得很好，因而提供了一種非常好用的互動式數據繪圖環境。繪制的圖表也是互動式的，你可以利用繪圖窗口中的工具欄放大圖表中的某個區域或對整個圖表進行平移瀏覽。


  • TVTK

是python數據三維可視化庫，是一套功能十分強大的三維數據可視化庫，它提供了Python風格的API，並支持Trait屬性(由於Python是動態編程語言，其變數沒有類型，這種靈活性有助於快速開發，但是也有缺點。而Trait庫可以為對象的屬性添加檢校功能，從而提高程序的可讀性，降低出錯率。) 和NumPy數組。此庫非常龐大，因此開發公司提供了一個查詢文檔，用戶可以通過下面語句運行它：

>>> from enthought.tvtk.toolsimport tvtk_doc

>>> tvtk_doc.main()


  • Scikit-Learn

是基於python的機器學習庫，建立在NumPy、SciPy和matplotlib基礎上，操作簡單、高效的數據挖掘和數據分析。其文檔、實例都比較齊全。


小編建議：初學者使用python(x, y)，其是一個免費的科學和工程開發包，提供數學計算、數據分析和可視化展示。非常方便！

其官網：www.pythonxy.com（由於某種原因，國內上不去，需要翻牆）

下載地址：ftp://ftp.ntua.gr/pub/devel/pythonxy/（小編到網上搜到的一個地址，親測可以用）

下圖展示了python(x, y) 強大功能。

⑷ 如何進行python性能分析

使用time工具粗糙定時

首先，我們可以使用快速然而粗糙的工具：古老的unix工具time，來為我們的代碼檢測運行時間。
1 $ time python yourprogram.py
2
3 real 0m1.028s
4 user 0m0.001s
5 sys 0m0.003s
上面三個輸入變數的意義在文章 stackoverflow article 中有詳細介紹。簡單的說：

real - 表示實際的程序運行時間
user - 表示程序在用戶態的cpu總時間
sys - 表示在內核態的cpu總時間

通過sys和user時間的求和，你可以直觀的得到系統上沒有其他程序運行時你的程序運行所需要的CPU周期。

若sys和user時間之和遠遠少於real時間，那麼你可以猜測你的程序的主要性能問題很可能與IO等待相關。

使用計時上下文管理器進行細粒度計時

我們的下一個技術涉及訪問細粒度計時信息的直接代碼指令。這是一小段代碼，我發現使用專門的計時測量是非常重要的：

timer.py
01 import time
02
03 class Timer(object):
04 def __init__(self, verbose=False):
05 self.verbose = verbose
06
07 def __enter__(self):
08 self.start = time.time()
09 return self
10
11 def __exit__(self, *args):
12 self.end = time.time()
13 self.secs = self.end - self.start
14 self.msecs = self.secs * 1000 # millisecs
15 if self.verbose:
16 print 'elapsed time: %f ms' % self.msecs

為了使用它，你需要用Python的with關鍵字和Timer上下文管理器包裝想要計時的代碼塊。它將會在你的代碼塊開始執行的時候啟動計時器，在你的代碼塊結束的時候停止計時器。

這是一個使用上述代碼片段的例子：
01 from timer import Timer
02 from redis import Redis
03 rdb = Redis()
04
05 with Timer() as t:
06 rdb.lpush("foo", "bar")
07 print "=> elasped lpush: %s s" % t.secs
08
09 with Timer as t:
10 rdb.lpop("foo")
11 print "=> elasped lpop: %s s" % t.secs

我經常將這些計時器的輸出記錄到文件中，這樣就可以觀察我的程序的性能如何隨著時間進化。

使用分析器逐行統計時間和執行頻率

Robert Kern有一個稱作line_profiler的不錯的項目，我經常使用它查看我的腳步中每行代碼多快多頻繁的被執行。

想要使用它，你需要通過pip安裝該python包：
1 $ pip install line_profiler

一旦安裝完成，你將會使用一個稱做「line_profiler」的新模組和一個「kernprof.py」可執行腳本。

想要使用該工具，首先修改你的源代碼，在想要測量的函數上裝飾@profile裝飾器。不要擔心，你不需要導入任何模組。kernprof.py腳本將會在執行的時候將它自動地注入到你的腳步的運行時。

primes.py
01 @profile
02 def primes(n):
03 if n==2:
04 return [2]
05 elif n<2:
06 return []
07 s=range(3,n+1,2)
08 mroot = n ** 0.5
09 half=(n+1)/2-1
10 i=0
11 m=3
12 while m <= mroot:
13 if s[i]:
14 j=(m*m-3)/2
15 s[j]=0
16 while j
17 s[j]=0
18 j+=m
19 i=i+1
20 m=2*i+3
21 return [2]+[x for x in s if x]
22 primes(100)
一旦你已經設置好了@profile裝飾器，使用kernprof.py執行你的腳步。
1 $ kernprof.py -l -v fib.py
-l選項通知kernprof注入@profile裝飾器到你的腳步的內建函數，-v選項通知kernprof在腳本執行完畢的時候顯示計時信息。上述腳本的輸出看起來像這樣：
01 Wrote profile results to primes.py.lprof
02 Timer unit: 1e-06 s
03
04 File: primes.py
05 Function: primes at line 2
06 Total time: 0.00019 s
07
08 Line # Hits Time Per Hit % Time Line Contents
09 ==============================================================
10 2 @profile
11 3 def primes(n):
12 4 1 2 2.0 1.1 if n==2:
13 5 return [2]
14 6 1 1 1.0 0.5 elif n<2:
15 7 return []
16 8 1 4 4.0 2.1 s=range(3,n+1,2)
17 9 1 10 10.0 5.3 mroot = n ** 0.5
18 10 1 2 2.0 1.1 half=(n+1)/2-1
19 11 1 1 1.0 0.5 i=0
20 12 1 1 1.0 0.5 m=3
21 13 5 7 1.4 3.7 while m <= mroot:
22 14 4 4 1.0 2.1 if s[i]:
23 15 3 4 1.3 2.1 j=(m*m-3)/2
24 16 3 4 1.3 2.1 s[j]=0
25 17 31 31 1.0 16.3 while j
26 18 28 28 1.0 14.7 s[j]=0
27 19 28 29 1.0 15.3 j+=m
28 20 4 4 1.0 2.1 i=i+1
29 21 4 4 1.0 2.1 m=2*i+3
30 22 50 54 1.1 28.4 return [2]+[x for x in s if x]

尋找具有高Hits值或高Time值的行。這些就是可以通過優化帶來最大改善的地方。

程序使用了多少內存？

現在我們對計時有了較好的理解，那麼讓我們繼續弄清楚程序使用了多少內存。我們很幸運，Fabian Pedregosa模仿Robert Kern的line_profiler實現了一個不錯的內存分析器。

首先使用pip安裝:
1 $ pip install -U memory_profiler
2 $ pip install psutil

（這里建議安裝psutil包，因為它可以大大改善memory_profiler的性能）。

就像line_profiler，memory_profiler也需要在感興趣的函數上面裝飾@profile裝飾器：
1 @profile
2 def primes(n):
3 ...
4 ...
想要觀察你的函數使用了多少內存，像下面這樣執行：
1 $ python -m memory_profiler primes.py
一旦程序退出，你將會看到看起來像這樣的輸出：
01 Filename: primes.py
02
03 Line # Mem usage Increment Line Contents
04 ==============================================
05 2 @profile
06 3 7.9219 MB 0.0000 MB def primes(n):
07 4 7.9219 MB 0.0000 MB if n==2:
08 5 return [2]
09 6 7.9219 MB 0.0000 MB elif n<2:
10 7 return []
11 8 7.9219 MB 0.0000 MB s=range(3,n+1,2)
12 9 7.9258 MB 0.0039 MB mroot = n ** 0.5
13 10 7.9258 MB 0.0000 MB half=(n+1)/2-1
14 11 7.9258 MB 0.0000 MB i=0
15 12 7.9258 MB 0.0000 MB m=3
16 13 7.9297 MB 0.0039 MB while m <= mroot:
17 14 7.9297 MB 0.0000 MB if s[i]:
18 15 7.9297 MB 0.0000 MB j=(m*m-3)/2
19 16 7.9258 MB -0.0039 MB s[j]=0
20 17 7.9297 MB 0.0039 MB while j
21 18 7.9297 MB 0.0000 MB s[j]=0
22 19 7.9297 MB 0.0000 MB j+=m
23 20 7.9297 MB 0.0000 MB i=i+1
24 21 7.9297 MB 0.0000 MB m=2*i+3
25 22 7.9297 MB 0.0000 MB return [2]+[x for x in s if x]

line_profiler和memory_profiler的IPython快捷方式

memory_profiler和line_profiler有一個鮮為人知的小竅門，兩者都有在IPython中的快捷命令。你需要做的就是在IPython會話中輸入以下內容：
1 %load_ext memory_profiler
2 %load_ext line_profiler

在這樣做的時候你需要訪問魔法命令%lprun和%mprun，它們的行為類似於他們的命令行形式。主要區別是你不需要使用@profiledecorator來修飾你要分析的函數。只需要在IPython會話中像先前一樣直接運行分析：
1 In [1]: from primes import primes
2 In [2]: %mprun -f primes primes(1000)
3 In [3]: %lprun -f primes primes(1000)

這樣可以節省你很多時間和精力，因為你的源代碼不需要為使用這些分析命令而進行修改。

內存泄漏在哪裡？

cPython解釋器使用引用計數做為記錄內存使用的主要方法。這意味著每個對象包含一個計數器，當某處對該對象的引用被存儲時計數器增加，當引用被刪除時計數器遞減。當計數器到達零時，cPython解釋器就知道該對象不再被使用，所以刪除對象，釋放佔用的內存。

如果程序中不再被使用的對象的引用一直被佔有，那麼就經常發生內存泄漏。

查找這種「內存泄漏」最快的方式是使用Marius Gedminas編寫的objgraph，這是一個極好的工具。該工具允許你查看內存中對象的數量，定位含有該對象的引用的所有代碼的位置。

⑸ python相關性分析如何生成兩個相關性最強的兩門

方法/步驟

  • 第一步我們首先需要知道相關性主要有兩個方向，一個是正方向一個是負方向，相關性系數是衡量兩個變數之間影響程度，如下圖所示：

⑹ 如何利用python進行數據的相關性分析

1. 運算優先順序
括弧、指數、乘、除、加、減
2
如果你使用了非 ASCII 字元而且碰到了編碼錯誤，記得在最頂端加一行 # -- coding: utf-8 --
3. Python格式化字元
使用更多的格式化字元。例如 %r 就是是非常有用的一個，它的含義是「不管什麼都列印出來」。
%s -- string
%% 百分號標記 #就是輸出一個%
%c 字元及其ASCII碼
%s 字元串
%d 有符號整數(十進制)
%u 無符號整數(十進制)
%o 無符號整數(八進制)
%x 無符號整數(十六進制)
%X 無符號整數(十六進制大寫字元)
%e 浮點數字(科學計數法)
%E 浮點數字(科學計數法，用E代替e)
%f 浮點數字(用小數點符號)
%g 浮點數字(根據值的大小採用%e或%f)
%G 浮點數字(類似於%g)
%p 指針(用十六進制列印值的內存地址)
%n 存儲輸出字元的數量放進參數列表的下一個變數中
%c 轉換成字元（ASCII 碼值，或者長度為一的字元串）
%r 優先用repr()函數進行字元串轉換（Python2.0新增）
%s 優先用str()函數進行字元串轉換
%d / %i 轉成有符號十進制數
%u 轉成無符號十進制數
%o 轉成無符號八進制數
%x / %X (Unsigned)轉成無符號十六進制數（x / X 代表轉換後的十六進制字元的大小寫）
%e / %E 轉成科學計數法（e / E控制輸出e / E）
%f / %F 轉成浮點數（小數部分自然截斷）
%g / %G : %e和%f / %E和%F 的簡寫
%% 輸出%
輔助符號 說明
* 定義寬度或者小數點精度
- 用做左對齊
+ 在正數前面顯示加號(+)
<sp> 在正數前面顯示空格
# 在八進制數前面顯示零(0)，在十六進制前面顯示「0x」或者「0X」（取決於用的是「x」還是「X」）
0 顯示的數字前面填充「0」而不是默認的空格
m.n m 是顯示的最小總寬度，n 是小數點後的位數（如果可用的話）

⑺ 初學python，怎樣用python做pearson相關系數的檢驗呢，求指導啊

scipy.stats.pearsonr(x, y)

x和y為相同長來度的兩組數據

返回值 r, p-value

r是相關源系數，取值-1~1. 表示線性相關程度
p-value越小，表示相關程度越顯著。按照文檔的說法「The p-values are not entirely reliable but are probably reasonable for datasets larger than 500 or so.」，p-value在500個樣本值以上有較高的可靠性

⑻ python中如何分析這是一本關於什麼的文檔

最基本的就是做來分詞後取自最高頻詞。

作為優化，可以從詞性角度排除一些高頻詞，如高頻詞「的」之類的。
如果還想進一步優化，就需要使用大數據了，建立一個詞相關性評分表，對文檔分詞後的詞頻與這相應的相關度做加權，選取加權最高的一組詞或幾組詞為文檔的索引詞表。
然後從文檔中提取整句與提取的索引詞表履蓋度最高的若干句作為文檔的摘要。
大部分的摘要演算法就是按這個思路來完成的。