Python數據處理與計算——概述

時間 2019-11-12

原文原文鏈接

Python是一種面向對象的，動態的程序設計語言，具備很是簡潔而清晰的語法，適合於完成各類高層任務。它既能夠用來快速開發程序腳本，也能夠用來開發大規模的軟件。html

隨着NumPy、SciPy、Matplotlib、Enthoughtlibrarys等衆多程序庫的開發，Python愈來愈適合於作科學計算、繪製高質量的2D和3D圖像。與科學計算領域最流行的商業軟件MATLAB相比，Python是一門通用的程序設計語言，比MATLAB所採用的腳本語言的應用範圍更普遍，有更多的程序庫的支持。雖然MATLAB中的許多高級功能和toolbox目前仍是沒法替代的，不過在平常的科研開發之中仍然不少的工做是能夠用Python代勞的。python

經常使用的模塊概覽與導入程序員

1.數值計算庫算法

NumPy爲Python提供了快速的多維數據處理的能力，而SciPy則在NumPy基礎上添加了衆多的科學計算所需的各類工具包，有利這兩個庫，Python就具備幾乎與MATLAB同樣的處理數據和計算的能力了。編程

NumPy和SciPy官方網址分別爲http://www.numpy.org/和https://www.scipy.org/數組

NumPy爲Python帶來了真正的多維數據處理功能，而且提供了豐富的函數庫處理這些數組。它將經常使用的數學函數進行數組化，使得這些數學函數可以直接對數組進行操做，將原本須要在Python級別進行的循環，放到C語言的運算中，明顯地提升了程序的運算速度。編程語言

SciPy的核心計算部分都是一些久經考驗的Fortran數值計算庫，例如：函數

線性代數使用lapack庫；
快速傅里葉變換使用fftpack庫；
常微分方程求解使用odepack庫；
非線性方程組求解及最小值求解等使用minpack庫

2.符號計算庫工具

SymPy是一套進行符號數學運算的Python函數庫，它足夠好用，能夠幫助咱們進行公式推導，進行符號求解。動畫

SymPy官方網址：http://www.sympy.org/en/index.html

3.界面設計

製做界面一直都是一件十分複雜的工做，使用Traits庫，將使得咱們沒必要再界面設計上耗費大量精力，從而能把注意力集中到如何處理數據上去。

Traits官方網站：http://code.enthought.com/pages/traits.html

Traits庫分爲Traits和TraitsUI兩大部分，Traits爲Python添加了類型定義的功能，使用它定義的Traits屬性具備初始化、校驗、代理、事件等諸多功能。

TraitsUI庫基於Traits庫，使用MVC結構快速地定義用戶界面，在最簡單的狀況下，編碼者都不須要寫一句關於界面的代碼，就能夠經過Traits屬性定義得到一個能夠工做的用戶界面。使用TraitsUI庫編寫的程序自動支持wxPython和pyQt兩個經典的界面庫。

4.繪圖與可視化

Chaco和Matplotlib是很優秀的2D繪圖庫，Chaco庫和Traits庫緊密相連，方便製做動態交互式的圖表功能。而Matplotlib庫則可以快速地繪製精美的圖表，以各類格式輸出，而且帶有簡單的3D繪圖的功能。

Chaco官方網站：http://code.enthought.com/projects/chaco/

Matplotlib官方網站：https://matplotlib.org/

TVTK庫在標準的VTK庫之上用Traits庫進行封裝，若是要在Python下使用VTK，用TVTK是再好不過的選擇。Mayavi2則在TVTK的基礎上再添加了一套面向應用的方便工具，它既能夠單獨做爲3D可視化程序使用，也能夠快速地嵌入到用戶的程序中去。

Mayavi官方網址：http://code.enthought.com/pages/mayavi-project.html

視覺化工具函式庫（Visualization Toolkit，VTK）是一個開放源碼，跨平臺、支援平行處理（VTK曾用與處理大小近乎1個Petabyte的資料，其平臺爲美國Los Alamos國家實驗室全部的具備1024個處理器之大型系統）的圖形應用函式庫。2005年曾被美國陸軍研究實驗室用於即時模擬俄羅斯制反導彈戰車ZSU23-4受到平面波攻擊的情形，其計算節點高達2.5兆之多。

此外，使用Visual庫可以快速、方便地製做3D動畫演示，使數據結果更有說服力。

Visual官方網站：http://vpython.org/

5.圖像處理和計算機視覺

openCV由英特爾公司發起並參與開發，以BSD許可證受權發行，能夠在商業和研究領域中無償使用。OpenCV可用於開發實時的圖像處理、計算機視覺及模式識別程序。OpenCV提供的Python API方便咱們快速實現算法，查看結果而且和其餘的庫進行數據交換。

Numpy簡介

標準安裝的Python中用列表（list）保存一組值，能夠用來當作數組使用，可是因爲列表的元素能夠是任何對象，所以列表中所保存的是對象的指針。這樣爲了保存一個簡單的[1,2,3]，須要有3個指針和3個整數對象。對於數值運算來講這種結構顯然比較浪費內存和CPU計算時間。

此外，Python還提供了一個array模塊，array對象和列表不一樣，它直接保存數值，與C語言的一維數組比較相似。可是因爲它不支持多維，也沒有各類運算函數，所以不適合作數值運算。

NumPy的誕生彌補了以上不足，NumPy提供了兩種基本的對象：ndarray（N-dimensional array object）和ufunc（universal function object）。ndarray（後面內容統一稱之爲數組）是存儲單一數據類型的多維數組，而ufunc則是可以對數組進行處理的函數。

1）Numpy庫的導入

在進行Numpy相關操做時，在此須要先導入該庫：

import numpy as np #導入numpy以後使用np可代替numpy

2）數組的建立與生產

首先須要建立數組才能對其進行其餘操做。能夠經過給array函數傳遞Python的序列對象來建立對象，若是傳遞的是多層嵌套的序列，將建立多維數組

1.直接複製建立數組：

#數組建立直接賦值

import numpy as np

a=np.array([1,2,3,4]);
b=np.array([5,6,7,8]);
c=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]]);

print(a.shape);#a的shape屬性
print(a);
print(b);
print(c);#多維數組
print(c.shape);#c的shape屬性
print(c.dtype)#查看c的數據類型

#output：
# (4,)
# [1 2 3 4]
# [5 6 7 8]
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]
# (3, 4)
# int32

2.改變數組的形式：經過shape屬性查看並更改。數組a的shape只有一個元素，所以它是一維數組。而數組c的shape有兩個元素，所以它是二維數組，其中第0軸的長度爲3，第1軸的長度爲4.還能夠經過修改數組的shape屬性，還保持數組元素個數不變的狀況下，改變數組每一個軸的長度。

下面的例子將數組c的shape改成（4,3），注意從（3,4）改成（4,3）並非對數組進行轉置，而只是改變每一個軸的大小，數組元素在內存中的位置並無改變：

#接上面程序
c.shape=3,4;
print(c.shape);
print(c)
c.shape=4,3;
print(c.shape);
print(c)

# output：
# (3, 4)
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]
# (4, 3)
# [[ 1  2  3]
#  [ 4  5  6]
#  [ 7  8  9]
#  [10 11 12]]

3.使用reshape方法，從新改變數組的尺寸，而原數組的尺寸不變：

#接上面程序
print(a)
d=a.reshape(2,2)
print(d)
print(a)

# output:
# [1 2 3 4]
# [[1 2]
#  [3 4]]
# [1 2 3 4]

4.數組a和d實際上是共享數據存儲內存區域的，所以修改其中任意一個數組的元素都會同時修改另一個數組的內容：

#接上面程序
print(d)
a[0]=1000000;#將數組a的一個元素改成1000000
print(d)

# output:
# [[1 2]
#  [3 4]]
# [[1000000       2]
#  [      3       4]]

5.前面所說的都是默認的dtype，如今改變其dtype參數：

# 指定數據類型
e=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]],dtype=np.float);
print(e)

# output:
# [[ 1.  2.  3.  4.]
#  [ 5.  6.  7.  8.]
#  [ 9. 10. 11. 12.]]

6.固然，到如今爲止，所建立的array都是基於手動賦值操做，Python還提供一些函數能夠自動化地建立數組。

# 利用函數建立數組

# numpy中的arange（）函數相似於Python中的range（）函數
# 經過指定開始值，終值和步長來建立一維數組，注意數組不包括終值
arr1=np.arange(0,10,1.0);
print(arr1);
# output:
# [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

#linspace函數經過指定開始值，終值和元素的個數來建立一維數組
#能夠經過endpoint關鍵字指定是否包括終值，缺省設置是包括終值
print(np.linspace(0,1,12));
# output:
# [0.         0.09090909 0.18181818 0.27272727 0.36363636 0.45454545
#  0.54545455 0.63636364 0.72727273 0.81818182 0.90909091 1.        ]


# logspace函數和linspace函數相似，不過它建立等比數列
#下面的例子產生1（10^0）到10(10^2)，有10個元素的等比數列
print(np.logspace(0,2,10))
# output:
# [  1.           1.66810054   2.7825594    4.64158883   7.74263683
#   12.91549665  21.5443469   35.93813664  59.94842503 100.        ]

3）利用數組進行數據處理

1.多維數組

在具體的應用中咱們更多的是使用多維數組進行數據處理，而多維數組的存取和一維數組相似，只是多維數組有多個軸，所以，它的下標須要多個值來表示。Numpy採用元組（tuple）做爲數組的下標。

2.多維數組建立

0	1	2	3	4	5
10	11	12	13	14	15
20	21	22	23	24	25
30	31	32	33	34	35
40	41	42	43	44	45
50	51	52	53	54	55

《=======數組a

首先來看如何建立該數組，數組a其實是一個加法表，縱軸的值爲0,10,20,30,40,50；橫軸的值爲0,1,2,3,4,5。縱軸的每一個元素與橫軸的每一個元素求和獲得上表中所示的數組a。

arr2=np.arange(0,6)+np.arange(0,60,10).reshape(-1,1);
print(arr2);

# output:
# [[ 0  1  2  3  4  5]
#  [10 11 12 13 14 15]
#  [20 21 22 23 24 25]
#  [30 31 32 33 34 35]
#  [40 41 42 43 44 45]
#  [50 51 52 53 54 55]]

3.多維數組存取

多維數組一樣也可使用整數序列和布爾數組進行存取。

import numpy as np

arr2=np.arange(0,6)+np.arange(0,60,10).reshape(-1,1);
print(arr2)
# output:
# [[ 0  1  2  3  4  5]
#  [10 11 12 13 14 15]
#  [20 21 22 23 24 25]
#  [30 31 32 33 34 35]
#  [40 41 42 43 44 45]
#  [50 51 52 53 54 55]]

# 第一種獲取
a=arr2[(0,1,2,3,4),(1,2,3,4,5)];#至關於arr2[0][1],arr2[1][2]....
print(a);
# output:
# [ 1 12 23 34 45]

# 第二種獲取
# 注意：別忘了中間的逗號
a=arr2[3:,[0,2,5]];#至關因而從第3行到最後一行的第0列，第2列，第5列
print(a)
# output:
# [[30 32 35]
#  [40 42 45]
#  [50 52 55]]

# 第三種獲取（經過bool值獲取數組的數據）
mask=np.array([1,0,1,0,0,1],dtype=np.bool)
print(mask)#mask製做的是bool型列表
print(arr2[mask,2])#至關於行都是布爾值（true表示顯示，false表示不顯示），列都是2
# 注意：在此處mask充當的是行，那麼它的值的數量必須和行數相等，不然則報錯
# output:
# [ True False  True False False  True]
# [ 2 22 52]

用於數組的文件輸入輸出

1）把數組數據寫入file

保存數組數據的文件能夠是二進制格式或者是文本格式。但不會保存數組數組形狀和元素類型等信息。

a=np.arange(0,16).reshape(4,4);
a.tofile(r'C:\Users\123\Desktop\a.bin')#文件後綴是bin
a.tofile(r'C:\Users\123\Desktop\a.txt')#文件後綴是txt

保存的後文件內容彷佛不能有價值的人工讀取。

2）讀取文件file中的數組

由於保存時就未保存數組形狀和元素類型等信息，故讀取時必須爲你要使用的數組設置合適的形狀和元素類型。

#! /usr/bin/env python  
#coding=utf-8  
import numpy as np

a=np.arange(0,16).reshape(4,4);
print(a)
a.tofile(r'C:\Users\123\Desktop\a.bin')#文件後綴是bin
a.tofile(r'C:\Users\123\Desktop\a.txt')#文件後綴是txt
b=np.fromfile(r'C:\Users\123\Desktop\a.txt',dtype=np.int32);
print();
print("取出後的信息並未保存存入文件時的數組類型和元素類型信息:");
print(b);
b.shape=4,4;
print();
print("從txt文件中提取：");
print(b);
c=np.fromfile(r'C:\Users\123\Desktop\a.bin');
print();
print("從bin文件中提取：");
print(c);
# output:
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]
#  [12 13 14 15]]

# 取出後的信息並未保存存入文件時的數組類型和元素類型信息:
# [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]

# 從txt文件中提取：
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]
#  [12 13 14 15]]

# 從bin文件中提取：
# [2.12199579e-314 6.36598737e-314 1.06099790e-313 1.48539705e-313
#  1.90979621e-313 2.33419537e-313 2.75859453e-313 3.18299369e-313]

3）numpy.load和numpy.save

numpy.load和numpy.save函數以Numpy專用的二進制類型保存數據，這兩個函數會自動處理元素類型和shape等信息，使用它們讀寫數組就方便多了，可是numpy.save輸出的文件很難用其餘語言編寫的程序讀入（由於數據讀取問題，利用numpy.save進行保存到的文件，在使用其餘編程語言進行讀取時增長了難度）。

np.save(r'C:\Users\123\Desktop\a.npy',a);#後綴名稱爲.npy
d=np.load(r'C:\Users\123\Desktop\a.npy');
print(d);
# output:
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]
#  [12 13 14 15]]

4）numpy.savetxt和numpy.loadtxt

使用numpy.savetxt和numpy.loadtxt能夠讀寫一維和二維的數組。

a=np.arange(0,12,0.5).reshape(4,-1);
print(a);
np.savetxt(r'C:\Users\123\Desktop\aTxt.txt',a);#缺省值按照「%.18e」格式保存數據，以空格分隔
print("讀取信息：")
print(np.loadtxt(r'C:\Users\123\Desktop\aTxt.txt'));
# output:
# [[ 0.   0.5  1.   1.5  2.   2.5]
#  [ 3.   3.5  4.   4.5  5.   5.5]
#  [ 6.   6.5  7.   7.5  8.   8.5]
#  [ 9.   9.5 10.  10.5 11.  11.5]]
# 讀取信息：
# [[ 0.   0.5  1.   1.5  2.   2.5]
#  [ 3.   3.5  4.   4.5  5.   5.5]
#  [ 6.   6.5  7.   7.5  8.   8.5]
#  [ 9.   9.5 10.  10.5 11.  11.5]]

使用該方法獲得的文件能夠人工讀取。

也可將數組該保存在整數。

np.savetxt(r'C:\Users\123\Desktop\aTxt.txt',a,fmt="%d",delimiter=",");#改保存爲整數，以逗號分隔
#讀入的時候也須要自定逗號分隔（能夠看到這樣的方式數據失真）
print(np.loadtxt(r'C:\Users\123\Desktop\aTxt.txt',delimiter=","))
# output:
# [[ 0.  0.  1.  1.  2.  2.]
#  [ 3.  3.  4.  4.  5.  5.]
#  [ 6.  6.  7.  7.  8.  8.]
#  [ 9.  9. 10. 10. 11. 11.]]

此時，文件是這樣的。

數組的算術和統計運算

1）數組的算術

數組的算術在實際的應用過程當中大都經過矩陣matrix的運算來實現，Numpy和MATLAB不同，對於多維數組的運算，缺省值的狀況下並不使用矩陣運算，若是但願對數組的進行矩陣運算的話，能夠調用相應的函數。之因此在Python中加入matrix運算是由於它的運算快，並且數組通常的表示就是一維、二維數組，值得注意的是雖然基於矩陣matrix運算代碼較少，執行效率高，可是比較考驗程序員的數學水平，而基於數組的運算能夠多謝一堆代碼，可是若是數據量大的狀況下執行的運算容易崩潰，此處簡單介紹matrix運算。

#能夠把matrix理解爲多維數組
ma=np.matrix([[1,2,3],[4,5,6],[7,8,9]]);
print(ma);
# output:
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

2）基於矩陣matrix的運算

#能夠把matrix理解爲多維數組
ma=np.matrix([[1,2,3],[4,5,6],[7,8,9]]);
ma+ma   #矩陣加法
# output:
# matrix([[ 2,  4,  6],
#         [ 8, 10, 12],
#         [14, 16, 18]])


ma-ma   #矩陣減法
# output:
# matrix([[0, 0, 0],
#         [0, 0, 0],
#         [0, 0, 0]])

ma*ma   #矩陣乘法
# ouput:
# matrix([[ 30,  36,  42],
#         [ 66,  81,  96],
#         [102, 126, 150]])

ma**-1   #矩陣求逆
# output:
# matrix([[ 3.15251974e+15, -6.30503948e+15,  3.15251974e+15],
#         [-6.30503948e+15,  1.26100790e+16, -6.30503948e+15],
#         [ 3.15251974e+15, -6.30503948e+15,  3.15251974e+15]])

3）基於矩陣matrix的統計運算

1.dot內積（能夠基於一維數組，也能夠基於兩個矩陣）運算

a=np.arange(12).reshape(3,4);
b=np.arange(12,24).reshape(4,3);
c=np.dot(a,b);#求a和b的內積
print(a);
print();
print(b);
print();
print(c);
# output:
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

# [[12 13 14]
#  [15 16 17]
#  [18 19 20]
#  [21 22 23]]

# [[114 120 126]
#  [378 400 422]
#  [642 680 718]]

2.inner運算

與dot乘積同樣，對於兩個一維數組，計算的是這兩個數組對應下標元素的乘積和；對於多維數組，它計算的結果數組中的每一個元素都是數組a和b的最後一維的內積，所以數組a和b的最後一維的長度必須相同。

a=np.arange(12).reshape(3,4);
b=np.arange(12,24).reshape(3,4);#注意此處和dot運算要求不同
c=np.inner(a,b);#求a和b的內積
print(a);
print();
print(b);
print();
print(c);
# output:
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

# [[12 13 14 15]
#  [16 17 18 19]
#  [20 21 22 23]]

# [[ 86 110 134]
#  [302 390 478]
#  [518 670 822]]

3.outer運算

只按照一維數組進行運算，若是傳入參數是多維數組，則先將此數組展平爲一維數組以後再進行運算。outer乘積計算的是列向量和行向量的矩陣乘積：

a=np.arange(12).reshape(3,4);
b=np.arange(12,24).reshape(3,4);#注意此處和inner運算要求同樣
c=np.outer(a,b);
print(c);
# output:
# [[  0   0   0   0   0   0   0   0   0   0   0   0]
#  [ 12  13  14  15  16  17  18  19  20  21  22  23]
#  [ 24  26  28  30  32  34  36  38  40  42  44  46]
#  [ 36  39  42  45  48  51  54  57  60  63  66  69]
#  [ 48  52  56  60  64  68  72  76  80  84  88  92]
#  [ 60  65  70  75  80  85  90  95 100 105 110 115]
#  [ 72  78  84  90  96 102 108 114 120 126 132 138]
#  [ 84  91  98 105 112 119 126 133 140 147 154 161]
#  [ 96 104 112 120 128 136 144 152 160 168 176 184]
#  [108 117 126 135 144 153 162 171 180 189 198 207]
#  [120 130 140 150 160 170 180 190 200 210 220 230]
#  [132 143 154 165 176 187 198 209 220 231 242 253]]

5.數組統計運算

針對數組進行統計計算，如下只是經過簡單的例子來講明能夠基於數組進行相應的統計計算，更多的統計函數參考Python手冊（numpy部分）。

#統計數組
a=np.arange(12).reshape(3,4);
print("a矩陣：\n",a);
#以第0行數據爲例進行統計運算
print("第0行：\n",a[0]);
print("和值：\n",np.sum(a[0]));
print("平均值：\n",np.mean(a[0]));
print("方差：\n",np.var(a[0]));
# output:
# a矩陣：
#  [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
# 第0行：
#  [0 1 2 3]
# 和值：
#  6
# 平均值：
#  1.5
# 方差：
#  1.25