python Pandas庫的學習

Pandas

Series對象

​ Series 對象用於表示一維的數據結構，其主數組的每個元素都會有一個與之相關聯的標簽。（大致如下圖所示）

對象的聲明

​ 通過 pd.Series() 進行聲明，在未指定標簽的情況下，默認使用從0開始一次遞增的數值作爲標簽。

s = pd.Series([12, -4, 7, 9])
print(s)
------------------------------------
0    12
1    -4
2     7
3     9
dtype: int64

s = pd.Series([12, -4, 7, 9], index=["A", "B", "C", "D"])
print(s)
-------------------------------
A    12
B    -4
C     7
D     9
dtype: int64

​ 當然，也可以通過其他的形式來聲明對象（操作如下：

​ 注意，在這種情況下，如果原有對象的值改變，則 Series 對象中的元素也會發生改變。

arr = np.array([1, 2, 3, 4])
s = pd.Series(arr)
print(s)
--------------------------------
0    1
1    2
2    3
3    4
dtype: int32

​ Series 亦可使用字典來進行初始化（其格式其實與字典相差無几）。

my_dict = {"red":100, "blue":200,"green":300}
s = pd.Series(my_dict)
print(s)
-----------------------------------
red      100
blue     200
green    300
dtype: int64

屬性的獲取

​ 毫無疑問，可以獲取 Seris 的兩個屬性，Index 和 Values。

s = pd.Series([12, -4, 7, 9], index = ["A", "B", "C", "D"])
print(s)
print("values:",s.values)
print("index:",s.index)
----------------------------------
A    12
B    -4
C     7
D     9
dtype: int64
values: [12 -4  7  9]
index: Index(['A', 'B', 'C', 'D'], dtype='object')

對象操作

元素賦值

​ 通過下標或索引對元素進行賦值。

s = pd.Series([12, -4, 7, 9], index=["A", "B", "C", "D"])
print(s)
s[0] = 0
print("0:",s[0])
s["B"] = 0
print("B",s["B"])
-----------------------------------
A    12
B    -4
C     7
D     9
dtype: int64
0: 0
B 0

元素篩選

​ s[s > x]，用於篩選 Series數組中元素值大於 x 的元素。

s = pd.Series([10, 5, -5, 12], index=["A", "B", "C", "D"])
print(s)
print()
print(s[s > 8])
--------------------------
A    10
B     5
C    -5
D    12
dtype: int64

A    10
D    12
dtype: int64

元素運算

​ 由於可將 Series 看作 np.narray的升級版，故在對象運算和數學函數時，兩者的表現均一樣。(加減乘除、取對數等等，不再進行過多演示

import pandas as pd
s = pd.Series([12, 5, 4, 9])
print(s)
s = s - 2
print(s)
-------------------------
0    12
1     5
2     4
3     9
dtype: int64
0    10
1     3
2     2
3     7
dtype: int64

元素去重

​ 若要對 Series 對象進行去重，則需調用函數 unique()，注意，去重后順序可能發生變化。

import pandas as pd
s = pd.Series([12, 5, 9, 4, 4, 5, 5])
print("去重前：",s.values)
s = s.unique()
print("去重后",s)
--------------------------------------
去重前： [12  5  9  4  4  5  5]
去重后 [12  5  9  4]

元素出現頻度

​ 使用函數 $Series.value_counts() 即可計算其中元素的頻度。

s = pd.Series([12, 5, 5, 5, 1, 1, 2])
print(s.value_counts())
---------------------------------
5     3
1     2
12    1
2     1
dtype: int64

所屬關係判斷

​ 使用函數 Series.isin()即可進行判斷，另外，其也可以作爲一個篩選條件哦。

s = pd.Series([1, 5, 8, 10, 15])
print(s.isin([5,10]))
print()
print(s[s.isin([5, 10])])
--------------------------------------
0    False
1     True
2    False
3     True
4    False
dtype: bool

1     5
3    10
dtype: int64

NaN

​ NaN，即 Not a Number,儅進行數據處理時而其中某項屬性丟失時（或未收集到時）可以使用。另外，可配合 isnull() 和 notnull()進行食用。（不是

​ 另外請注意，雖然在 Pandas裏介紹NaN，但其聲明是：np.NaN。

​ isnull() 是函數， isnull 可將其看作一種屬性，可以用於在元素篩選。

s = pd.Series([12, 5, np.NaN, 10])
print(s[pd.isnull])
print()
print(s.isnull())
print()
print(s.notnull())
-----------------------------------
2   NaN
dtype: float64

0    False
1    False
2     True
3    False
dtype: bool

0     True
1     True
2    False
3     True
dtype: bool

對象閒的運算

​ 考慮到 Series 對象之間的運算，其實類似于 narray 裏的廣播機制，但不同的是，此處僅會有共同標簽(index)的屬性才會有結果，否則為 NaN(非數)。

s1 = pd.Series([10, 5, 2],index=["R", "G", "B"])
s2 = pd.Series([5, 2, 1],index=["G", "B", "F"])
print(s1 + s2)
----------------------------------
B     4.0
F     NaN
G    10.0
R     NaN
dtype: float64

DataFrame對象

​ DateFrame 實際上就是多維的 Series(也可以考慮為多個 Series 的組合)。其有兩個索引，行索引，和列索引（可把 DataFrame 中的列索引想作單個 Series 中的行索引）。

​ 也可將 DataFrame 看作由 Series 組成的字典。

對象的聲明

​ 可以通過一個字典 + 列表進行初始化。

my_dict = {"color":["R", "G", "B"],
           "object":["you", "me", "him"],
           "value":[1, 3, 5]}

frame = pd.DataFrame(my_dict,index=["A", "B", "C"])
print(frame)
-------------------------------------
  color object  value
A     R    you      1
B     G     me      3
C     B    him      5

​ DataFrame 中存在屬性 clolumns,即可以達到對列表進行提純的作用，也可以在對 DataFrame 進行初始化時使用。

my_dict = {"color":["R", "G", "B"],
           "object":["you", "me", "him"],
           "value":[1, 3, 5]}
frame = pd.DataFrame(my_dict, columns=["color","value"])
print(frame)
-------------------------------------
  color  value
0     R      1
1     G      3
2     B      5

frame = pd.DataFrame(np.arange(25).reshape(5, 5), columns=["A", "B", "C", "D", "E"],
                     index=["1", "2", "3", "4", "5"])
print(frame)
------------------------------------
    A   B   C   D   E
1   0   1   2   3   4
2   5   6   7   8   9
3  10  11  12  13  14
4  15  16  17  18  19
5  20  21  22  23  24

對象操作

元素選取

​ 考慮到 DataFrames 存在著許多屬性，因此有許多方法可以對元素進行選取。

​ DataFrame.columns: 獲取所有列的名稱（其實就是最上面那一排）

dict_data = {"color":["R", "G", "B"],
             "object":["pen","pan","pencil"],
             "value":[100, 200, 300]}
frame = pd.DataFrame(dict_data)
print(frame.columns)
--------------------------------
Index(['color', 'object', 'value'], dtype='object')

​

DataFrame.values：獲取其中的每個元素，以列表存儲。（[列名1_1,列名1_2，…],[],…)

dict_data = {"color":["R", "G", "B"],
             "object":["pen","pan","pencil"],
             "value":[100, 200, 300]}
frame = pd.DataFrame(dict_data)
print(frame.values)
------------------------------------------
[['R' 'pen' 100]
 ['G' 'pan' 200]
 ['B' 'pencil' 300]]

DataFrame.index:獲取行索引（其實就是最左邊竪著的那一排啦~）

dict_data = {"color":["R", "G", "B"],
             "object":["pen","pan","pencil"],
             "value":[100, 200, 300]}
frame = pd.DataFrame(dict_data)
print(frame.index)
-------------------------------------
RangeIndex(start=0, stop=3, step=1)

​ 直接通過索引進行獲取（既然是[]，肯定能通過這種方式獲取拉~）

dict_data = {"color":["R", "G", "B"],
             "object":["pen","pan","pencil"],
             "value":[100, 200, 300]}
frame = pd.DataFrame(dict_data)
print(frame["value"])
print()
print(frame.loc[1])
print()
print(frame["object"][1])
----------------------------
0    100
1    200
2    300
Name: value, dtype: int64
        
color       G
object    pan
value     200
Name: 1, dtype: object
        
pan

​ 多行選取（即數組的切片操作）

​ 此處需注意，frame[0:2]為正確操作，而frame[0]則為錯誤操作哦！

dict_data = {"color":["R", "G", "B"],
             "object":["pen","pan","pencil"],
             "value":[100, 200, 300]}
frame = pd.DataFrame(dict_data)
print(frame[0:2])
---------------------------------
  color object  value
0     R    pen    100
1     G    pan    200

元素賦值

​ 部分值的賦值如同 Series 對象，但在 DataFrame 這裏還有添加列的操作哦~

​ ps：不能理解爲什麽此處 A 在前面┭┮﹏┭┮

frame = pd.DataFrame(np.arange(25).reshape(5, 5),
                     columns=["A", "B", "C", "D", "E"],
                     index=["a", "b", "c", "d", "e"])
frame["A"]["a"] = 100
print(frame)
-------------------------------
     A   B   C   D   E
a  100   1   2   3   4
b    5   6   7   8   9
c   10  11  12  13  14
d   15  16  17  18  19
e   20  21  22  23  24

​

​ 添加新的列。簡單的使用 frame[] = []，即可，類似於字典的添加操作。

​ 不過請注意保持元素的個數一致哦~

frame = pd.DataFrame(np.arange(25).reshape(5, 5),
                     columns=["A", "B", "C", "D", "E"],
                     index=["a", "b", "c", "d", "e"])
frame["hahaha!"] = [1, 2, 3, 4, 5]
print(frame)
---------------------------
    A   B   C   D   E  hahaha!
a   0   1   2   3   4        1
b   5   6   7   8   9        2
c  10  11  12  13  14        3
d  15  16  17  18  19        4
e  20  21  22  23  24        5

所屬關係

​ 大致與 Series 中的相同，不在過多闡釋。

​ （ps：可以看上下的結果對比一下哦

frame = pd.DataFrame(np.arange(25).reshape(5, 5),
                     columns=["A", "B", "C", "D", "E"],
                     index=["a", "b", "c", "d", "e"])
print(frame.isin([4, 1]))
------------------------------------
	   A      B      C      D      E  hahaha!
a  False   True  False  False   True     True
b  False  False  False  False  False    False
c  False  False  False  False  False    False
d  False  False  False  False  False     True
e  False  False  False  False  False    False

元素篩選

​ 同上。（看看代碼即可

frame = pd.DataFrame(np.arange(25).reshape(5, 5),
                     columns=["A", "B", "C", "D", "E"],
                     index=["a", "b", "c", "d", "e"])
print(frame[frame >= 20])
#此處可能數組名亦可代表每個元素的變量名（不是很懂
-------------------------------------
      A     B     C     D     E  hahaha!
a   NaN   NaN   NaN   NaN   NaN      NaN
b   NaN   NaN   NaN   NaN   NaN      NaN
c   NaN   NaN   NaN   NaN   NaN      NaN
d   NaN   NaN   NaN   NaN   NaN      NaN
e  20.0  21.0  22.0  23.0  24.0      NaN

刪除列

调用 del DataFrame[列名] 即可。（应用广泛，但也说明一下）

frame = pd.DataFrame(np.arange(25).reshape(5, 5),
                     columns=["A", "B", "C", "D", "E"],
                     index=["a", "b", "c", "d", "e"])
del frame["A"]
print(frame)
-----------------------------
    B   C   D   E
a   1   2   3   4
b   6   7   8   9
c  11  12  13  14
d  16  17  18  19
e  21  22  23  24

转置

​ 调用 DataFrame 中的属性 T即可进行轉置。

frame = pd.DataFrame(np.arange(25).reshape(5, 5),
                     columns=["A", "B", "C", "D", "E"],
                     index=["a", "b", "c", "d", "e"])
print(frame.T)
---------------------------
   a  b   c   d   e
B  1  6  11  16  21
C  2  7  12  17  22
D  3  8  13  18  23
E  4  9  14  19  24

Index對象

​ Index對象即是上文所使用的數組的軸（橫、竪）。

​

方法使用

​ 獲取索引的最小值， XXX.idxmin()。

s = pd.Series([5, 10, 15, 20],index=["a1", "b2", "c3", "d4"])
print(s.index)
print(s.idxmin())
---------------------------
Index(['a1', 'b2', 'c3', 'd4'], dtype='object')
a1

​ 獲取索引的最大值， XXX.idxmax()。

​ ps:比較方法即對各個字符串進行比較，字符串之間的比較方法不再進行過多的闡釋。

s = pd.Series([5, 10, 15, 20],index=["a1", "b2", "c3", "d4"])
print(s.index)
print(s.idxmax())
----------------------------------------
Index(['a1', 'b2', 'c3', 'd4'], dtype='object')
d4

索引更換

​ 當你對數組中當前的索引不滿意時，可以用 reindex() 函數來更換對象的索引。

​ 另外，若增加了新的索引，會添加NaN作爲新索引的數值。

​ （再另外，爲什麽不開始就初始化令您滿意的索引呢（不是

s = pd.Series([5, 10, 15, 20],index=["a1", "b2", "c3", "d4"])
print(s)
s = s.reindex(["a1", "B", "c3", "D","d4"])
print(s)
-----------------------------
a1     5
b2    10
c3    15
d4    20
dtype: int64

a1     5.0
B      NaN
c3    15.0
D      NaN
d4    20.0
dtype: float64

​ reindex() 具有參數 method,即是參數的填補方法。

​ 若 method = “ffill”，即 front fill，用前一個下標來對當前的 NaN 的值進行填充。

​ method = “bfill”，即back fill，于上描述相反。

frame = pd.DataFrame(np.arange(9).reshape(3, 3),columns=["A", "B", "C"],
                     index=["a", "b", "c"])
print(frame)
frame = frame.reindex(["a", "d", "daa!", "b"],method="ffill")
print(frame)
------------------------------------------
   A  B  C
a  0  1  2
b  3  4  5
c  6  7  8

       A  B  C
a      0  1  2
d      6  7  8
daa!  6  7  8
b      3  4  5

​ 或，可直接使用 fill_value = 0,即將默認的NaN 填充為 0。

​ (這個就不再進行演示了≡(▔﹏▔)≡

刪除索引

​ 同 del Array[] 相同，不過這裏是換了另外一個函數 .drop() 進行處理。

​ ps：Series(DataFrame亦是)似乎為不可變對象，因此要使用s = s.drop(“A”)，而非單單的 s.drop(“A”)。請謹記。

s = pd.Series(np.arange(4), index=["A", "B", "C", "d"])
print(s)
print()
s = s.drop("A")
print(s)
--------------------------
A    0
B    1
C    2
d    3
dtype: int32

B    1
C    2
d    3
dtype: int32

​

數據對齊

​ 與 Series 之間進行相加一樣，礙於篇幅過長，不再進行闡釋。

數據結構之間的運算

​ 數據結構之間可直接通過算數運算符進行運算，當然也可以通過下列的方法達到相同的目的。

​ add（）

​ sub（）

​ div （）

​ sub（）

字如其人，不再解釋。

運算

​ 通過加法來對運算的原理進行演示。

​ 注意，這裏的 Series 對齊的是 DataFrame 裏的列名稱（columns) 而非 index。

frame = pd.DataFrame(np.arange(9).reshape(3, 3),
                     index = ["A", "B", "C"],
                     columns=["a", "b", "c"])

ser = pd.Series(np.arange(3), index=["a", "b", "c"])

print(frame + ser)
-------------------------------
   a  b   c
A  0  2   4
B  3  5   7
C  6  8  10

​ 其餘運算也與上述的演示同理。

函數應用和映射

通用函數

平方根

​ np.sqrt() 可以求序列中每個元素的平方根。

frame = pd.DataFrame(np.arange(9).reshape(3, 3),
                     columns=["A", "B", "C"],
                     index=["a", "B", "c"])
print(np.sqrt(frame))
--------------------------------------------
    A         B         C
a  0.000000  1.000000  1.414214
B  1.732051  2.000000  2.236068
c  2.449490  2.645751  2.828427

求和與平均值

​ np.sum() 用於求序列的元素之和， np.mean() 用於求序列的平均值。其中，更牛逼的要數 .describe()。

frame = pd.DataFrame(np.arange(9).reshape(3, 3),
                     columns=["A", "B", "C"],
                     index=["a", "B", "c"])
print(np.sum(frame))
print()
print(np.mean(frame))
print()
print(frame.describe())
------------------------------
A     9
B    12
C    15
dtype: int64

A    3.0
B    4.0
C    5.0
dtype: float64
    
         A    B    C
count  3.0  3.0  3.0
mean   3.0  4.0  5.0
std    3.0  3.0  3.0
min    0.0  1.0  2.0
25%    1.5  2.5  3.5
50%    3.0  4.0  5.0
75%    4.5  5.5  6.5
max    6.0  7.0  8.0    

相關性

​ 通過DataFrame.corr() 即可實現。

frame = pd.DataFrame(np.arange(25).reshape(5, 5),
                     columns = ["B", "C", "A", "D", "E"],
                     index=["a", "c", "b", "d", "e"])
print(frame.corr())
----------------------------
     B    C    A    D    E
B  1.0  1.0  1.0  1.0  1.0
C  1.0  1.0  1.0  1.0  1.0
A  1.0  1.0  1.0  1.0  1.0
D  1.0  1.0  1.0  1.0  1.0
E  1.0  1.0  1.0  1.0  1.0

協方差

​ 簡單的通過 .cov() 即可實現。（請不要再自己手寫函數了！

frame = pd.DataFrame(np.arange(25).reshape(5, 5),
                     columns = ["B", "C", "A", "D", "E"],
                     index=["a", "c", "b", "d", "e"])
print(frame.cov())
-------------------------------
      B     C     A     D     E
B  62.5  62.5  62.5  62.5  62.5
C  62.5  62.5  62.5  62.5  62.5
A  62.5  62.5  62.5  62.5  62.5
D  62.5  62.5  62.5  62.5  62.5
E  62.5  62.5  62.5  62.5  62.5

排序和排次

​ 通過函數 DataFrame.sort_index() 進行排序，其有兩個參數， ascending,用於指定按照降序（False)，還是按照升序(True 且為默認值）排列； $axis，axis = 0時按照列進行排列（且爲默認值）， axis = 1時按照行進行排列。

​ 注意，這裏説的排列均是針對 Index 而非其中的 Value。

frame = pd.DataFrame(np.arange(25).reshape(5, 5),
                     columns = ["B", "C", "A", "D", "E"],
                     index=["a", "c", "b", "d", "e"])
print(frame)
print()
print(frame.sort_index(ascending=False))
print()
print(frame.sort_index(axis=1))
----------------------------------------------
    B   C   A   D   E
a   0   1   2   3   4
c   5   6   7   8   9
b  10  11  12  13  14
d  15  16  17  18  19
e  20  21  22  23  24

    B   C   A   D   E
e  20  21  22  23  24
d  15  16  17  18  19
c   5   6   7   8   9
b  10  11  12  13  14
a   0   1   2   3   4

    A   B   C   D   E
a   2   0   1   3   4
c   7   5   6   8   9
b  12  10  11  13  14
d  17  15  16  18  19
e  22  20  21  23  24

當然，也可以基於你給定的列進行排序，如：sort_values(by = [“A”, “B”])，結果就不再進行演示了。

排位次操作

​ 通過 DataFrame.rank() 以達到安排位次的目的（不過實際意義鄙人尚且不能理解。

frame = pd.DataFrame(np.arange(25).reshape(5, 5),
                     columns = ["B", "C", "A", "D", "E"],
                     index=["a", "c", "b", "d", "e"])
print(frame.rank())
--------------------------------------
     B    C    A    D    E
a  1.0  1.0  1.0  1.0  1.0
c  2.0  2.0  2.0  2.0  2.0
b  3.0  3.0  3.0  3.0  3.0
d  4.0  4.0  4.0  4.0  4.0
e  5.0  5.0  5.0  5.0  5.0

NaN數據

NaN過濾

​ .dropna() 和 notnull() 篩選 即可以實現過濾掉 NaN 元素的目的。

​ 在使用 dropna() 時需注意，可能會存在整行或整列均爲 NaN 的情況，則需要對 how 參數變量進行設置。 若 how = “any”，則只要有缺省值出現，就會刪除行或列，若 how = “all”，則只有所有值為 NaN時，才刪除。

frame = pd.DataFrame([[1, 2, 3], [np.nan, np.nan, np.nan], [4, 5, 6]]
                     ,columns=["A", "B", "C"],
                     index=["a", "b", "c"])
print(frame)

print()

print(frame.dropna(how="all"))
--------------------------------------
     A    B    C
a  1.0  2.0  3.0
b  NaN  NaN  NaN
c  4.0  5.0  6.0


     A    B    C
a  1.0  2.0  3.0
c  4.0  5.0  6.0

填充NaN

​ 使用 .fillna(x)即可將序列裏的 NaN 變換為 x 值哦~

frame = pd.DataFrame([[1, 2, 3], [np.nan, np.nan, np.nan], [4, 5, 6]]
                     ,columns=["A", "B", "C"],
                     index=["a", "b", "c"])
print(frame)
print()
print(frame.fillna(0))
------------------------------------
     A    B    C
a  1.0  2.0  3.0
b  NaN  NaN  NaN
c  4.0  5.0  6.0

     A    B    C
a  1.0  2.0  3.0
b  0.0  0.0  0.0
c  4.0  5.0  6.0

層級順序的調整

​ （太複雜且不常用，略了吧。。。。