Numpy 使用 （使用jupyter学习）

创建数组

import numpy as np

创建一维数组

one_array=np.array([1,2,3,4])

one_array

array([1, 2, 3, 4])

创建二维数组（矩阵）

two_array=np.array([[1,2,3],[4,5,6]])
two_array

array([[1, 2, 3],
       [4, 5, 6]])

创建全0数组

zeros_array=np.zeros(shape=(5,3)) #dtype default is float
zeros_array

array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])

创建全1数组

ones_array=np.ones(shape=(5,3)) 
ones_array

array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

创建有连续序列的数组arange

arange_array=np.arange(0,10,3)  # 0-10的数据 步长为 3
arange_array

array([0, 3, 6, 9])

创建有连续间隔的数组（线性等分向量）

1. 也可以称为线性等分向量（linear space）
2. 计算公式
   $$\text{间隔大小}=\frac{\text{结束值}-\text{开始值}}{\text{数据点数量}-1}$$
3. 示例：np.linspace(1,10,5)
   $$\text{间隔大小}=\frac{10-1}{5-1}=\frac{9}{4}=2.25$$

linspace_array = np.linspace(1,10,5) # 开始端1 ，结束端10 且分割成20个数据，生成线段
linspace_array

array([ 1.  ,  3.25,  5.5 ,  7.75, 10.  ])

创建随机数组

random_array = np.random.rand(3,4)  # 创建一个3x4的随机数组
random_array

array([[0.7262943 , 0.7271133 , 0.5237984 , 0.03820645],
       [0.49013218, 0.23940966, 0.02700341, 0.69228529],
       [0.71300896, 0.33444564, 0.83529101, 0.22492859]])

int type 创建

int_random_array = (np.random.rand(3,4)*10).astype(int) # 创建一个3x4的随机 整数 数组
int_random_array

array([[8, 8, 6, 6],
       [7, 2, 2, 9],
       [0, 7, 4, 1]])

使用Numpy库创建一个4x5（4行5列）的随机整数数组 其中每个元素的值在2-5之间

numpy_random_array = np.random.randint(2,5,size=(4,5))
numpy_random_array

array([[2, 3, 3, 3, 3],
       [2, 4, 3, 2, 4],
       [3, 4, 3, 2, 4],
       [2, 4, 2, 2, 4]])

改变数组的的形状(例如：2x3改成3x2)

shape_array1 = [1,2,3,4,5]
shape_array2 = [1,2,3,4,5]
shape_array3 = np.array([shape_array1,shape_array2])
print(f"数组改变之前：{shape_array3.shape}")
print(shape_array3)
shape_array3 = shape_array3.reshape((5,2))
print(f"数组改变之后：{shape_array3.shape}")
print(shape_array3)

数组改变之前：(2, 5)
[[1 2 3 4 5]
 [1 2 3 4 5]]
数组改变之后：(5, 2)
[[1 2]
 [3 4]
 [5 1]
 [2 3]
 [4 5]]

数组转置 (将一个二维数组中的行和列进行互换)|

array = [[1,2,3],[4,5,6],[7,8,9]]
array = np.array(array)
print(f"转置之前：\n{array}")
print(f"转置之后：\n{array.T}")

转置之前：
[[1 2 3]
 [4 5 6]
 [7 8 9]]
转置之后：
[[1 4 7]
 [2 5 8]
 [3 6 9]]

数组显示操作

数组维度 ndim (ndim属性代表数组维度 可查询指定数组为几维)

one_array = np.array([1,2,3])
two_array = np.array([[1,2,3],[4,5,6]])
three_array = np.array([[[1,2,3],[4,5,6],[7,8,9]]])
print(f"一维数组：{one_array.ndim}")
print(f"二维数组：{two_array.ndim}")
print(f"三维数组：{three_array.ndim}")

一维数组：1
二维数组：2
三维数组：3

数组形状 shape (shape属性代表数组形状，描述了数组在各个维度上的大小,可以这么理解shape是各个方向的维度(ndim))

shape属性是一个非常重要的属性，它描述了数组在各个维度上的大小。具体来说，shape属性返回一个元组（tuple），其中的每个元素对应数组在该维度上的大小。

​
例如，一个三维数组可能具有形状(x, y, z)，其中x是第一个维度的大小，y是第二个维度的大小，而z是第三个维度的大小 。

这里有一些关于shape属性的 要 点：

对于一个一维数组，shape是一个单元素元组，只包含该
维 度的大小。
对于一个二维数组，shape通常包含两个元素，分别代
表 行数和列数。
shape的长度（即元组中的元素数量）实际上就是数组的维数（ndim）。

one_array = np.array([1,2,3])
two_array = np.array([[1,2,3],[4,5,6]])
three_array = np.array([[[1,2,3],[4,5,6],[7,8,9]]])
print(f"一维数组：{one_array.shape}")
print(f"二维数组：{two_array.shape}")
print(f"三维数组：{three_array.shape}")

一维数组：(3,)
二维数组：(2, 3)
三维数组：(1, 3, 3)

数组中的元素个数（size）

array = np.array([1,2,3])
array1 = np.array([[1,2,3],[4,5,6]])
array2 = np.array([[[1,2,3],[4,5,6]],[[1,2,3],[4,5,6]]])
array.size,array1.size,array2.size

(3, 6, 12)

数组的数据类型（dtype）

整数类型：

int8: 8位有符号整数（-128至127）
int16: 16位有符号整数（-32768至32767）
int32: 32位有符号整数（-2^31至2^31-1）
int64: 64位有符号整数（-2^63至2^63-1）
uint8: 8位无符号整数（0至255）
uint16: 16位无符号整数（0至65535）
uint32: 32位无符号整数（0至2^32-1）
uint64: 64位无符号整数（0至2^64-1）

浮点类型：

float16: 16位半精度浮点数
float32: 32位单精度浮点数
float64: 64位双精度浮点数（默认）
float96: 96位扩展精度浮点数（非标准）
float128: 128位扩展精度浮点数（非标准）

复数类型：

complex64: 由两个32位浮点数表示的复数
complex128: 由两个64位浮点数表示的复数（默认）
complex192: 由两个96位浮点数表示的复数（非标准）
complex256: 由两个128位浮点数表示的复数（非标准）

布尔类型：

bool: 布尔类型，存储True或False

字符串类型：

str: 字符串类型，用于文本数据
字符串数组的 dtype 取决于数组中字符串的最大长度，`U` 表示 Unicode 字符串类型，后面的数字表示字符的最大长度。

对象类型：

object: Python对象类型，可以存储任意Python对象

日期和时间类型：

datetime64: 日期和时间类型，可以存储纳秒精度的时间戳
这里的 < 表示数据是按照小端字节序存储的，M8 表示数据类型是时间戳，而 [D] 表示时间单位是“天”。所以，'<M8[D]' 完全正确地表示了一个按天为单位的时间戳数据类型。

其他类型：

void: 专用于空类型或特殊用途的数据类型其他类型型

array = np.array([1,2,3])
array1 = np.array([1.6,2.8,3.14])
array2 = np.array(['张三','lisi','wang二']) # 字符串数组的 dtype 取决于数组中字符串的最大长度，`U` 表示 Unicode 字符串类型，后面的数字表示字符的最大长度。
array3 = np.array([True,False])
array4 = np.array(['2024-11-04'],dtype="datetime64")
array.dtype,array1.dtype,array2.dtype,array3.dtype,array4.dtype

(dtype('int32'),
 dtype('float64'),
 dtype('<U5'),
 dtype('bool'),
 dtype('<M8[D]'))

数组的运算

数组加法

array = np.array([1,2,3])
array1 = np.array([1,2,3])
array+array1

array([2, 4, 6])

数组乘法

array = np.array([1,2,3])
array1 = np.array([1,2,3])
array*array1

array([1, 4, 9])

数组除法

array = np.array([1,2,3])
array1 = np.array([1,2,3])
array/array1

array([1., 1., 1.])

数组中的数据统计

计算数组的平均值(mean)

array = np.array([10,22,31])
np.mean(array)

21.0

计算数组的中位数

array = np.array([25,22,31])
np.median(array)

25.0

计算数组的标准差

函数：numpy.std(arr, axis=None, dtype=None, out=None, ddof=0)
参数：
arr：输入数组。
axis：计算标准差的轴。默认为 None，计算所有元素的标准差；如果指定轴，则在该轴上计算标准差。
dtype：返回值的数据类型。
out：输出数组。
ddof：Delta Degrees of Freedom，默认为 0。如果设置为 1，则计算样本标准差而不是总体标准差。

计算数组的方差

函数：numpy.var(arr, axis=None, dtype=None, out=None, ddof=0)
参数：
arr：输入数组。
axis：计算方差的轴。
dtype：返回值的数据类型。
out：输出数组。
ddof：Delta Degrees of Freedom，默认为 0。如果设置为 1，则计算样本方差。

计算数组的最小值

函数：numpy.min(arr, axis=None, out=None)
参数：
arr：输入数组。
axis：计算最小值的轴。
out：输出数组。

计算数组的最大值

函数：numpy.max(arr, axis=None, out=None)
参数：
arr：输入数组。
axis：计算最大值的轴。
out：输出数组。

计算数组的元素之和

函数：numpy.sum(arr, axis=None, dtype=None, out=None)
参数：
arr：输入数组。
axis：计算和的轴。
dtype：返回值的数据类型。
out：输出数组。

计算数组的元素乘积

函数：numpy.prod(arr, axis=None, dtype=None, out=None)
参数：
arr：输入数组。
axis：计算乘积的轴。
dtype：返回值的数据类型。
out：输出数组。

计算数组的累积和

函数：numpy.cumsum(arr, axis=None, dtype=None, out=None)
参数：
arr：输入数组。
axis：计算累积和的轴。
dtype：返回值的数据类型。
out：输出数组。295

数组的索引和切片

一维数组切片

arr = np.array([1,2,3,4,5,6]) # 切片操作是左闭右开的，即包括起始位置，但不包括结束位置
arr[1:4],arr[2:5]

(array([2, 3, 4]), array([3, 4, 5]))

多维数组切片

arr1 = [1,2,3,4,5]
arr2 = [6,7,8,9,10]
arr3 = [11,12,13,14,15]
arr4 = [16,17,18,19,20]
arr5 = [21,22,23,24,25]
arr6 = [26,27,28,29,30]
arr = np.array([[arr1,arr2,arr3],[arr4,arr5,arr6]])
arr.shape # 首先创建一个 shape为（2，3，5）的数组

(2, 3, 5)

行切片

arr[0:1] # 先取第一维数据

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

arr[0:1,0:2] # 先取第一维数据,然后在取二维数组的前两行

array([[[ 1,  2,  3,  4,  5],
        [ 6,  7,  8,  9, 10]]])

列切片

arr[:,] # 只取 列 忽略行

#在 NumPy 中，arr[:,] 通常用于索引多维数组（例如二维数组或矩阵）的所有行和所有列。这里的 : 符号是一个切片操作符，它表示选择数组的全部元素。下面是对 arr[:,] 操作的解释：
# arr 是一个多维数组。
# : 在第一个位置（行索引）表示选择所有行。
# : 在第二个位置（列索引）表示选择所有列。

array([[[ 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]]])

arr[:,:,0:3] # 数组的前三列
# 在 NumPy 中，arr[:,:,0:3] 用于索引一个三维数组（或更高维度的数组）的一部分。这里每个冒号 : 和切片操作符 0:3 有特定的含义：
# 第一个 : 表示选择所有第一个维度（通常是行）的元素。
# 第二个 : 表示选择所有第二个维度（通常是列）的元素。
# 0:3 是一个切片操作，表示从第三个维度的开始（索引为 0）到索引 3（不包括索引 3）的所有元素。
# 不管列切片或行切片，一维一维的去进行拆分，进行切片

array([[[ 1,  2,  3],
        [ 6,  7,  8],
        [11, 12, 13]],

       [[16, 17, 18],
        [21, 22, 23],
        [26, 27, 28]]])

数组堆叠

垂直堆叠

arr1 = [1,2,3]
arr2 = [4,5,6]
np.vstack((arr1,arr2)),np.vstack((arr2,arr2))

(array([[1, 2, 3],
        [4, 5, 6]]),
 array([[4, 5, 6],
        [4, 5, 6]]))

水平堆叠

np.hstack((arr1,arr2)),np.hstack((arr2,arr2))

(array([1, 2, 3, 4, 5, 6]), array([4, 5, 6, 4, 5, 6]))

保存和加载数组

保存数组到文件

arr = [1,2,3,'test']
np.save('array_file.npy',arr)

从文件加载数组

np.load('array_file.npy')

['1' '2' '3' 'test']