NumPy学习

基础：

概念：

全称是“ Numeric Python”，Python 的第三方扩展包，主要用来计算、处理一维或多维数组

优点：

便捷高效地处理大量数据

ndarray 对象可以用来构建多维数组

能够执行傅立叶变换与重塑多维数组形状

提供了线性代数，以及随机数生成的内置函数

与python列表区别：

NumPy 数组是同质数据类型（homogeneous），即数组中的所有元素必须是相同的数据类型。数据类型在创建数组时指定，并且数组中的所有元素都必须是该类型。

Python 列表是异质数据类型（heterogeneous），即列表中的元素可以是不同的数据类型。列表可以包含整数、浮点数、字符串、对象等各种类型的数据。

安装：

pip install numpy==1.26.0 -i https://pypi.tuna.tsinghua.edu.cn/simple/

ndarray：

NumPy 定义了一个 n 维数组对象，简称 ndarray 对象

array创建对象：

内置函数 array() 可以创建 ndarray 对象

语法：

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

object： 表示一个数组序列

dtype：可选参数，通过它可以更改数组的数据类型

copy：可选参数，表示数组能否被复制，默认是 True

order：以哪种内存布局创建数组，有 3 个可选值，分别是 C(行序列)/F(列序列)/A(默认)

ndmin：用于指定数组的维度

示例：

import numpy as np

# 创建一个一维数组
dimensionalArray = np.array([1,2,3,4])

# 创建一个二维数组
dimensionalArray = np.array([[1,2,3,4],[5,6,7,8]])

指定/查看数组维度：

示例：

import numpy as np

threeArray = np.array([1,2,3,4],ndmin=2)
print("ndim 查看维度：",threeArray.ndim)

reshape数组变维：

reshape() 函数允许你在不改变数组数据的情况下，改变数组的维度。 返回的是一个新的数组，原数组的形状不会被修改。

示例：

import numpy as np

# 数组变维
oneArray = np.array([1,2,3,4,5,6])
oneArray = oneArray.reshape((3,2))

数据类型：

数据类型对象：

可以在创建数组时指定 dtype 参数来定义数组中元素的数据类型。

示例：

import numpy as np

# 创建一个 int32 类型的数组
arr_int = np.array([1, 2, 3], dtype=np.int32)
print(arr_int.dtype)  # 输出: int32

# 创建一个 float64 类型的数组
arr_float = np.array([1, 2, 3], dtype=np.float64)
print(arr_float.dtype)  # 输出: float64

可以使用数组的 dtype 属性来获取数组中元素的数据类型。

示例：

arr = np.array([1, 2, 3])
print(arr.dtype)  # 输出: int32

可以使用 astype() 方法来转换数组中元素的数据类型。

示例：

arr = np.array([1, 2, 3])
arr_float = arr.astype(np.float64)
print(arr_float.dtype)  # 输出: float64

数据类型标识码：

NumPy 中每种数据类型都有一个唯一标识的字符码，int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替

自定义一个int32的数据类型

示例：

dt=np.dtype('i4')
data = np.array([1,2,3,4],dtype=dt)
print(data)   #输出：[1 2 3 4]
print(data.dtype)	#输出：int32

数组属性：

shape：

返回一个元组，元组中的每个元素表示数组在对应维度上的大小。元组的长度等于数组的维度数。

示例：

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

ndim：

返回的是数组的维数

itemsize：

返回数组中每个元素的大小（以字节为单位），即每个元素占用的字节数

示例：

array_one = np.array([[1,2,3],[4,5,6]],dtype=np.int8)
print('array_one 数组中每个元素的大小：',array_one.itemsize)	#输出：1
array_one = np.array([[1,2,3],[4,5,6]],dtype=np.int16)
print('array_one 数组中每个元素的大小：',array_one.itemsize)	#输出：2

flags：

返回 ndarray 数组的内存信息

示例：

array_one = np.array([[1,2,3],[4,5,6]])
print('array_one 数数组的内存信息：\n',array_one.flags)

#C_CONTIGUOUS : True
#F_CONTIGUOUS : False
#OWNDATA : True
#WRITEABLE : True
#ALIGNED : True
#WRITEBACKIFCOPY : False

创建数组的其他方法：

empty():

创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组（数组元素为随机值）

语法：

numpy.empty(shape, dtype = float, order = 'C')

shape：数组的形状，可以是整数或整数元组

dtype：数组的数据类型，默认为 float

order：数组的内存布局，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序

zeros()：

创建指定大小的数组，数组元素以 0 来填充

语法：

numpy.zeros(shape, dtype = float, order = 'C')

 shape：数组形状

dtype：数据类型

order：'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组

ones()：

创建指定形状的数组，数组元素以 1 来填充

语法：

numpy.ones(shape, dtype = None, order = 'C')

arange()：

创建一个等差数列的数组

语法：

numpy.arange(start, stop, step, dtype)

 start：起始值，默认为 0

stop：终止值（不包含）

step：步长，默认为 1

dtype：返回 ndarray 的数据类型，如果没有提供，则会使用输入数据的类型

linspace：

在指定的数值区间内，返回均匀间隔的一维等差数组，默认均分 50 份

语法：

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

num：表示数值区间内要生成多少个均匀的样本，默认值为 50

endpoint：默认为 True，表示数列包含 stop 终止值，反之不包含

retstep：表示是否返回步长。如果为 True，则返回一个包含数组和步长的元组；如果为 False，则只返回数组。默认为 False。

full()：

full()用于创建一个填充指定值的数组。

语法：

numpy.full(shape, fill_value, dtype=None, order='C')

fill_value：填充的值

full_like():用于创建一个与给定数组形状和数据类型相同的数组，并用指定的值填充。

语法：

full_like():用于创建一个与给定数组形状和数据类型相同的数组，并用指定的值填充。

a：输入的数组，新数组的形状和数据类型将与 a 相同

切片：

ndarray 对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样；

高级索引：

 相比于基本索引，高级索引可以访问到数组中的任意元素，并且可以用来对数组进行复杂的操作和修改。

整数数组索引：

返回的新数组是一个副本，修改它不会影响原数组。

示例：

#取出 4 * 3 数组四个角的数据
import numpy as np

def two():
    array_one = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
    print('原数组：\n',array_one)
    array_one = array_one[[0,0,-1,-1], [0,-1,0,-1]]
    print('这个数组的四个角元素是：')
    print(array_one)

布尔索引：

布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。

示例：

import numpy as np

# 创建一个二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 使用布尔索引筛选大于 5 的元素
bool_idx = arr > 5
print(bool_idx)
# 输出:
# [[False False False]
#  [False False  True]
#  [ True  True  True]]

# 使用布尔索引获取满足条件的元素
result = arr[bool_idx]
print(result)  # 输出: [6 7 8 9]

 通过广播原理取到索引值：

示例：

import numpy as np
a = np.arange(1,13).reshape(3,4)
print(a[[[2],[1]],[0,1,2]])

"""
[[ 9 10 11]
 [ 5  6  7]]
"""

广播（*）：

广播规则 ：

维度匹配：如果两个数组的维度数不同，维度数较少的数组会在前面补上长度为 1 的维度。

示例：

# 示例 1：维度匹配
a = np.array([[1, 2, 3], [4, 5, 6]])  # 形状: (2, 3)
b = np.array([10, 20, 30])            # 形状: (3,)
c = a + b
print(c)
# 输出:
# [[11 22 33]
#  [14 25 36]]

形状匹配：如果两个数组在某个维度上的长度不同，但其中一个数组在该维度上的长度为 1，则该数组会沿着该维度进行广播。

# 示例 2：形状匹配
# 1.d是2维数组，e是一维数组，e自动广播为2为数组：[[10 20 30] [10 20 30]]，形状为(2,3)
# 2.d和e在行维度上都为2，d在列维度上是一维，自动广播为：[[1 1 1] [2 2 2]]，形状为(2,3)
d = np.array([[1], [2]])  # 形状: (2, 1)
e = np.array([10, 20, 30])  # 形状: (3,)
f = d + e
print(f)
# 输出:
# [[11 21 31]
#  [12 22 32]]

遍历数组：

遍历数组的第一维度：

示例：

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])
for i in arr:
    print(i)

nditer逐个访问元素：

order 参数用于指定数组的遍历顺序 ，C 风格（行优先），Fortran 风格（列优先）

flags 参数 指定迭代器的额外行为，multi_index: 返回每个元素的多维索引，external_loop: 返回一维数组而不是单个元素，减少函数调用的次数，从而提高性能

op_flags 参数 用于指定操作数的行为。 readonly: 只读操作数，readwrite: 读写操作数，writeonly: 只写操作数。

数组操作：

数组变维：

flat：

返回一个一维迭代器，用于遍历数组中的所有元素。 无论数组的维度如何，ndarray.flat属性都会将数组视为一个扁平化的一维数组，按行优先的顺序遍历所有元素。

示例：

import numpy as np

def flat_test():
    array_one = np.arange(4).reshape(2,2)
    print("原数组元素：")
    for i in array_one:
        print(i,end=" ")
    print()
    print("使用flat属性，遍历数组：")
    for i in array_one.flat:
        print(i,end=" ")

flatten()：

将多维数组转换为一维数组。 一个拷贝，进行修改不会影响原数组。

示例：

import numpy as np

# 创建一个二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])

# 使用 flatten 方法按行优先顺序展开
flat_arr = arr.flatten(order='C')

print(flat_arr)
# 输出:
# [1 2 3 4 5 6]

ravel()：

ravel() 返回的是原数组的一个视图（view），而不是副本。因此，对返回的数组进行修改会影响原数组。

示例：

import numpy as np

# 创建一个二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])

# 使用 ravel 方法按行优先顺序展开
ravel_arr = arr.ravel()

print(ravel_arr)
# 输出:
# [1 2 3 4 5 6]

ravel_arr[-1] = 7
print(arr)
# 输出:
# [[1 2 3]
#  [4 5 7]]

数组转置：

transpose：将数组的维度值进行对换，比如二维数组维度(2,4)使用该方法后为(4,2)

ndarray.T 与 transpose 方法相同

修改数组维度：

多维数组（也称为 ndarray）的维度（或轴）是从外向内编号的。这意味着最外层的维度是轴0，然后是轴1，依此类推。

expand_dims(arr, axis)：arr：输入数组 axis：新轴插入的位置

squeeze(arr, axis)：arr：输入数的组 axis：取值为整数或整数元组，用于指定需要删除的维度所在轴，指定的维度值必须为 1 ，否则将会报错，若为 None，则删除数组维度中所有为 1 的项

示例：

import numpy as np

# 创建一个一维数组
a = np.array([1, 2, 3])
print(a.shape)  # 输出: (3,)

# 在第 0 维插入新维度
b = np.expand_dims(a, axis=0)
print(b)
# 输出:
# [[1 2 3]]
print(b.shape)  # 输出: (1, 3)

# 在第 1 维插入新维度
c = np.expand_dims(a, axis=1)
print(c)
# 输出:
# [[1]
#  [2]
#  [3]]
print(c.shape)  # 输出: (3, 1)

连接数组：

hstack(tup)：按水平顺序堆叠序列中数组（列方向）

vstack(tup)：按垂直方向堆叠序列中数组（行方向）

tup：可以是元组，列表，或者numpy数组，返回结果为numpy的数组

示例：

import numpy as np

# 创建两个形状不同的数组，行数一致
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5], [6]])
print(arr1.shape) 	# (2, 2)
print(arr2.shape)	# (2, 1)

# 使用 hstack 水平堆叠数组
result = np.hstack((arr1, arr2))
print(result)
# 输出：
# [[1 2 5]
#  [3 4 6]]

hstack函数要求堆叠的数组在垂直方向（行）上具有相同的形状。如果行数不一致，hstack() 将无法执行，并会抛出 ValueError 异常。

vstack() 要求堆叠的数组在水平方向（列）上具有相同的形状。如果列数不一致，将无法执行堆叠操作。

vstack() 和 hstack() 要求堆叠的数组在某些维度上具有相同的形状。如果维度不一致，将无法执行堆叠操作。

分割数组：

hsplit(ary, indices_or_sections)：将一个数组水平分割为多个子数组（按列）

vsplit(ary, indices_or_sections)：将一个数组垂直分割为多个子数组（按行）

ary：原数组 indices_or_sections：按行分割的索引位置

示例：

import numpy as np

'''
    hsplit 函数：
        1、将一个数组水平分割为多个子数组（按列）
        2、ary：原数组
        3、indices_or_sections：按列分割的索引位置
'''
# 创建一个二维数组
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

# 使用 np.hsplit 将数组分割成三个子数组
# 分割点在索引1和3处，这意味着：
# 第一个子数组将包含从第0列到索引1（不包括索引1）的列，即第0列。
# 第二个子数组将包含从索引1（包括索引1）到索引3（不包括索引3）的列，即第1列到第2列。
# 第三个子数组将包含从索引3（包括索引3）到末尾的列，即第3列。
result = np.hsplit(arr, [1, 3])

# 查看结果
print("第一个子数组:\n", result[0])  # 输出包含第0列的子数组
print("第二个子数组:\n", result[1])  # 输出包含第1列和第2列的子数组
print("第三个子数组:\n", result[2])  # 输出包含第3列的子数组

矩阵运算：

np.dot

是一个通用的点积函数，适用于多种维度的数组。

对于二维数组（矩阵），np.dot 等价于矩阵乘法。

示例：

import numpy as np

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

result = np.dot(a, b)
print(result)

对于一维数组（向量），np.dot 计算的是向量的点积（内积）。

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

result = np.dot(a, b)
print(result)

np.matmul ：

用于矩阵乘法的函数，适用于二维及更高维度的数组。

示例：

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])​
result = np.matmul(a, b)
print(result)

np.dot是通用点积函数，np.matmul专门用于矩阵运算，性能要好于np.dot

np.linalg.det ：

计算一个方阵（行数和列数相等的矩阵）的行列式。

示例：

a = np.array([[1, 2], [3, 4]],dtype=int)
# 计算行列式
det_a = np.linalg.det(a)
print(det_a)

#输出：
-2.0000000000000004

数组元素的增删改查:

resize:

语法：

np.resize(a, new_shape)

返回指定形状的新数组

示例：

import numpy as np
a = np.array([1,2,3,4,5])
#np.resize改变数组形状后元素不够，重写遍历原数组元素进行填充
#np.reshipe要求改变形状后要求与原数组元素数量相同
b = np.resize(a,(3,3))
print(b)

"""
[[1 2 3]
 [4 5 1]
 [2 3 4]]
"""

append:

语法：

np.append(arr, values, axis=None)

在数组的末尾添加值，返回一个一维数组

示例：

import numpy as np
a = np.array([[1,2,3],[4,5,6]])
#axis为None时，返回的是一维数组
b = np.append(a,[7,8,9])
#axis为0时，按行添加到数组尾部，添加的列数要与原数组一致，添加的值维度必须与原数组的维度保持一致，否则抛异常
c = np.append(a,[[7,8,9]],axis=0)
#axis为1时，按列添加到数组尾部，添加的行数要与原数组一致
d = np.append(a,[[1,1,1],[2,2,2]],axis=1)
print(b)
print(c)
print(d)

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

insert:

语法：

np.insert(arr, obj, values, axis)

沿规定的轴将元素值插入到指定的元素前  

示例：

a = np.array([[1,2,3],[5,6,7]])
#insert在原数组指定的索引前面插入元素，axis为None返回一维数组，0按行插入，1按列插入
b = np.insert(a,3,[4])
c = np.insert(a,1,[4],axis=0)
d = np.insert(a,3,[4,8],axis=1)
print(b)
print(c)
print(d)

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

delete:

语法：

np.delete(arr, obj, axis)

删掉某个轴上的子数组，并返回删除后的新数组

示例：

import numpy as np
#np.delete按照指定索引删除原数组的元素，axis为None则返回一维数组，0按行删除，1按列删除
a = np.array([[1,2,3],[4,5,6]])
b = np.delete(a,5)
c = np.delete(a,1,axis=0)
d = np.delete(a,1,axis=1)
print(b)
print(c)
print(d)

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

argwhere:

示例：

a = np.array([[0,2,3],[4,5,6]])
#np.argwhere默认返回数组中非零元素的下标，也可以使用布尔索引获取满足条件的下标
b = np.argwhere(a)
c = np.argwhere(a>4)
print(b)
print(c)

"""
[[0 1]
 [0 2]
 [1 0]
 [1 1]
 [1 2]]
[[1 1]
 [1 2]]
"""

unique:

示例：

a = np.array([1,2,2,3,3,3,4,4,4,4])
#unique数组去重，return_index为True返回新数组元素在原数组中的索引位置
#return_inverse为True返回原数组元素在新数组中的索引位置，可以用来倒退原数组
#return_counts为True返回元素在数组出现的次数
unique_el,ind,inind,count = np.unique(a, return_index=True, return_inverse=True,  return_counts=True)
print(unique_el)
print(ind)
print(inind)
print(count)

"""
[1 2 3 4]
[0 1 3 6]
[0 1 1 2 2 2 3 3 3 3]
[1 2 3 4]
"""

统计函数：

amin() 和 amax()：

示例：

import numpy as np
#amax求数组的最大值，amin求数组的最小值，axis为None则求整个数组的最值，axis为0求垂直方向的最值，axis为1求水平方向的最值
a = np.array([[1,2,3],[4,5,6]])
print(np.amax(a,axis=0))
print(np.amin(a,axis=1))
print(np.amax(a))

"""
[4 5 6]
[1 4]
6
"""

ptp():

示例：

a = np.array([[1,2,3],[4,5,6]])
#ptp相当于amax-amin，axis=1 表示沿着水平方向，axis=0 表示沿着垂直方向
print(np.ptp(a))
print(np.ptp(a,axis=0))
print(np.ptp(a,axis=1))

"""
5
[3 3 3]
[2 2]
"""

median():

示例：

a = np.array([[1,2,3],[4,5,6]])
#median求数组中位数，如果个数为偶数，则中位数为最中间的两个数的平均数，奇数则是最中间的那个数
print(np.median(a))
print(np.median(a,axis=0))
print(np.median(a,axis=1))

"""
3.5
[2.5 3.5 4.5]
[2. 5.]
"""

mean()：

沿指定的轴，计算数组中元素的算术平均值（即元素之总和除以元素数量）

示例：

a = np.array([[1,2,3],[4,5,6]])
print(np.mean(a))
print(np.mean(a,axis=0))
print(np.mean(a,axis=1))

"""
3.5
[2.5 3.5 4.5]
[2. 5.]
"""

average()：

示例：

a = np.array([1,2,3,4])
weights = np.array([0.1,0.2,0.3,0.4])
#np.average计算数组的加权平均值，所有元素值乘以对应权重之和除以所有权重之和
print(np.average(a,weights=weights))

"""
3.0
"""

var():

示例：

a = np.array([1,2,3,4,5])
#var计算数组的方差，ddof默认使用总体方差，为1时为样本方差
print(np.var(a))
print(np.var(a,ddof=1))

"""
2.0
2.5
"""

std()：

标准差用来描述一组数据平均值的分散程度。若一组数据的标准差较大，说明大部分的数值和其平均值之间差异较大；若标准差较小，则代表这组数值比较接近平均值

示例：

a = np.array([1,2,3,4,5])
#std计算标准方差 也就是方差的算术平方根
print(np.std(a))

"""
1.4142135623730951
"""