數據處理分析環境搭建+Numpy使用教程

環境搭建

數據分析常用開源庫

Numpy
- NumPy(Numerical Python) 是 Python 語言的一個擴展程序庫。
- 是一個運行速度非常快的數學庫，主要用于數組計算
- 包含：
  1. 一個強大的N維數組對象 ndarray
  2. 廣播功能函數
  3. 整合 C/C++/Fortran 代碼的工具
  4. 線性代數、傅里葉變換、隨機數生成等功能
Pandas
- Pandas是一個強大的分析結構化數據的工具集
- 它的使用基礎是Numpy（提供高性能的矩陣運算）
- 用于數據挖掘和數據分析，同時也提供數據清洗功能
- “利器”：
  1. Pandas利器之 Series，是一種類似于一維數組的對象
  2. Pandas利器之 DataFrame，是Pandas中的一個表格型的數據結構
Matplotlib
- Matplotlib 是一個功能強大的數據可視化開源Python庫
- 功能：
  1. Python中使用最多的圖形繪圖庫
  2. 可以創建靜態, 動態和交互式的圖表
Seaborn
- Seaborn是一個Python數據可視化開源庫
- 特點：
  1. 建立在matplotlib之上，并集成了pandas的數據結構
  2. Seaborn通過更簡潔的API來繪制信息更豐富，更具吸引力的圖像
  3. 面向數據集的API，與Pandas配合使用起來比直接使用Matplotlib更方便
Sklearn
- scikit-learn 是基于 Python 語言的機器學習工具
- 介紹：
  1. 簡單高效的數據挖掘和數據分析工具
  2. 可供大家在各種環境中重復使用
  3. 建立在 NumPy ，SciPy 和 matplotlib 上

安裝Anaconda

1. 介紹

anaconda是最流行的數據分析平臺，全球兩千多萬人在使用
特點：
1. Anaconda 附帶了一大批常用數據科學包
2. Anaconda 是在 conda（一個包管理器和環境管理器）上發展出來的
3. 可以幫助你在計算機上安裝和管理數據分析相關包
4. 包含了虛擬環境管理工具

2.安裝

Anaconda 可用于多個平臺（ Windows、Mac OS X 和 Linux）
安裝：
1. 可以在官網上下載對應平臺的安裝包
2. 如果計算機上已經安裝了 Python，安裝不會對你有任何影響
3. 安裝的過程很簡單，一路下一步即可
4. https://www.anaconda.com/products/individual

3.界面

圖形化使用

主界面：
anaconda界面
包和虛擬環境管理：
管理界面

命令行方式使用

下載包

conda install 包名字
pip install 包名字
- 注意，使用pip時最好指定安裝源：
  1. 阿里云：https://mirrors.aliyun.com/pypi/simple/
  2. 豆瓣：https://pypi.douban.com/simple/
  3. 清華大學：https://pypi.tuna.tsinghua.edu.cn/simple/
  4. 中國科學技術大學 http://pypi.mirrors.ustc.edu.cn/simple/
    舉例：pip install 包名 -i https://mirrors.aliyun.com/pypi/simple/ #通過阿里云鏡像安裝

虛擬環境管理
1. conda create -n 虛擬環境名字 python=python版本 #創建虛擬環境
2. conda activate 虛擬環境名字 #進入虛擬環境
3. conda deactivate #退出虛擬環境
4. conda remove -n 虛擬環境名字 --all #刪除虛擬環境

虛擬環境的作用

很多開源庫版本升級后API有變化，老版本的代碼不能在新版本中運行
將不同Python版本/相同開源庫的不同版本隔離
不同版本的代碼在不同的虛擬環境中運行

有興趣的話也可以應用一下Jupyter Notebook，在處理數據時可以更加直觀的查看數據，不過在實際項目開發中還是使用pycharm居多。

Numpy入門

簡介：

1.介紹

NumPy（Numerical Python）是Python數據分析必不可少的第三方庫

NumPy的出現一定程度上解決了Python運算性能不佳的問題，同時提供了更加精確的數據類型，使其具備了構造復雜數據類型的能力。

本身是由C語言開發，是個很基礎的擴展，NumPy被Python其它科學計算包作為基礎包，因此理解np的數據類型對python數據分析十分重要。

NumPy重在數值計算，主要用于多維數組（矩陣）處理的庫。用來存儲和處理大型矩陣，比Python自身的嵌套列表結構要高效的多

2. 功能

高性能科學計算和數據分析的基礎包
ndarray，多維數組，具有矢量運算能力，快速、節省空間
矩陣運算，無需循環，可完成類似Matlab中的矢量運算
用于讀寫磁盤數據的工具以及用于操作內存映射文件的工具

3. 屬性

NumPy的數組類被稱作ndarray，通常被稱作數組。

ndarray對象屬性有：
- ndarray.ndim ——對象維度
- ndarray.shape ——對象形狀
- ndarray.size ——對象元素個數
- ndarray.dtype ——對象元素類型
- ndarray.itemsize ——對象每個元素字節數

數組的維度。這是一個指示數組在每個維度上大小的整數元組。例如一個n排m列的矩陣，它的shape屬性將是(n,m),這個元組的長度顯然是秩，即維度或者ndim屬性。
示例：

import numpy as np  # 后續省略導包
a = np.arange(15).reshape(3,5)
print(f"數組對象：{a}")
print(f"數組的維度：{a.shape}")
print(f"數組軸的個數(維度數)：{a.ndim}")
print(f"數組元素的類型：{a.dtype}")
print(f"數組中每個元素的字節大小：{a.itemsize}")
print(f"數組元素的總個數：{a.size}")
print(f"數組類型：{type(a)}")

輸出結果：
數組對象：[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
數組的維度：(3, 5)
數組軸的個數(維度數)：2
數組元素的類型：int32
數組中每個元素的字節大小：4
數組元素的總個數：15
數組類型：<class ‘numpy.ndarray’>

創建ndarray

NumPy數組是一個多維的數組對象（矩陣），稱為ndarray，具有矢量算術運算能力和復雜的廣播能力，并具有執行速度快和節省空間的特點。注意：ndarray的下標從0開始，且數組里的所有元素必須是相同類型。

1.array()

最基礎的創建方式將列表轉換為數組
示例：

a = np.array([2,3,4])
print(f"數組a；{a}")
print(f"數組a的類型：{type(a)}")
print(f"數組a的元素類型：{a.dtype}")
b = np.array([1.2,3.5,4.5])
print(f"數組b；{b}")
print(f"數組b的類型：{type(b)}")
print(f"數組b的元素類型：{b.dtype}")

輸出結果：
數組a；[2 3 4]
數組a的類型：<class ‘numpy.ndarray’>
數組a的元素類型：int32
數組b；[1.2 3.5 4.5]
數組b的類型：<class ‘numpy.ndarray’>
數組b的元素類型：float64

2.zeros()、ones()、empty()

函數zeros創建一個全是0的數組，函數ones創建一個全是1的數組，函數empty創建一個內容隨機并且依賴于內存狀態的數組。默認創建的數組類型（dtype）都是float64
示例：

zeros1 = np.zeros((3,4))
print(f"zeros1對象：{zeros1}")
ones1 = np.ones((2,3,4))
print(f"ones1對象：{ones1}")
empty1 = np.empty((2,3))
print(f"empty1對象：{empty1}")

輸出結果：
zeros1對象：[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
ones1對象：[[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]

[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]]
empty1對象：[[0. 0. 0.]
[0. 0. 0.]] ——也可能全是‘1.’，具體看當前內存狀態

3.arange()

arange()類似python中的range()，創建一個一維ndarray數組
示例：

# 創建一維數組
arange1 = np.arange(1,10,2,dtype=int)
print(f"arange1對象：{arange1}")
print(f"arange1的元素類型：{arange1.dtype}")
print(f"arange1的類型：{type(arange1)}")
# 創建多維數組
arange2 = np.arange(1,24,2).reshape(2,3,2)
print(f"arange2對象：{arange2}")

輸出結果：
arange1對象：[1 3 5 7 9]
arange1的元素類型：int32
arange1的類型：<class ‘numpy.ndarray’>
arange2對象：[[[ 1 3]
[ 5 7]
[ 9 11]]

[[13 15]
[17 19]
[21 23]]]

4.matrix()

matrix()是ndarray的子類，只能生成二維矩陣
示例：

#%%
matrix1 = np.mat("1 2 ;3 4")
print(f"matrix1對象：{matrix1}")
matrix2 = np.mat("1,2;3,4")
print(f"matrix2對象：{matrix2}")
matrix3 = np.matrix([[1,2],[3,4]])
print(f"matrix3對象：{matrix3}")

執行結果：
matrix1對象：[[1 2]
[3 4]]
matrix2對象：[[1 2]
[3 4]]
matrix3對象：[[1 2]
[3 4]]

5.創建隨機數矩陣random()、randint()、rand()

示例：

# 生成指定維度大小（3行4列）的隨機多維浮點數類型（二維），rand固定區間0-1
rand1 = np.random.rand(3,4)
print(f"rand1對象：{rand1}")
print(f"rand1對象類型：{type(rand1)}")
# 生成指定維度大小（3行4列）的隨機多維整型類型（二維），randint可指定區間
randint2 = np.random.randint(-1,5,size=(3,4))
print(f"randint2對象：{randint2}")
print(f"randint2對象類型：{type(randint2)}")
# 生成指定維度大小（3行4列）的隨機多維浮點類型（二維），uniform()可指定區間產生區間內的均勻分布的樣本值
randbool3 = np.random.uniform(-1,5,size=(3,4))
print(f"randbool3對象：{randbool3}")
print(f"randbool3對象類型：{type(randbool3)}")

輸出結果：
rand1對象：[[0.51657543 0.46933998 0.54730841 0.59782747]
[0.27987993 0.81272003 0.1197689 0.3966129 ]
[0.80375874 0.85541626 0.70941071 0.90645264]]
rand1對象類型：<class ‘numpy.ndarray’>
randint2對象：[[0 4 2 1]
[2 2 2 1]
[4 3 0 3]]
randint2對象類型：<class ‘numpy.ndarray’>
randbool3對象：[[ 3.04256546 0.81151277 3.75742076 2.05055554]
[ 1.43728236 -0.51144312 3.93002313 3.23797794]
[ 4.33968391 4.09649474 -0.05946382 2.73362253]]
randbool3對象類型：<class ‘numpy.ndarray’>

6.等比、等差數列 logspace()、linspace()

等比數列（geometric sequence）：
使用 np.logspace() 函數創建等比數列
語法：np.logspace(start, stop, num, base)
- start: 起始指數
- stop: 結束指數
- num: 生成元素個數
- base: 底數，默認為10

示例：

# 創建以10為底，指數從0到0的等比數列（10^0 = 1），共10個元素，所有元素都是1
a = np.logspace(0,0,10)
print(f"a對象：{a}")# 創建以10為底，指數從0到9的等比數列（10^0, 10^1, ..., 10^9），共10個元素
a = np.logspace(0,9,10)
print(f"a對象：{a}")# 創建以2為底，指數從0到9的等比數列（2^0, 2^1, ..., 2^9），共10個元素
a = np.logspace(0,9,10,base=2)
print(f"a對象：{a}")

輸出結果：
a對象：[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
a對象：[1.e+00 1.e+01 1.e+02 1.e+03 1.e+04 1.e+05 1.e+06 1.e+07 1.e+08 1.e+09]
a對象：[ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]

等差數列（arithmetic sequence）：
使用 np.linspace() 函數創建等差數列
語法：np.linspace(start, stop, num, endpoint)
- start: 起始值
- stop: 結束值
- num: 生成元素個數
- endpoint: 是否包含結束值，默認為True

示例：

# 創建從1到10的等差數列，不包含終點值10，共10個元素
# 實際生成1, 1.9, 2.8, ..., 9.1（不包含10）
a = np.linspace(1,10,10,endpoint=False)
print(f"a對象：{a}")# 創建從1到10的等差數列，包含終點值10，共10個元素
# 生成1, 2, 3, ..., 10
a = np.linspace(1,10,10)
print(f"a對象：{a}")

輸出結果：
a對象：[1. 1.9 2.8 3.7 4.6 5.5 6.4 7.3 8.2 9.1]
a對象：[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]

7.補充（ndarray的數據類型）

dtype參數，指定數組的數據類型，類型名+位數，如float64, int32
astype方法，轉換數組的數據類型
示例：

# 初始化3行4列數組，數據類型為float64
arr = np.zeros((3,4),dtype=np.float64)
print(f"arr對象：{arr}")
print(f"arr.dtype對象：{arr.dtype}")
# astype()轉換數據類型，將已有的數組的數據類型轉換為int32
arr = arr.astype(np.int32)
print(f"arr對象：{arr}")
print(f"arr.dtype對象：{arr.dtype}")

輸出結果：
arr對象：[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
arr.dtype對象：float64
arr對象：[[0 0 0 0]
[0 0 0 0]
[0 0 0 0]]
arr.dtype對象：int32

Numpy內置函數

1.基本函數

np.ceil(): 向上最接近的整數，參數是 number 或 array
np.floor(): 向下最接近的整數，參數是number 或 array
np.rint(): 四舍五入，參數是 number 或 array
np.isnan():判斷元素是否為 NaN(Not a Number)，參數是 number 或 array
np.multiply(): 元素相乘，參數是number 或 array
np.divide(): 元素相除，參數是 number 或 array
np.abs()：元素的絕對值，參數是 number 或 array
np.where(condition, x, y):三元運算符，x if condition else y
示例：

# randn()返回具有標準正太分布的序列
arr = np.random.randn(2,3)
print(f"arr對象：{arr}")
print(f"向上最接近的整數：{np.ceil(arr)}")
print(f"向下最接近的整數：{np.floor(arr)}")
print(f"四舍五入：{np.rint(arr)}")
print(f"是否為NaN：{np.isnan(arr)}")
print(f"元素相乘：{np.multiply(arr,2)}")
print(f"元素相除：{np.divide(arr,2)}")
print(f"元素的絕對值：{np.abs(arr)}")
print(f"三元運算符：{np.where(arr>0,arr,0)}")

輸出結果：(由于數組是隨機生成，結果可能不一致，可自行嘗試)
arr對象：[[-0.30998461 -0.47490616 -0.71112109]
[-0.30427226 -0.0176675 0.63126093]]
向上最接近的整數：[[-0. -0. -0.]
[-0. -0. 1.]]
向下最接近的整數：[[-1. -1. -1.]
[-1. -1. 0.]]
四舍五入：[[-0. -0. -1.]
[-0. -0. 1.]]
是否為NaN：[[False False False]
[False False False]]
元素相乘：[[-0.61996921 -0.94981233 -1.42224219]
[-0.60854452 -0.03533501 1.26252186]]
元素相除：[[-0.1549923 -0.23745308 -0.35556055]
[-0.15213613 -0.00883375 0.31563046]]
元素的絕對值：[[0.30998461 0.47490616 0.71112109]
[0.30427226 0.0176675 0.63126093]]
三元運算符：[[0. 0. 0. ]
[0. 0. 0.63126093]]

2.統計函數

np.mean(), np.sum()：所有元素的平均值，所有元素的和，參數是 number 或 array
np.max(), np.min()：所有元素的最大值，所有元素的最小值，參數是 number 或 array
np.std(), np.var()：所有元素的標準差，所有元素的方差，參數是 number 或 array
np.argmax(), np.argmin()：最大值的下標索引值，最小值的下標索引值，參數是 number 或 array
np.cumsum(), np.cumprod()：返回一個一維數組，每個元素都是之前所有元素的累加和和累乘積，參數是 number 或 array

多維數組默認統計全部維度，axis參數可以按指定軸心統計，值為0則按列統計，值為1則按行統計。

示例：

arr = np.arange(12).reshape(3,4)
print(f"arr對象：{arr}")
print(f"平均值：{arr.mean()}")
print(f"行平均值：{arr.mean(axis=1)}")
print(f"列平均值：{arr.mean(axis=0)}")
print(f"求和：{arr.sum()}")
print(f"最大值：{arr.max()}")
print(f"行最大值：{arr.max(axis=1)}")
print(f"列最大值：{arr.max(axis=0)}")
print(f"最小值：{arr.min()}")
print(f"標準差：{arr.std()}")
print(f"方差：{arr.var()}")
print(f"argmax最大值索引值：{arr.argmax()}")
print(f"argmin最小值索引值：{arr.argmin()}")
print(f"cumsum累計求和：{arr.cumsum()}")
print(f"cumprod累計乘積：{arr.cumprod()}")

輸出結果：
arr對象：[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
平均值：5.5
行平均值：[1.5 5.5 9.5]
列平均值：[4. 5. 6. 7.]
求和：66
最大值：11
行最大值：[ 3 7 11]
列最大值：[ 8 9 10 11]
最小值：0
標準差：3.452052529534663
方差：11.916666666666666
argmax最大值索引值：11
argmin最小值索引值：0
cumsum累計求和：[ 0 1 3 6 10 15 21 28 36 45 55 66]
cumprod累計乘積：[0 0 0 0 0 0 0 0 0 0 0 0]

3.比較函數

假如我們想要知道矩陣a和矩陣b中所有對應元素是否相等，我們需要使用all方法，假如我們想要知道矩陣a和矩陣b中對應元素是否有一個相等，我們需要使用any方法。

np.any(): 至少有一個元素滿足指定條件，返回True
np.all(): 所有的元素滿足指定條件，返回True
示例：

arr = np.random.randn(2,3)
print(f"arr對象：{arr}")
print(f"any:{np.any(arr>0)}")
print(f"all:{np.all(arr>0)}")

輸出結果：(注意隨機生成，結果不唯一)
arr對象：[[-0.10424761 0.07216956 -0.56395871]
[-1.69753658 1.27939205 -0.43498833]]
any:True
all:False

4.去重函數

np.unique():找到唯一值并返回排序結果，類似于Python的set集合
示例：

arr = np.array([[1,2,1],[2,3,4]])
print(f"arr對象：{arr}")
print(f"去重后arr對象：{np.unique(arr)}")

輸出結果：
arr對象：[[1 2 1]
[2 3 4]]
去重后arr對象：[1 2 3 4]

5.排序函數

對數組元素進行排序
示例：

arr = np.array([4,2,3,5,1])
print(f"arr對象：{arr}")
# np.sort()函數排序,返回排序后的副本
sortarr1 = np.sort(arr)
print(f"np.sort(arr)對象：{sortarr1}")
print(f"使用np.sort()后的arr對象：{arr}")
# ndarray直接調用sort，在原數據上進行修改
arr.sort()
print(f"ndarray直接調用sort后的arr對象：{arr}")

輸出結果：（注意區分兩種排序的區別）
arr對象：[4 2 3 5 1]
np.sort(arr)對象：[1 2 3 4 5]
使用np.sort()后的arr對象：[4 2 3 5 1]
ndarray直接調用sort后的arr對象：[1 2 3 4 5]

Numpy運算

1.基本運算

數組的算數運算是按照元素的。新的數組被創建并且被結果填充。
示例：

# numpy基礎
a = np.array([1,2,3])
b = np.array([4,5,6])
c = a - b
d = a + b
print(f"a對象：{a}")
print(f"b對象：{b}")
print(f"c對象：{c}")
print(f"d對象：{d}")

輸出結果：
a對象：[1 2 3]
b對象：[4 5 6]
c對象：[-3 -3 -3]
d對象：[5 7 9]

2.矩陣乘法

行列數相同時

示例：

a = np.array([[1,2,3],[4,5,6]])
b = np.array([[7,8,9],[10,11,12]])
c = a * b
print(f"a對象：{a}")
print(f"b對象：{b}")
print(f"c對象：{c}")

輸出結果：
a對象：[[1 2 3]
[4 5 6]]
b對象：[[ 7 8 9]
[10 11 12]]
c對象：[[ 7 16 27]
[40 55 72]]

行列數不同時

計算方法：

示例：

a = np.array([[1,2,3],[4,5,6]])
b = np.array([[7,8],[9,10],[11,12]])
c = a.dot(b) # 此時不能用a*b，因為a和b的行數和列數不同
print(f"a對象：{a}")
print(f"b對象：{b}")
print(f"c對象：{c}")