模塊_數據分析

時間 2019-11-17

標籤模塊數據分析简体版

原文原文鏈接

numpy模塊

numpy說明

說明

NumPy是高性能科學計算和數據分析的基礎包。它是pandas等其餘各類工具的基礎。

NumPy的主要功能：
ndarray，一個多維數組結構，高效且節省空間
無需循環對整組數據進行快速運算的數學函數
*讀寫磁盤數據的工具以及用於操做內存映射文件的工具
*線性代數、隨機數生成和傅里葉變換功能
*用於集成C、C++等代碼的工具

安裝

pip install numpy

import numpy
# import numpy as np

numpy經常使用

建立ndarray對象

array()        將列表轉換爲數組，可選擇顯式指定dtype
arange()        range的numpy版，支持浮點數
linspace()    相似arange()，第三個參數爲數組長度
zeros()        根據指定形狀和dtype建立全0數組
ones()        根據指定形狀和dtype建立全1數組
empty()        根據指定形狀和dtype建立空數組（隨機值）
eye()        根據指定邊長和dtype建立單位矩陣

以上全部方法都可使用reshape進行重構

import numpy as np #引入numpy庫

#建立一維的narray對象
a = np.array([1,2,3,4,5])
# <class 'numpy.ndarray'> [1 2 3 4 5]

#建立二維的narray對象
a2 = np.array([[1,2,3,4,5],[6,7,8,9,10]])
# <class 'numpy.ndarray'> [[ 1  2  3  4  5] [ 6  7  8  9 10]]


#建立多維對象以其類推

經過array建立ndarray

import numpy as np

a = np.arange(10) # 默認從0開始到10（不包括10），步長爲1
print(a) # 返回 [0 1 2 3 4 5 6 7 8 9]

a1 = np.arange(5,10) # 從5開始到10（不包括10），步長爲1
print(a1) # 返回 [5 6 7 8 9]

a2 = np.arange(5,20,2) # 從5開始到20（不包括20），步長爲2
print(a2) # 返回 [ 5  7  9 11 13 15 17 19]

經過numpy.arrange建立ndarray

import numpy as np

a = np.linspace(0,10,7) # 生成首位是0，末位是10，含7個數的等差數列
print(a) 
# 結果 
# [  0.           1.66666667   3.33333333   5.         6.66666667  8.33333333  10.     ]

經過linspace建立ndarray，等差數列

import numpy as np


# 下面的例子用於生成首位是10的0次方，末位是10的2次方，含5個數的等比數列。
a = np.logspace(0,2,5)  # 參數2是指10的2次方
print(a)
# 結果
# [   1.      3.16227766   10.           31.6227766   100.  ]

經過logspace建立ndarray，等比數列

# ones建立全1矩陣
# zeros建立全0矩陣
# eye建立單位矩陣
# empty建立空矩陣（實際有值）

import numpy as np

a_ones = np.ones((3,4)) # 建立3*4的全1矩陣
print(a_ones)
# 結果
# [[ 1.  1.  1.  1.]
#  [ 1.  1.  1.  1.]
#  [ 1.  1.  1.  1.]]

a_zeros = np.zeros((3,4)) # 建立3*4的全0矩陣
print(a_zeros)
# 結果
# [[ 0.  0.  0.  0.]
#  [ 0.  0.  0.  0.]
#  [ 0.  0.  0.  0.]]

a_eye = np.eye(3) # 建立3階單位矩陣
print(a_eye)
# 結果
# [ 1.  0.  0.]
#  [ 0.  1.  0.]
#  [ 0.  0.  1.]]

a_empty = np.empty((3,4)) # 建立3*4的空矩陣
print(a_empty)
# 結果
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

經過ones/zeros/eye/empty建立ndarray

# fromstring()方法能夠將字符串轉化成ndarray對象，須要將字符串數字化時這個方法比較有用，能夠得到字符串的ascii碼序列。
import numpy as np
a = "abcdef"
b = np.fromstring(a,dtype=np.int8) # 由於一個字符爲8位，因此指定dtype爲np.int8
print(b) # 返回 [ 97  98  99 100 101 102]

經過fromstring建立ndarray，由ascii碼組成的序列

# fromfunction()方法能夠根據矩陣的行號列號生成矩陣的元素。 
# 例如建立一個矩陣，矩陣中的每一個元素都爲行號和列號的和。
import numpy as np

def func(i,j): 
    return i+j

a = np.fromfunction(func,(5,6)) 
# 第一個參數爲指定函數，第二個參數爲列表list或元組tuple,說明矩陣的大小
print(a)
# 返回
# [[ 0.  1.  2.  3.  4.  5.]
#  [ 1.  2.  3.  4.  5.  6.]
#  [ 2.  3.  4.  5.  6.  7.]
#  [ 3.  4.  5.  6.  7.  8.]
#  [ 4.  5.  6.  7.  8.  9.]]
#注意這裏行號的列號都是從0開始的

經過fromfunction建立ndarray

NaN

import numpy as np


print(np.nan)
# nan

Nan

random

import numpy as np

print(np.random.rand())  # 給定形狀產生隨機數組（0到1之間的數） 0.5428533738729602  # float

print(np.random.randint(1,100))  # 給定形狀產生隨機整數 40  # int

print(np.random.choice(list(range(10)),5))  # 在樣本中選擇n個數據 [8 6 5 0 8]  # ndarray

x = np.arange(1,6) # 用list也是能夠的[1,2,3,4,5]
print(np.random.shuffle(x))  # None
print(x)  # [4, 1, 2, 3, 5]

print(np.random.uniform(0,100,5))  # None
# [34.40384563 96.14040662 32.90570129 58.28899661 60.20901579]

random

shape方法，數組的維度大小（以元組形式），獲取ndarray的列數、行數，

import numpy as np #引入numpy庫

#建立一維的narray對象
a = np.array([1,2,3,4,5])
print(a.shape)  # (5,)

#建立二維的narray對象
a2 = np.array([[1,2,3,4,5],[6,7,8,9,10]])
print(a2.shape)  # (2, 5)
print(a2.shape[0])  # 得到行數,2
print(a2.shape[1])  # 得到列數,5

獲取列數、行數

reshape

import numpy as np

a = np.arange(0,12).reshape(3,4)
print(a)

'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
'''

reshape

查看dtype

import numpy as np

a = np.arange(1.1111111,20,2)
b = np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15]])

print(a.dtype)  # float64
print(b.dtype)  # int32

dtype

索引

import numpy as np

a = np.array([[1,2,3],[4,5,6],[7,8,9]])

print(a[2])  # 獲取index爲2的列  [7 8 9]
print(a[2][2])  # 9
print(a[2,2])  # 9

普通索引

import numpy as np

a = np.arange(0,20,2)
print(a)
# [ 0  2  4  6  8 10 12 14 16 18]

# 問題1：對於一個數組，選出其第1，3，4，6，7個元素，組成新的二維數組。
print(a[[1,3,4,6,7]])
# [ 2  6  8 12 14]


a = np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15]])
# 問題2：對一個二維數組，選出其第一列和第三列，組成新的二維數組。
print(a[:,[1,3]])
# [[ 2  4]
#  [ 7  9]
#  [12 14]]

花式索引

切片

import numpy as np
a = np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15]])

print(a[0:2]) #截取第1-2行,返回 [[1 2 3 4 5] [ 6  7  8  9 10]]
print(a[1,2:5]) #截取第2行，第3、4、五列，返回 [8 9 10]

print(a[2,:]) #截取第3行,返回 [11 12 13 14 15]

按行、列切片，相似於列表的切片

import numpy as np

a = np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15]])

# 其實布爾語句首先生成一個布爾矩陣，將布爾矩陣傳入[]（方括號）實現截取
print(a>3)
# [[False False False  True  True]
#  [ True  True  True  True  True]
#  [ True  True  True  True  True]]


# 問題1：給一個數組，選出數組中全部大於5的偶數
print(a[(a>5) & (a%2==0)])
# [ 6  8 10 12 14]

# 問題2：給一個數組，選出數組中全部大於5的數和偶數
print(a[(a>5) | (a%2==0)])
# [ 2  4  6  7  8  9 10 11 12 13 14 15]

# 問題3：給一個數組，選出數組中全部大於6的數
print(a[a>6])
# [ 7  8  9 10 11 12 13 14 15]

# 問題4：給一個數組，把大於6的數置零
a[a>6] = 0
print(a)
#大於6清零後矩陣爲
# [[1 2 3 4 5]
#  [6 0 0 0 0]
#  [0 0 0 0 0]]

布爾切片和切片賦值

copy

與列表不一樣，數組切片時並不會自動複製，在切片數組上的修改會影響原數組。【解決方法：copy()】正則表達式

"""
某位置累積和指的是該位置以前(包括該位置)全部元素的和。

例如序列[1,2,3,4,5]，其累計和爲[1,3,6,10,15]，即第一個元素爲1，第二個元素爲1+2=3，……，第五個元素爲1+2+3+4+5=15。

矩陣求累積和的函數是cumsum()，能夠對行，列，或整個矩陣求累積和。


"""

import numpy as np

a = np.array([1,2,3,4,5])
print(a)  # [1 2 3 4 5]
a_ = a[:3]
print(a_)  # [1 2 3]
a_[:] = 0
print(a)  # [0 0 0 4 5]  # 切片數據的修改會影響本來的array
print(a_)  # [0 0 0]


b = np.array([6,7,8,9,10])
print(b)  # [ 6  7  8  9 10]
b_ = b[:3].copy()
print(b_)  # [6 7 8]
b_[:] = 0
print(b)  # [ 6  7  8  9 10]  # 使用copy後，對原array無影響
print(b_)  # [0 0 0]

copy

copy

合併

import numpy as np

a1 = np.array([[1,2],[3,4]])
a2 = np.array([[5,6],[7,8]])

#!注意 參數傳入時要以列表list或元組tuple的形式傳入
print(np.hstack([a1,a2]))
# 等價於tmp = np.concatenate( (a1,a2), axis=1 )
#橫向合併，返回結果以下
# [[1 2 5 6]
#  [3 4 7 8]]

print(np.vstack((a1,a2)))
# 等價於np.concatenate( (a1,a2), axis=0 )
#縱向合併，返回結果以下
# [[1 2]
#  [3 4]
#  [5 6]
#  [7 8]]

合併 hstack、vstack 和 concatenate

運算

一元函數：abs, sqrt, exp, log, ceil, floor, rint, trunc, modf, isnan, isinf, cos, sin, tan
二元函數：add, substract, multiply, divide, power, mod,  maximum, mininum, 


sum    求和
mean    求平均數
std    求標準差
var    求方差
min    求最小值
max    求最大值
argmin    求最小值索引
argmax    求最大值索引

"""
運算符    說明
+    矩陣對應元素相加
-    矩陣對應元素相減
*    矩陣對應元素相乘
/    矩陣對應元素相除，若是都是整數則取商
%    矩陣對應元素相除後取餘數
**    矩陣每一個元素都取n次方，如**2：每一個元素都取平方
"""

import numpy as np
a1 = np.array([[4,5,6],[1,2,3]])
a2 = np.array([[6,5,4],[3,2,1]])

print(a1+a2) # 相加
# [[10 10 10]
#  [ 4  4  4]]

print(a1/a2) # 整數相除取商
# [[0.66666667 1.         1.5       ]
#  [0.33333333 1.         3.        ]]

print(a1%a2) # 相除取餘數
# [[4 0 2]
#  [1 0 0]]

print(a1 % 2)
# [[0 1 0]
#  [1 0 1]]

print(a1 ** 2)
# [[16 25 36]
#  [ 1  4  9]]

print(a1 ** a2)
# [[4096 3125 1296]
#  [   1    4    3]]

運算符 + - * / % **

"""
np.sin(a)    對矩陣a中每一個元素取正弦,sin(x)
np.cos(a)    對矩陣a中每一個元素取餘弦,cos(x)
np.tan(a)    對矩陣a中每一個元素取正切,tan(x)
np.arcsin(a)    對矩陣a中每一個元素取反正弦,arcsin(x)
np.arccos(a)    對矩陣a中每一個元素取反餘弦,arccos(x)
np.arctan(a)    對矩陣a中每一個元素取反正切,arctan(x)
np.exp(a)    對矩陣a中每一個元素取指數函數,ex
np.sqrt(a)    對矩陣a中每一個元素開根號√x
"""
import numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(np.sin(a))
# 結果
# [[ 0.84147098  0.90929743  0.14112001]
#  [-0.7568025  -0.95892427 -0.2794155 ]]

print(np.arcsin(a))
# 結果
# C:\Users\Administrator\Desktop\learn.py:6: RuntimeWarning: invalid value encountered in arcsin
#   print(np.arcsin(a))
# [[ 1.57079633         nan         nan]
#  [        nan         nan         nan]]

numpy自帶函數

# 矩陣乘法必須知足矩陣乘法的條件，即第一個矩陣的列數等於第二個矩陣的行數。 
import numpy as np

a1 = np.array([[1,2,3],[4,5,6]]) # a1爲2*3矩陣
a2 = np.array([[1,2],[3,4],[5,6]]) # a2爲3*2矩陣

print(a1.shape[1]==a2.shape[0]) # True, 知足矩陣乘法條件
print(a1.dot(a2))
# a1.dot(a2)至關於matlab中的a1*a2
# 而python中的a1*a2至關於matlab中的a1.*a2
# [[22 28]
#  [49 64]]

print(a2.dot(a1))  # 注意，與a1.dot(a2)是不同的
# [[ 9 12 15]
#  [19 26 33]
#  [29 40 51]]

點乘

"""
求矩陣的逆須要先導入numpy.linalg，用linalg的inv函數來求逆。 
矩陣求逆的條件是矩陣的行數和列數相同。
"""

import numpy as np
import numpy.linalg as lg

a = np.array([[1,2,3],[4,5,6],[7,8,9]])

print(lg.inv(a))
# 結果
# [[ -4.50359963e+15   9.00719925e+15  -4.50359963e+15]
#  [  9.00719925e+15  -1.80143985e+16   9.00719925e+15]
#  [ -4.50359963e+15   9.00719925e+15  -4.50359963e+15]]

a = np.eye(3) # 3階單位矩陣
print(lg.inv(a)) # 單位矩陣的逆爲他自己
# 結果
# [[ 1.  0.  0.]
#  [ 0.  1.  0.]
#  [ 0.  0.  1.]]

逆

import numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(a.max()) #獲取整個矩陣的最大值 結果： 6
print(a.min()) #結果：1

# 能夠指定關鍵字參數axis來得到行最大（小）值或列最大（小）值
# axis=0 行方向最大（小）值，即得到每列的最大（小）值
# axis=1 列方向最大（小）值，即得到每行的最大（小）值
# 例如

print(a.max(axis=0))
# 結果爲 [4 5 6]

print(a.max(axis=1))
# 結果爲 [3 6]

# 要想得到最大最小值元素所在的位置，能夠經過argmax函數來得到
print(a.argmax(axis=1))
# 結果爲 [2 2]

最大值最小值 max/min

import numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(a.mean()) #結果爲： 3.5

# 一樣地，能夠經過關鍵字axis參數指定沿哪一個方向獲取平均值
print(a.mean(axis=0)) # 結果 [ 2.5  3.5  4.5]
print(a.mean(axis=1)) # 結果 [ 2.  5.]

平均值 mean

"""
方差的函數爲var(),方差函數var()至關於函數mean(abs(x - x.mean())**2),其中x爲矩陣。
"""
import numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(a.var()) # 結果 2.91666666667

print(a.var(axis=0)) # 結果 [ 2.25  2.25  2.25]
print(a.var(axis=1)) # 結果 [ 0.66666667  0.66666667]

方差 var

"""
標準差的函數爲std()。 
std()至關於sqrt(mean(abs(x - x.mean())**2))，或至關於sqrt(x.var())。
"""
import numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(a.std()) # 結果 1.70782512766

print(a.std(axis=0)) # 結果 [ 1.5  1.5  1.5]
print(a.std(axis=1)) # 結果 [ 0.81649658  0.81649658]

標準差 std

"""
中值指的是將序列按大小順序排列後，排在中間的那個值，若是有偶數個數，則是排在中間兩個數的平均值。

例如序列[5,2,6,4,2]，按大小順序排成 [2,2,4,5,6]，排在中間的數是4，因此這個序列的中值是4。

又如序列[5,2,6,4,3,2]，按大小順序排成 [2,2,3,4,5,6]，由於有偶數個數，排在中間兩個數是三、4，因此這個序列中值是3.5。

中值的函數是median()，調用方法爲numpy.median(x,[axis])，axis可指定軸方向，默認axis=None，對全部數去中值。
"""

import numpy as np
x = np.array([[1,2,3],[4,5,6]])

print(np.median(x))  # 對全部數取中值
# 3.5

print(np.median(x,axis=0))  # 沿第一維方向取中值
# [ 2.5  3.5  4.5]

print(np.median(x,axis=1))  # 沿第二維方向取中值
# [ 2.  5.]

中值 median

import numpy as np

a = np.array([[1,2,3],[4,5,6]])

print(a.sum())           # 對整個矩陣求和
# 結果 21

print(a.sum(axis=0)) # 對行方向求和
# 結果 [5 7 9]

print(a.sum(axis=1)) # 對列方向求和
# 結果 [ 6 15]

求和 sum

"""
某位置累積和指的是該位置以前(包括該位置)全部元素的和。

例如序列[1,2,3,4,5]，其累計和爲[1,3,6,10,15]，即第一個元素爲1，第二個元素爲1+2=3，……，第五個元素爲1+2+3+4+5=15。

矩陣求累積和的函數是cumsum()，能夠對行，列，或整個矩陣求累積和。


"""

import numpy as np

a = np.array([[1,2,3],[4,5,6]])

print(a.cumsum())            # 對整個矩陣求累積和
# [ 1  3  6 10 15 21]

print(a.cumsum(axis=0))  # 對行方向求累積和
# [[1 2 3]
#  [5 7 9]]

print(a.cumsum(axis=1))  # 對列方向求累積和
# [[ 1  3  6]
#  [ 4  9 15]]

累計和 cumsum

轉置

import numpy as np

a = np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15]])
print(a)
# [[ 1  2  3  4  5]
#  [ 6  7  8  9 10]
#  [11 12 13 14 15]]

print(a.T)
# [[ 1  6 11]
#  [ 2  7 12]
#  [ 3  8 13]
#  [ 4  9 14]
#  [ 5 10 15]]

print(a.transpose())
# [[ 1  6 11]
#  [ 2  7 12]
#  [ 3  8 13]
#  [ 4  9 14]
#  [ 5 10 15]]

轉置 T 或 transpose

numpy函數和屬性

numpy數據類型

類型	類型代碼	說明
int八、uint8	i一、u1	有符號和無符號8位整型（1字節）
int1六、uint16	i二、u2	有符號和無符號16位整型（2字節）
int3二、uint32	i四、u4	有符號和無符號32位整型（4字節）
int6四、uint64	i八、u8	有符號和無符號64位整型（8字節）
float16	f2	半精度浮點數
float32	f四、f	單精度浮點數
float64	f八、d	雙精度浮點數
float128	f1六、g	擴展精度浮點數
complex64	c8	分別用兩個32位表示的複數
complex128	c16	分別用兩個64位表示的複數
complex256	c32	分別用兩個128位表示的複數
bool	?	布爾型
object	O	python對象
string	Sn	固定長度字符串，每一個字符1字節，如S10
unicode	Un	固定長度Unicode，字節數由系統決定，如U10

numpy經常使用函數

生成函數	做用
np.array( x)sql np.array( x, dtype)數據庫	將輸入數據轉化爲一個ndarrayjson 將輸入數據轉化爲一個類型爲type的ndarray數組
np.asarray( array )	將輸入數據轉化爲一個新的（copy）ndarray
np.ones( N )數據結構 np.ones( N, dtype)app np.ones_like( ndarray )less	生成一個N長度的一維全一ndarray 生成一個N長度類型是dtype的一維全一ndarray 生成一個形狀與參數相同的全一ndarray
np.zeros( N) np.zeros( N, dtype) np.zeros_like(ndarray)	生成一個N長度的一維全零ndarray 生成一個N長度類型位dtype的一維全零ndarray 相似np.ones_like( ndarray )
np.empty( N ) np.empty( N, dtype) np.empty(ndarray)	生成一個N長度的未初始化一維ndarray 生成一個N長度類型是dtype的未初始化一維ndarray 相似np.ones_like( ndarray )
np.eye( N ) np.identity( N )	建立一個N * N的單位矩陣（對角線爲1，其他爲0）
np.arange( num) np.arange( begin, end) np.arange( begin, end, step)	生成一個從0到num-1步數爲1的一維ndarray 生成一個從begin到end-1步數爲1的一維ndarray 生成一個從begin到end-step的步數爲step的一維ndarray
np.mershgrid(ndarray, ndarray,...)	生成一個ndarray * ndarray * ...的多維ndarray
np.where(cond, ndarray1, ndarray2)	根據條件cond，選取ndarray1或者ndarray2，返回一個新的ndarray
np.in1d(ndarray, [x,y,...])	檢查ndarray中的元素是否等於[x,y,...]中的一個，返回bool數組

矩陣函數	說明
np.diag( ndarray) np.diag( [x,y,...])	以一維數組的形式返回方陣的對角線（或非對角線）元素將一維數組轉化爲方陣（非對角線元素爲0）
np.dot(ndarray, ndarray)	矩陣乘法
np.trace( ndarray)	計算對角線元素的和


排序函數	說明
np.sort( ndarray)	排序，返回副本
np.unique(ndarray)	返回ndarray中的元素，排除重複元素以後，並進行排序
np.intersect1d( ndarray1, ndarray2) np.union1d( ndarray1, ndarray2) np.setdiff1d( ndarray1, ndarray2) np.setxor1d( ndarray1, ndarray2)	返回兩者的交集並排序。返回兩者的並集並排序。返回兩者的差。返回兩者的對稱差

一元計算函數	說明
np.abs(ndarray) np.fabs(ndarray)	計算絕對值計算絕對值（非複數）
np.mean(ndarray)	求平均值
np.sqrt(ndarray)	計算x^0.5
np.square(ndarray)	計算x^2
np.exp(ndarray)	計算e^x
log、log十、log二、log1p	計算天然對數、底爲10的log、底爲2的log、底爲(1+x)的log
np.sign(ndarray)	計算正負號：1（正）、0（0）、-1（負）
np.ceil(ndarray) np.floor(ndarray) np.rint(ndarray)	計算大於等於改值的最小整數計算小於等於該值的最大整數四捨五入到最近的整數，保留dtype
np.modf(ndarray)	將數組的小數和整數部分以兩個獨立的數組方式返回
np.isnan(ndarray)	返回一個判斷是不是NaN的bool型數組
np.isfinite(ndarray) np.isinf(ndarray)	返回一個判斷是不是有窮（非inf，非NaN）的bool型數組返回一個判斷是不是無窮的bool型數組
cos、cosh、sin、sinh、tan、tanh	普通型和雙曲型三角函數
arccos、arccosh、arcsin、arcsinh、arctan、arctanh	反三角函數和雙曲型反三角函數
np.logical_not(ndarray)	計算各元素not x的真值，至關於-ndarray
多元計算函數	說明
np.add(ndarray, ndarray) np.subtract(ndarray, ndarray) np.multiply(ndarray, ndarray) np.divide(ndarray, ndarray) np.floor_divide(ndarray, ndarray) np.power(ndarray, ndarray) np.mod(ndarray, ndarray)	相加相減乘法除法圓整除法（丟棄餘數）次方求模
np.maximum(ndarray, ndarray) np.fmax(ndarray, ndarray) np.minimun(ndarray, ndarray) np.fmin(ndarray, ndarray)	求最大值求最大值（忽略NaN）求最小值求最小值（忽略NaN）
np.copysign(ndarray, ndarray)	將參數2中的符號賦予參數1
np.greater(ndarray, ndarray) np.greater_equal(ndarray, ndarray) np.less(ndarray, ndarray) np.less_equal(ndarray, ndarray) np.equal(ndarray, ndarray) np.not_equal(ndarray, ndarray)	> >= < <= == !=
logical_and(ndarray, ndarray) logical_or(ndarray, ndarray) logical_xor(ndarray, ndarray)	& \| ^
np.dot( ndarray, ndarray)	計算兩個ndarray的矩陣內積
np.ix_([x,y,m,n],...)	生成一個索引器，用於Fancy indexing(花式索引)

文件讀寫	說明
np.save(string, ndarray)	將ndarray保存到文件名爲 [string].npy 的文件中（無壓縮）
np.savez(string, ndarray1, ndarray2, ...)	將全部的ndarray壓縮保存到文件名爲[string].npy的文件中
np.savetxt(sring, ndarray, fmt, newline='\n')	將ndarray寫入文件，格式爲fmt
np.load(string)	讀取文件名string的文件內容並轉化爲ndarray對象（或字典對象）
np.loadtxt(string, delimiter)	讀取文件名string的文件內容，以delimiter爲分隔符轉化爲ndarray

ndarray屬性

ndarray.ndim	獲取ndarray的維數
ndarray.shape	獲取ndarray各個維度的長度
ndarray.dtype	獲取ndarray中元素的數據類型
ndarray.T	簡單轉置矩陣ndarray

ndarray函數

函數	說明
ndarray.astype(dtype)	轉換類型，若轉換失敗則會出現TypeError
ndarray.copy()	複製一份ndarray(新的內存空間)
ndarray.reshape((N,M,...))	將ndarray轉化爲NM...的多維ndarray（非copy）
ndarray.transpose((xIndex,yIndex,...))	根據維索引xIndex,yIndex...進行矩陣轉置，依賴於shape，不能用於一維矩陣（非copy）
ndarray.swapaxes(xIndex,yIndex)	交換維度（非copy）

計算函數	說明
ndarray.mean( axis=0 )	求平均值
ndarray.sum( axis= 0)	求和
ndarray.cumsum( axis=0) ndarray.cumprod( axis=0)	累加累乘
ndarray.std() ndarray.var()	方差標準差
ndarray.max() ndarray.min()	最大值最小值
ndarray.argmax() ndarray.argmin()	最大值索引最小值索引
ndarray.any() ndarray.all()	是否至少有一個True 是否所有爲True
ndarray.dot( ndarray)	計算矩陣內積
排序函數	說明
ndarray.sort(axis=0)	排序，返回源數據

ndarray索引/切片方式

ndarray[n]	選取第n+1個元素
ndarray[n:m]	選取第n+1到第m個元素
ndarray[:]	選取所有元素
ndarray[n:]	選取第n+1到最後一個元素
ndarray[:n]	選取第0到第n個元素
ndarray[ bool_ndarray ] 注：bool_ndarray表示bool類型的ndarray	選取爲true的元素
ndarray[[x,y,m,n]]...	選取順序和序列爲x、y、m、n的ndarray
ndarray[n,m] ndarray[n][m]	選取第n+1行第m+1個元素
ndarray[n,m,...] ndarray[n][m]....	選取n行n列....的元素

numpy.random經常使用函數

函數	說明
seed() seed(int) seed(ndarray)	肯定隨機數生成種子
permutation(int) permutation(ndarray)	返回一個一維從0~9的序列的隨機排列返回一個序列的隨機排列
shuffle(ndarray)	對一個序列就地隨機排列
rand(int) randint(begin,end,num=1)	產生int個均勻分佈的樣本值從給定的begin和end隨機選取num個整數
randn(N, M, ...)	生成一個NM...的正態分佈（平均值爲0，標準差爲1）的ndarray
normal(size=(N,M,...))	生成一個NM...的正態（高斯）分佈的ndarray
beta(ndarray1,ndarray2)	產生beta分佈的樣本值，參數必須大於0
chisquare()	產生卡方分佈的樣本值
gamma()	產生gamma分佈的樣本值
uniform()	產生在[0,1)中均勻分佈的樣本值

numpy.linalg經常使用函數

函數	說明
det(ndarray)	計算矩陣列式
eig(ndarray)	計算方陣的本徵值和本徵向量
inv(ndarray) pinv(ndarray)	計算方陣的逆計算方陣的Moore-Penrose僞逆
qr(ndarray)	計算qr分解
svd(ndarray)	計算奇異值分解svd
solve(ndarray)	解線性方程組Ax = b，其中A爲方陣
lstsq(ndarray)	計算Ax=b的最小二乘解

pandas模塊

pandas說明

說明

pandas是一個強大的Python數據分析的工具包。

pandas是基於NumPy構建的。

pandas的主要功能
    具有對其功能的數據結構DataFrame、Series
    集成時間序列功能
    提供豐富的數學運算和操做
    靈活處理缺失數據

官網

http://pandas.pydata.org/pandas-docs/stable/index.html

安裝

pip install pandas


import pandas
# import pandas as pd
# from pandas import Series, DataFrame


# 查看pandas版本
pandas.show_version()
pandas.__version__

pandas經常使用

copy

與列表不一樣，Series/DataFrame切片時並不會自動複製，在切片上的修改會影響原數據。【解決方法：copy()】

過程略。

建立Series對象

"""
Series是一種相似於一位數組的對象，由一組數據和一組與之相關的數據標籤（索引）組成。
Series比較像列表（數組）和字典的結合體
"""


import pandas as pd


a = pd.Series([4,7,-5,3])
# 0    4
# 1    7
# 2   -5
# 3    3
# dtype: int64
b = pd.Series([4,7,-5,3],index=['a','b','c','d'])
# a    4
# b    7
# c   -5
# d    3
# dtype: int64
c = pd.Series({'a':1, 'b':2})
# a    1
# b    2
# dtype: int64
d = pd.Series(0, index=['a','b','c','d'])
# a    0
# b    0
# c    0
# d    0
# dtype: int64

Series對象，具備value值和index值

Series修改dtypes

"""
"""

import numpy as np
import pandas as pd

sr = pd.Series([1,2,3,4])
# 0    1
# 1    2
# 2    3
# 3    4
# dtype: int64

print(sr.dtypes)
# int64
sr = sr.astype(float)
print(sr.dtypes)
# float64

print(sr)
# 0    1.0
# 1    2.0
# 2    3.0
# 3    4.0
# dtype: float64

Series修改dtypes

Series索引

import numpy as np
import pandas as pd


sr = pd.Series(np.arange(4.0))
print(sr)
# 0    0.0
# 1    1.0
# 2    2.0
# 3    3.0
# dtype: float64

sr.index = ["a","b","c","d"]
print(sr)
# a    0.0
# b    1.0
# c    2.0
# d    3.0
# dtype: float64

指定Series索引

"""
s4[3]
s4['e']
s4[[1,3,5]]
s4[['a','b','d','f']]
s4[:4]
s4['c':]
s4['b':'e']
"""

import numpy as np
import pandas as pd


sr = pd.Series(np.arange(4.0))
print(sr)
# 0    0.0
# 1    1.0
# 2    2.0
# 3    3.0
# dtype: float64

sr.index = ["a","b","c","d"]
print(sr)
# a    0.0
# b    1.0
# c    2.0
# d    3.0
# dtype: float64

print(sr[0])  # 0.0
print(sr["a"])  # 0.0
print(sr[[0,2,3]])
# a    0.0
# c    2.0
# d    3.0
# dtype: float64
print(sr[["a","c","d"]])
# a    0.0
# c    2.0
# d    3.0
# dtype: float64
print(sr[:3])
# a    0.0
# b    1.0
# c    2.0
# dtype: float64
print(sr["c":])
# c    2.0
# d    3.0
# dtype: float64
print(sr['b':'d'])
# b    1.0
# c    2.0
# d    3.0
# dtype: float64

經過索引獲取Series數據

# loc 對應標籤
# iloc 對應index

import numpy as np
import pandas as pd

sr1 = pd.Series(np.array([10,15,20,30,55,80]),index = ['a','b','c','d','e','f'])

print(sr1.iloc[1])  # 15
print(sr1.iloc[3:])
# d    30
# e    55
# f    80
# dtype: int32
print(sr1.iloc[3:5])  # 注意，不包含右邊界數據
# d    30
# e    55
# dtype: int32
print(sr1.loc['b'])  # 15
print(sr1.loc['d':])
print(sr1.loc["d":"f"])  # 注意，這是左右包含邊界數據
# d    30
# e    55
# f    80
# dtype: int32

iloc 和 loc

import numpy as np
import pandas as pd



data=pd.Series(np.random.rand(9), index=[['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c'], [1,2,3,1,2,3,1,2,3]])
print(data)
# a  1    0.369071
#    2    0.799169
#    3    0.633432
# b  1    0.080917
#    2    0.484825
#    3    0.462479
# c  1    0.463004
#    2    0.591250
#    3    0.541369
# dtype: float64

層次化索引

注意：

import numpy as np
import pandas as pd

# sr1 = pd.Series(np.array([10,15,20,30,55,80]),index = ['a','b','c','d','e','f'])

sr1 = pd.Series(np.array([10,15,20,30,55,80]),index = [1,2,3,4,5,6])
print(sr1)
# 1    10
# 2    15
# 3    20
# 4    30
# 5    55
# 6    80
# dtype: int32
print(sr1[1])  # 10

若是索引是整數類型，則根據整數進行數據操做時老是面向標籤的

Series運算

注意：Series對象運算時，可以使用fill_value參數進行缺失數據補全

import numpy as np
import pandas as pd

sr1 = pd.Series([12,23,34], index=['c','a','d'])

sr3 = pd.Series([11,20,10,14], index=['d','c','a','b'])

print(sr1.add(sr3,fill_value=0))
# a    33.0
# b    14.0
# c    32.0
# d    45.0
# dtype: float64

# 同理： add, sub, div, mul

add,sub,div,mul等

Series處理缺失數據 NaN

"""
缺失數據：使用NaN（Not a Number）來表示缺失數據。其值等於np.nan。內置的None值也會被當作NaN處理。


處理缺失數據的相關方法：
dropna()        過濾掉值爲NaN的行
fillna()        填充缺失數據
isnull()        返回布爾數組，缺失值對應爲True
notnull()        返回布爾數組，缺失值對應爲False


過濾缺失數據：sr.dropna() 或 sr[data.notnull()]
填充缺失數據：fillna(0)
"""

import numpy as np
import pandas as pd

sr1 = pd.Series([12,23,34,None], index=['a','b','c', 'd'])
print(sr1.dropna())
# 等同於sr1[sr1.notnull()]
# a    12.0
# b    23.0
# c    34.0
# dtype: float64
print(sr1.fillna(0))
# a    12.0
# b    23.0
# c    34.0
# d     0.0
# dtype: float64
print(sr1.isnull())
# a    False
# b    False
# c    False
# d     True
# dtype: bool
print(sr1.notnull())
# a     True
# b     True
# c     True
# d    False
# dtype: bool

處理缺失數據NaN

Series支持numpy和dict的特性

Series支持NumPy模塊的特性（下標）：
    從ndarray建立Series：Series(arr)
    與標量運算：sr*2
    兩個Series運算：sr1+sr2
    索引：sr[0], sr[[1,2,4]]
    切片：sr[0:2]
    通用函數：np.abs(sr)
    布爾值過濾：sr[sr>0]
Series支持字典的特性（標籤）：
    從字典建立Series：Series(dic), 
    in運算：’a’ in sr
    鍵索引：sr['a'], sr[['a', 'b', 'd']]

注意：

import numpy as np
import pandas as pd

sr1 = pd.Series([12,23,34], index=['c','a','d'])
sr2 = pd.Series([11,20,10], index=['d','c','a',])
print(sr1+sr2)
# a    33
# c    32
# d    45
# dtype: int64
sr3 = pd.Series([11,20,10,14], index=['d','c','a','b'])
print(sr1+sr3)
# a    33.0
# b     NaN
# c    32.0
# d    45.0
# dtype: float64

pandas在運算時，會按索引進行對齊而後計算。若是存在不一樣的索引，則結果的索引是兩個操做數索引的並集。

建立DataFrame對象

DataFrame是一個表格型的數據結構，含有一組有序的列。
DataFrame能夠被看作是由Series組成的字典，而且共用一個索引。

import numpy as np
import pandas as pd

df = pd.DataFrame({'one':[1,2,3,4],'two':[4,3,2,1]})
print(df)
#    one  two
# 0    1    4
# 1    2    3
# 2    3    2
# 3    4    1

df = pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']), 'two':pd.Series([1,2,3,4],index=['b','a','c','d'])})
print(df)
#    one  two
# a  1.0    2
# b  2.0    1
# c  3.0    3
# d  NaN    4

建立DataFrame

DataFrame CSV

import numpy as np
import pandas as pd

df = pd.read_csv("test.csv")  # 從csv導入爲DataFrame
print(df)
"""
           date    open    high    ...       v_ma10    v_ma20  turnover
0    2018-05-25   28.11   28.28    ...     42531.08  50972.04      1.09
1    2018-05-24   28.11   28.49    ...     44772.36  52807.80      0.82
2    2018-05-23   28.18   28.53    ...     45845.72  53660.69      1.21
...
"""

df.to_csv("new.csv")  # 寫入csv文件

csv導入導出

df = pd.read_csv("601318.csv")   #默認以,爲分隔符
    - pd.read_csv("601318.csv",sep='\s+')  #匹配空格，支持正則表達式
    - pd.read_table("601318.csv",sep=',')  #和df = pd.read_csv("601318.csv")   同樣
    - pd.read_excle("601318.xlsx")  #讀Excel文件
    sep：指定分隔符
    header = NOne,就會吧默認的表名去除 了
    df.rename(column={0:'a',1:"b"})  #修改列名
    pd.read_csv(index_col=0)  #第0列
    若是想讓時間成爲索引
        pd.read_csv(index_col='date')  #時間列
    pd.read_csv(index_col='date',parse_datas=True)  #時間列
    parse_datas轉換爲時間對象，設爲true是吧全部能轉的都轉
    pd.read_csv(index_col='date',parse_datas=['date'])   #知識吧date的那一列轉換成時間對象
        
    na_values=['None']  #吧表裏面爲None的轉換成NaN，是吧字符串轉換成缺失值
    na_rep()  #是吧缺失值nan轉換成字符串

    cols #指定輸出的列，傳入列表

csv

DataFrame增刪改查

# -*- coding:utf-8 -*-

import numpy as np
import pandas as pd

df = pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']), 'two':pd.Series([1,2,3,4],index=['b','a','c','d'])})
df2 = pd.DataFrame({'one':pd.Series([5,6,7],index=['a','b','c']), 'three':pd.Series([2,4,6],index=['a','b','c'])})
# print(df.drop(["two"],axis=1))
#    one
# a  1.0
# b  2.0
# c  3.0
# d  NaN

df3 = pd.concat([df,df2])  # 拼接 兩df，axis默認=0，對應位置無值的填NaN
#    one  three  two
# a  1.0    NaN  2.0
# b  2.0    NaN  1.0
# c  3.0    NaN  3.0
# d  NaN    NaN  4.0
# a  5.0    2.0  NaN
# b  6.0    4.0  NaN
# c  7.0    6.0  NaN

x = pd.concat([df,df2],axis=1)
#    one  two  one  three
# a  1.0    2  5.0    2.0
# b  2.0    1  6.0    4.0
# c  3.0    3  7.0    6.0
# d  NaN    4  NaN    NaN


df4 = pd.DataFrame(df3,columns=["one","two","three","ten"])  # 新增一列ten，填充值爲NaN
#    one  two  three  ten
# a  1.0  2.0    NaN  NaN
# b  2.0  1.0    NaN  NaN
# c  3.0  3.0    NaN  NaN
# d  NaN  4.0    NaN  NaN
# a  5.0  NaN    2.0  NaN
# b  6.0  NaN    4.0  NaN
# c  7.0  NaN    6.0  NaN

df4["xyz"] = 9999
#    one  two  three  ten   xyz
# a  1.0  2.0    NaN  NaN  9999
# b  2.0  1.0    NaN  NaN  9999
# c  3.0  3.0    NaN  NaN  9999
# d  NaN  4.0    NaN  NaN  9999
# a  5.0  NaN    2.0  NaN  9999
# b  6.0  NaN    4.0  NaN  9999
# c  7.0  NaN    6.0  NaN  9999

拼接新增列

# -*- coding:utf-8 -*-

import numpy as np
import pandas as pd

df = pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']), 'two':pd.Series([1,2,3,4],index=['b','a','c','d']),'three':pd.Series([8,9,10,11,12],index=['a','b','c','d','e'])})

del df["two"]
print(df)
#    one  three
# a  1.0      8
# b  2.0      9
# c  3.0     10
# d  NaN     11
# e  NaN     12

print(df.drop("c"))
#    one  two  three
# a  1.0  2.0      8
# b  2.0  1.0      9
# d  NaN  4.0     11
# e  NaN  NaN     12

print(df.drop("three",axis=1))
#    one  two
# a  1.0  2.0
# b  2.0  1.0
# c  3.0  3.0
# d  NaN  4.0
# e  NaN  NaN


df = pd.DataFrame({'one':pd.Series([1,2,3]), 'two':pd.Series([1,2,3,4]),'three':pd.Series([8,9,10,11,12])})
#    one  two  three
# 0  1.0  1.0      8
# 1  2.0  2.0      9
# 2  3.0  3.0     10
# 3  NaN  4.0     11
# 4  NaN  NaN     12

print(df.drop([0,2,4]))
#    one  two  three
# 1  2.0  2.0      9
# 3  NaN  4.0     11

刪

# -*- coding:utf-8 -*-

import numpy as np
import pandas as pd

df = pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']), 'two':pd.Series([1,2,3,4],index=['b','a','c','d']),'three':pd.Series([8,9,10,11,12],index=['a','b','c','d','e'])})
#    one  two  three
# a  1.0  2.0      8
# b  2.0  1.0      9
# c  3.0  3.0     10
# d  NaN  4.0     11
# e  NaN  NaN     12

df.loc["b"] = "B"
df.loc["c"].loc["three"] = 8888
print(df)
#    one  two three
# a    1    2     8
# b    B    B     B
# c    3    3  8888
# d  NaN    4    11
# e  NaN  NaN    12

改

DataFrame修改dtypes

# -*- coding:utf-8 -*-

import numpy as np
import pandas as pd

df = pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']), 'two':pd.Series([1,2,3,4],index=['b','a','c','d']),'three':pd.Series([8,9,10,11,12],index=['a','b','c','d','e'])})
#    one  two  three
# a  1.0  2.0      8
# b  2.0  1.0      9
# c  3.0  3.0     10
# d  NaN  4.0     11
# e  NaN  NaN     12

print(df.dtypes)
# one      float64
# two      float64
# three      int64
# dtype: object
df["three"] = df["three"].astype(float)
print(df.dtypes)
# one      float64
# two      float64
# three    float64
# dtype: object
print(df)
#    one  two  three
# a  1.0  2.0    8.0
# b  2.0  1.0    9.0
# c  3.0  3.0   10.0
# d  NaN  4.0   11.0
# e  NaN  NaN   12.0

DataFrame修改dtypes

DataFrame查看數據

"""
index                    獲取索引
columns                    獲取列索引
T                        轉置
values                    獲取值數組
describe()                獲取快速統計
"""


import numpy as np
import pandas as pd

df = pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']), 'two':pd.Series([1,2,3,4],index=['b','a','c','d'])})
#    one  two
# a  1.0    2
# b  2.0    1
# c  3.0    3
# d  NaN    4

print(df.index)  # Index(['a', 'b', 'c', 'd'], dtype='object')
print(df.columns)  # Index(['one', 'two'], dtype='object')
print(df.values)  # <class 'numpy.ndarray'>
# [[ 1.  2.]
#  [ 2.  1.]
#  [ 3.  3.]
#  [nan  4.]]
print(df.describe())
#        one       two
# count  3.0  4.000000
# mean   2.0  2.500000
# std    1.0  1.290994
# min    1.0  1.000000
# 25%    1.5  1.750000
# 50%    2.0  2.500000
# 75%    2.5  3.250000
# max    3.0  4.000000
print(df.T)
#        a    b    c    d
# one  1.0  2.0  3.0  NaN
# two  2.0  1.0  3.0  4.0

index、colums、values、T、describe

DataFrame索引

"""
df[‘A’]   # 單個時，表示列
df[[‘A’, ‘B’]]   # 單個花式索引，表示列
df[‘A’][0]  # 第一個是列，單列表示Series，[0]表示索引
df[0:10][[‘A’, ‘C’]]  # 切片時，表示行；第二個花式索引表示列
df.loc[:,[‘A’,‘B’]]  # 第一個表示行
df.loc[:,'A':'C']  # 行，列
df.loc[0,'A']  # 行，列
df.loc[0:10,['A','C']]  # 出錯，loc對應的參數爲索引，若是用index，則須要用iloc
print(df.iloc[0:2,0:1])  # iloc對應是index
"""


import numpy as np
import pandas as pd

df = pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']), 'two':pd.Series([1,2,3,4],index=['b','a','c','d'])})
#    one  two
# a  1.0    2
# b  2.0    1
# c  3.0    3
# d  NaN    4

print(df["one"])  # 單個時，表示列
# a    1.0
# b    2.0
# c    3.0
# d    NaN
# Name: one, dtype: float64
print(df["one"]["a"])  # 單個花式索引，表示列
# 1.0
print(df[["one","two"]])  # 第一個是列，單列表示Series，[0]表示索引
#    one  two
# a  1.0    2
# b  2.0    1
# c  3.0    3
# d  NaN    4
print(df[1:3][["one","two"]])  # 切片時，表示行；第二個花式索引表示列
#    one  two
# b  2.0    1
# c  3.0    3

普通索引

"""
df.loc[:,[‘A’,‘B’]]  # 第一個表示行
df.loc[:,'A':'C']  # 行，列
df.loc[0,'A']  # 行，列
df.loc[0:10,['A','C']]  # 出錯，loc對應的參數爲索引，若是用index，則須要用iloc
df.iloc[3]
df.iloc[3,3]
df.iloc[0:3,4:6]
df.iloc[1:5,:]
df.iloc[[1,2,4],[0,3]]

"""


import numpy as np
import pandas as pd

df = pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']), 'two':pd.Series([1,2,3,4],index=['b','a','c','d'])})
#    one  two
# a  1.0    2
# b  2.0    1
# c  3.0    3
# d  NaN    4

print(df.loc["a":"c",["one","two"]])  # 行，列
#    one  two
# a  1.0    2
# b  2.0    1
# c  3.0    3
print(df.loc[:,'one':'two'])  # 行，列
#    one  two
# a  1.0    2
# b  2.0    1
# c  3.0    3
# d  NaN    4
print(df.loc["a",'two'])  # 行，列
# 2
# print(df.loc[0:2,["one","two"]])  # 出錯，loc對應的參數爲索引，若是用index，則須要用iloc
# 出錯


print(df.iloc[0:2,0:1])  # iloc對應是index
#    one
# a  1.0
# b  2.0
print(df.iloc[3])
# one    NaN
# two    4.0
# Name: d, dtype: float64
print(df.iloc[0:3,0:2])
#    one  two
# a  1.0    2
# b  2.0    1
# c  3.0    3
print(df.iloc[1:3,:])
#    one  two
# b  2.0    1
# c  3.0    3
print(df.iloc[[1,2],[0,1]])
#    one  two
# b  2.0    1
# c  3.0    3

loc iloc

"""
df[df['A']>0]
df[df['A'].isin([1,3,5])]
df[df<0] = 0

"""

import numpy as np
import pandas as pd

df = pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']), 'two':pd.Series([1,2,3,4],index=['b','a','c','d'])})
#    one  two
# a  1.0    2
# b  2.0    1
# c  3.0    3
# d  NaN    4

print(df[df["one"] > 2])
#    one  two
# c  3.0    3

print(df[df['one'].isin([1,3,5])])
#    one  two
# a  1.0    2
# c  3.0    3

df[df<=2] = 0
print(df)
#    one  two
# a  0.0    0
# b  0.0    0
# c  3.0    3
# d  NaN    4

布爾索引和賦值

DataFrame數據缺失

DataFrame處理缺失數據的方法：
dropna(axis=0,how=‘any’,…)  # 行axis=0，列axis=1
fillna()  # method="ffill" 使用前值填充 # method="bfill" 使用後值填充 # 字典，根據列進行填充
isnull()
notnull()

"""
DataFrame處理缺失數據的方法：
dropna(axis=0,how=‘any’,…)  # 行axis=0，列axis=1
fillna()  # method="ffill" 使用前值填充 # method="bfill" 使用後值填充 # 字典，根據列進行填充
isnull()
notnull()
"""

import numpy as np
import pandas as pd

df = pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']), 'two':pd.Series([None,None,3,4],index=['b','a','c','d'])})
#    one  two
# a  1.0  NaN
# b  2.0  NaN
# c  3.0  3.0
# d  NaN  4.0

print(df.dropna(axis=0,how="any"))  # 默認axis=0 行axis=0，列axis=1
#    one  two
# c  3.0  3.0
print(df.dropna(axis=1,how="any"))  # 因爲兩列均有None，則都drop掉
# Empty DataFrame
# Columns: []
# Index: [a, b, c, d]

print(df.fillna(10000000))
# 等價於 df[df.isnull()] = 10000000
#           one         two
# a         1.0  10000000.0
# b         2.0  10000000.0
# c         3.0         3.0
# d  10000000.0         4.0

print(df.fillna(method="ffill"))
#    one  two
# a  1.0  NaN
# b  2.0  NaN
# c  3.0  3.0
# d  3.0  4.0
print(df.fillna(method="bfill"))
#    one  two
# a  1.0  3.0
# b  2.0  3.0
# c  3.0  3.0
# d  NaN  4.0
print(df.fillna({"one":2000,"two":1999}))
#       one     two
# a     1.0  1999.0
# b     2.0  1999.0
# c     3.0     3.0
# d  2000.0     4.0

print(df.isnull())
#      one    two
# a  False   True
# b  False   True
# c  False  False
# d   True  False
print(df.notnull())
#      one    two
# a   True  False
# b   True  False
# c   True   True
# d  False   True

dropna/fillna/isnull/notnull

DataFrame其餘方法 mean sum sort apply等

"""
mean(axis=0,skipna=False)
sum(axis=1)
sort_index(axis, …, ascending)        按行或列索引排序，ascending=True/False順序、倒序
sort_values(by, axis, ascending)    按值排序
NumPy的通用函數一樣適用於pandas
apply(func, axis=0)    將自定義函數應用在各行或者各列上                                  ，func可返回標量或者Series
applymap(func)        將函數應用在DataFrame各個元素上
map(func)        將函數應用在Series各個元素上

"""

import numpy as np
import pandas as pd

df = pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']), 'two':pd.Series([None,None,3,4],index=['b','a','c','d'])})
#    one  two
# a  1.0  NaN
# b  2.0  NaN
# c  3.0  3.0
# d  NaN  4.0

print(df.mean(axis=0))  # 按列取平均
# one    2.0
# two    3.5
# dtype: float64
print(df.mean(axis=0,skipna=False))  # 按列取平均
# one   NaN
# two   NaN
# dtype: float64
print(df.mean(axis=1))  # 按行取平均
# a    1.0
# b    2.0
# c    3.0
# d    4.0
# dtype: float64


print(df.sum(axis=0))
# print(df.sum(axis=0,skipna=False))
# one    6.0
# two    7.0
# dtype: float64
print(df.sum(axis=1))
# a    1.0
# b    2.0
# c    6.0
# d    4.0
# dtype: float64


print(df.sort_index(axis=0,ascending=True))
#    one  two
# a  1.0  NaN
# b  2.0  NaN
# c  3.0  3.0
# d  NaN  4.0


print(df.sort_values(by=["two","one"],axis=0,ascending=False))  # 先two後one進行排序
#    one  two
# d  NaN  4.0
# c  3.0  3.0
# b  2.0  NaN
# a  1.0  NaN




def f(x):
    return x ** x

print(df.apply(f))
#     one    two
# a   1.0    NaN
# b   4.0    NaN
# c  27.0   27.0
# d   NaN  256.0

print(df.applymap(f))
#     one    two
# a   1.0    NaN
# b   4.0    NaN
# c  27.0   27.0
# d   NaN  256.0



x = pd.Series(np.arange(10))
print(x.apply(f))
# 0            1
# 1            1
# 2            4
# 3           27
# 4          256
# 5         3125
# 6        46656
# 7       823543
# 8     16777216
# 9    387420489
# dtype: int64
print(x.map(f))
# 0            1
# 1            1
# 2            4
# 3           27
# 4          256
# 5         3125
# 6        46656
# 7       823543
# 8     16777216
# 9    387420489
# dtype: int64

mean/sum/sort/apply等

import numpy as np
import pandas as pd

df = pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']), 'two':pd.Series([None,None,3,4],index=['b','a','c','d'])})
#    one  two
# a  1.0  NaN
# b  2.0  NaN
# c  3.0  3.0
# d  NaN  4.0


# 查詢數據的前n行或末尾n行
print(df.head(3))
#    one  two
# a  1.0  NaN
# b  2.0  NaN
# c  3.0  3.0
print(df.tail(2))
#    one  two
# c  3.0  3.0
# d  NaN  4.0

head tail

DataFrame文件處理

從文件讀取
"""
讀取文件：從文件名、URL、文件對象中加載數據
read_csv        默認分隔符爲,
read_table    默認分隔符爲\t
讀取文件函數主要參數：
sep        指定分隔符，可用正則表達式如'\s+'
header=None    指定文件無列名
name        指定列名
index_col    指定某列做爲索引
na_values    指定某些字符串表示缺失值
parse_dates    指定某些列是否被解析爲日期，布爾值或列表

nrows        指定讀取幾行文件
chunksize    分塊讀取文件，指定塊大小
skip_row    (多是skiprows，版本)    指定跳過某些行
"""


寫入到文件：
"""
to_csv
寫入文件函數的主要參數：
sep
na_rep        指定缺失值轉換的字符串，默認爲空字符串
header=False    不輸出列名一行
index=False    不輸出行索引一列
cols        指定輸出的列，傳入列表

其餘文件類型：json, XML, HTML, 數據庫
pandas轉換爲二進制文件格式（pickle）:
save
load
"""

pandas的時間處理

時間序列類型：
    時間戳：特定時刻
    固定時期：如2017年7月
    時間間隔：起始時間-結束時間
Python標準庫：datetime
    datetime.datetime.timedelta  # 表示 時間間隔
    dt.strftime() #f：format吧時間對象格式化成字符串
    strptime()  #吧字符串解析成時間對象p：parse
靈活處理時間對象：dateutil包
    dateutil.parser.parse('2018/1/29') 
     dateutil.parser.parse('27/6/2017',dayfirst =True)
成組處理時間對象：pandas
    pd.to_datetime(['2001-01-01', '2002-02-02'])
    DatetimeIndex(['2001-01-01', '2002-02-02'], dtype='datetime64[ns]', freq=None)



產生時間對象數組：date_range

    start 開始時間
    end 結束時間
    periods 時間長度
    freq 時間頻率，默認爲'D'，可選H(our),W(eek),B(usiness),S(emi-)M(onth),(min)T(es), S(econd), A(year),…


import pandas as pd
import numpy as np
x = pd.date_range(start="2015-01-01",periods=100,freq="D")
x = pd.date_range(start="2015-01-01",end="2016-01-01",freq="D")
print(x)

時間對象處理

1、時間序列就是以時間對象爲索引的Series或DataFrame。

2、datetime對象做爲索引時是存儲在DatetimeIndex對象中的。

3、時間序列特殊功能：

傳入「年」或「年月」做爲切片方式
傳入日期範圍做爲切片方式
豐富的函數支持：resample(), strftime(), ……
批量轉換爲datetime對象：to_pydatetime()

時間序列說明

import pandas as pd
import numpy as np

dates = ['2017-06-20','2017-06-21','2017-06-22','2017-06-23','2017-06-24','2017-06-25','2017-06-26','2017-06-27']


ts = pd.Series(np.random.randn(8),index = pd.to_datetime(dates))
print(ts)
# 2017-06-20   -0.228449
# 2017-06-21    0.938766
# 2017-06-22    0.474168
# 2017-06-23   -0.868375
# 2017-06-24    0.777883
# 2017-06-25   -1.248373
# 2017-06-26   -0.306503
# 2017-06-27    0.406621
# dtype: float64
print(ts.index)
# DatetimeIndex(['2017-06-20', '2017-06-21', '2017-06-22', '2017-06-23',
#                '2017-06-24', '2017-06-25', '2017-06-26', '2017-06-27'],
#               dtype='datetime64[ns]', freq=None)

print(ts["20170622"])
# 0.4741684129056889

print(ts["2017-06-24":"20170627"])
# 2017-06-24    0.543603
# 2017-06-25    0.006838
# 2017-06-26    0.953454
# 2017-06-27    0.870791
# dtype: float64

時間序列

import pandas as pd
import numpy as np

df = pd.read_csv("test.csv",index_col="date")
print(df)
#               open    high   close    ...       v_ma10    v_ma20  turnover
# date                                  ...                                 
# 2018-05-25   28.11   28.28   27.35    ...     42531.08  50972.04      1.09
# 2018-05-24   28.11   28.49   28.04    ...     44772.36  52807.80      0.82
# 2018-05-23   28.18   28.53   28.03    ...     45845.72  53660.69      1.21
# 2018-05-22   26.88   28.50   28.20    ...     45417.26  54292.05      2.11
# 2018-05-21   26.40   27.08   26.76    ...     43111.53  53120.01      1.39

讀取csv，以時間爲index

pandas函數和屬性

pandas經常使用函數

函數	說明
pd.isnull(series) pd.notnull(series)	判斷是否爲空(NaN) 判斷是否不爲空(not NaN)

Series經常使用屬性

屬性	說明
values	獲取數組
index	獲取索引
name	values的name
index.name	索引的name

Series經常使用函數

函數	說明
Series([x,y,...])Series({'a':x,'b':y,...}, index=param1)	生成一個Series
Series.copy()	複製一個Series
Series.reindex([x,y,...], fill_value=NaN) Series.reindex([x,y,...], method=NaN) Series.reindex(columns=[x,y,...])	重返回一個適應新索引的新對象，將缺失值填充爲fill_value 返回適應新索引的新對象，填充方式爲method 對列進行從新索引 reindex的method選項： ffill, bfill　　　　　向前填充/向後填充　　pad, backfill　　　向前搬運，向後搬運
Series.drop(index)	丟棄指定項
Series.map(f)	應用元素級函數

排序函數	說明
Series.sort_index(ascending=True)	根據索引返回已排序的新對象
Series.order(ascending=True)	根據值返回已排序的對象，NaN值在末尾
Series.rank(method='average', ascending=True, axis=0)	爲各組分配一個平均排名 rank的method選項 'average'　　　　在相等分組中，爲各個值分配平均排名 'max','min'　　　使用整個分組中的最小排名 'first'　　　　　　按值在原始數據中出現的順序排名
df.argmax() df.argmin()	返回含有最大值的索引位置返回含有最小值的索引位置

DataFrame經常使用屬性

屬性	說明
values	DataFrame的值
index	行索引
index.name	行索引的名字
columns	列索引
columns.name	列索引的名字
ix	返回行的DataFrame
ix[[x,y,...], [x,y,...]]	對行從新索引，而後對列從新索引
T	frame行列轉置

Dataframe經常使用函數

函數	說明
DataFrame(dict, columns=dict.index, index=[dict.columnnum]) DataFrame(二維ndarray) DataFrame(由數組、列表或元組組成的字典) DataFrame(NumPy的結構化/記錄數組) DataFrame(由Series組成的字典) DataFrame(由字典組成的字典) DataFrame(字典或Series的列表) DataFrame(由列表或元組組成的列表) DataFrame(DataFrame) DataFrame(NumPy的MaskedArray)	構建DataFrame 數據矩陣，還能夠傳入行標和列標每一個序列會變成DataFrame的一列。全部序列的長度必須相同相似於「由數組組成的字典」每一個Series會成爲一列。若是沒有顯式制定索引，則各Series的索引會被合併成結果的行索引各內層字典會成爲一列。鍵會被合併成結果的行索引。各項將會成爲DataFrame的一行。索引的並集會成爲DataFrame的列標。相似於二維ndarray 沿用DataFrame 相似於二維ndarray，但掩碼結果會變成NA/缺失值
df.reindex([x,y,...], fill_value=NaN, limit) df.reindex([x,y,...], method=NaN) df.reindex([x,y,...], columns=[x,y,...],copy=True)	返回一個適應新索引的新對象，將缺失值填充爲fill_value，最大填充量爲limit 返回適應新索引的新對象，填充方式爲method 同時對行和列進行從新索引，默認複製新對象。
df.drop(index, axis=0)	丟棄指定軸上的指定項。

排序函數	說明
df.sort_index(axis=0, ascending=True) df.sort_index(by=[a,b,...])	根據索引排序

彙總統計函數	說明
df.count()	非NaN的數量
df.describe()	一次性產生多個彙總統計
df.min() df.min()	最小值最大值
df.idxmax(axis=0, skipna=True) df.idxmin(axis=0, skipna=True)	返回含有最大值的index的Series 返回含有最小值的index的Series
df.quantile(axis=0)	計算樣本的分位數
df.sum(axis=0, skipna=True, level=NaN) df.mean(axis=0, skipna=True, level=NaN) df.median(axis=0, skipna=True, level=NaN) df.mad(axis=0, skipna=True, level=NaN) df.var(axis=0, skipna=True, level=NaN) df.std(axis=0, skipna=True, level=NaN) df.skew(axis=0, skipna=True, level=NaN) df.kurt(axis=0, skipna=True, level=NaN) df.cumsum(axis=0, skipna=True, level=NaN) df.cummin(axis=0, skipna=True, level=NaN) df.cummax(axis=0, skipna=True, level=NaN) df.cumprod(axis=0, skipna=True, level=NaN) df.diff(axis=0) df.pct_change(axis=0)	返回一個含有求和小計的Series 返回一個含有平均值的Series 返回一個含有算術中位數的Series 返回一個根據平均值計算平均絕對離差的Series 返回一個方差的Series 返回一個標準差的Series 返回樣本值的偏度（三階距）返回樣本值的峯度（四階距）返回樣本的累計和返回樣本的累計最大值返回樣本的累計最小值返回樣本的累計積返回樣本的一階差分返回樣本的百分比數變化


計算函數	說明
df.add(df2, fill_value=NaN, axist=1) df.sub(df2, fill_value=NaN, axist=1) df.div(df2, fill_value=NaN, axist=1) df.mul(df2, fill_value=NaN, axist=1)	元素級相加，對齊時找不到元素默認用fill_value 元素級相減，對齊時找不到元素默認用fill_value 元素級相除，對齊時找不到元素默認用fill_value 元素級相乘，對齊時找不到元素默認用fill_value
df.apply(f, axis=0)	將f函數應用到由各行各列所造成的一維數組上
df.applymap(f)	將f函數應用到各個元素上
df.cumsum(axis=0, skipna=True)	累加，返回累加後的dataframe

Dataframe經常使用索引方式

索引方式	說明
df[val]	選取DataFrame的單個列或一組列
df.ix[val]	選取Dataframe的單個行或一組行
df.ix[:,val]	選取單個列或列子集
df.ix[val1,val2]	將一個或多個軸匹配到新索引
reindex方法	將一個或多個軸匹配到新索引
xs方法	根據標籤選取單行或者單列，返回一個Series
icol、irow方法	根據整數位置選取單列或單行，並返回一個Series
get_value、set_value	根據行標籤和列標籤選取單個值

主要的Index屬性

主要的Index對象	說明
Index	最普遍的Index對象，將軸標籤表示爲一個由Python對象組成的NumPy數組
Int64Index	針對整數的特殊Index
MultiIndex	「層次化」索引對象，表示單個軸上的多層索引。能夠看作由元組組成的數組
DatetimeIndex	存儲納秒級時間戳（用NumPy的Datetime64類型表示）
PeriodIndex	針對Period數據（時間間隔）的特殊Index

經常使用Index函數

函數	說明
Index([x,y,...])	建立索引
append(Index)	鏈接另外一個Index對象，產生一個新的Index
diff(Index)	計算差集，產生一個新的Index
intersection(Index)	計算交集
union(Index)	計算並集
isin(Index)	檢查是否存在與參數索引中，返回bool型數組
delete(i)	刪除索引i處元素，獲得新的Index
drop(str)	刪除傳入的值，獲得新Index
insert(i,str)	將元素插入到索引i處，獲得新Index
is_monotonic()	當各元素大於前一個元素時，返回true
is_unique()	當Index沒有重複值時，返回true
unique()	計算Index中惟一值的數組