numpy基本知识

NumPy概述

NumPy(Numerical Python)是Python语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库，主要用于数组计算。
NumPy通常与SciPy (Scientific Python）和Matplotlib （绘图库）一起使用，这种组合广泛用于替代MatLab，是一个强大的科学计算环境，有助于我们通过Python学习数据科学或者机器学习。
NumPy安装:在cmd终端输入pipinstall numpy。在使用Numpy之前，通过import命令将numpy库导入，并命名为np，例如: import numpy as np。

import numpy as np

1. 多维数组（np.array）

NumPy Ndarray对象:NumPy最重要的一个特点是其N维数组对象ndarray，它是一系列同类型数据的集合，以0下标为开始进行集合中元素的索引。

1.1创建Ndarray对象

numpy.array(object, dtype=None, copy=True，order=None，subok=False, ndmin=0)

名称	描述
object	数组或嵌套的数列
dtype	数组元素的数据类型，可选
copy	对象是否需要复制，可选
order	创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok	默认返回一个与基本类型一致的数组
ndmin	指定生成数组的最小维度

案例一

a1 = np.array([1,2,3,4])
a2 = np.array([[1,2],[3,4]])
print("一维数组，\n",a1)
print("二维数组，\n",a2)

输出：

一维数组，
 [1 2 3 4]
二维数组，
 [[1 2]
 [3 4]]

创建数组时，我们可以通过dtype属性指定数组元素的数据类型。例如:创建一个一维数组，数组的元素都是float类型。
arr = np.array([1，2，3], dtype=np.float64)
我们还可以使用ndarray的astype方法显示的转换其数据类型，例如:arr_int = arr.astype (np.int64)
最后，通过dtype属性可以获取数组元素的数据类型，例如:arr_int.dtype。常见数据类型如下。

类型	类型代码	说明
int8、uint8	i1、u1	有符号和无符号的8位（1个字节）整型
int16、uint16	i2、u2	有符号和无符号的16位（2个字节）整型
int32、uint32	i4、u4	有符号和无符号的32位（4个字节）整型
int64、uint64	i8、u8	有符号和无符号的64位（8个字节）整型
float16	f2	半精度浮点数
float32	f4或f	标准的单精度浮点数，与C的float兼容
float64	f8或d	标准的双精度浮点数，与C的double和Python的float对象兼容
float128	f16或g	扩展精度浮点数

1.2 由列表创建数组

（1）一维数组
可以首先定义一个列表，然后再通过 np.array() 函数进行数据类型转换定义一维数组。

案例二

# 创建列表
data=[1,2,3,4,5,6]
# 转换为一维数组
a=np.array(data)
print(a)

输出：

[1 2 3 4 5 6]

（2）二维数组
首先定义一个嵌套列表元素的列表，然后再通过 np.array() 函数进行数据类型转换定义二维数组。

案例三

# 创建嵌套序列
data=[[1,2,3,4],[5,6,7,8]]
# 转换为二维数组
b=np.array(data)
print(b)

输出：

[[1 2 3 4]
 [5 6 7 8]]

1.3 由函数创建数组

利用 numpy 提供的函数方便的创建一些特定的数组，具体内容如下：

函数	含义
np.zeros()	创建指定维度全 0 多维数组。
np.ones()	创建指定维度全 1 多维数组。
np.eye()	创建指定维度的单位矩阵。
np.arange()	创建指定数量的顺序数组（默认 0 开始）。
linspace()	创建指定范围的一维数组，并分成若干等分 。
reshape()	更改数组的维度。

案例四

(1) np.zeros() 创建指定维度全 0 多维数组。

# 一维数组
a1=np.zeros(3)
print(a1)
print("********************")

# 二维数组
a2=np.zeros((2,3))
print(a2)
print("********************")

# 三维数组
a3=np.zeros((2,3,4))
print(a3)

输出：

[0. 0. 0.]
********************
[[0. 0. 0.]
 [0. 0. 0.]]
********************
[[[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]

 [[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]]

(2) np.ones() 创建指定维度全 1 多维数组。

# 一维数组
b1=np.ones(3)
print(b1)
print("********************")
# 二维数组
b2=np.ones((2,3))
print(b2)
print("********************")
# 三维数组
b3=np.ones((2,2,3))
print(b3)

输出：

[1. 1. 1.]
********************
[[1. 1. 1.]
 [1. 1. 1.]]
********************
[[[1. 1. 1.]
  [1. 1. 1.]]

 [[1. 1. 1.]
  [1. 1. 1.]]]

(3) np.eye() 创建指定维度的单位矩阵（二维数组）。

numpy.eye(M,N=None,k=0,dtype=<class ‘float’>,order='C)
返回一个二维数组(N,M)，对角线的地方为1，其余为0.

参数介绍：

-	-
M	int型，表示的是输出的行数
N	int型，可选项，输出的列数，如果没有就默认为M
k	int型，可选项，对角线的下标，默认为0表示的是主对角线，负数表示的是低对角，正数表示的是高对角。
dtype	数据的类型，可选项，返回数据的数据类型
order：{‘C’，‘F’}	可选项，输出的数组的形式是按照C语言的行优先’C’，还是按照Fortran形式的列优先‘F’存储在内存中

c1=np.eye(1)
print(c1)
print("********************")
c2=np.eye(2)
print(c2)
print("********************")
c3=np.eye(3)
print(c3)
print("********************")
c4=np.eye(3,4)
print(c4)
print("********************")
c5=np.eye(4,4,2)
print(c5)
print("********************")
c6=np.eye(4,4,-1)
print(c6)

输出：

[[1.]]
********************
[[1. 0.]
 [0. 1.]]
********************
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
 ********************
 [[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]]
 ********************
 [[0. 0. 1. 0.]
 [0. 0. 0. 1.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
********************
[[0. 0. 0. 0.]
 [1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]]

(4) np.arange() 创建指定数量的顺序数组（默认 0 开始）。

# 一维数组，数字从0开始，到数字2结束，步长为1
d1=np.arange(3)
print(d1)
print("********************")

# 一维数组，数字从1开始，到数字9结束，步长为2
d2=np.arange(1,10,2)
print(d2)

输出：

[0 1 2]
********************
[1 3 5 7 9]

(5) np.linspace() 创建指定范围的一维数组，并分成若干等分 。

# 将0至3之间划分为10等份
e1=np.linspace(0,3,10)
print(e1)

输出：

[0.         0.33333333 0.66666667 1.         1.33333333 1.66666667
 2.         2.33333333 2.66666667 3.        ]

(6) np.reshape() 更改数组的维度。

# 将一维数组转换为二维数组
f1=np.array([1,2,3,4])
print(f1)
print("********************")
f2=f1.reshape(2,2)
print(f2)

输出：

[1 2 3 4]
********************
[[1 2]
 [3 4]]

2. 数组的运算

2.1 数组和标量之间的运算

标量表示实数。数组与标量的运算，表示标量和数组的每一个元素进行运算。例如实数加上一个数组，表示实数和数组里面的每一个元素相加。

案例五

# 创建二维数组
arr=np.array([[1,2,3],[4,5,6]])
print(arr+2)
print("********************")
print(arr-2)
print("********************")
print(arr*2)
print("********************")
print(arr/2)

输出：

[[3 4 5]
 [6 7 8]]
********************
[[-1  0  1]
 [ 2  3  4]]
********************
[[ 2  4  6]
 [ 8 10 12]]
********************
[[0.5 1.  1.5]
 [2.  2.5 3. ]]

2.2 同维度数组之间的运算

两个同维度数组之间的运算表示两个数组中对应的元素之间进行运算。例如两个数组相加，表示两个数组对应的元素两两相加。

案例六

arr1=np.array([[1,2,3],[4,5,6]])
arr2=np.array([[2,2,2],[2,2,2]])
print(arr1+arr2)
print("********************")
print(arr1-arr2)
print("********************")
print(arr1*arr2)
print("********************")
print(arr1/arr2)

输出：

[[3 4 5]
 [6 7 8]]
********************
[[-1  0  1]
 [ 2  3  4]]
********************
[[ 2  4  6]
 [ 8 10 12]]
********************
[[0.5 1.  1.5]
 [2.  2.5 3. ]]

矩阵是数组的一个特例，它只能是二维的数据结构。而数组可以是多维的。首先通过 np.mat() 函数将二维数组转换为矩阵，然后通过 * ，可以实现矩阵的乘法。

案例七

obj1=np.array([[1,0],
               [0,1]])
obj2=np.array([[1,2],
               [2,3]])
mat1=np.mat(obj1)
mat2=np.mat(obj2)
print(mat1*mat2)

输出：

[[1 2]
 [2 3]]

2.3 不同维度数组之间的运算

不同维度的数组进行运算时，数组具有广播特性，即自动将维度进行扩展。
例如一个 3x3 的二维数组和一个 1x3 的一维数组进行减法，1x3 的一维数组会进行广播，将维度扩展为 3x3 。

案例八

a=np.array([[1,2,3],
            [1,2,3],
            [1,2,3]])
b=np.array([1,2,3])
print(a-b)
print("********************")
print(a+b)

输出：

[[0 0 0]
 [0 0 0]
 [0 0 0]]
********************
[[2 4 6]
 [2 4 6]
 [2 4 6]]

2.4 轴

在 numpy 中可以理解为方向，使用 0,1,2… 数字表示，对于一个一维数组，只有一个 0 轴，对于二维数组 (shape(2,2))，有 0 轴和 1 轴，对于三维数 (shape(2,2,3))，有 0，1，2 轴。

二维数据的轴

三维数据的轴

3. 数组的索引

含有 n 个元素数组的索引为 0，1，···，n-1。

3.1 一维数组索引

案例九

arr=np.arange(10)
print(arr)
print("********************")
# 索引第6个元素
print(arr[5])
print("********************")
# 选择第 6 到第 8 个元素作为数组
print(arr[5:8])
print("********************")
# 将数组的全部元素改为 3
arr[:]=3
print(arr)

输出：

[0 1 2 3 4 5 6 7 8 9]
********************
5
********************
[5 6 7]
********************
[3 3 3 3 3 3 3 3 3 3]

3.2 二维数组索引

案例十

arr=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(arr)
print("********************")
# 索引二维数组的第 2 行
print(arr[1])
print("********************")
# 索引二维数组的 1 行 3 列元素
print(arr[0][2])
print("********************")
# 选择二维数组的第 1 行和第 2 行(不含第 3 行)
print(arr[:2])
print("********************")
# 选择二维数组第 2 列
print(arr[:,1])

输出：

[[1 2 3]
 [4 5 6]
 [7 8 9]]
********************
[4 5 6]
********************
3
********************
[[1 2 3]
 [4 5 6]]
********************
[2 5 8]

3.3 布尔索引

案例十一

arr=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(arr<5)
print("********************")
arr[arr<5]=0
print(arr)

输出：

[[ True  True  True]
 [ True False False]
 [False False False]]
********************
[[0 0 0]
 [0 5 6]
 [7 8 9]]

3.4 三元运算符

三元运算符 np.where(表达式，数1，数2)，当表达式为真，结果为数 1，否则结果为数 2。

案例十二

arr=np.array([[1,2,3],[4,5,6],[7,8,9]])
np.where(arr<5,0,10)

输出：

array([[ 0,  0,  0],
       [ 0, 10, 10],
       [10, 10, 10]])

4. 函数

4.1 通用函数

通用函数是一种对 array 中的数据执行元素级运算的函数。可以将其看做简单函数的矢量化包装器。一元函数有下面这些：

函数	说明
abs、fabs	计算整数、浮点数或复数的绝对值，对于非复数值，可以使用更快的fabs
sqrt	计算各元素的平方根。相当于 arr**0.5
square	计算各元素的平方。相当于 arr**2
exp	计算各元素的指数 e**x
log、log10、log2、log1p	分别为自然对数（底数为e）、底数为 10的log、底数为 2的log、log(1+x)）
sign	计算各元素的正负号：1（正数）、0（零）、-1（负数）
cell	计算各元素的 celling值，即大于等于该值的最小整数
floor	计算各元素的 floor值，即小于等于该值的最大整数

案例十三

arr1=np.array([[1,2,3],[-1,-2,-3]])
arr2=np.array([1,2,4])
arr3=np.array([0,3,-4])
arr4=np.array([1.3,0,-4.2])
# 绝对值
a=np.fabs(arr1)
print(a)
print("********************")
# 平方根
b=np.sqrt(arr2)
print(b)
print("********************")
# 平方
c=np.square(arr1)
print(c)
print("********************")
# 指数
d=np.exp(arr1)
print(d)
print("********************")
# 对数
e=np.log(arr2)
print(e)
print("********************")
# 正负
f=np.sign(arr3)
print(f)
print("********************")
# 大于等于最小整数
g=np.ceil(arr4)
print(g)
print("********************")
# 小于等于最大整数
h=np.floor(arr4)
print(h)

输出：

[[1. 2. 3.]
 [1. 2. 3.]]
********************
[1.         1.41421356 2.        ]
********************
[[1 4 9]
 [1 4 9]]
********************
[[ 2.71828183  7.3890561  20.08553692]
 [ 0.36787944  0.13533528  0.04978707]]
********************
[0.         0.69314718 1.38629436]
********************
[ 0  1 -1]
********************
[ 2.  0. -4.]
********************
[ 1.  0. -5.]

二元函数有如下这些：

函数	说明
add	将数组中对应的元素相加
subtract	从第一个数组中减去第二个数组中的元素
multiply	数组元素相乘
divide、floor_divide	除法或向下圆整除法（丢弃余数）
power	对第一个数组中的元素A，根据第二个数组中的相应元素B，计算A**B
maximum、fmax	元素级的最大值计算、fmax将忽略NaN
minimum、fmin	元素级的最小值计算、fmin将忽略NaN
mod	元素级的求模计算（除法的余数）
copysign	将第二个数组中的值的符号复制给第一个数组中的值

4.2 数学统计方法

4.2.1 均值 mean

mean 表示求数组的平均值。

案例十四

arr=np.random.randn(2,3)
print(arr)
print("********************")

# 统计二维数组所有元素的均值
# print(arr.mean())
print(np.mean(arr))
print("********************")

# 统计每行的均值，返回列表
print(arr.mean(axis=1))
print("********************")

# 统计每列的均值，返回列表
print(arr.mean(axis=0))

输出：

[[-1.21450927 -1.05943347 -1.57280241]
 [-0.33900153  0.58684712  0.44653087]]
********************
-0.5253947808426508
********************
[-1.28224838  0.23145882]
********************
[-0.7767554  -0.23629317 -0.56313577]

4.2.2 sum方法

sum 表示计算数组元素的和。

案例十五

arr=np.array([[0,2,1],[3,5,6],[0,1,1]])
# 统计二维数组所有元素的和
print(arr.sum())
print("********************")

# 统计每列的和，返回列表
print(arr.sum(axis=0))
print("********************")

# 统计每行的和，返回列表
print(arr.sum(axis=1))

输出：

19
********************
[3 8 8]
********************
[ 3 14  2]

4.2.3 最大值与最小值

min 和 max 表示数组元素的最小值和最大值。

案例十六

arr=np.array([[1,5,3],[4,2,6]])
# 无参，所有中的最小(大）值
print(arr.min())
# print(arr.max())
print("********************")

# axis=0，每列的最小(大）值
print(arr.min(axis=0))
# print(arr.max(axis=0))
print("********************")

# axis=1，每行的最小(大）值
print(arr.min(axis=1))
# print(arr.max(axis=1))

输出：

1
********************
[1 2 3]
********************
[1 2]

4.3 排序（sort）

sort 表示对数组元素进行排序。

案例十七

arr=np.array([[1,5,3],[4,2,6]])
# 二维数组按行排列
print(np.sort(arr,axis=1))
print("********************")
# 二维数组按列排序
print(np.sort(arr,axis=0))

输出：

[[1 3 5]
 [2 4 6]]
********************
[[1 2 3]
 [4 5 6]]

4.4 唯一化（unique）

NumPy 提供了一些针对一维 ndarray 的基本集合运算。最常见的可能要数 np.unique了，它用于找出数组中的唯一值并返回已排好序的结果。

案例十八

names=np.array([3,3,3,2,2,1,1,4,4])
# 找出 names 数组中的唯一值并返回已排序的结果
a=np.unique(names)
print(a)

输出：

[1 2 3 4]

4.5 生成随机函数（uniform）

函数	说明
rand(d0,d1,…,dn)	根据 d0-dn 创建随机数数组，浮点数，[0,1)，均匀分布	np.random.rand(3,4)
randn(d0,d1,…,dn)	根据d0-dn 创建随机数数组，标准正态分布	np.random.randn(3,4)
randint(low,high,shape)	根据 shape 创建随机整数或整数数组，范围是[low.high]	np.random.randint(100,200,(3,4))
uniform(low,high,size)	产生具有均匀分布的数组，low 起始值，high结束值，size形状	np.random.uniform(0,10,(3,4))
normal(loc,scale,size)	产生具有正态分布的数组，loc均值，scale标准差，size形状	np.random.normal(10,5,(3,4))
poisson(lam,size)	产生具有泊松分布的数组，lam随机事件发生率，size形状	np.random.poisson(3,(3,4))

补充：

（1）均匀分布：在相同的大小范围内的出现概率是等可能的。
（2）正态分布：呈钟型，两头底，中间高，左右对称。

4.6 数组拼接

数组拼接包括 np.vstack() 和 np.hstack()，其中 vstack 表示竖拼接，hstack 表示行拼接。

案例十九

a=np.array([[1,2,3],[4,5,6]])
b=np.array([[7,8,9],[10,11,12]])
# 竖拼接
a1=np.vstack((a,b))
print(a1)
print("********************")
# 行拼接
b1=np.hstack((a,b))
print(b1)

输出：

[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
********************
[[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]

（完。）