NumPy - 简介

NumPy 是一个 Python 包。 它代表 “Numeric Python”。 它是一个由多维数组对象和用于处理数组的例程集合组成的库。

NumPy 操作

使用NumPy，开发人员可以执行以下操作：

    数组的算数和逻辑运算。

    傅立叶变换和用于图形操作的例程。

    与线性代数有关的操作。 NumPy 拥有线性代数和随机数生成的内置函数。

NumPy的一些主要特点

多维数组对象：NumPy的核心数据结构是ndarray，它是一个多维数组，用于存储同质数据类型的元素。这些数组可以是一维、二维、三维等，非常适用于向量化操作和矩阵运算。

广播功能：NumPy允许在不同形状的数组之间执行操作，通过广播功能，它可以自动调整数组的形状，以使操作变得有效。

丰富的数学函数：NumPy提供了大量的数学、统计和线性代数函数，包括基本的加减乘除、三角函数、指数和对数函数、随机数生成、矩阵操作等。

索引和切片：NumPy允许使用索引和切片操作来访问和修改数组中的元素，这使得数据的选择和处理非常灵活。

高性能计算：NumPy的底层实现是用C语言编写的，因此它在处理大规模数据时非常高效。此外，NumPy还与其他高性能计算库（如BLAS和LAPACK）集成，提供了快速的线性代数运算。

互操作性：NumPy可以与许多其他Python库和数据格式（例如Pandas、SciPy、Matplotlib）无缝集成，这使得数据科学工作流更加流畅。

NumPy 使用

创建数组

1.1创建一维数组   

import numpy as np
data=np.array([1,2,3,4])
print(data)

1.2创建创建二维数组（矩阵）array

import numpy as np
data=np.array([[1,2,3,4],[4,5,6,7]])
print(data)

1.3创建全0 数组

  shape属性代表形状 shape（2，5） 就代表创建2行5列的全零数组

import numpy as np
#shape代表形状，比如我这里创建的就是5行三列的2维数组
data=np.ones(shape=(5,3))
print(data)

1.4创建全1数组

创建全1数组的用途是初始化一个具有特定形状和大小的数组，其中所有元素都设置为1。在处理一些数学问题或算法时，全1数组可以用作初始值或占位符。

例如，假设我们要计算一个矩阵与自身的转置相乘的结果，我们可以创建一个与输入矩阵相同维度的全1数组，然后将输入矩阵读入该数组进行填充。这样做的好处是，我们可以直接将原始矩阵数据存储在全1数组中，而无需担心数据溢出或其他问题。

import numpy as np
#shape代表形状，比如我这里创建的就是5行三列的2维数组
data=np.ones(shape=(5,3))
print(data)

1.5创建全空数组

创建出来的全空数组中的数据都是无限小的、无限接近于0但不是0，这方便我们数学上的一些操作

import numpy as np
#shape代表维度，比如我这里创建的就是5行三列的2维数组
data=np.empty(shape=(5,3))
print(data)

1.6 创建有连续序列的数组 arange

数组从10开始步长为2，所以创建出来数组元素就是10，12，14

import numpy as np
data = np.arange(10,16,2) # 10-16的数据，步长为2
print(data)

1.7 创建有连续间隔的数组 linspace 

         也可以称为线性等分向量（linear space），在一个指定区间内按照指定的步长，将区间均等分，生成的是一个线段类型的数组。生成的线性间隔数据中，是有把区间的两端加进去的

import numpy as np
# 创建线段型数据
data= np.linspace(1,10,20) # 开始端1，结束端10，且分割成20个数据，生成线段
print(data)

输出：

[ 1.          1.47368421  1.94736842  2.42105263  2.89473684  3.36842105
  3.84210526  4.31578947  4.78947368  5.26315789  5.73684211  6.21052632
  6.68421053  7.15789474  7.63157895  8.10526316  8.57894737  9.05263158
  9.52631579 10.        ]

 1.8创建随机数组

       创建随机数组的用途是初始化一个具有特定形状和大小的数组，其中所有元素都是随机生成的。在处理一些需要模拟随机数据的情况时，随机数组可以用作占位符或测试数据。

import numpy as np
data = np.random.rand(3,4)
print(data)

这段代码使用NumPy库创建了一个4行5列的随机整数数组，其中每个元素的值在2到5之间

import numpy as np
data=np.random.randint(2,5,size=(4,5));
print(data)

输出：

[[2 3 2 3 3]
 [2 2 3 4 3]
 [2 2 2 3 2]
 [3 3 2 3 4]]

1.9改变数组形状

              这个怎么理解呢，比如说你本来有一个2行3列的数组，你可以把它改成为3行2列的数组

注意：因为数组中元素是没有改变的，所以重塑数组指定的尺寸大小是否和原本的尺寸大小一样，大一点和小一点都会报错，2行3列的数组，你可以把它改成为3行2列的数组 ，或者1行6列，改后尺寸必须一样，reshape本质就是原本数组中的元素按顺序展开来，然后依次填入新定义的尺寸中去.注意 reshape后面填的是元组数据类型

import numpy as np
data1=[1,2,3,4,5]
data2=[1,2,3,4,5]
data=np.array([data1,data2])
print("改之前的数组形状为:")
print(data.shape)
data=data.reshape((5,2))
print("改之后的数组形状为:")
print(data.shape)

输出：

改之前的数组形状为:
(2, 5)
改之后的数组形状为:
(5, 2)

1.10数组转置

import numpy as np
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
data_array = np.array(data)
print("没有转置数组之前数组为：")
print(data)
print("转置数组之后数组为：")
print(data_array.T)

输出：

没有转置数组之前数组为：
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
转置数组之后数组为：
[[1 4 7]
 [2 5 8]
 [3 6 9]]

数组显示操作 

2.1数组维度 ndim

   ndim属性代表数组维度

      data = np.array([1, 2, 3])
        print(data.ndim)

输出 ：1

2.2数组形状shape

  shape属性代表数组形状，可以这么理解shape是各个方向的维度(ndim)

print(data.shape)

 输出：(3,)

2.3数组中元素个数

print(data.size)

  2.4 数组的数据类型 dtype

print(data.dtype)

2.1----2.4

outPut:

1
(3,)
3
int32

数组的运算

数组加法

import numpy as np
array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])
result = array1 + array2
print(result)

outPut:

[5 7 9]

数组乘法

result=array1*array2
print(result)

outPut:

[ 4 10 18]

数组中的数据统计

计算数组的平均值

numpy.mean(arr, axis=None, dtype=None, out=None): 计算数组的平均值。参数axis表示沿着哪个轴进行计算，默认为None，表示计算整个数组的平均值；dtype表示返回结果的数据类型，默认为float64；out表示将结果存储在指定的数组中,一般情况下，传个数组进去就可以了，其他的用默认

import numpy as np
data=[1,5,6,9]
mindle=np.mean(data)
print(mindle)

OutPut:

5.25

注意：输出的是一个 float:

计算数组的中位数

numpy.median(arr, axis=None, out=None): 计算数组的中位数。参数axis和out的含义与numpy.mean()相同

import numpy as np
data=[1,5,6,9]
data1=np.median(data)
print(data1)

outPut:

5.5

注意：输出的是一个 float:

计算数组的标准差

numpy.std(arr, axis=None, dtype=None, out=None): 计算数组的标准差。参数axis、dtype和out的含义与numpy.mean()相同。

计算数组的方差

numpy.var(arr, axis=None, dtype=None, out=None): 计算数组的方差。参数axis、dtype和out的含义与numpy.mean()相同。

 计算数组的最小值

numpy.min(arr, axis=None, out=None): 计算数组的最小值。参数axis和out的含义与numpy.mean()相同。

 计算数组的最大值

numpy.max(arr, axis=None, out=None): 计算数组的最大值。参数axis和out的含义与numpy.mean()相同

计算数组的元素之和

numpy.sum(arr, axis=None, dtype=None, out=None): 计算数组的元素之和。参数axis、dtype和out的含义与numpy.mean()相同。

计算数组的元素乘积

numpy.prod(arr, axis=None, dtype=None, out=None): 计算数组的元素乘积。参数axis、dtype和out的含义与numpy.mean()相同

计算数组的累积和

numpy.cumsum(arr, axis=None, dtype=None, out=None): 计算数组的累积和。参数axis、dtype和out的含义与numpy.mean()相同。

数组的索引和切片

一维数组切片

    对于一维数组来说，它类似于一条直线，其上的坐标位置用一个数字就可以表示。例如，对于一个长度为5的一维数组arr = [1, 2, 3, 4, 5]，我们可以用数字0到4来表示它的每一个位置。当我们使用切片操作时，就可以通过指定起始位置和结束位置来获取数组中的一部分元素。例如，如果我们想要获取从索引1到索引3的元素，可以使用切片操作arr[1:4]，结果为[2, 3, 4]。需要注意的是，切片操作是左闭右开的，即包括起始位置，但不包括结束位置 (index :0---xx)

import numpy as np
arr = np.array([1,2,3,4,5])
print(arr[1:4]) 
print(arr[0:4])

OutPut:

[2 3 4]

[1 2 3 4]

多维数组切片

      多维数组单纯讲不太好讲，我多举几个例子吧

import numpy as np
data1=[1,2,3,4,5]
data2=[6,7,8,9,10]
data3=[11,12,13,14,15]
data4=[16,17,18,19,20]
data5=[21,22,23,24,25]
data6=[26,27,28,29,30]
data=np.array([[data1,data2,data3],[data4,data5,data6]])

print(data.shape)
print(data)

我先创建了一个3维数组，其形状shape=(2,3,5)运行效果图如下

(2, 3, 5)
[[[ 1  2  3  4  5]
  [ 6  7  8  9 10]
  [11 12 13 14 15]]

 [[16 17 18 19 20]
  [21 22 23 24 25]
  [26 27 28 29 30]]]

 行切片 

           假设我们现在只想取前面两行，那我们应该怎么做呢？

          思路：我们先取第一维数据

print(data[0:1])

[[[ 1  2  3  4  5]
  [ 6  7  8  9 10]
  [11 12 13 14 15]]]

 

现在它现在是不是就被分解成一个2维数组，我们再对这个2维数组进行操作，要想取这个2维数组前面两行，代码是啥呢？是不是就是data[0:2],那我们结合第一步的代码，应该怎么做呢？

print(data[0:1,0:2])

OutPut:

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

这样是不是就取到最前面两行了

  其实就是进行分解操作就行，一维一维的进行分解，那我们再来看看列切片吧

列切片

    还是以这个数组进行列切片操作

print(data[:,])

运行效果图：

[[[ 1  2  3  4  5]
  [ 6  7  8  9 10]
  [11 12 13 14 15]]

 [[16 17 18 19 20]
  [21 22 23 24 25]
  [26 27 28 29 30]]]

可能这个操作小伙伴有些就看不懂了，啥意思呢，还是一句话，一维一维的进行分解，因为我们要取的是列，所有全部的行我们就应该都算进去，换句话来说，忽略行的影响 代码就是data[:,]

再来取第2维

    代码还是data[:]结合起来就是

print(data[:,:])

 

[[[ 1  2  3  4  5]
  [ 6  7  8  9 10]
  [11 12 13 14 15]]

 [[16 17 18 19 20]
  [21 22 23 24 25]
  [26 27 28 29 30]]]

 

我们再来取最后一维

print(data[:,:,0:2])

 运行效果 ：

[[[ 1  2]
  [ 6  7]
  [11 12]]

 [[16 17]
  [21 22]
  [26 27]]]

至此，列取片也完成

总结：不管是列取片，还是行取片，你都去一维一维的去进行拆分，一维一维的去切片就好了 

 

数组堆叠

垂直堆叠

# 垂直堆叠
stacked_vertically = np.vstack((array1, array2))

水平堆叠

# 水平堆叠
stacked_horizontally = np.hstack((array1, array2))

保存和加载数组

保存数组到文件

# 保存数组到文件
np.save('my_array.npy', data)

加载数组

# 加载数组
loaded_data = np.load('my_array.npy')

样例测试：

numpy[:, :3]

numpy[:, :3] 的含义是选择 NumPy 数组的所有行和前三列的数据。

# 创建一个示例的 NumPy 数组
arr = np.array([[1, 2, 3, 4, 5],
                [6, 7, 8, 9, 10],
                [11, 12, 13, 14, 15]])

# 选择所有行和前三列的数据
subset = arr[:, :3]

print(subset)

outPut:

[[ 1  2  3]
 [ 6  7  8]
 [11 12 13]]

解析这个语法：

• numpy：这是一个代表 NumPy 数组的变量名，通常在代码中被赋予。你需要用实际的变量名替换 numpy。
• [:, :3]：这是一个切片语法，用于指定要获取的元素范围。这里的逗号,分隔两个部分，第一个部分:表示选择所有的行，第二个部分:3表示选择从第 0 列到第 3 列（但不包括第 3 列）的所有列。