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 語言的一個擴展程序庫，支持大量的維度數組與矩陣運算，此外也針對數組運算提供大量的數學函數庫。

1、建立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的數據結構

一、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表達式