1. python數據分析與應用第三章代碼3-5的數據哪來的
savetxt
import numpy as np
i2 = np.eye(2)
np.savetxt("eye.txt", i2)
3.4 讀入CSV文件
# AAPL,28-01-2011, ,344.17,344.4,333.53,336.1,21144800
c,v=np.loadtxt('data.csv', delimiter=',', usecols=(6,7), unpack=True) #index從0開始
3.6.1 算術平均值
np.mean(c) = np.average(c)
3.6.2 加權平均值
t = np.arange(len(c))
np.average(c, weights=t)
3.8 極值
np.min(c)
np.max(c)
np.ptp(c) 最大值與最小值的差值
3.10 統計分析
np.median(c) 中位數
np.msort(c) 升序排序
np.var(c) 方差
3.12 分析股票收益率
np.diff(c) 可以返回一個由相鄰數組元素的差
值構成的數組
returns = np.diff( arr ) / arr[ : -1] #diff返回的數組比收盤價數組少一個元素
np.std(c) 標准差
對數收益率
logreturns = np.diff( np.log(c) ) #應檢查輸入數組以確保其不含有零和負數
where 可以根據指定的條件返回所有滿足條件的數
組元素的索引值。
posretindices = np.where(returns > 0)
np.sqrt(1./252.) 平方根,浮點數
3.14 分析日期數據
# AAPL,28-01-2011, ,344.17,344.4,333.53,336.1,21144800
dates, close=np.loadtxt('data.csv', delimiter=',', usecols=(1,6), converters={1:datestr2num}, unpack=True)
print "Dates =", dates
def datestr2num(s):
return datetime.datetime.strptime(s, "%d-%m-%Y").date().weekday()
# 星期一 0
# 星期二 1
# 星期三 2
# 星期四 3
# 星期五 4
# 星期六 5
# 星期日 6
#output
Dates = [ 4. 0. 1. 2. 3. 4. 0. 1. 2. 3. 4. 0. 1. 2. 3. 4. 1. 2. 4. 0. 1. 2. 3. 4. 0.
1. 2. 3. 4.]
averages = np.zeros(5)
for i in range(5):
indices = np.where(dates == i)
prices = np.take(close, indices) #按數組的元素運算,產生一個數組作為輸出。
>>>a = [4, 3, 5, 7, 6, 8]
>>>indices = [0, 1, 4]
>>>np.take(a, indices)
array([4, 3, 6])
np.argmax(c) #返回的是數組中最大元素的索引值
np.argmin(c)
3.16 匯總數據
# AAPL,28-01-2011, ,344.17,344.4,333.53,336.1,21144800
#得到第一個星期一和最後一個星期五
first_monday = np.ravel(np.where(dates == 0))[0]
last_friday = np.ravel(np.where(dates == 4))[-1]
#創建一個數組,用於存儲三周內每一天的索引值
weeks_indices = np.arange(first_monday, last_friday + 1)
#按照每個子數組5個元素,用split函數切分數組
weeks_indices = np.split(weeks_indices, 5)
#output
[array([1, 2, 3, 4, 5]), array([ 6, 7, 8, 9, 10]), array([11,12, 13, 14, 15])]
weeksummary = np.apply_along_axis(summarize, 1, weeks_indices,open, high, low, close)
def summarize(a, o, h, l, c): #open, high, low, close
monday_open = o[a[0]]
week_high = np.max( np.take(h, a) )
week_low = np.min( np.take(l, a) )
friday_close = c[a[-1]]
return("APPL", monday_open, week_high, week_low, friday_close)
np.savetxt("weeksummary.csv", weeksummary, delimiter=",", fmt="%s") #指定了文件名、需要保存的數組名、分隔符(在這個例子中為英文標點逗號)以及存儲浮點數的格式。
.png
格式字元串以一個百分號開始。接下來是一個可選的標志字元:-表示結果左對齊,0表示左端補0,+表示輸出符號(正號+或負號-)。第三部分為可選的輸出寬度參數,表示輸出的最小位數。第四部分是精度格式符,以」.」開頭,後面跟一個表示精度的整數。最後是一個類型指定字元,在例子中指定為字元串類型。
numpy.apply_along_axis(func1d, axis, arr, *args, **kwargs)
>>>def my_func(a):
... """Average first and last element of a 1-D array"""
... return (a[0] + a[-1]) * 0.5
>>>b = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>>np.apply_along_axis(my_func, 0, b) #沿著X軸運動,取列切片
array([ 4., 5., 6.])
>>>np.apply_along_axis(my_func, 1, b) #沿著y軸運動,取行切片
array([ 2., 5., 8.])
>>>b = np.array([[8,1,7], [4,3,9], [5,2,6]])
>>>np.apply_along_axis(sorted, 1, b)
array([[1, 7, 8],
[3, 4, 9],
[2, 5, 6]])
3.20 計算簡單移動平均線
(1) 使用ones函數創建一個長度為N的元素均初始化為1的數組,然後對整個數組除以N,即可得到權重。如下所示:
N = int(sys.argv[1])
weights = np.ones(N) / N
print "Weights", weights
在N = 5時,輸出結果如下:
Weights [ 0.2 0.2 0.2 0.2 0.2] #權重相等
(2) 使用這些權重值,調用convolve函數:
c = np.loadtxt('data.csv', delimiter=',', usecols=(6,),unpack=True)
sma = np.convolve(weights, c)[N-1:-N+1] #卷積是分析數學中一種重要的運算,定義為一個函數與經過翻轉和平移的另一個函數的乘積的積分。
t = np.arange(N - 1, len(c)) #作圖
plot(t, c[N-1:], lw=1.0)
plot(t, sma, lw=2.0)
show()
3.22 計算指數移動平均線
指數移動平均線(exponential moving average)。指數移動平均線使用的權重是指數衰減的。對歷史上的數據點賦予的權重以指數速度減小,但永遠不會到達0。
x = np.arange(5)
print "Exp", np.exp(x)
#output
Exp [ 1. 2.71828183 7.3890561 20.08553692 54.59815003]
Linspace 返回一個元素值在指定的范圍內均勻分布的數組。
print "Linspace", np.linspace(-1, 0, 5) #起始值、終止值、可選的元素個數
#output
Linspace [-1. -0.75 -0.5 -0.25 0. ]
(1)權重計算
N = int(sys.argv[1])
weights = np.exp(np.linspace(-1. , 0. , N))
(2)權重歸一化處理
weights /= weights.sum()
print "Weights", weights
#output
Weights [ 0.11405072 0.14644403 0.18803785 0.24144538 0.31002201]
(3)計算及作圖
c = np.loadtxt('data.csv', delimiter=',', usecols=(6,),unpack=True)
ema = np.convolve(weights, c)[N-1:-N+1]
t = np.arange(N - 1, len(c))
plot(t, c[N-1:], lw=1.0)
plot(t, ema, lw=2.0)
show()
3.26 用線性模型預測價格
(x, resials, rank, s) = np.linalg.lstsq(A, b) #系數向量x、一個殘差數組、A的秩以及A的奇異值
print x, resials, rank, s
#計算下一個預測值
print np.dot(b, x)
3.28 繪制趨勢線
>>> x = np.arange(6)
>>> x = x.reshape((2, 3))
>>> x
array([[0, 1, 2], [3, 4, 5]])
>>> np.ones_like(x) #用1填充數組
array([[1, 1, 1], [1, 1, 1]])
類似函數
zeros_like
empty_like
zeros
ones
empty
3.30 數組的修剪和壓縮
a = np.arange(5)
print "a =", a
print "Clipped", a.clip(1, 2) #將所有比給定最大值還大的元素全部設為給定的最大值,而所有比給定最小值還小的元素全部設為給定的最小值
#output
a = [0 1 2 3 4]
Clipped [1 1 2 2 2]
a = np.arange(4)
print a
print "Compressed", a.compress(a > 2) #返回一個根據給定條件篩選後的數組
#output
[0 1 2 3]
Compressed [3]
b = np.arange(1, 9)
print "b =", b
print "Factorial", b.prod() #輸出數組元素階乘結果
#output
b = [1 2 3 4 5 6 7 8]
Factorial 40320
print "Factorials", b.cumprod()
#output
2. 用python編寫:輸入n對數,輸出其中max與min。
a = input()
max(a)
min(a)
第一行注意下輸入的格式和類型。
python裡面自帶max和min方法。不用再去對元組或列表進行排序,找最大值最小值
3. Python數據分析 | 數據描述性分析
首先導入一些必要的數據處理包和可視化的包,讀文檔數據並通過前幾行查看數據欄位。
對於我的數據來說,由於數據量比較大,因此對於缺失值可以直接做刪除處理。
得到最終的數據,並提取需要的列作為特徵。
對類別數據進行統計:
類別型欄位包括location、cpc_class、pa_country、pa_state、pa_city、assignee六個欄位,其中:
單變數統計描述是數據分析中最簡單的形式,其中被分析的數據只包含一個變數,不處理原因或關系。單變數分析的主要目的是通過對數據的統計描述了解當前數據的基本情況,並找出數據的分布模型。
單變數數據統計描述從集中趨勢上看,指標有:均值,中位數,分位數,眾數;從離散程度上看,指標有:極差、四分位數、方差、標准差、協方差、變異系數,從分布上看,有偏度,峰度等。需要考慮的還有極大值,極小值(數值型變數)和頻數,構成比(分類或等級變數)。
對於數值型數據,首先希望了解一下數據取值范圍的分布,因此可以用統計圖直觀展示數據分布特徵,如:柱狀圖、正方圖、箱式圖、頻率多邊形和餅狀圖。
按照發布的時間先後作為橫坐標,數值范圍的分布情況如圖所示.
還可以根據最終分類的結果查看這些數值數據在不同類別上的分布統計。
箱線圖可以更直觀的查看異常值的分布情況。
異常值指數據中的離群點,此處定義超出上下四分位數差值的1.5倍的范圍為異常值,查看異常值的位置。
參考:
python數據分析之數據分布 - yancheng111 - 博客園
python數據統計分析 -
科爾莫戈羅夫檢驗(Kolmogorov-Smirnov test),檢驗樣本數據是否服從某一分布,僅適用於連續分布的檢驗。下例中用它檢驗正態分布。
在使用k-s檢驗該數據是否服從正態分布,提出假設:x從正態分布。最終返回的結果,p-value=0.9260909172362317,比指定的顯著水平(一般為5%)大,則我們不能拒絕假設:x服從正態分布。這並不是說x服從正態分布一定是正確的,而是說沒有充分的證據證明x不服從正態分布。因此我們的假設被接受,認為x服從正態分布。如果p-value小於我們指定的顯著性水平,則我們可以肯定的拒絕提出的假設,認為x肯定不服從正態分布,這個拒絕是絕對正確的。
衡量兩個變數的相關性至少有以下三個方法:
皮爾森相關系數(Pearson correlation coefficient) 是反應倆變數之間線性相關程度的統計量,用它來分析正態分布的兩個連續型變數之間的相關性。常用於分析自變數之間,以及自變數和因變數之間的相關性。
返回結果的第一個值為相關系數表示線性相關程度,其取值范圍在[-1,1],絕對值越接近1,說明兩個變數的相關性越強,絕對值越接近0說明兩個變數的相關性越差。當兩個變數完全不相關時相關系數為0。第二個值為p-value,統計學上,一般當p-value<0.05時,可以認為兩變數存在相關性。
斯皮爾曼等級相關系數(Spearman』s correlation coefficient for ranked data ) ,它主要用於評價順序變數間的線性相關關系,在計算過程中,只考慮變數值的順序(rank, 秩或稱等級),而不考慮變數值的大小。常用於計算類型變數的相關性。
返回結果的第一個值為相關系數表示線性相關程度,本例中correlation趨近於1表示正相關。第二個值為p-value,p-value越小,表示相關程度越顯著。
kendall :
也可以直接對整體數據進行相關性分析,一般來說,相關系數取值和相關強度的關系是:0.8-1.0 極強 0.6-0.8 強 0.4-0.6 中等 0.2-0.4 弱 0.0-0.2 極弱。
4. 後端編程Python3-調試、測試和性能剖析(下)
單元測試(Unit Testing)
為程序編寫測試——如果做的到位——有助於減少bug的出現,並可以提高我們對程序按預期目標運行的信心。通常,測試並不能保證正確性,因為對大多數程序而言, 可能的輸入范圍以及可能的計算范圍是如此之大,只有其中最小的一部分能被實際地進 行測試。盡管如此,通過仔細地選擇測試的方法和目標,可以提高代碼的質量。
大量不同類型的測試都可以進行,比如可用性測試、功能測試以及整合測試等。這里, 我們只講單元測試一對單獨的函數、類與方法進行測試,確保其符合預期的行為。
TDD的一個關鍵點是,當我們想添加一個功能時——比如為類添加一個方法—— 我們首次為其編寫一個測試用例。當然,測試將失敗,因為我們還沒有實際編寫該方法。現在,我們編寫該方法,一旦方法通過了測試,就可以返回所有測試,確保我們新添加的代碼沒有任何預期外的副作用。一旦所有測試運行完畢(包括我們為新功能編寫的測試),就可以對我們的代碼進行檢查,並有理有據地相信程序行為符合我們的期望——當然,前提是我們的測試是適當的。
比如,我們編寫了一個函數,該函數在特定的索引位置插入一個字元串,可以像下面這樣開始我們的TDD:
def insert_at(string, position, insert):
"""Returns a of string with insert inserted at the position
>>> string = "ABCDE"
>>> result =[]
>>> for i in range(-2, len(string) + 2):
... result.append(insert_at(string, i,「-」))
>>> result[:5]
['ABC-DE', 'ABCD-E', '-ABCDE','A-BCDE', 'AB-CDE']
>>> result[5:]
['ABC-DE', 'ABCD-E', 'ABCDE-', 'ABCDE-']
"""
return string
對不返回任何參數的函數或方法(通常返回None),我們通常賦予其由pass構成的一個suite,對那些返回值被試用的,我們或者返回一個常數(比如0),或者某個不變的參數——這也是我們這里所做的。(在更復雜的情況下,返回fake對象可能更有用一一對這樣的類,提供mock對象的第三方模塊是可用的。)
運行doctest時會失敗,並列出每個預期內的字元串('ABCD-EF'、'ABCDE-F' 等),及其實際獲取的字元串(所有的都是'ABCD-EF')。一旦確定doctest是充分的和正確的,就可以編寫該函數的主體部分,在本例中只是簡單的return string[:position] + insert+string[position:]。(如果我們編寫的是 return string[:position] + insert,之後復制 string [:position]並將其粘貼在末尾以便減少一些輸入操作,那麼doctest會立即提示錯誤。)
Python的標准庫提供了兩個單元測試模塊,一個是doctest,這里和前面都簡單地提到過,另一個是unittest。此外,還有一些可用於Python的第三方測試工具。其中最著名的兩個是nose (code.google.com/p/python-nose)與py.test (codespeak.net/py/dist/test/test.html), nose 致力於提供比標準的unittest 模塊更廣泛的功能,同時保持與該模塊的兼容性,py.test則採用了與unittest有些不同的方法,試圖盡可能消除樣板測試代碼。這兩個第三方模塊都支持測試發現,因此沒必要寫一個總體的測試程序——因為模塊將自己搜索測試程序。這使得測試整個代碼樹或某一部分 (比如那些已經起作用的模塊)變得很容易。那些對測試嚴重關切的人,在決定使用哪個測試工具之前,對這兩個(以及任何其他有吸引力的)第三方模塊進行研究都是值 得的。
創建doctest是直截了當的:我們在模塊中編寫測試、函數、類與方法的docstrings。 對於模塊,我們簡單地在末尾添加了 3行:
if __name__ =="__main__":
import doctest
doctest.testmod()
在程序內部使用doctest也是可能的。比如,blocks.py程序(其模塊在後面)有自己函數的doctest,但以如下代碼結尾:
if __name__== "__main__":
main()
這里簡單地調用了程序的main()函數,並且沒有執行程序的doctest。要實驗程序的 doctest,有兩種方法。一種是導入doctest模塊,之後運行程序---比如,在控制台中輸 入 python3 -m doctest blocks.py (在 Wndows 平台上,使用類似於 C:Python3 lpython.exe 這樣的形式替代python3)。如果所有測試運行良好,就沒有輸出,因此,我們可能寧願執行python3-m doctest blocks.py-v,因為這會列出每個執行的doctest,並在最後給出結果摘要。
另一種執行doctest的方法是使用unittest模塊創建單獨的測試程序。在概念上, unittest模塊是根據Java的JUnit單元測試庫進行建模的,並用於創建包含測試用例的測試套件。unittest模塊可以基於doctests創建測試用例,而不需要知道程序或模塊包含的任何事物——只要知道其包含doctest即可。因此,為給blocks.py程序製作一個測試套件,我們可以創建如下的簡單程序(將其稱為test_blocks.py):
import doctest
import unittest
import blocks
suite = unittest.TestSuite()
suite.addTest(doctest.DocTestSuite(blocks))
runner = unittest.TextTestRunner()
print(runner.run(suite))
注意,如果釆用這種方法,程序的名稱上會有一個隱含的約束:程序名必須是有效的模塊名。因此,名為convert-incidents.py的程序的測試不能寫成這樣。因為import convert-incidents不是有效的,在Python標識符中,連接符是無效的(避開這一約束是可能的,但最簡單的解決方案是使用總是有效模塊名的程序文件名,比如,使用下劃線替換連接符)。這里展示的結構(創建一個測試套件,添加一個或多個測試用例或測試套件,運行總體的測試套件,輸出結果)是典型的機遇unittest的測試。運行時,這一特定實例產生如下結果:
...
.............................................................................................................
Ran 3 tests in 0.244s
OK
每次執行一個測試用例時,都會輸出一個句點(因此上面的輸出最前面有3個句點),之後是一行連接符,再之後是測試摘要(如果有任何一個測試失敗,就會有更多的輸出信息)。
如果我們嘗試將測試分離開(典型情況下是要測試的每個程序和模塊都有一個測試用例),就不要再使用doctests,而是直接使用unittest模塊的功能——尤其是我們習慣於使用JUnit方法進行測試時ounittest模塊會將測試分離於代碼——對大型項目(測試編寫人員與開發人員可能不一致)而言,這種方法特別有用。此外,unittest單元測試編寫為獨立的Python模塊,因此,不會像在docstring內部編寫測試用例時受到兼容性和明智性的限制。
unittest模塊定義了 4個關鍵概念。測試夾具是一個用於描述創建測試(以及用完之後將其清理)所必需的代碼的術語,典型實例是創建測試所用的一個輸入文件,最後刪除輸入文件與結果輸出文件。測試套件是一組測試用例的組合。測試用例是測試的基本單元—我們很快就會看到實例。測試運行者是執行一個或多個測試套件的對象。
典型情況下,測試套件是通過創建unittest.TestCase的子類實現的,其中每個名稱 以「test」開頭的方法都是一個測試用例。如果我們需要完成任何創建操作,就可以在一個名為setUp()的方法中實現;類似地,對任何清理操作,也可以實現一個名為 tearDown()的方法。在測試內部,有大量可供我們使用的unittest.TestCase方法,包括 assertTrue()、assertEqual()、assertAlmostEqual()(對於測試浮點數很有用)、assertRaises() 以及更多,還包括很多對應的逆方法,比如assertFalse()、assertNotEqual()、failIfEqual()、 failUnlessEqual ()等。
unittest模塊進行了很好的歸檔,並且提供了大量功能,但在這里我們只是通過一 個非常簡單的測試套件來感受一下該模塊的使用。這里將要使用的實例,該練習要求創建一個Atomic模塊,該模塊可以用作一 個上下文管理器,以確保或者所有改變都應用於某個列表、集合或字典,或者所有改變都不應用。作為解決方案提供的Atomic.py模塊使用30行代碼來實現Atomic類, 並提供了 100行左右的模塊doctest。這里,我們將創建test_Atomic.py模塊,並使用 unittest測試替換doctest,以便可以刪除doctest。
在編寫測試模塊之前,我們需要思考都需要哪些測試。我們需要測試3種不同的數據類型:列表、集合與字典。對於列表,需要測試的是插入項、刪除項或修改項的值。對於集合,我們必須測試向其中添加或刪除一個項。對於字典,我們必須測試的是插入一個項、修改一個項的值、刪除一個項。此外,還必須要測試的是在失敗的情況下,不會有任何改變實際生效。
結構上看,測試不同數據類型實質上是一樣的,因此,我們將只為測試列表編寫測試用例,而將其他的留作練習。test_Atomic.py模塊必須導入unittest模塊與要進行測試的Atomic模塊。
創建unittest文件時,我們通常創建的是模塊而非程序。在每個模塊內部,我們定義一個或多個unittest.TestCase子類。比如,test_Atomic.py模塊中僅一個單獨的 unittest-TestCase子類,也就是TestAtomic (稍後將對其進行講解),並以如下兩行結束:
if name == "__main__":
unittest.main()
這兩行使得該模塊可以單獨運行。當然,該模塊也可以被導入並從其他測試程序中運行——如果這只是多個測試套件中的一個,這一點是有意義的。
如果想要從其他測試程序中運行test_Atomic.py模塊,那麼可以編寫一個與此類似的程序。我們習慣於使用unittest模塊執行doctests,比如:
import unittest
import test_Atomic
suite = unittest.TestLoader().loadTestsFromTestCase(test_Atomic.TestAtomic)
runner = unittest.TextTestRunner()
pnnt(runner.run(suite))
這里,我們已經創建了一個單獨的套件,這是通過讓unittest模塊讀取test_Atomic 模塊實現的,並且使用其每一個test*()方法(本實例中是test_list_success()、test_list_fail(),稍後很快就會看到)作為測試用例。
我們現在將查看TestAtomic類的實現。對通常的子類(不包括unittest.TestCase 子類),不怎麼常見的是,沒有必要實現初始化程序。在這一案例中,我們將需要建立 一個方法,但不需要清理方法,並且我們將實現兩個測試用例。
def setUp(self):
self.original_list = list(range(10))
我們已經使用了 unittest.TestCase.setUp()方法來創建單獨的測試數據片段。
def test_list_succeed(self):
items = self.original_list[:]
with Atomic.Atomic(items) as atomic:
atomic.append(1999)
atomic.insert(2, -915)
del atomic[5]
atomic[4]= -782
atomic.insert(0, -9)
self.assertEqual(items,
[-9, 0, 1, -915, 2, -782, 5, 6, 7, 8, 9, 1999])
def test_list_fail(self):
items = self.original_list[:]
with self.assertRaises(AttributeError):
with Atomic.Atomic(items) as atomic:
atomic.append(1999)
atomic.insert(2, -915)
del atomic[5]
atomic[4] = -782
atomic.poop() # Typo
self.assertListEqual(items, self.original_list)
這里,我們直接在測試方法中編寫了測試代碼,而不需要一個內部函數,也不再使用unittest.TestCase.assertRaised()作為上下文管理器(期望代碼產生AttributeError)。 最後我們也使用了 Python 3.1 的 unittest.TestCase.assertListEqual()方法。
正如我們已經看到的,Python的測試模塊易於使用,並且極為有用,在我們使用 TDD的情況下更是如此。它們還有比這里展示的要多得多的大量功能與特徵——比如,跳過測試的能力,這有助於理解平台差別——並且這些都有很好的文檔支持。缺失的一個功能——但nose與py.test提供了——是測試發現,盡管這一特徵被期望在後續的Python版本(或許與Python 3.2—起)中出現。
性能剖析(Profiling)
如果程序運行很慢,或者消耗了比預期內要多得多的內存,那麼問題通常是選擇的演算法或數據結構不合適,或者是以低效的方式進行實現。不管問題的原因是什麼, 最好的方法都是准確地找到問題發生的地方,而不只是檢査代碼並試圖對其進行優化。 隨機優化會導致引入bug,或者對程序中本來對程序整體性能並沒有實際影響的部分進行提速,而這並非解釋器耗費大部分時間的地方。
在深入討論profiling之前,注意一些易於學習和使用的Python程序設計習慣是有意義的,並且對提高程序性能不無裨益。這些技術都不是特定於某個Python版本的, 而是合理的Python程序設計風格。第一,在需要只讀序列時,最好使用元組而非列表; 第二,使用生成器,而不是創建大的元組和列表並在其上進行迭代處理;第三,盡量使用Python內置的數據結構 dicts、lists、tuples 而不實現自己的自定義結構,因為內置的數據結構都是經過了高度優化的;第四,從小字元串中產生大字元串時, 不要對小字元串進行連接,而是在列表中累積,最後將字元串列表結合成為一個單獨的字元串;第五,也是最後一點,如果某個對象(包括函數或方法)需要多次使用屬性進行訪問(比如訪問模塊中的某個函數),或從某個數據結構中進行訪問,那麼較好的做法是創建並使用一個局部變數來訪問該對象,以便提供更快的訪問速度。
Python標准庫提供了兩個特別有用的模塊,可以輔助調査代碼的性能問題。一個是timeit模塊——該模塊可用於對一小段Python代碼進行計時,並可用於諸如對兩個或多個特定函數或方法的性能進行比較等場合。另一個是cProfile模塊,可用於profile 程序的性能——該模塊對調用計數與次數進行了詳細分解,以便發現性能瓶頸所在。
為了解timeit模塊,我們將查看一些小實例。假定有3個函數function_a()、 function_b()、function_c(), 3個函數執行同樣的計算,但分別使用不同的演算法。如果將這些函數放於同一個模塊中(或分別導入),就可以使用timeit模塊對其進行運行和比較。下面給出的是模塊最後使用的代碼:
if __name__ == "__main__":
repeats = 1000
for function in ("function_a", "function_b", "function_c"):
t = timeit.Timer("{0}(X, Y)".format(function),"from __main__ import {0}, X, Y".format(function))
sec = t.timeit(repeats) / repeats
print("{function}() {sec:.6f} sec".format(**locals()))
賦予timeit.Timer()構造子的第一個參數是我們想要執行並計時的代碼,其形式是字元串。這里,該字元串是「function_a(X,Y)」;第二個參數是可選的,還是一個待執行的字元串,這一次是在待計時的代碼之前,以便提供一些建立工作。這里,我們從 __main__ (即this)模塊導入了待測試的函數,還有兩個作為輸入數據傳入的變數(X 與Y),這兩個變數在該模塊中是作為全局變數提供的。我們也可以很輕易地像從其他模塊中導入數據一樣來進行導入操作。
調用timeit.Timer對象的timeit()方法時,首先將執行構造子的第二個參數(如果有), 之後執行構造子的第一個參數並對其執行時間進行計時。timeit.Timer.timeit()方法的返回值是以秒計數的時間,類型是float。默認情況下,timeit()方法重復100萬次,並返回所 有這些執行的總秒數,但在這一特定案例中,只需要1000次反復就可以給出有用的結果, 因此對重復計數次數進行了顯式指定。在對每個函數進行計時後,使用重復次數對總數進行除法操作,就得到了平均執行時間,並在控制台中列印出函數名與執行時間。
function_a() 0.001618 sec
function_b() 0.012786 sec
function_c() 0.003248 sec
在這一實例中,function_a()顯然是最快的——至少對於這里使用的輸入數據而言。 在有些情況下一一比如輸入數據不同會對性能產生巨大影響——可能需要使用多組輸入數據對每個函數進行測試,以便覆蓋有代表性的測試用例,並對總執行時間或平均執行時間進行比較。
有時監控自己的代碼進行計時並不是很方便,因此timeit模塊提供了一種在命令行中對代碼執行時間進行計時的途徑。比如,要對MyMole.py模塊中的函數function_a()進行計時,可以在控制台中輸入如下命令:python3 -m timeit -n 1000 -s "from MyMole import function_a, X, Y" "function_a(X, Y)"(與通常所做的一樣,對 Windows 環境,我們必須使用類似於C:Python3lpython.exe這樣的內容來替換python3)。-m選項用於Python 解釋器,使其可以載入指定的模塊(這里是timeit),其他選項則由timeit模塊進行處理。 -n選項指定了循環計數次數,-s選項指定了要建立,最後一個參數是要執行和計時的代碼。命令完成後,會向控制台中列印運行結果,比如:
1000 loops, best of 3: 1.41 msec per loop
之後我們可以輕易地對其他兩個函數進行計時,以便對其進行整體的比較。
cProfile模塊(或者profile模塊,這里統稱為cProfile模塊)也可以用於比較函數 與方法的性能。與只是提供原始計時的timeit模塊不同的是,cProfile模塊精確地展示 了有什麼被調用以及每個調用耗費了多少時間。下面是用於比較與前面一樣的3個函數的代碼:
if __name__ == "__main__":
for function in ("function_a", "function_b", "function_c"):
cProfile.run("for i in ranged 1000): {0}(X, Y)".format(function))
我們必須將重復的次數放置在要傳遞給cProfile.run()函數的代碼內部,但不需要做任何創建,因為模塊函數會使用內省來尋找需要使用的函數與變數。這里沒有使用顯式的print()語句,因為默認情況下,cProfile.run()函數會在控制台中列印其輸出。下面給出的是所有函數的相關結果(有些無關行被省略,格式也進行了稍許調整,以便與頁面適應):
1003 function calls in 1.661 CPU seconds
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.003 0.003 1.661 1.661 :1 ( )
1000 1.658 0.002 1.658 0.002 MyMole.py:21 (function_a)
1 0.000 0.000 1.661 1.661 {built-in method exec}
5132003 function calls in 22.700 CPU seconds
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.487 0.487 22.700 22.700 : 1 ( )
1000 0.011 0.000 22.213 0.022 MyMole.py:28(function_b)
5128000 7.048 0.000 7.048 0.000 MyMole.py:29( )
1000 0.00 50.000 0.005 0.000 {built-in method bisectjeft}
1 0.000 0.000 22.700 22.700 {built-in method exec}
1000 0.001 0.000 0.001 0.000 {built-in method len}
1000 15.149 0.015 22.196 0.022 {built-in method sorted}
5129003 function calls in 12.987 CPU seconds
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.205 0.205 12.987 12.987 :l ( )
1000 6.472 0.006 12.782 0.013 MyMole.py:36(function_c)
5128000 6.311 0.000 6.311 0.000 MyMole.py:37( )
1 0.000 0.000 12.987 12.987 {built-in method exec}
ncalls ("調用的次數")列列出了對指定函數(在filename:lineno(function)中列出) 的調用次數。回想一下我們重復了 1000次調用,因此必須將這個次數記住。tottime (「總的時間」)列列出了某個函數中耗費的總時間,但是排除了函數調用的其他函數內部花費的時間。第一個percall列列出了對函數的每次調用的平均時間(tottime // ncalls)。 cumtime ("累積時間")列出了在函數中耗費的時間,並且包含了函數調用的其他函數內部花費的時間。第二個percall列列出了對函數的每次調用的平均時間,包括其調用的函數耗費的時間。
這種輸出信息要比timeit模塊的原始計時信息富有啟發意義的多。我們立即可以發現,function_b()與function_c()使用了被調用5000次以上的生成器,使得它們的速度至少要比function_a()慢10倍以上。並且,function_b()調用了更多通常意義上的函數,包括調用內置的sorted()函數,這使得其幾乎比function_c()還要慢兩倍。當然,timeit() 模塊提供了足夠的信息來查看計時上存在的這些差別,但cProfile模塊允許我們了解為什麼會存在這些差別。正如timeit模塊允許對代碼進行計時而又不需要對其監控一樣,cProfile模塊也可以做到這一點。然而,從命令行使用cProfile模塊時,我們不能精確地指定要執行的 是什麼——而只是執行給定的程序或模塊,並報告所有這些的計時結果。需要使用的 命令行是python3 -m cProfile programOrMole.py,產生的輸出信息與前面看到的一 樣,下面給出的是輸出信息樣例,格式上進行了一些調整,並忽略了大多數行:
10272458 function calls (10272457 primitive calls) in 37.718 CPU secs
ncalls tottime percall cumtime percall filename:lineno(function)
10.000 0.000 37.718 37.718 :1 ( )
10.719 0.719 37.717 37.717 :12( )
1000 1.569 0.002 1.569 0.002 :20(function_a)
1000 0.011 0.000 22.560 0.023 :27(function_b)
5128000 7.078 0.000 7.078 0.000 :28( )
1000 6.510 0.007 12.825 0.013 :35(function_c)
5128000 6.316 0.000 6.316 0.000 :36( )
在cProfile術語學中,原始調用指的就是非遞歸的函數調用。
以這種方式使用cProfile模塊對於識別值得進一步研究的區域是有用的。比如,這里 我們可以清晰地看到function_b()需要耗費更長的時間,但是我們怎樣獲取進一步的詳細資料?我們可以使用cProfile.run("function_b()")來替換對function_b()的調用。或者可以保存完全的profile數據並使用pstats模塊對其進行分析。要保存profile,就必須對命令行進行稍許修改:python3 -m cProfile -o profileDataFile programOrMole.py。 之後可以對 profile 數據進行分析,比如啟動IDLE,導入pstats模塊,賦予其已保存的profileDataFile,或者也可以在控制台中互動式地使用pstats。
下面給出的是一個非常短的控制台會話實例,為使其適合頁面展示,進行了適當調整,我們自己的輸入則以粗體展示:
$ python3 -m cProfile -o profile.dat MyMole.py
$ python3 -m pstats
Welcome to the profile statistics browser.
% read profile.dat
profile.dat% callers function_b
Random listing order was used
List reced from 44 to 1 e to restriction
Function was called by...
ncalls tottime cumtime
:27(function_b) <- 1000 0.011 22.251 :12( )
profile.dat% callees function_b
Random listing order was used
List reced from 44 to 1 e to restriction
Function called...
ncalls tottime cumtime
:27(function_b)->
1000 0.005 0.005 built-in method bisectJeft
1000 0.001 0.001 built-in method len
1000 1 5.297 22.234 built-in method sorted
profile.dat% quit
輸入help可以獲取命令列表,help後面跟隨命令名可以獲取該命令的更多信息。比如, help stats將列出可以賦予stats命令的參數。還有其他一些可用的工具,可以提供profile數據的圖形化展示形式,比如 RunSnakeRun (www.vrplumber.com/prograinming/runsnakerun), 該工具需要依賴於wxPython GUI庫。
使用timeit與cProfile模塊,我們可以識別出我們自己代碼中哪些區域會耗費超過預期的時間;使用cProfile模塊,還可以准確算岀時間消耗在哪裡。
以上內容部分摘自視頻課程 05後端編程Python-19調試、測試和性能調優(下) ,更多實操示例請參照視頻講解。跟著張員外講編程,學習更輕松,不花錢還能學習真本領。
5. 【Python】基礎總結
input("提示性信息")
如:
input("請輸入數字")
因為 Python 沒有特別人為規定數據類型,數據類型是由計算機進行判定,所以我們 input() 輸入的數據均默認作為字元串處理,而如果要輸入一些數字,著需要 eval() 評估函數對字元串進行評估,化為語句(數字)。
print(...)
默認空一行,如果想不空行,則
print(...., end = "")
特性:
進制:
特性:
浮點數間運算存在不確定尾數,不是 bug
如:0.1+0.3 → 0.4
0.1+0.2 → 0.30000000000000004
這是由於在計算機中一切數據都是化為二進制進行存儲的,而有的浮點數並不能完全化為相等的二進制數,只能無限趨近於二進制數。
如:0.1 →
解決方法:
四捨五入:
例如:z = 1.23e-4 + 5.6e+89j
z.real 獲得實部,z.imag 獲得虛部
三種類型存在一種逐漸「擴展」或「變寬」的關系:
整數 → 浮點數 → 復數
特點:
字元串有 2 類共 4 種表示方法:
擴展:
使用[]獲取字元串中一個或多個字元
使用[M:N:K]根據步長對字元串切片
{<參數序號>:<格式控制標記>}
> 右對齊
^ 居中對齊 | 槽設定的輸出寬度 | 數字的千位分隔符 | 浮點數小數精度 或 字元串最大輸出長度 | 整數類型
b , c , d , o , x , X
浮點數類型
e , E , f , % |
填充、對齊、寬度這三個一組,例如:
"{0:=^20}".format("PYTHON")
→ '=======PYTHON======='
"{0:*>20}".format("BIT")
→ '*****************BIT'
"{:10}".format("BIT")
'BIT '
剩下的三個一組,例如:
"{0:,.2f}".format(12345.6789)
→ ,345.68'
"{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}x".format(425)
→ ,Σ,425,651,1a9,1A9'
"{0:e},{0:E},{0:f},{0:%}".format(3.14)
Ɖ.140000e+00,3.140000E+00,3.140000,314.000000%'
↓CloseCode↓
使用 raise 語句拋出一個指定的異常。
raise [Exception [, args [, traceback]]]
緊湊形式:適用於簡單表達式的二分支結構
<表達式1> if <條件> else <表達式2>
例如:
↓CloseCode↓
↓CloseCode↓
↓CloseCode↓
↓CloseCode↓
例如:
↓CloseCode↓
運行結果:
↓CloseCode↓
↓CloseCode↓
例如:
↓CloseCode↓
運行結果:
↓CloseCode↓
↓CloseCode↓
例如:
↓CloseCode↓
運行結果:
↓CloseCode↓
↓CloseCode↓
例如:
↓CloseCode↓
運行結果:
↓CloseCode↓
↓CloseCode↓
例如:
↓CloseCode↓
運行結果:
↓CloseCode↓
由條件控制的循環運行方式
↓CloseCode↓
例如:
↓CloseCode↓
運行結果:
↓CloseCode↓
↓CloseCode↓
↓CloseCode↓
例如:
↓CloseCode↓
運行結果:
↓CloseCode↓
例如:
↓CloseCode↓
運行結果:
↓CloseCode↓
↓CloseCode↓
可選參數例如:
↓CloseCode↓
運行結果:
↓CloseCode↓
可變參數例如:
↓CloseCode↓
運行結果:
↓CloseCode↓
在函數定義中,經常會碰到 *args(arguments) 和作為參數 **kwargs(keyword arguments)。
(事實上在函數中,和才是必要的,args 和 kwargs 可以用其他名稱代替)
*args 是指不定數量的非鍵值對參數。
**kwargs 是指不定數量的鍵值對參數。
*args 作為作為元組匹配沒有指定參數名的參數。而 **kwargs 作為字典,匹配指定了參數名的參數。
*args 必須位於 **kwargs 之前。
args( 通常緊跟一個標識符,你會看到a或者args都是標識符)是python用於接收或者傳遞任意基於位置的參數的語法。當你接收到一個用這種語法描敘參數時(比如你在函數def語句中對函數簽名使用了星號語法),python會將此標識符綁定到一個元祖,該元祖包含了所有基於位置的隱士的接收到的參數。當你用這種語法傳遞參數時,標識符可以被綁定到任何可迭代對象(事實上,它也可以是人和表達式,並不必須是一個標識符),只要這個表達式的結果是一個可迭代的對象就行。
**kwds(標識符可以是任意的,通常k或者kwds表示)是python用於接收或者傳遞任意基於位置的參數的語法。(python有時候會將命名參數稱為關鍵字參數,他們其實並不是關鍵字--只是用他們來給關鍵字命名,比如pass,for或者yield,還有很多,不幸的是,這種讓人疑惑的術語目前仍是這門語言極其文化根深蒂固的一個組成部分。)當你接收到用這種語法描敘的一個參數時(比如你在函數的def語句中對函數簽名使用了雙星號語法)python會將標識符綁定到一個字典,該字典包含了所有接收到的隱士的命名參數。當你用這種語法傳遞參數時,標識符只能被綁定到字典(我ID號I它也可以是表達式,不一定是一個標識符,只要這個表達式的結果是一個字典即可)。
當你在定義或調用一個函數的時候,必須確保a和k在其他所有參數之後。如果這兩者同時出現,要將k放在a之後。
lambda函數返回函數名作為結果
↓CloseCode↓
例如:
↓CloseCode↓
運行結果:
↓CloseCode↓
謹慎使用lambda函數
6. python非極大值抑制演算法的閾值越大越好還是越小越好,怎麼設
非極大值抑制(NMS),可理解為局部最大搜索,即搜索鄰域范圍內的最大值。行人檢測後期,對檢測出的窗口要執行非極大值抑制進行窗口的融合,從而過濾掉一些內部窗口等,達到窗口融合效果,從而使檢測的准確率更高!
7. python如何實現求函數的在一個連續區間的最值
先求得一個函數的導函數,然後令導函數=0
得到關於一個x的值
他也許是極大值
或是極小值
(還要考慮定義域進行取捨),然後將所求的極值和兩個端點值帶入原函數進行比較
,最後確定min
max就行
8. python中(a and b)返回0是啥意思
返回值為0,表示結果是假。說明a和b至少有一個不是真。
9. python如何找到列表中極大值
對列表進行排序,最後一個就是最大值。
10. python數據統計分析
1. 常用函數庫
scipy包中的stats模塊和statsmodels包是python常用的數據分析工具,scipy.stats以前有一個models子模塊,後來被移除了。這個模塊被重寫並成為了現在獨立的statsmodels包。
scipy的stats包含一些比較基本的工具,比如:t檢驗,正態性檢驗,卡方檢驗之類,statsmodels提供了更為系統的統計模型,包括線性模型,時序分析,還包含數據集,做圖工具等等。
2. 小樣本數據的正態性檢驗
(1) 用途
夏皮羅維爾克檢驗法 (Shapiro-Wilk) 用於檢驗參數提供的一組小樣本數據線是否符合正態分布,統計量越大則表示數據越符合正態分布,但是在非正態分布的小樣本數據中也經常會出現較大的W值。需要查表來估計其概率。由於原假設是其符合正態分布,所以當P值小於指定顯著水平時表示其不符合正態分布。
正態性檢驗是數據分析的第一步,數據是否符合正態性決定了後續使用不同的分析和預測方法,當數據不符合正態性分布時,我們可以通過不同的轉換方法把非正太態數據轉換成正態分布後再使用相應的統計方法進行下一步操作。
(2) 示例
(3) 結果分析
返回結果 p-value=0.029035290703177452,比指定的顯著水平(一般為5%)小,則拒絕假設:x不服從正態分布。
3. 檢驗樣本是否服務某一分布
(1) 用途
科爾莫戈羅夫檢驗(Kolmogorov-Smirnov test),檢驗樣本數據是否服從某一分布,僅適用於連續分布的檢驗。下例中用它檢驗正態分布。
(2) 示例
(3) 結果分析
生成300個服從N(0,1)標准正態分布的隨機數,在使用k-s檢驗該數據是否服從正態分布,提出假設:x從正態分布。最終返回的結果,p-value=0.9260909172362317,比指定的顯著水平(一般為5%)大,則我們不能拒絕假設:x服從正態分布。這並不是說x服從正態分布一定是正確的,而是說沒有充分的證據證明x不服從正態分布。因此我們的假設被接受,認為x服從正態分布。如果p-value小於我們指定的顯著性水平,則我們可以肯定地拒絕提出的假設,認為x肯定不服從正態分布,這個拒絕是絕對正確的。
4.方差齊性檢驗
(1) 用途
方差反映了一組數據與其平均值的偏離程度,方差齊性檢驗用以檢驗兩組或多組數據與其平均值偏離程度是否存在差異,也是很多檢驗和演算法的先決條件。
(2) 示例
(3) 結果分析
返回結果 p-value=0.19337536323599344, 比指定的顯著水平(假設為5%)大,認為兩組數據具有方差齊性。
5. 圖形描述相關性
(1) 用途
最常用的兩變數相關性分析,是用作圖描述相關性,圖的橫軸是一個變數,縱軸是另一變數,畫散點圖,從圖中可以直觀地看到相關性的方向和強弱,線性正相關一般形成由左下到右上的圖形;負面相關則是從左上到右下的圖形,還有一些非線性相關也能從圖中觀察到。
(2) 示例
(3) 結果分析
從圖中可以看到明顯的正相關趨勢。
6. 正態資料的相關分析
(1) 用途
皮爾森相關系數(Pearson correlation coefficient)是反應兩變數之間線性相關程度的統計量,用它來分析正態分布的兩個連續型變數之間的相關性。常用於分析自變數之間,以及自變數和因變數之間的相關性。
(2) 示例
(3) 結果分析
返回結果的第一個值為相關系數表示線性相關程度,其取值范圍在[-1,1],絕對值越接近1,說明兩個變數的相關性越強,絕對值越接近0說明兩個變數的相關性越差。當兩個變數完全不相關時相關系數為0。第二個值為p-value,統計學上,一般當p-value<0.05時,可以認為兩變數存在相關性。
7. 非正態資料的相關分析
(1) 用途
斯皮爾曼等級相關系數(Spearman』s correlation coefficient for ranked data ),它主要用於評價順序變數間的線性相關關系,在計算過程中,只考慮變數值的順序(rank, 值或稱等級),而不考慮變數值的大小。常用於計算類型變數的相關性。
(2) 示例
(3) 結果分析
返回結果的第一個值為相關系數表示線性相關程度,本例中correlation趨近於1表示正相關。第二個值為p-value,p-value越小,表示相關程度越顯著。
8. 單樣本T檢驗
(1) 用途
單樣本T檢驗,用於檢驗數據是否來自一致均值的總體,T檢驗主要是以均值為核心的檢驗。注意以下幾種T檢驗都是雙側T檢驗。
(2) 示例
(3) 結果分析
本例中生成了2列100行的數組,ttest_1samp的第二個參數是分別對兩列估計的均值,p-value返回結果,第一列1.47820719e-06比指定的顯著水平(一般為5%)小,認為差異顯著,拒絕假設;第二列2.83088106e-01大於指定顯著水平,不能拒絕假設:服從正態分布。
9. 兩獨立樣本T檢驗
(1) 用途
由於比較兩組數據是否來自於同一正態分布的總體。注意:如果要比較的兩組數據不滿足方差齊性, 需要在ttest_ind()函數中添加參數equal_var = False。
(2) 示例
(3) 結果分析
返回結果的第一個值為統計量,第二個值為p-value,pvalue=0.19313343989106416,比指定的顯著水平(一般為5%)大,不能拒絕假設,兩組數據來自於同一總結,兩組數據之間無差異。
10. 配對樣本T檢驗
(1) 用途
配對樣本T檢驗可視為單樣本T檢驗的擴展,檢驗的對象由一群來自正態分布獨立樣本更改為二群配對樣本觀測值之差。它常用於比較同一受試對象處理的前後差異,或者按照某一條件進行兩兩配對分別給與不同處理的受試對象之間是否存在差異。
(2) 示例
(3) 結果分析
返回結果的第一個值為統計量,第二個值為p-value,pvalue=0.80964043445811551,比指定的顯著水平(一般為5%)大,不能拒絕假設。
11. 單因素方差分析
(1) 用途
方差分析(Analysis of Variance,簡稱ANOVA),又稱F檢驗,用於兩個及兩個以上樣本均數差別的顯著性檢驗。方差分析主要是考慮各組之間的平均數差別。
單因素方差分析(One-wayAnova),是檢驗由單一因素影響的多組樣本某因變數的均值是否有顯著差異。
當因變數Y是數值型,自變數X是分類值,通常的做法是按X的類別把實例成分幾組,分析Y值在X的不同分組中是否存在差異。
(2) 示例
(3) 結果分析
返回結果的第一個值為統計量,它由組間差異除以組間差異得到,上例中組間差異很大,第二個返回值p-value=6.2231520821576832e-19小於邊界值(一般為0.05),拒絕原假設, 即認為以上三組數據存在統計學差異,並不能判斷是哪兩組之間存在差異 。只有兩組數據時,效果同 stats.levene 一樣。
12. 多因素方差分析
(1) 用途
當有兩個或者兩個以上自變數對因變數產生影響時,可以用多因素方差分析的方法來進行分析。它不僅要考慮每個因素的主效應,還要考慮因素之間的交互效應。
(2) 示例
(3) 結果分析
上述程序定義了公式,公式中,"~"用於隔離因變數和自變數,」+「用於分隔各個自變數, ":"表示兩個自變數交互影響。從返回結果的P值可以看出,X1和X2的值組間差異不大,而組合後的T:G的組間有明顯差異。
13. 卡方檢驗
(1) 用途
上面介紹的T檢驗是參數檢驗,卡方檢驗是一種非參數檢驗方法。相對來說,非參數檢驗對數據分布的要求比較寬松,並且也不要求太大數據量。卡方檢驗是一種對計數資料的假設檢驗方法,主要是比較理論頻數和實際頻數的吻合程度。常用於特徵選擇,比如,檢驗男人和女人在是否患有高血壓上有無區別,如果有區別,則說明性別與是否患有高血壓有關,在後續分析時就需要把性別這個分類變數放入模型訓練。
基本數據有R行C列, 故通稱RC列聯表(contingency table), 簡稱RC表,它是觀測數據按兩個或更多屬性(定性變數)分類時所列出的頻數表。
(2) 示例
(3) 結果分析
卡方檢驗函數的參數是列聯表中的頻數,返回結果第一個值為統計量值,第二個結果為p-value值,p-value=0.54543425102570975,比指定的顯著水平(一般5%)大,不能拒絕原假設,即相關性不顯著。第三個結果是自由度,第四個結果的數組是列聯表的期望值分布。
14. 單變數統計分析
(1) 用途
單變數統計描述是數據分析中最簡單的形式,其中被分析的數據只包含一個變數,不處理原因或關系。單變數分析的主要目的是通過對數據的統計描述了解當前數據的基本情況,並找出數據的分布模型。
單變數數據統計描述從集中趨勢上看,指標有:均值,中位數,分位數,眾數;從離散程度上看,指標有:極差、四分位數、方差、標准差、協方差、變異系數,從分布上看,有偏度,峰度等。需要考慮的還有極大值,極小值(數值型變數)和頻數,構成比(分類或等級變數)。
此外,還可以用統計圖直觀展示數據分布特徵,如:柱狀圖、正方圖、箱式圖、頻率多邊形和餅狀圖。
15. 多元線性回歸
(1) 用途
多元線性回歸模型(multivariable linear regression model ),因變數Y(計量資料)往往受到多個變數X的影響,多元線性回歸模型用於計算各個自變數對因變數的影響程度,可以認為是對多維空間中的點做線性擬合。
(2) 示例
(3) 結果分析
直接通過返回結果中各變數的P值與0.05比較,來判定對應的解釋變數的顯著性,P<0.05則認為自變數具有統計學意義,從上例中可以看到收入INCOME最有顯著性。
16. 邏輯回歸
(1) 用途
當因變數Y為2分類變數(或多分類變數時)可以用相應的logistic回歸分析各個自變數對因變數的影響程度。
(2) 示例
(3) 結果分析
直接通過返回結果中各變數的P值與0.05比較,來判定對應的解釋變數的顯著性,P<0.05則認為自變數具有統計學意義。