Python学习笔记（二.NumPy模块）

系列文章持续更新中…

前言

这篇我们粗略的讲讲NumPy模块的内容。
NumPy模块可以构建多维数据的容器，将多个类型的数据快速的整合在一起，完成多维数据的计算及大型矩阵的存储和处理。
—————————————————————————————————

数组的存储和处理

1.创建数组

NumPy模块最主要的特点就是引入了数组的概念。
所谓数组即一些相同类型数据的集合，它们按一定顺序排列，并且每个数据占用大小相同的存储空间。

A.array（）函数创建数组

使用array（）函数创建数组是最常见的方法，array（）可基于序列型的对象创建任意维度的数组。

基本语法：
array（object, dtype=None, copy=True, order=None, subok=False, ndmin=0）

参数	说明
object	必选，是一个序列型的对象，如列表、元素、集合、已建好的数组等
dtype	可选，用于指定数组元素的数据类型
copy	可选，用于设置是否需要复制对象
order	可选，用于指定创建数组的样式
subok	可选，默认返回一个与基类的类型一致的数组
ndmin	可选，用于指定生成数组的最小维度

eg：
import numpy as np
a = np.array([1,2,3]) #array（）函数创建一维数组
print(a)
运行结果：
[1 2 3]

import numpy as np
b = np.array([[1,2,3],[4,5,6],[7,8,9]])#array（）函数创建多维数组
print(b)
运行结果：
[[1 2 3]
[4 5 6]
[7 8 9]]

注意：同一个数组中的元素数据类型必须相同。

B.arange（）函数创建等差数组

基本语法：
arange(start,stop,step,dtype=None)

参数	说明
start	可选，表示起始值，如果省略，则默认为0
stop	必选，表示结束值，生成数组元素不包括该值
step	可选，表示步长，如果省略，则默认为1；如果指定了该参数，则必须给出参数start的值
dtype	可选，表示创建的数组元素的数据类型。默认值为None，如果省略，则从其他参数推断数据类型

eg：
import numpy as np
a = np.arange(1,20,4,)#起始值为1，结束值为20，步长为4的等差序列
print(a)
运行结果：
[ 1 5 9 13 17]

import numpy as np
b = np.arange(1,20)#起始值为1，结束值为20，步长为1的等差序列
print(b)
运行结果：
[ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]

import numpy as np
c = np.arange(20)#起始值为0，结束值为20，步长为1的等差序列
print(c）
运行结果：
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]

C.创建随机数组

a.rand（）函数

rand（）函数创建的数组中每一个元素都是[0,1)区间内的随机数。

eg：
import numpy as np
a = np.random.rand(3)#在[0,1)区间内的生成3个元素的一维数组
print(a)
运行结果：
[0.58961408 0.84257266 0.39352484]

import numpy as np
a = np.random.rand(2,3)#在[0,1)区间内的生成2行3列的二维数组
print(a)
运行结果：
[[0.78707828 0.20435021 0.1425843 ]
[0.27193029 0.54096423 0.0970038 ]]

b.randn（）函数

randn（）函数创建的数组中每一个元素都是符合标准正态分布的（均值为0，标准差为1）的随机数。

eg:
import numpy as np
a = np.random.randn(3)#生成一个有3个符合标准正态分布的一维数组
print(a)
运行结果：
[0.98816895 0.6358875 0.46980648]

import numpy as np
a = np.random.randn(3,3)#生成一个3行3列且元素符合标准正态分布的二维数组
print(a)
运行结果：
[[ 1.26679149 1.1567839 -1.05699411]
[-1.36220912 -0.76734058 0.47540726]
[ 0.63482082 -0.71100172 0.12748036]]

c.randint（）函数

randint（）函数创建的数组中的元素是指定范围内的随机证整数。

eg：
import numpy as np
a = np.random.randint(0,9,10)#生成一个[0,9)随机生成10个元素的一维数组
print(a)
运行结果：
[0 2 4 6 1 1 3 2 8 6]

import numpy as np
a = np.random.randint(0,9,(3,3))#生成一个[0,9)随机3行3列的二维数组
print(a)
运行结果：
[[5 4 0]
[1 4 7]
[1 8 0]]

2.查看数组的属性

数组的属性指的是数组的行列数、元素个数、元素的数据类型、数组的维数。

A.shape属性查看数组的行列数

数组的shape属性可查看数组的行数和列数，shape属性只获取的是一个元组，若只想查看数组的行数和列数，可以通过提取元组元素实现。

eg：
import numpy as np
arr = np.array([[1,2],[3,4],[5,6]])#生成一个3行3列的二维数组
print(arr.shape)#shape属性查看数组arr的行数和列数
运行结果：
(3, 2)

import numpy as np
arr = np.array([[1,2],[3,4],[5,6]])#生成一个3行3列的二维数组
print(arr.shape[0])#shape[0]表示查看数组arr的行数
print(arr.shape[1])#shape[1]表示查看数组arr的列数
运行结果：
3
2

B.size属性查看数组的元素个数

数组的size属性可以查看数组的大小，也就是元素个数。

eg：
import numpy as np
arr = np.array([[1,2],[3,4],[5,6]])#生成一个3行3列的二维数组
print(arr.size)#size属性查看数组arr大小
运行结果：
6

C.查看和转换数组元素的数据类型

数组的dtype属性可以查看数组元素的数据类型；
数组的astype（）函数可以转换数组元素的数据类型。

eg:
import numpy as np
arr = np.array([[1,2],[3,4],[5,6]])#生成一个3行3列的二维数组
print(arr.dtype)#dtype属性查看数组arr数据类型
运行结果：
int32

import numpy as np
arr = np.array([[1.1,2.2],[3.3,4.4],[5.5,6.6]])#生成一个3行3列的二维数组
arr1 = arr.astype(int)#使用astype()函数将float型转换成int型
print(arr1)
print(arr1.dtype)#查看数组arr1数据类型
运行结果：
[[1 2]
[3 4]
[5 6]]
int32

D.ndim属性查看数组的维数

数组的维数是指数组的几维数组。
可以直接调用ndim属性查看数组的维数。

eg:
import numpy as np
arr = np.array([[1.1,2.2],[3.3,4.4],[5.5,6.6]])#生成一个3行3列的二维数组
print(arr.ndim)#查看数组维数
运行结果：
2

3.选取数组元素

数组元素可以通过数组的索引值和切片功能来选取。

A.一维数组的元素选取

一维数组的结构比较简单，数组元素的选取也比较简单，既可以选取单个元素，也可以选取多个连续元素，还可以按照一点的规律选取多个不连续的元素。

a.选取单个元素

选取单个元素通过数组的索引值即可。

eg:
import numpy as np
arr = np.array([0,1,2,3,4,5,6,7,8,9,10])
print(arr[6])#正序索引，第一个元素索引值为0
print(arr[-5])#倒序索引，最后第一个元素索引值为-1
运行结果：
6
6

b.选取多个连续元素

选取多个连续元素可以通过切片功能来实现,给出起始位置和结束位置的索引值即可。

eg：
import numpy as np
arr = np.array([0,1,2,3,4,5,6,7,8,9,10])
print(arr[1:6])
print(arr[:-5])
运行结果：
[1 2 3 4 5]
[0 1 2 3 4 5]

c.选取多个不连续元素

选取多个不连续元素也是通过切片功能来实现。
[起始位置:结束位置:步长]

eg：
import numpy as np
arr = np.array([0,1,2,3,4,5,6,7,8,9,10])
print(arr[1:6:2])
print(arr[:-5:2])
运行结果：
[1 3 5]
[0 2 4]

B.二维数组的元素选取

与一维数组类似，也是基于索引值进行，但要用英文的【,】分隔行和列的索引值。

a.选取单个元素

选取单个元素，直接输入行和列的索引值即可。

eg：
import numpy as np
arr = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
print(arr[1,2])#行索引值为1（第2行），列索引值为2（第三列）的元素
运行结果：
5

b.选取单行或单列元素

选取单行或单列元素，直接输入这一行或这一列的索引位置即可。

eg：
import numpy as np
arr = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
print(arr[2])#输出行索引位置为2（第三行）的元素
print(arr[:,0])#输出列索引位置为0（第一列）的元素
运行结果：
[6 7 8]
[0 3 6 9]

c.选取某些行或某些列的元素

选取某些行或某些列的元素，输入这些行或列的索引值区间即可（遵循左闭右开的规则）。

eg:
import numpy as np
arr = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
print(arr[1:3])#输出第二行和第三行的元素
print(arr[:,:2])#输出第一列h和第二列的元素
运行结果：
[[3 4 5]
[6 7 8]]
[[ 0 1]
[ 3 4]
[ 6 7]
[ 9 10]]

d.同时选取行列元素

同时选取行列元素，同时给出要选取的行或列的索引值区间即可。

eg：
import numpy as np
arr = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
print(arr[0:2,0:2])#同时输出第一第二行和第一第二列的元素
运行结果：
[[0 1]
[3 4]]

4.数组的重塑和转置

数组的重塑即改变数组的形状（维度）；
数组的转置是一种特殊的重塑形式；
（此处的知识与线性代数互通）
注意：数组重塑时要，新数组形状要与原数组的形状兼容。

A.一维数组的重塑

Numpy模块中reshape（）函数可以在不改变数组内容和个数的情况下重塑数组的形状。

eg：
import numpy as np
arr = np.array([1,2,3,4,5,6,7,8])
a = arr.reshape(2,4)#将arr数组重塑为2行4列的二维数组
print(a)
运行结果：
[[1 2 3 4]
[5 6 7 8]]

B.多维数组的重塑

多维数组在维度不变时变换行列数
eg:
import numpy as np
arr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
a = arr.reshape(4,3)#将数组重塑为4行3列的二维数组
print(a)
运行结果：
[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]

多维数组转换成一维数组
通过flatten()或ravel()函数实现
eg：
import numpy as np
arr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
print(arr.flatten())#转换成一维数组
print(arr.ravel())#转换成一维数组
运行结果：
[ 1 2 3 4 5 6 7 8 9 10 11 12]
[ 1 2 3 4 5 6 7 8 9 10 11 12]

C.数组的转置

a.T属性

在需要转置的数组后调用T属性即可。

eg：
import numpy as np
arr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
print(arr)
print(arr.T)#调用T属性
运行结果：
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
[[ 1 5 9]
[ 2 6 10]
[ 3 7 11]
[ 4 8 12]]

b.transpose（）函数

transpose（）函数s是通过调换数组行和列的索引值来实现转置的。

eg：
import numpy as np
arr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
arr1 = np.transpose(arr)
print(arr1)
运行结果：
[[ 1 5 9]
[ 2 6 10]
[ 3 7 11]
[ 4 8 12]]

5.数组的处理

常见的处理包括在数组中添加、删除元素，处理数组中的缺失值和重复值，对数组进行拼和拆分等。

A.append（）函数添加数组元素

a.append（）函数

append（）函数可以在数组末尾添加元素。
基本语法：
append（arr,values,axis=None）

参数	说明
arr	必选，要添加元素的数组
values	必选，要添加的数组元素
axis	可选，axis=0，元素添加在数组的行方向上，行数改变，列数不变；axis=1，元素添加在数组的列方向上，列数改变，行数不变。

eg:
import numpy as np
arr = np.array([[1,2,3,4],[5,6,7,8]])
arr1 = np.append(arr,[[9,10,11,12]],axis=0)#将[9,10,11,12]添加在数组末尾
print(arr1)
运行结果：
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]

b.insert（）函数

insert（）函数用于在数组内指定位置插入元素。
基本语法：
insert（arr,obj,values,axis）

参数	说明
arr	必选，要添加元素的数组
obj	必选，数组的索引值，插入元素的位置
values	必选，要添加的数组元素
axis	可选，axis=0，元素添加在数组的行方向上，行数改变，列数不变；axis=1，元素添加在数组的列方向上，列数改变，行数不变。

eg:
import numpy as np
arr = np.array([[1,2],[3,4],[5,6]])
arr1 = np.insert(arr,1,[7,8],axis=0)#将[7,8]添加在数组第二行
print(arr1)
运行结果：
[[1 2]
[7 8]
[3 4]
[5 6]]

B.删除数组元素

使用delete（）函数即可删除数组元素。

eg:
import numpy as np
arr = np.array([[1,2],[3,4],[5,6]])
arr1 = np.delete(arr,1,axis=0)#将第二行元素删除
arr2 = np.delete(arr,1,axis=1)#将第二列元素删除
print(arr1)
print(arr2)
运行结果：
[[1 2]
[5 6]]
[[1]
[3]
[5]]

C.处理数组的缺失值

使用isnan（）函数可以标记数组中缺失值的位置并填充缺失值。

eg:
import numpy as np
arr = np.array([1,2,3,4,5,6,np.nan,8,9])#np.nan表示缺失值
print(np.isnan(arr))#缺失值填充为True
arr[np.isnan(arr)]=7#将缺失值填充为7
print(arr)
运行结果：
[False False False False False False True False False]
[1. 2. 3. 4. 5. 6. 7. 8. 9.]

D.处理数组的重复值

使用unique（）函数可以处理数组的重复值，该函数会去除数组中的重复元素，并将去重后的数组从小到大排列。

eg：
arr = np.array([1,1,1,0,0,0,2,2,2,4,4,4])
arr1 = np.unique(arr)#去重，从小到大排列
arr1,arr2 = np.unique(arr,return_counts=True)#重复值的重复次数
print(arr1)
print(arr2)
运行结果：
[0 1 2 4]
[3 3 3 3]

E.拼接数组

拼接数组可以通过concatenate（）函数、hstack（）函数和vstack（）函数实现，只有同维度数组可以合并，若为多维数组合并，形状（行列数）必须相同。

a.concatenate（）函数

concatenate（）函数可以一次合并多个数组是最常用的方法。
eg：
import numpy as np
arr1 = np.array([[0,1,2],[3,4,5]])
arr2 = np.array([[6,7,8],[9,10,11]])
arr3 = np.array([[12,13,14],[15,16,17]])
arr4 = np.concatenate((arr1, arr2, arr3),axis=0)#列方向拼接
arr5 = np.concatenate((arr1, arr2, arr3),axis=1)#行方向拼接
print(arr4)
print(arr5)
运行结果：
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]
[12 13 14]
[15 16 17]]
[[ 0 1 2 6 7 8 12 13 14]
[ 3 4 5 9 10 11 15 16 17]]

b.hstack（）函数

hstack（）函数可以水平堆叠拼接数组。

eg：
import numpy as np
arr1 = np.array([[0,1,2],[3,4,5]])
arr2 = np.array([[6,7,8],[9,10,11]])
arr3 = np.array([[12,13,14],[15,16,17]])
arr4 = np.hstack((arr1, arr2, arr3))#水平堆叠拼接数组
print(arr4)
运行结果：
[[ 0 1 2 6 7 8 12 13 14]
[ 3 4 5 9 10 11 15 16 17]]

c.vstack（）函数

vstack（）函数可以垂直堆叠拼接数组。

eg：
import numpy as np
arr1 = np.array([[0,1,2],[3,4,5]])
arr2 = np.array([[6,7,8],[9,10,11]])
arr3 = np.array([[12,13,14],[15,16,17]])
arr4 = np.vstack((arr1, arr2, arr3))#垂直堆叠拼接数组
print(arr4)
运行结果：
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]
[12 13 14]
[15 16 17]]

F.拆分数组

拆分数组即将一个数组分割成多个数组。可以通过split（）函数、hsplit（）函数、vsplit（）函数实现。

a.split（）函数

split（）函数可将一个数组均匀分割成多个数组。

eg：
import numpy as np
arr = np.array([0,1,2,3,4,5,6,7,8,9])
arr1 = np.split(arr,2)#均匀割成2个数组
arr2 = np.split(arr,5)#均匀割成5个数组
print(arr1)
print(arr2)
运行结果：
[array([0, 1, 2, 3, 4]), array([5, 6, 7, 8, 9])]
[array([0, 1]), array([2, 3]), array([4, 5]), array([6, 7]), array([8, 9])]

此外，split（）函数还可以按照指定索引位置来拆分数组。
eg：
import numpy as np
arr = np.array([0,1,2,3,4,5,6,7,8,9])
arr1 = np.split(arr,[2,4])#拆分索引值为2的位置、拆分索引值为4的位置
print(arr1)
运行结果：
[array([0, 1]), array([2, 3]), array([4, 5, 6, 7, 8, 9])]

b.hsplit（）函数和vsplit（）函数

同理，（hstack（）函数和vstack（）函数）
hsplit（）函数横向拆分成多个数组；
vsplit（）函数纵向横向拆分成多个数组。

6.数组的运算

A.数组的四则运算

数组的四则运算：即是加减乘除，将对应位置元素进行四则运算即可。

eg：
import numpy as np
arr1 = np.array([[0,1,2],[3,4,5]])
arr2 = np.array([[6,7,8],[9,10,11]])
arr3 = arr1+arr2#加法运算
arr4 = arr1*arr2#乘法运算
print(arr3)
print(arr4)
运行结果：
[[ 6 8 10]
[12 14 16]]
[[ 0 7 16]
[27 40 55]]

B.数组元素之间的统计运算

a.sum（）函数求和

sum（）函数可以对整组元素求和也可以对数组的每一行或每一列求和。
eg：
import numpy as np
arr = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
arr1 = arr.sum()#对每个元素求和
arr2 = arr.sum(axis=0)#对每一行求和
arr3 = arr.sum(axis=1)#对每一列求和
print(arr1)
print(arr2)
print(arr3)
运行结果：
66
[18 22 26]
[ 3 12 21 30]

b.mean（）函数求平均值

mean（）函数可以对整组元素求平均值也可以对数组的每一行或每一列求
平均值。

eg:
import numpy as np
arr = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
arr1 = arr.mean()#对每个元素求平均数
arr2 = arr.mean(axis=0)#对每一行求平均数
arr3 = arr.mean(axis=1)#对每一列求平均数
print(arr1)
print(arr2)
print(arr3)
运行结果：
5.5
[4.5 5.5 6.5]
[ 1. 4. 7. 10.]

c.max（）函数和min（）函数求最值

max（）函数求最大值；
min（）函数求最小值。

eg：
import numpy as np
arr = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
arr1 = arr.max()#求所有元素最大值
arr2 = arr.max(axis=0)#求每一行最大值
arr3 = arr.max(axis=1)#求每一列最大值
print(arr1)
print(arr2)
print(arr3)
运行结果：
11
[ 9 10 11]
[ 2 5 8 11]

小结

这一篇我们还是讲python的一个基础部分，为后续学习打下基础。

此系列文，仅记录鄙人python学习路程的一个片段，参考价值可能不大，写的不好请多多谅解，欢迎大佬们评论留言，指正鄙人的不足之处。（感激不尽！！！）

最后，

生活于生活之上，便知晓百花和万物沉默的思想。不管怎样，记得好好吃饭。