關於pandas的這些乾貨，你也必須知道！

最近熱門博客都是一些職場面試啥的，我呢，還是個學生，不摻和這場職業博文，還是寫點乾貨，分享給所有像我這樣喜歡學習的人，一起進步，也是爲了以後的職業規劃，我自學python也快三個月了吧，最後還是選擇了數據分析和機器算法這條路，前段時間也寫完了numpy的解析，不看你一定後悔，基於 Numpy 的滿滿乾貨，你還在等什麼呢？，就是這篇，不知道python的路怎麼走，跟着跟着我的筆記學習，也一定有幫助的，後面我還會擴展其他筆記，關注我，別迷路！

Pandas 是 Python 中的數據操縱和分析軟件包，也是一個強大的數據分析庫，其中包含很多函數和功能！我個人感覺前提一定要學numpy，這樣知識點就能記得更全面點！

導入擴展庫

import pandas as pd

創建一個Pandas序列

pds = pd.Series(index = ['chinese', 'math', 'English', 'computer'], data = [100, 99, 98, 97])
print(pds)
print('形狀=',pds.shape)
print('維度=',pds.ndim)
print('大小=',pds.size)
print(f'pds序列包括的標籤=\t{pds.index}\npds序列包括的值= \t{pds.values}')

chinese     100
math         99
English      98
computer     97
dtype: int64
形狀= (4,)
維度= 1
大小= 4
pds序列包括的標籤=	Index(['chinese', 'math', 'English', 'computer'], dtype='object')
pds序列包括的值= 	[100  99  98  97]

判斷標籤或者值是否存在

當我們的數據很大，可能會忘記我們設置過的標籤或者值，那我們使用in關鍵詞，而這個我們都學過的，用in關鍵詞判斷可以返回布爾值

x = 'math' in pds
print(f'問:math是不是在標籤裏面呢？\t\t答:{x}')
y =  '95' in pds
print(f'問:95分是不是在值裏面呢? \t\t答:{y}')

問:math是不是在標籤裏面呢？		答:True
問:95分是不是在值裏面呢? 		答:False

序列的訪問

pandas的序列訪問多種多樣，這裏我們先通過標籤索引或者下標索引

PS： 如果你使用的是和我一樣f格式輸出，記住，這裏使用的索引方法pds[‘math’]，但二個引號’’ 和""一定要注意，一定不能和print的引號一樣，否則一定是語法錯誤！當然pandas也注意到了這一點，後面有更好的方法來索引

%pdb
pds = pd.Series(index = ['chinese', 'math', 'English', 'computer'], data = [100, 99, 98, 97])
print(pds)
print()
print(f"當我們使用標籤索引math時:\tmath -->{pds['math']}")
print(f"當我們使用標籤索引多個時:\tmath,chinese -->\n{pds[['math', 'chinese']]}")
print()
print(f'當我們使用下標索引第一個時:\t-->{pds[0]}')
print(f'當我們使用下標索引多個時:\t\n{pds[[0,1]]}')

Automatic pdb calling has been turned ON
chinese     100
math         99
English      98
computer     97
dtype: int64

當我們使用標籤索引math時:	math -->99
當我們使用標籤索引多個時:	math,chinese -->
math        99
chinese    100
dtype: int64

當我們使用下標索引第一個時:	-->100
當我們使用下標索引多個時:	
chinese    100
math        99
dtype: int64

• 對於上面的索引方式，你們感覺咋樣，腦袋現在是不是有點暈暈的，既可以標籤索引也可以下標索引，那下面我們換個索引方式，這樣就能表達的就很清晰，在pandas序列存在二個屬性，.loc 和 .iloc loc表示的是標籤索引，iloc表示的下標索引，我們來看二個例子。

print(f"使用loc屬性用於標籤索引,獲得math對應分數-->{pds.loc['math']}")
print(f"使用iloc屬性用於下標索引，獲得第一個分數-->{pds.iloc[0]}")

使用loc屬性用於標籤索引,獲得math對應分數-->99
使用iloc屬性用於下標索引，獲得第一個分數-->100

對序列賦值修改

pandas和numpy一樣都是可以修改的，方法一樣的，直接賦值修改就可以,那我們試着如何賦值修改吧

print(pds)
print('-'*40)
pds['chinese'] = 80
print(pds)

chinese     100
math         99
English      98
computer     97
dtype: int64
----------------------------------------
chinese     80
math        99
English     98
computer    97
dtype: int64

對序列進行刪除

我們還可以使用 .drop() 方法刪除 Pandas序列中的標籤和值。但是注意，Series.drop(label) 方法不在原序列從 Series 中刪除元素，即不會更改被修改的原始 Series，那如果我們要更改原序列的值呢，在括號裏面加入參數 inplace = True 就行

print(pds)
print('-' * 40)
print(f"當我們刪除數學:\n{pds.drop('math')}")
print('-' * 40)
print(f"原序列:\n{pds}")
print('-' * 40)
print(f"當我們加入參數:\n{pds.drop('math', inplace = True)},\t這樣就沒有返回序列，即對原序列進行操作")
print('-' * 40)
print(f'原序列:\n{pds}')

chinese     80
math        99
English     98
computer    97
dtype: int64
----------------------------------------
當我們刪除數學:
chinese     80
English     98
computer    97
dtype: int64
----------------------------------------
原序列:
chinese     80
math        99
English     98
computer    97
dtype: int64
----------------------------------------
當我們加入參數:
None,	這樣就沒有返回序列，即對原序列進行操作
----------------------------------------
原序列:
chinese     80
English     98
computer    97
dtype: int64

對序列進行算數運算

和numpy一樣，pandas序列也可以進行算數運算，但是如果要進行乘除操作，一定得注意類型一致，比如值中既有數字又有字符串，那麼操作會出錯

import numpy as np
import pandas as pd

fruits = pd.Series(index=['apple', 'banana','orange'], data = [8, 5, 3])
print(f'建立一個水果序列\n{fruits}\n')
print(f'水果漲價 + 2\n{fruits + 2}\n')
print(f'水果賤賣 - 4\n{fruits - 2}\n')
print(f'apple漲價 + 2  =  {fruits.loc["apple"] + 2}\n')
print(f'banana,orange半價\n {fruits.loc[["banana", "orange"]] / 2}')

建立一個水果序列
apple     8
banana    5
orange    3
dtype: int64

水果漲價 + 2
apple     10
banana     7
orange     5
dtype: int64

水果賤賣 - 4
apple     6
banana    3
orange    1
dtype: int64

apple漲價 + 2  =  10

banana,orange半價
 banana    2.5
orange    1.5
dtype: float64

對序列進行數學函數計算

同樣，基於numpy之上，pandas當然有理由使用numpy的內置函數，比如數學函數

import numpy as np
import pandas as pd

fruits = pd.Series(index=['apple', 'banana','orange'], data = [8, 5, 3])
print(f'水果價格平方\n{np.power(fruits, 2)}\n')
print(f'水果價格開方\n{np.sqrt(fruits)}\n')

水果價格平方
apple     64
banana    25
orange     9
dtype: int64

水果價格開方
apple     2.828427
banana    2.236068
orange    1.732051
dtype: float64

創建一個pandas DataFrames

Pandas DataFrames 是具有帶標籤的行和列的二維數據結構，可以存儲很多類型的數據。感覺類似excel表格，我們首先用pandas序列創建一個字典fruits，然後用 DataFrame() 函數把這個字典加載進去，就可以得到，下面我用水果的例子試試

import pandas as pd
fruits = {'Bob':pd.Series(data = [3, 4, 5, 8], index = ['orange', 'bananas', 'apple','pomegranate']),
          'Alice':pd.Series(data = [3.5, 4, 6, 2], index = ['bananas', 'apple', 'orange','watermelon'])}

print('字典類型:\t',type(fruits))
print()

fruit_items = pd.DataFrame(fruits)
print('fruit DataFrames \n',fruit_items)

字典類型:	 <class 'dict'>

fruit DataFrames 
              Bob  Alice
apple        5.0    4.0
bananas      4.0    3.5
orange       3.0    6.0
pomegranate  8.0    NaN
watermelon   NaN    2.0

這個水果數據框是不是很像excel表格呢，行表頭是根據字典的鍵來確定的，列表頭是根據字母排序來確定的，我們也可以看到NaN值，它的意思是非數字，從上面看到bob沒賣西瓜，alice沒有賣石榴，沒有值，所以用NaN代替，這個先放這裏，後面我們在講怎麼去掉這個值，下面講一講如果序列裏面沒有標籤

import pandas as np
scores = {'小明':pd.Series(data = [100, 100, 100]), '小紅':pd.Series(data = [99, 100, 98])}
s1_item = pd.DataFrame(scores)
print(f"當我們在序列裏面不加入標籤的時候\n{s1_item}")

print('-' * 40)
print('系統會默認用數字作爲標籤，當然這個數字是從0開始')

當我們在序列裏面不加入標籤的時候
    小明   小紅
0  100   99
1  100  100
2  100   98
----------------------------------------
系統會默認用數字作爲標籤，當然這個數字是從0開始

DataFrames 屬性

同numpy一樣，pandas也可以使用如下屬性進行訪問

• shape 形狀
• ndim 維度
• size 大小
• index 行標籤
• values 值
• columns 列標籤

import pandas as pd

fruits = {'Bob':pd.Series(data = [3, 4, 5, 8], index = ['orange', 'bananas', 'apple','pomegranate']),
          'Alice':pd.Series(data = [3.5, 4, 6, 2], index = ['bananas', 'apple', 'orange','watermelon'])}

fruit_item = pd.DataFrame(fruits) #還是用上面的水果來創建一個數據框


print(fruit_item)
print()

print(f'shape形狀 = {fruit_item.shape}')
print(f'ndim維度 = {fruit_item.ndim}')
print(f'size大小 = {fruit_item.size}')
print(f'index行標籤 = {fruit_item.index}\n')
print(f'values值 = {fruit_item.values}\n')
print(f'columns列標籤 = {fruit_item.columns}')

             Bob  Alice
apple        5.0    4.0
bananas      4.0    3.5
orange       3.0    6.0
pomegranate  8.0    NaN
watermelon   NaN    2.0

shape形狀 = (5, 2)
ndim維度 = 2
size大小 = 10
index行標籤 = Index(['apple', 'bananas', 'orange', 'pomegranate', 'watermelon'], dtype='object')

values值 = [[5.  4. ]
 [4.  3.5]
 [3.  6. ]
 [8.  nan]
 [nan 2. ]]

columns列標籤 = Index(['Bob', 'Alice'], dtype='object')

有了上面的屬性方法，那我們的操作一下子就變得簡單多了,也變得多種多樣，可以使用index和columns關鍵詞進行篩選，下面我給點例子

fruits = {'Bob':pd.Series(data = [3, 4, 5, 8], index = ['orange', 'bananas', 'apple','pomegranate']),
          'Alice':pd.Series(data = [3.5, 4, 6, 2], index = ['bananas', 'apple', 'orange','watermelon'])}


fruit_item1 = pd.DataFrame(fruits, index = ['apple', 'bananas'])
print(f'我們只需要蘋果和香蕉\n\n{fruit_item1}\n')
print('- ' * 40)
fruit_item2 = pd.DataFrame(fruits, columns=['Bob'])
print(f'我們只看bob的數據\n\n{fruit_item2}\n')
print('- ' * 40)
fruit_item3 = pd.DataFrame(fruits, index = ['apple'] , columns=['Alice'])
print(f'我們只看Alice的蘋果\n\n{fruit_item3}\n')

我們只需要蘋果和香蕉

         Bob  Alice
apple      5    4.0
bananas    4    3.5

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我們只看bob的數據

             Bob
orange         3
bananas        4
apple          5
pomegranate    8

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我們只看Alice的蘋果

       Alice
apple    4.0

DataFrames 的其他創建方式

在上面的實例中，我們的字典裏面都是使用pandas的序列，其實也可以使用其他的方式，比如列表或者字典，看這個例子

ps：列表或者字典，二個對象的長度一定一致

scores = {'bob': [100,99,98], 'tom':[98,92,100]}
score_item = pd.DataFrame(scores, index = ['第一次測試', '第二次測試', '第三次測試'])
print(score_item)

       bob  tom
第一次測試  100   98
第二次測試   99   92
第三次測試   98  100

DataFrames 元素的訪問

print('我們先創建一個數據框,這裏用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35}, 
          {'watches': 10, 'glasses': 50, 'bikes': 15, 'pants':5}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store'])
print(store)
print('- ' * 40)
print(f'這裏規定的是先訪問列標籤，然後訪問行標籤')
print()
print(f'我們查看自行車和手錶的庫存\n{store[["bikes", "watches"]]}')
print('- ' * 40)
print(f'我們查看一號店庫存\n{store.loc[["1-store"]]}')
print()
print('這裏用到了序列標籤查找方式 loc 忘記的趕緊往上翻')
print('- ' * 40)
print(f'我們看一號店的自行車庫存 = {store["bikes"]["1-store"]}')

我們先創建一個數據框,這裏用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store     20     30       35      NaN
2-store     15      5       10     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
這裏規定的是先訪問列標籤，然後訪問行標籤

我們查看自行車和手錶的庫存
         bikes  watches
1-store     20       35
2-store     15       10
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我們查看一號店庫存
         bikes  pants  watches  glasses
1-store     20     30       35      NaN

這裏用到了序列標籤查找方式 loc 忘記的趕緊往上翻
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我們看一號店的自行車庫存 = 20

DataFrames 行列增加

print('我們先創建一個數據框,這裏用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35}, 
          {'watches': 10, 'glasses': 50, 'bikes': 15, 'pants':5}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store'])
print(store)
print('- ' * 40)
store['jake'] = [10, 20]
print(f'我們增加一個商品jake\n{store}')
print('- ' * 40)
store_new = [{'bikes':30, 'pants':23, 'watches':21, 'jake':40}]
store3 = pd.DataFrame(store_new, index = ['3-store'])
store = store.append(store3)
print(f'我們增加一行 3-store\n{store}')

我們先創建一個數據框,這裏用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store     20     30       35      NaN
2-store     15      5       10     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我們增加一個商品jake
         bikes  pants  watches  glasses  jake
1-store     20     30       35      NaN    10
2-store     15      5       10     50.0    20
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我們增加一行 3-store
         bikes  pants  watches  glasses  jake
1-store     20     30       35      NaN    10
2-store     15      5       10     50.0    20
3-store     30     23       21      NaN    40

這裏增加用到了函數.append() 使用方法在代碼內

DataFrames 元素插入

函數dataframe.insert(loc,label,data) 可以讓我們在任意列中插入

print('我們先創建一個數據框,這裏用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35}, 
          {'watches': 10, 'glasses': 50, 'bikes': 15, 'pants':5}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store'])
print(store)
print('- ' * 40)
store.insert(0, 'jake',[10, 20])
print(f'在第0個位置上插入jake\n{store}')

我們先創建一個數據框,這裏用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store     20     30       35      NaN
2-store     15      5       10     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
在第0個位置上插入jake
         jake  bikes  pants  watches  glasses
1-store    10     20     30       35      NaN
2-store    20     15      5       10     50.0

DataFrames 元素刪除

對於序列我們講到過drop()方法，這裏同樣使用，加入參數axis 就可以選擇行和列了，當然還有一個獨特的方法pop，但是pop只能刪除列，看點例子

print('我們先創建一個數據框,這裏用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35}, 
          {'watches': 10, 'glasses': 50, 'bikes': 15, 'pants':5}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store'])
print(store)
print('- ' * 40)
store.pop("bikes")
print(f'使用pop刪除bikes\n{store}')
print('- ' * 40)
store = store.drop('pants', axis = 1)
print(f'使用drop刪除pants\n{store}')
print('- ' * 40)
store = store.drop('1-store', axis = 0)
print(f'使用drop刪除第一行\n{store}')

我們先創建一個數據框,這裏用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store     20     30       35      NaN
2-store     15      5       10     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
使用pop刪除bikes
         pants  watches  glasses
1-store     30       35      NaN
2-store      5       10     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
使用drop刪除pants
         watches  glasses
1-store       35      NaN
2-store       10     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
使用drop刪除第一行
         watches  glasses
2-store       10     50.0

DataFrames 標籤改名

函數DataFrame.rename() 可以給行標籤 或者 列標籤 進行改名操作

print('我們先創建一個數據框,這裏用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35}, 
          {'watches': 10, 'glasses': 50, 'bikes': 15, 'pants':5}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store'])
print(store)
print('- ' * 40)

store1 = store.rename(columns = {'bikes':"jake"})
print(f'我們改列標籤 bike改成jake \n{store1}')
print('- ' * 40)
store2 = store.rename(index = {'1-store':'3-store'})
print(f'我們改行標籤  1 改成 3 \n{store2}')

我們先創建一個數據框,這裏用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store     20     30       35      NaN
2-store     15      5       10     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我們改列標籤 bike改成jake 
         jake  pants  watches  glasses
1-store    20     30       35      NaN
2-store    15      5       10     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我們改行標籤  1 改成 3 
         bikes  pants  watches  glasses
3-store     20     30       35      NaN
2-store     15      5       10     50.0

NaN的處理手法

我們前面也涉及到NaN值，當缺少某個值的時候，dadaframe就會給他賦值NaN，但是在我們後面的計算，我們不希望出現這麼多NaN值，所以我們也有方法

NaN值的總數計算

這裏使用 dataframe.isnull() 和sum()來計算NaN的總數 ,使用方法是
isnull().sum().sum() 這裏就會感覺很奇怪，爲什麼二個sum，那下面我們一個個來看

print('我們先創建一個數據框,這裏用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35},\
             {'watches': 10, 'glasses': 50,  'pants':5},\
             {'pants':21, 'watches':20, 'bikes':10}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store', '3-store'])
print(store)
print('特意準備了一個NaN多的例子看看')
print('- ' * 40)
print(f'先看看isnull有啥用\n{store.isnull()}')
print(f'對比上表，NaN被替換成了布爾值的True，其他則是False')
print('- ' * 40)
print(f'再看看一個sum \n{store.isnull().sum()}')
print('對比上表，可以看到，這步只是計算了每個標籤中的NaN的值')
print('- ' * 40)
print(f'最後二個sum可以得到全部NaN值 = {store.isnull().sum().sum()}')

我們先創建一個數據框,這裏用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store   20.0     30       35      NaN
2-store    NaN      5       10     50.0
3-store   10.0     21       20      NaN
特意準備了一個NaN多的例子看看
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
先看看isnull有啥用
         bikes  pants  watches  glasses
1-store  False  False    False     True
2-store   True  False    False    False
3-store  False  False    False     True
對比上表，NaN被替換成了布爾值的True，其他則是False
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
再看看一個sum 
bikes      1
pants      0
watches    0
glasses    2
dtype: int64
對比上表，可以看到，這步只是計算了每個標籤中的NaN的值
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
最後二個sum可以得到全部NaN值 = 3

NaN值的刪除

使用 dataframe.dropna(axis)

axis = 0 刪除行， axis = 1 刪除列

print('我們先創建一個數據框,這裏用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35},\
             {'watches': 10, 'glasses': 50,  'pants':5},\
             {'pants':21, 'watches':20, 'bikes':10, 'glasses':20}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store', '3-store'])
print(store)
print('特意準備了一個NaN多的例子看看')
print('- ' * 40)
store1 =  store.dropna(axis = 0)
print(f'刪除行中有NaN值 \n{store1}')
print('- ' * 40)
store2 = store.dropna(axis = 1)
print(f'刪除列中有NaN值 \n {store2}')

我們先創建一個數據框,這裏用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store   20.0     30       35      NaN
2-store    NaN      5       10     50.0
3-store   10.0     21       20     20.0
特意準備了一個NaN多的例子看看
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
刪除行中有NaN值 
         bikes  pants  watches  glasses
3-store   10.0     21       20     20.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
刪除列中有NaN值 
          pants  watches
1-store     30       35
2-store      5       10
3-store     21       20

NaN值的更改

下面提到多種方法可以對NaN值的修改，具體使用還得根據實際情況來，怎麼能消去就怎麼弄，不要在意爲什麼會有什麼多方法

修改爲某值

使用函數dataframe.fillna() 加入要改後的值就行

print('我們先創建一個數據框,這裏用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35},\
             {'watches': 10, 'glasses': 50,  'pants':5},\
             {'pants':21, 'watches':20, 'bikes':10}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store', '3-store'])
print(store)
print('特意準備了一個NaN多的例子看看')
print('- ' * 40)
store1 = store.fillna(0)
print(f'這裏我把所有的NaN值全部改爲0\n{store1}')

我們先創建一個數據框,這裏用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store   20.0     30       35      NaN
2-store    NaN      5       10     50.0
3-store   10.0     21       20      NaN
特意準備了一個NaN多的例子看看
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
這裏我把所有的NaN值全部改爲0
         bikes  pants  watches  glasses
1-store   20.0     30       35      0.0
2-store    0.0      5       10     50.0
3-store   10.0     21       20      0.0

向前填充

使用dataframe.fill(method = ‘ffill’, axis) 函數，我們可以將NaN值，向前填充，其中axis選擇上還是左，看點例子

import pandas as pd
print('我們先創建一個數據框,這裏用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35},\
             {'watches': 10, 'glasses': 50,  'pants':5},\
             {'pants':21, 'watches':20, 'bikes':10}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store', '3-store'])
print(store)
print('特意準備了一個NaN多的例子看看')
print('- ' * 40)
store1 = store.fillna(method = 'ffill', axis = 0)
print(f'這裏我們先選擇向上填充\n{store1}\n')
print('1-store 中的 NaN 由於上面沒有數值， 所以保留原樣')
print('- ' * 40)
store2 = store.fillna(method = 'ffill', axis = 1)
print(f'這裏我們選擇向左填充\n{store2}')
print('至於爲什麼還有一個NaN值，大家應該知道原因了吧')

我們先創建一個數據框,這裏用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store   20.0     30       35      NaN
2-store    NaN      5       10     50.0
3-store   10.0     21       20      NaN
特意準備了一個NaN多的例子看看
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
這裏我們先選擇向上填充
         bikes  pants  watches  glasses
1-store   20.0     30       35      NaN
2-store   20.0      5       10     50.0
3-store   10.0     21       20     50.0

1-store 中的 NaN 由於上面沒有數值， 所以保留原樣
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
這裏我們選擇向左填充
         bikes  pants  watches  glasses
1-store   20.0   30.0     35.0     35.0
2-store    NaN    5.0     10.0     50.0
3-store   10.0   21.0     20.0     20.0
至於爲什麼還有一個NaN值，大家應該知道原因了吧

向後填充

使用 dataframe.fillna(method = ‘backfill’, axis) 可以向後填充，用法和上面類似

import pandas as pd
print('我們先創建一個數據框,這裏用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35},\
             {'watches': 10, 'glasses': 50,  'pants':5},\
             {'pants':21, 'watches':20, 'bikes':10}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store', '3-store'])
print(store)
print('特意準備了一個NaN多的例子看看')
print('- ' * 40)
store1 = store.fillna(method = 'backfill', axis = 0)
print(f'這裏我們選擇向下填充\n{store1}')
print('- ' * 40)
store2 = store.fillna(method = 'backfill', axis = 1)
print(f'這裏我們選擇向右填充\n{store2}')
print('同樣的理由可以解釋爲什麼還有NaN值')

我們先創建一個數據框,這裏用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store   20.0     30       35      NaN
2-store    NaN      5       10     50.0
3-store   10.0     21       20      NaN
特意準備了一個NaN多的例子看看
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
這裏我們選擇向下填充
         bikes  pants  watches  glasses
1-store   20.0     30       35     50.0
2-store   10.0      5       10     50.0
3-store   10.0     21       20      NaN
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
這裏我們選擇向右填充
         bikes  pants  watches  glasses
1-store   20.0   30.0     35.0      NaN
2-store    5.0    5.0     10.0     50.0
3-store   10.0   21.0     20.0      NaN
同樣的理由可以解釋爲什麼還有NaN值

對差填充

使用 dataframe.interpolate(method = ‘linear’, axis) 可以差值填充，依舊來看看

import pandas as pd
print('我們先創建一個數據框,這裏用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35},\
             {'watches': 10, 'glasses': 50,  'pants':5},\
             {'pants':21, 'watches':20, 'bikes':10}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store', '3-store'])
print(store)
print('特意準備了一個NaN多的例子看看')
print('- ' * 40)
store1 = store.interpolate(method = 'linear', axis = 0)
print(f'向上求等差填充\n{store1}')
print('- ' * 40)
store2 = store.interpolate(method = 'linear', axis = 1)
print(f'向左求等差填充\n{store2}')

我們先創建一個數據框,這裏用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store   20.0     30       35      NaN
2-store    NaN      5       10     50.0
3-store   10.0     21       20      NaN
特意準備了一個NaN多的例子看看
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
向上求等差填充
         bikes  pants  watches  glasses
1-store   20.0     30       35      NaN
2-store   15.0      5       10     50.0
3-store   10.0     21       20     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
向左求等差填充
         bikes  pants  watches  glasses
1-store   20.0   30.0     35.0     35.0
2-store    NaN    5.0     10.0     50.0
3-store   10.0   21.0     20.0     20.0

讀取CSV文件獲得DataFrames

獲得數據和數據屬性

我們用函數pd.read_csv() 可以從CSV文件中將數據加載出來

import pandas as pd
good_data  = pd.read_csv('goog-1.csv', encoding = 'utf-8')
print(f'這裏我們從網上找到的一個數據，先獲得基礎屬性')
print('- ' * 40)
print(type(good_data))
print(good_data.shape)
print('- ' * 40)
print(f'使用函數.head(N)  可以獲得數據的前N項 默認 N = 5 \n{good_data.head()}')
print('- ' * 40)
print(f'使用函數.tail(N)  可以獲得數據的後N項 默認 N = 5\n {good_data.tail()}')

這裏我們從網上找到的一個數據，先獲得基礎屬性
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
<class 'pandas.core.frame.DataFrame'>
(3313, 7)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
使用函數.head(N)  可以獲得數據的前N項 默認 N = 5 
         Date       Open       High        Low      Close  Adj Close    Volume
0  2004-08-19  49.676899  51.693783  47.669952  49.845802  49.845802  44994500
1  2004-08-20  50.178635  54.187561  49.925285  53.805050  53.805050  23005800
2  2004-08-23  55.017166  56.373344  54.172661  54.346527  54.346527  18393200
3  2004-08-24  55.260582  55.439419  51.450363  52.096165  52.096165  15361800
4  2004-08-25  52.140873  53.651051  51.604362  52.657513  52.657513   9257400
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
使用函數.tail(N)  可以獲得數據的後N項 默認 N = 5
             Date        Open        High         Low       Close   Adj Close  \
3308  2017-10-09  980.000000  985.424988  976.109985  977.000000  977.000000   
3309  2017-10-10  980.000000  981.570007  966.080017  972.599976  972.599976   
3310  2017-10-11  973.719971  990.710022  972.250000  989.250000  989.250000   
3311  2017-10-12  987.450012  994.119995  985.000000  987.830017  987.830017   
3312  2017-10-13  992.000000  997.210022  989.000000  989.679993  989.679993   

       Volume  
3308   891400  
3309   968400  
3310  1693300  
3311  1262400  
3312  1157700  

檢測數據是否存在NaN值

print('可以使用之前的方法 .isnull.sum().sum() = ',good_data.isnull().sum().sum())
print('- ' * 40)
print(f'這裏學一個新方法 isnull().any() \n\n{good_data.isnull().any()}')
print()
print('any()作用在isnull() 上，顯示每列是否存在NaN值')

可以使用之前的方法 .isnull.sum().sum() =  0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
這裏學一個新方法 isnull().any() 

Date         False
Open         False
High         False
Low          False
Close        False
Adj Close    False
Volume       False
dtype: bool

any()作用在isnull() 上，顯示每列是否存在NaN值

加載數據的重要信息

我們使用函數 .describe() 可以獲得這個數據的重要信息，便於我們處理，還是上面的數據作爲例子

good_data.describe()

	Open	High	Low	Close	Adj Close	Volume
count	3313.000000	3313.000000	3313.000000	3313.000000	3313.000000	3.313000e+03
mean	380.186092	383.493740	376.519309	380.072458	380.072458	8.038476e+06
std	223.818650	224.974534	222.473232	223.853780	223.853780	8.399521e+06
min	49.274517	50.541279	47.669952	49.681866	49.681866	7.900000e+03
25%	226.556473	228.394516	224.003082	226.407440	226.407440	2.584900e+06
50%	293.312286	295.433502	289.929291	293.029114	293.029114	5.281300e+06
75%	536.650024	540.000000	532.409973	536.690002	536.690002	1.065370e+07
max	992.000000	997.210022	989.000000	989.679993	989.679993	8.276810e+07

print(f'其實還可以採集某個特定的數\n\t\tOpen\n{good_data["Open"].describe()}')
print('- ' * 40)
print(f'或者用數學函數等等\n\t\tMax\n{good_data.max()}')

其實還可以採集某個特定的數
		Open
count    3313.000000
mean      380.186092
std       223.818650
min        49.274517
25%       226.556473
50%       293.312286
75%       536.650024
max       992.000000
Name: Open, dtype: float64
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
或者用數學函數等等
		Max
Date         2017-10-13
Open                992
High             997.21
Low                 989
Close            989.68
Adj Close        989.68
Volume         82768100
dtype: object

數據相關性

使用函數**.corr()** 可以知道數據是否關聯，越接近1 表示數據越關聯

good_data.corr()

	Open	High	Low	Close	Adj Close	Volume
Open	1.000000	0.999904	0.999845	0.999745	0.999745	-0.564258
High	0.999904	1.000000	0.999834	0.999868	0.999868	-0.562749
Low	0.999845	0.999834	1.000000	0.999899	0.999899	-0.567007
Close	0.999745	0.999868	0.999899	1.000000	1.000000	-0.564967
Adj Close	0.999745	0.999868	0.999899	1.000000	1.000000	-0.564967
Volume	-0.564258	-0.562749	-0.567007	-0.564967	-0.564967	1.000000

數據分組

使用函數 .groupby() 可以把不同屬性的數據分成一個組，然後進行數學運算，比如求和，平均

data = pd.Series(data = ['3-1','3-1','3-2','3-3'])
spend = pd.Series(data = [10, 11, 13, 15])
get = pd.Series(data = [0, 10, 5, 2])
day_item = {'data':data,
           'spend':spend,
           'get':get}
days = pd.DataFrame(day_item)
print('創建消費數據 \n ',days)
print('- ' * 40)
print(f'我們算算這些天花了多少錢\n {days.groupby(["data"])["spend"].sum()}')
print('- ' * 40)
print(f'算算平均每天得到多少錢\n {days.groupby(["data"])["get"].mean()}')

創建消費數據 
    data  spend  get
0  3-1     10    0
1  3-1     11   10
2  3-2     13    5
3  3-3     15    2
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我們算算這些天花了多少錢
 data
3-1    21
3-2    13
3-3    15
Name: spend, dtype: int64
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
算算平均每天得到多少錢
 data
3-1    5
3-2    5
3-3    2
Name: get, dtype: int64

願你我始終走在內心的崎嶇小路，一人一碼，播出屬於自己的種子！