编程语言
首页 > 编程语言> > python Pandas庫的學習

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

層級順序的調整

(太複雜且不常用,略了吧。。。。

标签:index,python,frame,NaN,DataFrame,print,pd,學習,Pandas
来源: https://blog.csdn.net/qq_45981397/article/details/121820669