Numpy
Numpy
〇、介绍
NumPy（Numerical Python，数值python）是Python数据分析必不可少的第三方库。NumPy本身是由C语言开发，摆脱了python语言的GIL（Global Interpreter Lock，全局解释器锁)。
GIL是Python解释器（尤其是CPython实现）中的一个机制，用于同步线程的执行，确保同一时刻只有一个线程可以执行Python字节码。防止多线程并发执行时出现资源竞争问题。即使在多核CPU上，Python的多线程程序也无法实现真正的并行执行（因为GIL会强制串行化线程）。
所以为了规避GIL，将计算密集型代码用C/C++编写（通过
ctypes或Cython调用），释放GIL。
NumPy重在数值计算，主要用于多维数组（矩阵）处理的库。Python中的array，虽然也是能存储相同类型的数据，存放在连续空间内，但是只能存储一维数据。
NumPy用来存储和处理大型矩阵，比Python自身的嵌套列表结构要高效的多（python自身的列表可以存储多种数据类型，数据分散存放，但是它是以两次索引为代价。列表中存储的是数据地址，再次索引才能找到数据。时间换连续空间）。
一、ndarray
numpy使用ndarray对象处理多维数组。ndarray中元素类型相同，内存空间连续。
# 导入numpy模块
import numpy as np
# 创建ndarray数组
score = np.array(
[1,2,3,4] # 一维数组
)
ndarray属性
| 属性名字 | 属性解释 |
|---|---|
| ndarray.shape | 数组维度的元组 |
| ndarray.ndim | 数组维数（也称秩） |
| ndarray.size | 对象中的全部元素数量 |
| ndarray.itemsize | 一个数组元素的长度（字节） |
| ndarray.nbytes | 对象中所有元素占的长度（字节） |
| ndarray.dtype | 数组元素的类型 |
| ndarray.T | 转置该对象，相当于numpy.transpose(ndarray) |
ndarray类型
| 名称 | 描述 | 简写 |
|---|---|---|
| np.bool | 用一个字节存储的布尔类型（True或False） | 'b' |
| np.int8 | 一个字节大小，-128 至 127 | 'i' |
| np.int16 | 整数，-32768 至 32767 | 'i2' |
| np.int32 | 整数，-2^31 至 2^32 -1 | 'i4' |
| np.int64 （整数默认） |
整数，-2^63 至 2^63 - 1 | 'i8' |
| np.uint8 | 无符号整数，0 至 255 | 'u' |
| np.uint16 | 无符号整数，0 至 65535 | 'u2' |
| np.uint32 | 无符号整数，0 至 2^32 - 1 | 'u4' |
| np.uint64 | 无符号整数，0 至 2^64 - 1 | 'u8' |
| np.float16 | 半精度浮点数：16位，正负号1位，指数5位，精度10位 | 'f2' |
| np.float32 | 单精度浮点数：32位，正负号1位，指数8位，精度23位 | 'f4' |
| np.float64 浮点数默认 |
双精度浮点数：64位，正负号1位，指数11位，精度52位 | 'f8' |
| np.complex64 | 复数，分别用两个32位浮点数表示实部和虚部 | 'c8' |
| np.complex128 | 复数，分别用两个64位浮点数表示实部和虚部 | 'c16' |
| np.object_ | python对象 | 'O' |
| np.string_ | 字符串 | 'S' |
| np.unicode_ | unicode类型 | 'U' |
二、ndarray基本操作
生成数组的方法 np.函数()
访问ndarray数组内元素
# 现有ndarray数组a,二维数组，形状(2,4),访问二行三列元素
a[1,2]
1、生成0，1, 空数组
① zeros()
np.zeros(shape, dtype=float, order='C', *, like=None)
"""
shape(必填)：int或tuple,数组的形状（如 5 或 (2,3)）
dtype：元素数据类型，默认是float64
👆（重要）👆
order：{'C', 'F'},'C'内存布局。C风格（行优先）或 Fortran风格（列优先）
like：array-like None参考对象（用于兼容其他数组库，如CuPy）
"""
# 生成0数组
np.zeros(shape=(3,4),dtype="float32") #元组指定ndarray数组形状
np.zeros(shape=[3,4],dtype="float32") #列表指定ndarray数组形状
numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)
"""
a, # (必填) 输入数组，新数组将继承其形状和数据类型
dtype=None, # (可选) 覆盖原数组的数据类型。如设为int，则返回整数零数组
👆（重要）👆
order='K', # (可选) 内存布局：'C'-行优先，'F'-列优先，'A'-保留输入布局，'K'-匹配输入布局(默认)
subok=True, # (可选) 若True保留输入数组的子类类型（如matrix），False强制转为ndarray
shape=None # (可选) NumPy 1.20+新增，可覆盖输入数组的形状
"""
②ones()
numpy.ones(shape, dtype=None, order='C', *, like=None)
"""
shape, # (必填) int或tuple，定义数组形状。如：3 → [1,1,1], (2,3) → [[1,1,1],[1,1,1]]
dtype=None, # (可选) 数据类型，默认float64。支持：'float32', 'int8', 'bool'等
👆（重要）👆
order='C', # (可选) 内存布局：'C'-行优先(默认)，'F'-列优先
*, # 分隔符
like=None # (可选) 兼容其他数组库（如CuPy/TensorFlow）
"""
# 生成1数组
np.ones(shape=(3,4),dtype="float32")
np.ones_like(a, dtype="")
numpy.ones_like(a, dtype=None, order='K', subok=True, shape=None)
"""
a, # (必填) 参考数组，新数组继承其形状和dtype
dtype=None, # (可选) 覆盖原数据类型。如原为int可改为'float64'
👆（重要）👆
order='K', # (可选) 内存布局：'C'/行优先，'F'/列优先，'K'/匹配输入(默认)，'A'/保留输入
subok=True, # (可选) True保留子类类型（如matrix），False强制转为ndarray
shape=None # (可选) NumPy 1.20+支持，覆盖原形状
"""
③empty()
创建一个内容随机并且依赖于内存状态的数组
numpy.empty(shape, dtype=float, order='C', *, like=None)
"""
shape, # (必填) int或tuple，定义数组形状。如：3 → 含3个未初始化值的一维数组
dtype=float, # (可选) 数据类型，默认float64。支持：'int8', 'float32', 'bool'等
👆（重要）👆
order='C', # (可选) 内存布局：'C'-行优先(默认)，'F'-列优先
*, # 分隔符
like=None # (可选) 兼容其他数组库（需实现__array_function__协议）
"""
④ndarray.fill()
直接修改原数组，而不是创建一个新的数组。
ndarray.fill(value)
"""
value:(标量值): 要填充到数组中的值。这个值可以是：
Python 标量（如整数、浮点数、布尔值等）
会自动转换为数组的 dtype（数据类型）
如果值无法转换为数组的数据类型，会引发 TypeError
"""
import numpy as np
array1 = np.empty((3,4),float)
array1.fill(10) # array([[10., 10., 10., 10.],
# [10., 10., 10., 10.],
# [10., 10., 10., 10.]])
⑤numpy.full()
np.full(shape, fill_value, dtype=None)
"""
shape: 数组的形状（整数或整数元组）
fill_value: 填充数组的值（标量）
dtype: 数组数据类型（可选）
返回值: 填充指定值的NumPy数组
----------------
1. 比先创建empty再fill()快约15%
2. 对大型数组，明确指定dtype可节省内存
3. 需要填充不同值时，考虑使用：
np.where(condition, x, y) # 条件填充
np.random.uniform(low, high, size) # 随机填充
"""
2、现有数组生成
①np.array()
深拷贝
numpy.array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0)
"""
object, # (必填) 输入数据（列表/元组/数组等）
dtype=None, # (可选) 强制指定数据类型
👆（重要）👆
copy=True, # (必填) 默认True执行深拷贝
order='K', # (可选) 内存布局：'C'/'F'/'A'/'K'(默认)
subok=False, # (可选) 是否保留子类类型
ndmin=0 # (可选) 指定最小维度数
"""
②copy()
深拷贝
两种用法
numpy.copy()
ndarray.copy()
numpy.copy(a, order='K')
"""
a, # (必填) 输入数组
👆（重要）👆
order='K', # (可选) 内存布局：'C'/'F'/'A'/'K'(默认)
"""
ndarray.copy()
"""
一般会用在更改数据但是却共享内存的情况下，之后会用一下copy()方法
如：
b = a.transpose(2,0,1).copy()
"""
③np.asarray(a)
浅拷贝
浅拷贝是数据值都是一样的，但是可以改变数据类型。
numpy.asarray(a, dtype=None, order=None)
"""
a, # (必填) 输入数据
dtype=None, # (可选) 数据类型转换
👆（重要）👆
order=None # (可选) 内存布局控制
"""
x=np.array([1,2,3,4],dtype=np.int32) # array([1, 2, 3, 4])
y=np.asarray(x, dtype=np.float64) # array([1., 2., 3., 4.])
3、生成固定范围数组
① linspace()
规定个数的等差数组
# 创建指定个数的等差数组
np.linspace(start, stop, num, endpoint)
"""
start: 起始值
stop: 终止值
num: 生成等间隔样例数量(总共生成多少数据)
endpoint: 是否包含终点，默认True
eg:
np.linspace(0, 100, 3) -> [0, 50, 100]
np.linspace(0, 100, 4) -> [0, 33.33334, 66.66667, 100]
"""
② arange()
规定步长的等差数组
# 创建指定步长的数组
np.arange(start, stop, step, dtype)
"""
step: 指定步长,不传入指定为1
stop: 终止值，默认不包含
"""
③ logspace()
等比数组
# 创建等比数列指定数量的数组
np.logspace(start, stop, num, base=10)
np.logspace(0,2,3) # [1., 10., 100.]
"""
start:起始点，10^start
stop: 终点，10^stop
num: 数组元素总数
base:默认是10，创建数据的基数
"""
4、生成随机数组
使用np.random模块
Ⅰ、正态分布
① normal()
np.random.normal(loc=0.0, scale=1.0, size=None)
"""
loc：float，概率分布的**均值**，图的中心
scale：float，概率分布的**标准差**，越大越胖矮，越小越瘦高
size：输出的形状(tuple)，默认为None，只输出一个值。生成一维数组就传入一个值，该值代表传入元素总数
"""
② randn()
python np.random.randn(d0,d1,...,dn)
"""
d0,d1,...,dn：生成的数组形状
功能：从标准正态分布中返回一个或多个样本值，与normal**区别**是randn**指定均值为0，标准差为1**。
"""
- 例子：
np.random.randn(2, 3)生成2行3列标准正态分布数组
③ standard_normal
np.random.standard_normal(size=None)
"""
np.random.standard_normal() 生成(单个)标准正态分布数字
np.random.standard_normal(8) 生成(一维)标准正态分布数组
np.random.standard_normal((2,3)) 生成(二维)标准正态分布数组
"""
Ⅱ、均匀分布
① uniform()
np.random.uniform(low=0.0, high=1.0, size=None) # 从[low, high）中随机抽样
"""
low：采样下界，float类型，默认为0
high：采样上届，float类型，默认为1
size：样本总数，或者为元组，元组描述数组的形状，默认值为1
返回值：ndarray类型
"""
② randn()
np.random.rand(d0,d1,...,dn)
"""
d0,d1,...,dn：生成数组的形状，一维就是数量
返回值：生成[0.0，1.0）内的均匀分布的数
"""
③ randint()
np.random.randint(low,high=None,size=None,dtype='I')
"""
high有值时，从[low,high)之间取整数，否则从[0,low)之间取整数
size: 无值传入，默认生成一个数
"""
5、matrix()生成二维数组
matrix 是 ndarray 的子类，只能生成 2 维的矩阵
numpy.matrix(data, dtype=None, copy=True)
"""
data, # (必填) 输入数据，可以是数组、列表、字符串等
dtype=None, # (可选) 输出矩阵的数据类型
copy=True # (必填) 是否创建数据副本（默认True）
"""
x1=np.mat("1 2;3 4")
print( x1)
x2=np.matrix("1,2;3,4")
print( x2)
x3=np.matrix([[1,2,3,4],[5,6,7,8]])
print( x3)
数组的索引&切片
①[ : , : ]的形式。
具体形式 [star:stop:step, star:stop:step]，同一维度切片由 star:stop:step组成，不同维度之间用逗号隔开。
二维数组的索引&切片
# 二维数组array2
array2[0,0:3]
# 三维数组array3
array3[0,0,1]
②bool索引
索引也可以是bool类型的ndarray数组，不过要求索引数组与原数组形状相同。
x=np.array( [1, 2, 3, 4, 5])
index=np.array([True,True,True,False,False],dtype="bool")
x[index] # array([1, 2, 3])
形状修改
①reshape()
两种用法
numpy.reshape(a, newshape, order='C')
ndarray.reshape(newshape, order='C')
不会改变原数组，而是生成新数组
numpy.reshape(a, newshape, order='C') # numpy中的函数
#或者
ndarray.reshape(newshape, order='C') # ndarray中的方法
"""
a：要变形的数组（可以是列表或NumPy数组）
newshape：新形状，比如(2,3)变2行3列，-1表示自动计算，除不尽会报错。
order：'C'按行排（默认），'F'按列排
返回值：
返回新形状的数组（通常是原数组的视图，不复制数据）
例子：
>>> np.arange(6).reshape(2,3)
[[0 1 2]
[3 4 5]]
"""
②resize()
两种用法
numpy.resize(a, new_shape)
ndarray.resize(new_shape, refcheck=True)
numpy.resize(a, new_shape) # numpy中的函数
"""
改变数组大小（可增减元素总数）
参数说明：
a：要调整的数组（列表/NumPy数组均可）
new_shape：整数或元组，指定新形状（如(3,4)）
返回值：
返回新数组（总是创建副本）
特点：
1. 新形状更大 → 循环填充原数据
2. 新形状更小 → 截取前部数据
3. 总元素数可变
示例：
>>> np.resize([1,2], (3,3))
[[1 2 1]
[2 1 2]
[1 2 1]]
"""
ndarray.resize(new_shape, refcheck=True) # ndarray中的方法
"""
原地修改数组形状（必须保持元素总数）
参数说明：
new_shape：整数或元组，新形状
refcheck：是否检查内存引用（默认True）
特点：
1. 直接修改当前数组
2. 总元素数不可变
3. 性能优于np.resize()
示例：
>>> a = np.array([1,2,3,4])
>>> a.resize((2,2)) # 直接修改a
>>> a
[[1 2]
[3 4]]
"""
③ndarray.T
不会改变原数组形状，而是创建一个新的改变了形状的视图，这个视图与原来的数组共享内存。所以一般会使用 ndarray.copy()创建新的独立的数组对象。
ndarray.T
"""
不会改变原数组形状，返回一个更改形状的新数组
"""
# 1. 基本用法
a = np.zeros((2,3))
b=a.T.copy() # a.shape (2,3)
# b.shape (3,2)
# 2. 高维数组的转置
#对于高维数组，.T 会默认反转所有维度顺序。例如，形状为 (d0, d1, d2) 的数组转置后变为 (d2, d1, d0)。
arr_3d = np.arange(6).reshape(3, 2, 1)
print("原数组形状:", arr_3d.shape) # (3, 2, 1)
print("转置后形状:", arr_3d.T.shape) # (1, 2, 3)
④transpose()
不会改变原数组形状，而是创建一个新的改变了形状的视图，这个视图与原来的数组共享内存。所以一般会使用 ndarray.copy()创建新的独立的数组对象。
两种用法
numpy.transpose()
ndarray.transpose()
numpy.transpose(a, axes=None)
"""
a：要转置的输入数组
axes：整数列表或元组（可选），指定新的轴顺序
example:
a = np.zeros((224,224,3))
b = np.transpose(a,(2,0,1).copy()
a → （224，224，3）
b → （3，224，224）
"""
ndarray.transpose(*axes)
"""
*axes：可变参数，指定新的轴排列顺序
- 不传参数：完全反转维度顺序（等价于.T）
- 传入整数序列：自定义每个维度的新位置
example:
a = np.zeros((2,3,4))
b = a.transpose().copy()
c = a.transpose(2,0,1)
a → （2，3，4）
b → （4，3，2）
c → （4，2，3）
"""
⑤np.astype()
ndarray.astype(dtype)
"""
dtype: 目标数据类型（支持字符串格式如 'float32' 或 numpy.dtype 对象如 np.int64）
返回值: 返回转换类型后的新数组（默认创建一个新的数组返回）
"""
类型修改 astype()
ndarray.astype(type)
"""
返回类型修改之后的新数组
"""
ndarray.tostring()
ndarray.tobytes()
"""
jupyter输出太大可能崩溃
"""
三、numpy内置函数
1.基本函数
1. np.ceil()
向上取整
np.ceil(x, dtype=None)
"""
x：输入数组或标量（支持 int, float, array_like）
dtype（可选）：指定输出数据类型（如 np.float32）
返回值：计算输入值的向上取整（返回 ≥ 输入的最小整数）,返回与x形状相同的数组或标量，
类型为整数或浮点数（尽量与x类型一致）。
"""
2.np.floor()
向下取整
np.floor(x, dtype=None)
"""
x: 输入数组或标量（支持 int, float, array_like）
dtype（可选）: 指定输出数据类型（如 np.float32）
返回值: 计算输入值的向下取整（返回 ≤ 输入的最大整数），返回与x形状相同的数组或标量，
类型为整数或浮点数（尽量与x类型一致）。
"""
3.np.rint()
四舍五入
np.rint(x, dtype=None)
"""
x: 输入数组或标量（支持 int, float, array_like）
dtype（可选）: 指定输出数据类型（如 np.float32）
返回值: 计算输入值的四舍五入（.5时向偶数取整），返回与x形状相同的数组或标量，
类型为整数或浮点数（尽量与x类型一致）。
"""
4.np.isnan()
np.isnan(x, dtype=None)
"""
x: 输入数组或标量（支持 int, float, array_like）
dtype（可选）: 指定输出数据类型（如 np.bool_）
返回值: 检测输入值是否为NaN（Not a Number），返回与x形状相同的布尔数组，
True表示对应位置是NaN。
"""
5.np.multiply()
*逐元素乘积，等价于 。
array1 * array2 ↔ np.multiply(array1, array2)
np.multiply(x1, x2, dtype=None) # 哈达玛积
"""
x1, x2: 输入数组或标量（支持广播）
dtype（可选）: 指定输出数据类型（如 np.float32）
返回值: 计算x1和x2的逐元素乘积，返回与广播后形状相同的数组，
类型由输入类型提升决定。
"""
6.np.divide()
逐元素相除，等价于 /。
array1 / array2 ↔ np.divide(array1, array2)
np.divide(x1, x2, dtype=None)
"""
x1, x2: 输入数组或标量（支持广播）
dtype（可选）: 指定输出数据类型（如 np.float32）
返回值: 计算x1和x2的逐元素商，返回与广播后形状相同的浮点型数组，
即使输入为整数也返回浮点数。
"""
7.np.abs()
输入值的绝对值
np.abs(x, dtype=None)
"""
x: 输入数组或标量（支持 int, float, array_like）
dtype（可选）: 指定输出数据类型（如 np.float32）
返回值: 计算输入值的绝对值，返回与x形状相同的非负数组，
类型尽量与x类型一致（复数输入返回浮点数）。
"""
8.np.where()
np.where(condition, x=None, y=None)
"""
condition: 布尔数组或条件表达式
x, y（可选）: 与condition广播兼容的数组或标量
返回值:
若提供x和y: 返回根据condition从x或y中选择的值组成的数组
若未提供x和y: 返回满足condition的元素的索引元组（如(row_idx, col_idx)）
"""
np.where(condition)
"""
condition表示条件
返回ndarray数组，表示数组元素值满足condition的索引。如果condition中的数组是一维，返回一个ndarray数组，二维返回两个ndarray数组(一个表示行索引，一个表示列索引...以此类推)
"""
2.统计函数
统计函数在不给定维度参数的时候，默认会展平高维数组，然后进行统计计算。
np.mean()/np.median()
np.mean(a, axis=None, dtype=None, keepdims=False)
"""
a: 输入数组或可转换为数组的对象
axis:
None - 计算所有元素的平均值（默认）
0 - 按列计算
1 - 按行计算
dtype: 计算时使用的数据类型（如np.float64）
keepdims:
True - 保持原数组维度
False - 降维（默认）
返回值: 计算后的平均值(中位数)数组或标量
"""
np.sum()
np.sum(a, axis=None, dtype=None, keepdims=False)
"""
a: 输入数组或可转换为数组的对象
axis:
None - 计算所有元素的和（默认）
0 - 按列求和
1 - 按行求和
dtype: 计算时使用的数据类型（如np.int32）
keepdims: 是否保持维度（默认False）
返回值: 计算后的和数组或标量
"""
np.max()/np.min()
np.max(a, axis=None, keepdims=False)
"""
a: 输入数组或可转换为数组的对象
axis:
None - 查找所有元素的最值（默认）
0 - 按列查找
1 - 按行查找
keepdims: 是否保持维度（默认False）
返回值: 最大值/最小值数组或标量
"""
np.std()/np.var()
np.std(a, axis=None, dtype=None, ddof=0, keepdims=False)
"""
a: 输入数组
axis: 计算轴（None/0/1）
dtype: 计算数据类型
ddof:
0 - 总体标准差/方差（默认）
1 - 样本标准差/方差
keepdims: 是否保持维度
返回值: 标准差/方差数组或标量
"""
np.argmax()/np.argmin()
np.argmax(a, axis=None)
"""
a: 输入数组
axis:
None - 展平数组后查找（默认）
0 - 按列查找
1 - 按行查找
返回值: 最大/最小值索引的数组或标量
"""
np.cumsum()/np.cumprod()
np.cumsum(a, axis=None, dtype=None)
"""
a: 输入数组
axis:
None - 展平数组后计算（默认）
0 - 按列计算
1 - 按行计算
dtype: 计算结果数据类型
返回值: 累加/累乘结果数组。指定维度计算时，返回值与a形状相同。不指定维度返回一维数(展平后计算)。
example:
arr = np.array([1, 2, 3, 4])
np.cumsum(arr) # 输出: [1, 2, 6, 10]
arr2 = np.array([[1, 2],
[3, 4]])
np.cumsum(arr_2d, axis=0) # [[1,2]
[4,6]]
np.cumsum(arr_2d, axis=1) # [[1,3]
[3,7]]
"""
3.比较函数
np.any()/np.all()
x=np.random.randint(0,10,(2,2))
#array([[1, 9],
# [9, 9]])
np.any(x > 5) # True
np.all(x < 10) # True
4.去重函数
np.unique()
找到唯一值并返回排序结果，类似于Python的set集合。
np.unique(x, return_index=False, return_inverse=False, return_counts=False, axis=None)
"""
x: 输入数组或可转换为数组的对象
return_index:
True - 返回唯一值在原数组中的首次出现位置索引
False - 不返回（默认）
return_inverse:
True - 返回重建原数组所需的索引数组
False - 不返回（默认）
return_counts:
True - 返回每个唯一值的出现次数
False - 不返回（默认）
axis:
None - 将数组展平后处理（默认）
0 - 按行处理（对二维数组）
1 - 按列处理（对二维数组）
返回值:
默认返回唯一值数组
当指定return_*参数时，返回包含额外结果的元组
"""
# example:
arr = np.array([3, 1, 2, 2, 3, 1, 4])
np.unique(arr) # [1,2,3,4]
arr2 = np.array([[1, 2], [3, 1], [1, 2]])
np.unique(arr) # 展开再计算 [1,2,3]
np.unique(arr_2d, axis=0) # [[1 2],[3 1]]
np.unique(arr_2d, axis=1) # [[1, 2], [3, 1], [1, 2]]
5.排序函数 sort()
两种用法
①np.sort()
np.sort(a, axis=-1, kind=None, order=None)
"""
a: 输入数组或可转换为数组的对象
axis:
-1 - 沿最后一个轴排序（默认）
None - 展平数组后排序
0 - 按列排序
1 - 按行排序
kind: 排序算法
'quicksort' - 快速排序（默认）
'mergesort' - 归并排序（稳定）
'heapsort' - 堆排序
'stable' - 稳定排序
order:
用于结构化数组的排序字段（字符串或字符串列表）
返回值: 排序后的数组（总是返回副本）
"""
②ndarray.sort()
ndarray.sort(axis=-1, kind=None, order=None)
"""
axis:
-1 - 沿最后一个轴排序（默认）
None - 展平数组后排序
0 - 按列排序
1 - 按行排序
kind: 排序算法
'quicksort' - 快速排序（默认）
'mergesort' - 归并排序（稳定）
'heapsort' - 堆排序
'stable' - 稳定排序
order:
用于结构化数组的排序字段（字符串或字符串列表）
返回值: None (原地排序，直接修改原数组)
"""
四、ndarray运算
逻辑运算
# 现有n维数组array
array>90
"""
返回一个和array一样形状的数组，元素值大于90时为True,否则为false
"""
array[array>90]=1
"""
将array数组中大于90的元素赋值为1
"""
# 两个数组之间的逻辑运算
a = np.array([1, 2, 3])
b = np.array([2, 2, 2])
# 大于
print(a > b) # [False False True]
# 大于等于
print(a >= b) # [False True True]
# 小于
print(a < b) # [ True False False]
# 小于等于
print(a <= b) # [ True True False]
# 等于
print(a == b) # [False True False]
# 不等于
print(a != b) # [ True False True]
通用判断函数
# 现有一个数组score,10行5列，表示10个学生的5门成绩
np.all(score[:2,:] >= 60)
"""
表示前两名同学[:2,:]是否成绩都及格了，满足返回True，否则返回False
函数的返回值为True或False
"""
np.any(score[:2,:] < 60)
"""
表示前两名同学成绩是否有不及格的，有返回True，否则返回False
函数的返回值为True或False
"""
np.where三元运算符
temp = score[:2, :]
np.where(temp >= 60, 1, 0)
"""
temp表示前两名同学的成绩
返回一个和temp形状相同的新数组，不改变原数组，temp元素大于等于60时，数组元素为1，否则为0
"""
np.where(temp >= 60)
"""
temp表示前两名同学的成绩
返回ndarray数组，表示数组中大于60的索引。如果temp是一维，返回一个ndarray数组，二维返回两个ndarray数组(一个表示行索引，一个表示列索引...以此类推)
"""
如果在where中，判断条件有多个（即大于10，又小于100）
np.logical_and(condition1, condition2) ↔ condition1 & condition2
np.local.or(condition1, condition2) ↔ condition1 | condition2
这两个函数仅支持二条件组合，多条件可以嵌套函数实现。
np.logical_and(temp > 60, temp < 90)
"""
返回一个与temp相同的形状数组，temp元素大于60且小于90时。新数组内元素为True，否则为False
和where混合使用
np.where(np.logical_and(temp>60, temp<90),1,0)
"""
np.local.or(temp < 60, temp > 90)
"""
返回一个与temp相同的形状数组，temp元素小于60或者大于90时。新数组内元素为True，否则为False
和where混合使用
np.where(np.logical_or(temp<60, temp>90),1,0)
"""
统计运算
# 传入的第一个参数是ndarray数组，第二个参数表示根据行还是列进行统计运算，axis=0表示列，axis=1表示行(不传入维度参数会展开高维数组再进行计算)
np.max(array,axis)
np.min(array,axis)
np.argmax(array,axis) # 最大值下标
np.argmin(array,axis) # 最小值下标
np.median(array,axis) # 中值
np.mean(array,axis) # 平均值
np.std(array,axis) # 标准差
np.var(array,axis) # 方差
五、数组间的运算
数组与数的运算
数组中每一个元素与该数进行运算
# array=[1,2,3]
array + 2
array - 2
array / 2
array * 2
"""
数组与数的运算是其中每一个元素与该数进行运算，返回一个新的数组。
ndarray数组之间可以这样运算，python列表不行
"""
数组与数组之间运算
数组之间运算要求两个数组形状完全相等，对应元素进行运算。
如果形状不相同，满足广播机制也可以进行运算。
广播机制：
首先将两个数组形状从右向左对齐，
对应维度之间满足任意一个要求就可以：
- 对应维度等长
- 对应维度其中一个维度为1
满足以上要求后发现有一个维度少也可以进行计算。如：（9，8，5，2）和（8，1，2）
举例说明：shape1 (2,3,4)
shape2 (1,3,1) 可以运算
shape1 (2, 1, 3)
shape2 (2, 2, 3) 可以运算
shape1 (2, 1, 3)
shape2 (3,) 可以运算
六、矩阵
存储矩阵的方法有两种
1.使用ndarray数组存储
array = np.array([[1,2,3],[1,2,6]])
ndarray存储的矩阵可以使用 @ 进行矩阵乘法
2.使用matrix存储矩阵
numpy.matrix(data, dtype=None, copy=True)
"""
data, # (必填) 输入数据，可以是数组、列表、字符串等
dtype=None, # (可选) 输出矩阵的数据类型
copy=True # (必填) 是否创建数据副本（默认True）
"""
array = np.mat([[1,2,3],[1,2,6]])
matrix存储的矩阵可以直接使用 * 进行运算
进行矩阵乘法的两个矩阵使用这两种存储也可以进行矩阵运算。
3.矩阵的乘法运算
np.matmul(ndarray1, ndarray2)
np.dot(ndarray1, ndarray2)
"""
np.matmul() 仅支持矩阵之间的乘法，不支持数与矩阵乘法
np.dot() 都支持
这两种的输入数据类型可以是ndarray,也可以是matrix
"""
七、合并与分割
合并
np.hstack()
# 水平拼接,高纬度拼接类似指定dim=1
np.hstack((array1, array2, array3))
"""
array维度多少都可以
example:
（3，）（3，）→ （6，）
（3，2）（3，2）→（3，4）
（3，2，4）（3，2，4）→（3，4，4）
（2，3，4，5）（2，3，4，5）→（2，6，4，5）
"""
np.vstack()
# 垂直拼接，高纬度拼接类似指定dim=0
np.vstack((array1, array2, array3))
"""
array维度多少都可以
example:
（3，）（3，）→ （2，3）
（3，2）（3，2）→（6，2）
（3，2，4）（3，2，4）→（6，2，4）
（2，3，4，5）（2，3，4，5）→（4，3，4，5）
"""
np.concatnate()
# 指定拼接方式 axis=0垂直拼接 axis=1水平拼接
np.concatnate((array1, array2, array3),axis=1)
"""
array维度多少都可以
"""
分割
# ①指定个数分割
np.split(array,3) # 每三个元素分割为一个新的数组，数组内元素必须是分割数的倍数
# example:
arr = np.array([1, 2, 3, 4, 5, 6])
np.split(arr, 3) # 分割为3份，每份2个元素
# [array([1, 2]), array([3, 4]), array([5, 6])]
arr_2d = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
np.split(arr_2d, 2) # 沿axis=0（行）分割为2份
# [array([[1, 2], [3, 4]]),
# array([[5, 6], [7, 8]])]
# ②指定下标分割
np.split(array,[3,4,7]) # 根据下标分割
# example
arr = np.array([10, 20, 30, 40, 50, 60, 70])
np.split(arr, [3, 4, 7]) # 在下标3,4,7处分割
# [array([10, 20, 30]), # arr[:3]
# array([40]), # arr[3:4]
# array([50, 60, 70]), # arr[4:7]
# array([], dtype=int64)] # arr[7:]（空数组）
浙公网安备 33010602011771号