python數據分析入門

時間 2019-11-17

原文原文鏈接

什麼是數據分析?python

數據分析:就是把隱藏在一些看似雜亂無章的數據背後的信息提煉出來,總結出所研究對象的內在規律.c++

數據分析三劍客:Numpy,Pandas,Matplotlb算法

NumPy簡介

NumPy(Numerical python)是python語言的一個擴展程序庫,支持大量的維度數組與矩陣運算,此外也針對數組運算提供大量的數學函數庫.編程

NumPy的前身Numeric 最先是由 Jim Hugunin 與其它協做者共同開發，2005 年，Travis Oliphant 在 Numeric 中結合了另外一個同性質的程序庫 Numarray 的特點，並加入了其它擴展而開發了 NumPy。NumPy 爲開放源代碼而且由許多協做者共同維護開發。數組

NumPy是一個運行速度很是快的數學庫,主要用於數組計算,包含:dom

- 一個強大的N維數組對象ndarray機器學習

- 廣播功能函數編程語言

- 整合 c/c++/Fortran 代碼的工具函數

- 線性代數, 傅里葉變換、隨機數生成等功能工具

NumPy應用

NumPy 一般與 SciPy（Scientific Python）和 Matplotlib（繪圖庫）一塊兒使用，這種組合普遍用於替代 MatLab，是一個強大的科學計算環境，有助於咱們經過 Python 學習數據科學或者機器學習。

SciPy 是一個開源的 Python 算法庫和數學工具包。

SciPy 包含的模塊有最優化、線性代數、積分、插值、特殊函數、快速傅里葉變換、信號處理和圖像處理、常微分方程求解和其餘科學與工程中經常使用的計算。

Matplotlib 是 Python 編程語言及其數值數學擴展包 NumPy 的可視化操做界面。它爲利用通用的圖形用戶界面工具包，如 Tkinter, wxPython, Qt 或 GTK+ 嚮應用程序嵌入式繪圖提供了應用程序接口（API）。

入門

NumPy的主要對象是同構多維數組.他是一個元素表(一般是數字),都是相同的類型,有正整數元組索引,在NumPy維度中成爲軸.

例如,3D空間中的點的座標[1,2,1]具備一個軸,該軸有三個元素,因此說它的長度爲3,在下面所示的例子中,數組有兩個軸,第一個軸長度爲2,第二個軸的長度爲3.

[[ 1., 0., 0.],
 [ 0., 1., 2.]]

NumPy的數組類被調用ndarray。它也被別名所知 array。請注意，numpy.array這與標準Python庫類不一樣array.array，後者只處理一維數組並提供較少的功能。ndarray對象更重要的屬性是：

ndarray.ndim --- 數組的軸數(尺寸)

ndarray.shape --- 數組的大小,這是一個整數元組,表示每一個維度中數組的大小,對於具備n行和m列的矩陣,shape將是(n,m).shape所以元組的長度是軸的數量ndim

ndarray.size --- 數組的元素總數。這等於元素的乘積shape

ndarray.itemsize --- 數組中每一個元素的大小（以字節爲單位）。例如，類型的元素數組float64有itemsize8（= 64/8），而其中一個類型complex32有itemsize4（= 32/8）。它至關於ndarray.dtype.itemsize。

ndarray.data --- 包含數組實際元素的緩衝區。一般，咱們不須要使用此屬性，由於咱們將使用索引工具訪問數組中的元素。

例子:

>>> import numpy as np
>>> a = np.arange(15).reshape(3, 5) # 建立一個二維數組
>>> a
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
>>> a.shape # 查看每一個維度中數組的大小
(3, 5)      # 3行5列
>>> a.ndim   # 數組的軸數,二維數組
2
>>> a.dtype.name # 描述數組中元素類型的對象
'int64'
>>> a.itemsize # 數組中每一個元素的大小爲8字節
8
>>> a.size # 數組的元素總數
15
>>> type(a)
<type 'numpy.ndarray'>
>>> b = np.array([6, 7, 8])
>>> b
array([6, 7, 8]) # 建立一個數組
>>> type(b)
<type 'numpy.ndarray'>
>>>  np.array([[1,2,3],['a','b',1.1]]) # 建立一個二維數組

array([['1', '2', '3'],
       ['a', 'b', '1.1']], dtype='<U11')

數組的建立

有如下集中方法能夠建立數組.

你可使用array函數從常規python列表或元組建立數組,結果數組的類型是從序列中元素的類型推導出來的

>>> import numpy as np
>>> a = np.array([2,3,4])
>>> a
array([2, 3, 4])
>>> a.dtype
dtype('int64')
>>> b = np.array([1.2, 3.5, 5.1])
>>> b.dtype
dtype('float64')

常見的錯誤在於array使用多個數字參數調用,而不是提供單個數字列表做爲參數.

>>> a = np.array(1,2,3,4)    # 錯誤的
>>> a = np.array([1,2,3,4])  # 正確的

array將兩個序列轉換成二維陣列,將序列轉換成三維陣列.等.

>>> b = np.array([(1.5,2,3), (4,5,6)])
>>> b
array([[ 1.5,  2. ,  3. ],
       [ 4. ,  5. ,  6. ]])

注意:

　　- numpy默認ndarray的全部元素的類型是相同的

- 若是傳進來的列表中包含不一樣的類型,則統一爲統一類型,優先級 str > float > int

也能夠在建立時顯式指定數組類型:

>>> c = np.array( [ [1,2], [3,4] ], dtype=complex )
>>> c
array([[ 1.+0.j,  2.+0.j],
       [ 3.+0.j,  4.+0.j]])

一般數組的元素最初是未知的,但其大小是已知的.所以,NumPy提供了幾個函數來建立具備初始佔位符內容的數組.這些最小化了增長舉證的必要性,這是一項昂貴的操做,

函數zeros建立一個充滿零的數組,

函數ones建立一個完整的數組,

函數empty建立一個數組,其初始內容是隨機的,取決於內存的狀態.默認狀況下,建立的數組的dtype是float64.

>>> np.zeros( (3,4) )
array([[ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.]])
>>> np.ones( (2,3,4), dtype=np.int16 )                # dtype can also be specified
array([[[ 1, 1, 1, 1],
        [ 1, 1, 1, 1],
        [ 1, 1, 1, 1]],
       [[ 1, 1, 1, 1],
        [ 1, 1, 1, 1],
        [ 1, 1, 1, 1]]], dtype=int16)
>>> np.empty( (2,3) )                                 # uninitialized, output may vary
array([[  3.73603959e-262,   6.02658058e-154,   6.55490914e-260],
       [  5.30498948e-313,   3.14673309e-307,   1.00000000e+000]])

爲了建立數字序列,NumPy提供了一個相似於range返回數組而不是列表的函數

>>> np.arange( 10, 30, 5 )
array([10, 15, 20, 25])
>>> np.arange( 0, 2, 0.3 )                 # it accepts float arguments
array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])

第一個參數開始數字,第二個是結束數字,第三個相似步長

當arange與浮點參數一塊兒使用時，因爲有限的浮點精度，一般不可能預測所得到的元素的數量。出於這個緣由，一般最好使用linspace做爲參數接收咱們想要的元素數量的函數，而不是步驟：

>>> from numpy import pi
>>> np.linspace( 0, 2, 9 )                 # 9 numbers from 0 to 2
array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ,  1.25,  1.5 ,  1.75,  2.  ])
>>> x = np.linspace( 0, 2*pi, 100 )        # useful to evaluate function at lots of points
>>> f = np.sin(x)

數組的打印

當您打印數組時，NumPy以與嵌套列表相似的方式顯示它，但具備如下佈局：

最後一個軸從左到右打印，
倒數第二個是從上到下打印的，
其他部分也從上到下打印，每一個切片用空行分隔。

而後將一維數組打印爲行，將二維數據打印爲矩陣，將三維數據打印爲矩陣列表。

>>> a = np.arange(6)                         # 而後將一維數組打印爲行
>>> print(a)
[0 1 2 3 4 5]
>>>
>>> b = np.arange(12).reshape(4,3)           # 將二維數據打印爲矩陣
>>> print(b)
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
>>>
>>> c = np.arange(24).reshape(2,3,4)         # 將三維數據打印爲矩陣列表
>>> print(c)
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]
 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]

若是數組太大而沒法打印，NumPy會自動跳過數組的中心部分並僅打印角落：

>>> print(np.arange(10000))
[   0    1    2 ..., 9997 9998 9999]
>>>
>>> print(np.arange(10000).reshape(100,100))
[[   0    1    2 ...,   97   98   99]
 [ 100  101  102 ...,  197  198  199]
 [ 200  201  202 ...,  297  298  299]
 ...,
 [9700 9701 9702 ..., 9797 9798 9799]
 [9800 9801 9802 ..., 9897 9898 9899]
 [9900 9901 9902 ..., 9997 9998 9999]]

要禁用此行爲並強制NumPy打印整個陣列，可使用更改打印選項set_printoptions。

>>> np.set_printoptions(threshold=np.nan)

基本操做

數組上的算術運算符應用於元素。建立一個新數組並填充結果。

>>> a = np.array( [20,30,40,50] )
>>> b = np.arange( 4 )
>>> b
array([0, 1, 2, 3])
>>> c = a-b
>>> c
array([20, 29, 38, 47])
>>> b**2
array([0, 1, 4, 9])
>>> 10*np.sin(a)
array([ 9.12945251, -9.88031624,  7.4511316 , -2.62374854])
>>> a<35
array([ True, True, False, False])

與許多矩陣語言不一樣，產品運算符*在NumPy數組中以元素方式運行。矩陣乘積可使用@運算符（在python> = 3.5中）或dot函數或方法執行：

>>> A = np.array( [[1,1],
...             [0,1]] )
>>> B = np.array( [[2,0],
...             [3,4]] )
>>> A * B                       # elementwise product
array([[2, 0],
       [0, 4]])
>>> A @ B                       # matrix product
array([[5, 4],
       [3, 4]])
>>> A.dot(B)                    # another matrix product
array([[5, 4],
       [3, 4]])

某些操做（例如+=和）*=用於修改現有陣列而不是建立新陣列。

>>> a = np.ones((2,3), dtype=int)
>>> b = np.random.random((2,3))
>>> a *= 3
>>> a
array([[3, 3, 3],
       [3, 3, 3]])
>>> b += a
>>> b
array([[ 3.417022  ,  3.72032449,  3.00011437],
       [ 3.30233257,  3.14675589,  3.09233859]])
>>> a += b                  # b is not automatically converted to integer type
Traceback (most recent call last):
  ...
TypeError: Cannot cast ufunc add output from dtype('float64') to dtype('int64') with casting rule 'same_kind'

當使用不一樣類型的數組進行操做時，結果數組的類型對應於更通常或更精確的數組（稱爲向上轉換的行爲）

>>> a = np.ones(3, dtype=np.int32)
>>> b = np.linspace(0,pi,3)
>>> b.dtype.name
'float64'
>>> c = a+b
>>> c
array([ 1.        ,  2.57079633,  4.14159265])
>>> c.dtype.name
'float64'
>>> d = np.exp(c*1j)
>>> d
array([ 0.54030231+0.84147098j, -0.84147098+0.54030231j,
       -0.54030231-0.84147098j])
>>> d.dtype.name
'complex128'

許多一元操做，例如計算數組中全部元素的總和，都是做爲ndarray類的方法實現的。

>>> a = np.random.random((2,3))
>>> a
array([[ 0.18626021,  0.34556073,  0.39676747],
       [ 0.53881673,  0.41919451,  0.6852195 ]])
>>> a.sum()
2.5718191614547998
>>> a.min()
0.1862602113776709
>>> a.max()
0.6852195003967595

默認狀況下，這些操做適用於數組，就像它是一個數字列表同樣，不管其形狀如何。可是，經過指定axis 參數，您能夠沿數組的指定軸應用操做：

>>> b = np.arange(12).reshape(3,4)
>>> b
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>>
>>> b.sum(axis=0)                            # 列的總和
array([12, 15, 18, 21])
>>>
>>> b.min(axis=1)                            # 行的總和
array([0, 4, 8])
>>>
>>> b.cumsum(axis=1)                         # cumulative sum along each row
array([[ 0,  1,  3,  6],
       [ 4,  9, 15, 22],
       [ 8, 17, 27, 38]])