jupter nootbok 快捷鍵、NumPy模塊、Pandas模塊初識

jupter nootbok 快捷鍵

插入cell：a b
刪除cell：x
cell模式的切換：m：Markdown模式 y：code模式
運行cell：shift+enter
tab：補全
shift+tab：打開幫助文檔

NumPy

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

一、創建ndarray

1. 使用np.array()創建
一維數據創建
import numpy as np
np.array([1,2,3,4,5],dtype=int)
二維數組創建
np.array([[1,2,3],[4,5,6],[7.7,8,9]])

注意：
numpy默認ndarray的所有元素的類型是相同的
如果傳進來的列表中包含不同的類型，則統一為同一類型，優先級：str>float>int

使用matplotlib.pyplot獲取一個numpy數組，數據來源於一張圖片

import matplotlib.pyplot as plt
img_arr = plt.imread('bobo.jpg')#當前目錄下的圖片
plt.imshow(img_arr)
img.shape
#(626, 413, 3)#前面兩個數字表示像素，最后一個表示顏色

使用np的routines函數創建數組

包含以下常見創建方法：
1) np.ones(shape, dtype=None, order='C')
np.ones(shape=(4,5),dtype=float)#默認為1
np.zeros(shape, dtype=None, order='C')#默認為0
np.full(shape, fill_value, dtype=None, order='C')
np.full(shape=(6,7),fill_value=999)
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None) 等差數列
np.linspace(0,100,20)#返回20個數，等差是5的一維數組
np.arange([start, ]stop, [step, ]dtype=None)
arr1 = np.arange(3,10,2) #3是開始，10是結束，2是步長 的一維數組
np.random.seed(10)#固定時間因子
np.random.randint(0,100,size=(3,4))#產生的隨機數固定
array([[ 9, 15, 64, 28],
       [89, 93, 29,  8],
       [73,  0, 40, 36]])

注意：只有arange和linspace產生一維數組，其他的都可產生一維或者多維數組

ndarray的屬性

4個必記參數： ndim：維度 shape：形狀（各維度的長度） size：總長度  dtype：元素類型

ndarray的基本操作

1. 索引
一維與列表完全一致 多維時同理
np.random.seed(1)
arr = np.random.randint(0,100,size=(5,5)) 
#根據索引修改數據
arr[1][2] = 6666444
#獲取二維數組前兩行
arr[0:2]
#獲取二維數組前兩列
arr[:,0:2]
#獲取二維數組前兩行和前兩列數據
arr[0:2,0:2]
#將數組的行倒序
arr[::-1]
#列倒序
arr[:,::-1]
#全部倒序
arr[::-1,::-1]
#將圖片進行全倒置操作
plt.imshow(img_arr[::-1,::-1,::-1])
變形
.將一維數組變形成多維數組
array([[     37,      12,      72,       9,      75],
       [      5,      79, 6666444,      16,       1],
       [     76,      71,       6,      25,      50],
       [     20,      18,      84,      11,      28],
       [     29,      14,      50,      68,      87]])
arr.shape
(5, 5)

使用arr.reshape()函數，注意參數是一個tuple！數組元素變形前后要統一!

a.reshape((5,-1))  #-1表示的是自動計算行或列
array([[  37,   12,   72,    9,   75],
       [   5,   79, 9999,   16,    1],
       [  76,   71,    6,   25,   50],
       [  20,   18,   84,   11,   28],
       [  29,   14,   50,   68,   87]])
將多維數組變形成一維數組
a = arr.reshape((25,))
a.shape
(25,)
圖片倒置
img_arr.shape
(626, 413, 3)
img_arr.size
775614
#將原數據三維數組變形成一維數組
arr_1 = img_arr.reshape((775614,))
#將arr_1元素倒置
arr_1 = arr_1[::-1]
#將arr_1變形成三維數組
a_img = arr_1.reshape((626, 413, 3))
plt.imshow(a_img)

級聯

np.concatenate((arr,arr),axis=1)  #0 縱軸  1 橫軸
級聯需要注意的點：
級聯的參數是列表：一定要加中括號或小括號
維度必須相同
形狀相符:在維度保持一致的前提下，如果進行橫向（axis=1）級聯，必須保證進行級聯的數組行數保持一致。如果進行縱向（axis=0）級聯，必須保證進行級聯的數組列數保持一致。
可通過axis參數改變級聯的方向
np.vstack():在豎直方向上堆疊
np.hstack():在水平方向上平鋪

切分

與級聯類似，三個函數完成切分工作：
np.split(arr,行／列號，軸):參數2是一個列表類型
plt.imshow(np.split(img,(400,),axis=0)[0])
np.vsplit
np.hsplit

副本

所有賦值運算不會為ndarray的任何元素創建副本。對賦值后的對象的操作也對原來的對象生效。
可使用copy()函數創建副本
c_arr = arr.copy()
c_arr[1][4] = 100100

ndarray的聚合操作

 求和np.sum
 arr.sum(axis=1)#求行的和
最大最小值：np.max/ np.min
平均值：np.mean()
其他聚合操作
Function Name    NaN-safe Version    Description
np.sum    np.nansum    Compute sum of elements
np.prod    np.nanprod    Compute product of elements
np.mean    np.nanmean    Compute mean of elements
np.std    np.nanstd    Compute standard deviation
np.var    np.nanvar    Compute variance
np.min    np.nanmin    Find minimum value
np.max    np.nanmax    Find maximum value
np.argmin    np.nanargmin    Find index of minimum value
np.argmax    np.nanargmax    Find index of maximum value
np.median    np.nanmedian    Compute median of elements
np.percentile    np.nanpercentile    Compute rank-based statistics of elements
np.any    N/A    Evaluate whether any elements are true
np.all    N/A    Evaluate whether all elements are true
np.power 冪運算

廣播機制

【重要】ndarray廣播機制的三條規則:缺失維度的數組將維度補充為進行運算的數組的維度。缺失的數組元素使用已有元素進行補充。
規則一：為缺失的維度補1(進行運算的兩個數組之間的維度只能相差一個維度)
規則二：缺失元素用已有值填充
規則三：缺失維度的數組只能有一行或者一列

m = np.ones((2, 3))
a = np.arange(3)
display(m,a)
array([[1., 1., 1.],
       [1., 1., 1.]])
array([0, 1, 2])
m+a
array([[1., 2., 3.],
       [1., 2., 3.]])

ndarray的排序

快速排序
np.sort()與ndarray.sort()都可以，但有區別：

np.sort()不改變輸入
ndarray.sort()本地處理，不占用空間，但改變輸入

Pandas的數據結構

1、Series

Series是一種類似與一維數組的對象，由下面兩個部分組成：

values：一組數據（ndarray類型）
index：相關的數據索引標簽

1）Series的創建

import pandas as pd
from pandas import Series,DataFrame
import numpy as np

兩種創建方式：

(1) 由列表或numpy數組創建

默認索引為0到N-1的整數型索引
#使用列表創建Series
Series(data=[1,2,3,4,5],name='bobo')
#使用numpy創建Series
Series(data=np.random.randint(0,10,size=(5,)))
#還可以通過設置index參數指定索引
s = Series(data=np.random.randint(0,10,size=(5,)),index=['a','b','c','d','e'])
由字典創建:不能在使用index.但是依然存在默認索引
dic = {
    '語文':100,
    '數學':90
}
s = Series(data=dic)

Series的索引和切片

可以使用中括號取單個索引（此時返回的是元素類型），或者中括號里一個列表取多個索引（此時返回的是一個Series類型）。

(1) 顯式索引：

- 使用index中的元素作為索引值
- 使用s.loc[]（推薦）:注意，loc中括號中放置的一定是顯示索引
注意，此時是閉區間，能取到尾

(2) 隱式索引：

- 使用整數作為索引值
- 使用.iloc[]（推薦）:iloc中的中括號中必須放置隱式索引
注意，此時是半開區間，取不到尾

切片:隱式索引切片和顯示索引切片
顯示索引切片:index和loc
s['a':'d']
s.loc['a':'c']
隱式索引切片：整數索引值和iloc
s.iloc[0:3]

Series的基本概念

可以把Series看成一個定長的有序字典

向Series增加一行：相當於給字典增加一組鍵值對
s['g'] = 10
可以通過shape，size，index,values等得到series的屬性
s.index
s.values

可以使用s.head(),tail()分別查看前n個和后n個值
s.head(3)
對Series元素進行去重
s.unique()  #返回的是一個ndarray

當索引沒有對應的值時，可能出現缺失數據顯示NaN（not a number）的情況
使得兩個Series進行相加
In [41]:

s1 = Series([1,2,3],index=['a','b','c'])
s2 = Series([1,2,3],index=['a','b','d'])
s = s1+s2
a    2.0
b    4.0
c    NaN
d    NaN
dtype: float64

可以使用pd.isnull()，pd.notnull()，或s.isnull(),notnull()函數檢測缺失數據
s.isnull()
a    False
b    False
c     True
d     True
dtype: bool
s.notnull()
a     True
b     True
c    False
d    False
dtype: bool
s[s.notnull()]#過濾掉空的數據
a    2.0
b    4.0
dtype: float64

Series的運算

(1) + - * /
(2) add() sub() mul() div()
(3) Series之間的運算

在運算中自動對齊不同索引的數據
如果索引不對應，則補NaN
s1 =  Series([1,2,31,2],index=["a","d","s","r"])
s2 = Series([11,2,2,3],index=["a","d","s","b"])
s = s1+s2
a    12.0
b     NaN
d     4.0
r     NaN
s    33.0
dtype: float64

s1.add(s2,fill_value=1) 

a    2.0
b    4.0
c    4.0
d    4.0
dtype: float64

DataFrame

DataFrame是一個【表格型】的數據結構。DataFrame由按一定順序排列的多列數據組成。設計初衷是將Series的使用場景從一維拓展到多維。DataFrame既有行索引，也有列索引。

• 行索引：index
• 列索引：columns
• 值：values

DataFrame的創建

最常用的方法是傳遞一個字典來創建。DataFrame以字典的鍵作為每一【列】的名稱，以字典的值（一個數組）作為每一列。

此外，DataFrame會自動加上每一行的索引。

使用字典創建的DataFrame后，則columns參數將不可被使用。

同Series一樣，若傳入的列與字典的鍵不匹配，則相應的值為NaN。

使用ndarray創建DataFrame

DataFrame(data=np.random.randint(0,100,size=(3,4)),index=['a','b','c'])

使用字典創建DataFrame

dic={
    "name":["john","tom"],
    "salay":[100,222]
}
df = DataFrame(data=dic,index=["a","b"])
df

DataFrame屬性：values、columns、index、shape

DataFrame的索引

 

(1) 對列進行索引

- 通過類似字典的方式  df['q']
- 通過屬性的方式     df.q

可以將DataFrame的列獲取為一個Series。返回的Series擁有原DataFrame相同的索引，且name屬性也已經設置好了，就是相應的列名。

#修改列索引

 

 #獲取前兩列

(2) 對行進行索引

- 使用.loc[]加index來進行行索引
- 使用.iloc[]加整數來進行行索引

同樣返回一個Series，index為原來的columns。

(3) 對元素索引的方法

- 使用列索引
- 使用行索引(iloc[3,1] or loc['C','q']) 行索引在前，列索引在后

更改某個元素

 

切片

【注意】 直接用中括號時：

• 索引表示的是列索引
• 切片表示的是行切片

 

在loc和iloc中使用切片(切列)

 

 

DataFrame的運算

（1） DataFrame之間的運算

同Series一樣：

• 在運算中自動對齊不同索引的數據
• 如果索引不對應，則補NaN

 

處理丟失數據

有兩種丟失數據：

• None
• np.nan(NaN)

1. None

None是Python自帶的，其類型為python object。因此，None不能參與到任何計算中。

np.nan（NaN）

np.nan是浮點類型，能參與到計算中。但計算的結果總是NaN。

 

pandas中的None與NaN

1) pandas中None與np.nan都視作np.nan

2) pandas處理空值操作

• isnull()
• notnull()
• dropna(): 過濾丟失數據
• fillna(): 填充丟失數據

(1)判斷函數

• isnull()
• notnull()

 

df.notnull/isnull().any()/all()

 

 

 

df.dropna() 可以選擇過濾的是行還是列（默認為行）:axis中0表示行，1表示的列

 只有函數名含有drop的函數的axis中0表示行，1表示的列

(3) 填充函數 Series/DataFrame


• fillna():value和method參數

創建多層列索引

1) 隱式構造

最常見的方法是給DataFrame構造函數的index或者columns參數傳遞兩個或更多的數組

2) 顯示構造pd.MultiIndex.from

使用product:

最簡單，推薦使用

 

多層索引對象的索引與切片操作

DataFrame的操作

 

 

# 總結：
#直接使用[],索引是列索引，切片是行切片
# 訪問一列或多列 直接用中括號[columnname]  [[columname1,columnname2...]]
#訪問一行或多行  .loc[inexname]/.loc[[indexname1,indexname2]]
# 訪問某一個元素  .loc[indexname,columnname]  
# 行切片          .loc[index1:index2]        
# 列切片          .loc[:,column1:column2]    

聚合操作

 所謂的聚合操作：平均數，方差，最大值，最小值……

 

pandas的拼接操作

pandas的拼接分為兩種：

• 級聯：pd.concat, pd.append
• 合並：pd.merge, pd.join

使用pd.concat()級聯

pandas使用pd.concat函數，與np.concatenate函數類似，只是多了一些參數：

objs
axis=0   #橫向還是縱向級聯
keys  #標識，跟級聯的表的個數一致
join='outer' / 'inner':表示的是級聯的方式，outer會將所有的項進行級聯（忽略匹配和不匹配），而inner只會將匹配的項級聯到一起，不匹配的不級聯
ignore_index=False #忽略行索引

不匹配級聯

不匹配指的是級聯的維度的索引不一致。例如縱向級聯時列索引不一致，橫向級聯時行索引不一致

有2種連接方式：

• 外連接：補NaN（默認模式）

• 內連接：只連接匹配的項

 

使用df.append()函數添加

由於在后面級聯的使用非常普遍，因此有一個函數append專門用於在后面縱向添加

使用pd.merge()合並

merge與concat的區別在於，merge需要依據某一共同的列來進行合並

使用pd.merge()合並時，會自動根據兩者相同column名稱的那一列，作為key來進行合並。

注意每一列元素的順序不要求一致

參數：

• how：out取並集 inner取交集

• on：當有多列相同的時候，可以使用on來指定使用那一列進行合並，on的值為一個列表

一對一合並

 

 

 多對一合並

 

 多對多合並

 

key的規范化

• 當列沖突時，即有多個列名稱相同時，需要使用on=來指定哪一個列作為key，配合suffixes指定沖突列名

 

• 當兩張表沒有可進行連接的列時，可使用left_on和right_on手動指定merge中左右兩邊的哪一列列作為連接的列

 

內合並與外合並:out取並集 inner取交集

• 內合並：只保留兩者都有的key（默認模式）

 

• 外合並 how='outer'：補NaN

 

pandas數據處理

刪除重復元素

使用duplicated()函數檢測重復的行，返回元素為布爾類型的Series對象，每個元素對應一行，如果該行不是第一次出現，則元素為True

- keep參數：指定保留哪一重復的行數據,first:第一行 last:最后一行 False全部刪

 

 

使用drop_duplicates()函數刪除重復的行

drop_duplicates(keep='first/last'/False)

 

映射

replace()函數：替換元素

使用replace()函數，對values進行映射操作

replace參數說明：

• method：對指定的值使用相鄰的值填充替換

Series替換操作

• 單值替換
  • 普通替換
  • 字典替換(推薦）
• 多值替換
  • 列表替換
  • 字典替換（推薦）
• 參數
  • to_replace:被替換的元素

單值普通替換

多值列表替換

單值字典替換

 

多值字典替換

 

DataFrame替換操作

• 單值替換
  • 普通替換： 替換所有符合要求的元素:to_replace=15,value='e'
  • 按列指定單值替換： to_replace={列標簽：替換值} value='value'

• 多值替換
  • 列表替換: to_replace=[] value=[]
  • 字典替換（推薦） to_replace={to_replace:value,to_replace:value}

 

按列指定單值替換

字典替換

 

map()函數

新建一列 ， map函數並不是df的方法，而是series的方法

• map()可以映射新一列數據
• map()中可以使用lambd表達式

• map()中可以使用方法，可以是自定義的方法

  eg:map({to_replace:value})

• 注意 map()中不能使用sum之類的函數，for循環

• 注意：並不是任何形式的函數都可以作為map的參數。只有當一個函數具有一個參數且有返回值，那么該函數才可以作為map的參數。

map當做一種運算工具，至於執行何種運算，是由map函數的參數決定的（參數：lambda，函數）

 

使用lambda表達式

使用聚合操作對數據異常值檢測和過濾

使用df.std()函數可以求得DataFrame對象每一列的標准差

 第一種方法

 

第二種方法

 

 排序

使用.take()函數排序

- take()函數接受一個索引列表，用數字表示,使得df根據列表中索引的順序進行排序
- eg:df.take([1,3,4,2,5])

可以借助np.random.permutation()函數隨機排序

• np.random.permutation(x)可以生成x個從0-(x-1)的隨機數列

數據分類處理【重點】

數據聚合是數據處理的最后一步，通常是要使每一個數組生成一個單一的數值。

數據分類處理：

• 分組：先把數據分為幾組
• 用函數處理：為不同組的數據應用不同的函數以轉換數據
• 合並：把不同組得到的結果合並起來

數據分類處理的核心：

 - groupby()函數
 - groups屬性查看分組情況
 - eg: df.groupby(by='item').groups

 

 

高級數據聚合

使用groupby分組后，也可以使用transform和apply提供自定義函數實現更多的運算

• df.groupby('item')['price'].sum() <==> df.groupby('item')['price'].apply(sum)
• transform和apply都會進行運算，在transform或者apply中傳入函數即可
• transform和apply也可以傳入一個lambda表達式