Python#numpy

原创 于 2024-12-25 20:02:25 发布 · 546 阅读 · 16 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#numpy #python #开发语言

遍历数组

遍历数组的第一维度

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

for i in arr: 遍历数组的第一维度

nditer 是 NumPy 中的一个强大的迭代器对象，用于高效地遍历多维数组。nditer 提供了多种选项和控制参数，使得数组的迭代更加灵活和高效。

控制参数

nditer 提供了多种控制参数，用于控制迭代的行为。

1.order 参数

order 参数用于指定数组的遍历顺序。默认情况下，nditer 按照 C 风格（行优先）遍历数组。

  • C 风格（行优先）: order='C'

  • Fortran 风格（列优先）: order='F'

# 创建一个二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
​
# 使用 C 风格遍历数组
for x in np.nditer(arr, order='C'):
    print(x)
# 输出:
# 1
# 2
# 3
# 4
# 5
# 6
​
# 使用 Fortran 风格遍历数组
for x in np.nditer(arr, order='F'):
    print(x)
# 输出:
# 1
# 4
# 2
# 5
# 3
# 6

2.flags 参数

flags 参数用于指定迭代器的额外行为。

  • multi_index: 返回每个元素的多维索引。

  • external_loop: 返回一维数组而不是单个元素，减少函数调用的次数，从而提高性能。

# 创建一个三维数组
    arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
​
    # 使用 nditer 遍历数组并获取多维索引
    it = np.nditer(arr, flags=['multi_index'])
    for x in it:
        print(f"Element: {x}, Index: {it.multi_index}")
​
# 输出：
# Element: 1, Index: (0, 0, 0)
# Element: 2, Index: (0, 0, 1)
# Element: 3, Index: (0, 1, 0)
# Element: 4, Index: (0, 1, 1)
# Element: 5, Index: (1, 0, 0)
# Element: 6, Index: (1, 0, 1)
# Element: 7, Index: (1, 1, 0)
# Element: 8, Index: (1, 1, 1)
​
​
# 创建一个二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 使用外部循环遍历数组，列优先
for x in np.nditer(arr, flags=['external_loop'], order='F'):
    print(x)
# 输出:
# [1 4]
# [2 5]
# [3 6]
# 注意：external_loop 和 order='F' 一起使用时，会将每列的元素打包成一个数组返回。
​
import numpy as np
​
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 使用外部循环遍历数组，行优先
for x in np.nditer(arr, flags=['external_loop'], order='C'):
    print(x)
# 输出：
[1 2 3 4 5 6]
# 注意：external_loop 会将所有元素打包成一个数组返回，而不是按行打包。

3.op_flags 参数

op_flags 参数用于指定操作数的行为。

  • readonly: 只读操作数。

  • readwrite: 读写操作数。

  • writeonly: 只写操作数。

# 创建一个二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
​
# 使用读操作数遍历数组
for x in np.nditer(arr, op_flags=['readonly']):
    # 不能对数据修改，否则报错：ValueError: assignment destination is read-only
    # x[...] = x * 2
    print(x)
​
# 使用读写操作数遍历数组
for x in np.nditer(arr, op_flags=['readwrite']):
    x[...] = 2 * x
​
print(arr)
# 输出:
# [[ 2  4  6]
#  [ 8 10 12]]

x[...]：是 NumPy 中的一种索引方式，表示获取数组 x 的一个视图，对数组 x 进行原地修改，而不是创建一个新的数组。

返回一个可写视图（writable view），允许直接修改原数组中的元素。

注意：当使用 x[...] 时，x 必须是一个数组或数组的视图，而不是一个标量。

修改单个元素

import numpy as np
​
# 创建一个数组
arr = np.array([1, 2, 3])
​
# 使用 x[...] 修改单个元素
x = arr[0]
x[...] = 100
print(arr)
​
#输出：
TypeError: 'numpy.int64' object does not support item assignment

此时x是一个标量，不能使用x[...] 修改，可以直接赋值：

import numpy as np
​
# 创建一个数组
arr = np.array([1, 2, 3])
​
# 使用 x[...] 修改单个元素
arr[0] = 100
print(arr)

在迭代中修改元素

import numpy as np
​
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 使用读写操作数遍历数组
# x[...] = x * 2 将数组 arr 中的每个元素乘以 2，并写回到原数组中。
# x实际返回一个包含当前元素的数组，而不是标量，所以可以使用x[...]
for x in np.nditer(arr, op_flags=['readwrite']):
    x[...] = 2 * x
​
print(arr)
# 输出:
# [[ 2  4  6]
#  [ 8 10 12]]

数组操作

数组变维

函数名称函数介绍
reshape在不改变数组元素的条件下，修改数组的形状
flat属性返回是一个迭代器，可以用 for 循环遍历其中的每一个元素
flatten以一维数组的形式返回一份数组的副本，对副本的操作不会影响到原数组
ravel返回一个连续的扁平数组（即展开的一维数组），与 flatten不同，它返回的是数组视图（修改视图会影响原数组）

flat

返回一个一维迭代器，用于遍历数组中的所有元素。无论数组的维度如何，ndarray.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()

用于将多维数组转换为一维数组。flatten() 返回的是原数组的一个拷贝，因此对返回的数组进行修改不会影响原数组。

语法：

ndarray.flatten(order='C')

参数

order: 指定数组的展开顺序。

  • 'C'：按行优先顺序展开（默认）。

  • 'F'：按列优先顺序展开。

  • 'A'：如果原数组是 Fortran 连续的，则按列优先顺序展开；否则按行优先顺序展开。

  • 'K'：按元素在内存中的顺序展开。

案例：

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]

如果order='F'，输出结果是什么？

 ravel()

用于将多维数组转换为一维数组。与 flatten() 不同，ravel() 返回的是原数组的一个视图（view），而不是副本。因此，对返回的数组进行修改会影响原数组。

语法：

ndarray.ravel()

参数

order: 指定数组的展开顺序。

  • 'C'：按行优先顺序展开（默认）。

  • 'F'：按列优先顺序展开。

  • 'A'：如果原数组是 Fortran 连续的，则按列优先顺序展开；否则按行优先顺序展开。

  • 'K'：按元素在内存中的顺序展开。

案例：

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 方法相同

import numpy as np
​
def transpose_test():
    array_one = np.arange(12).reshape(3, 4)
    print("原数组：")
    print(array_one)
    print("使用transpose()函数后的数组：")
    print(np.transpose(array_one))
​
​
def T_test():
    array_one = np.arange(12).reshape(3, 4)
    print("原数组：")
    print(array_one)
    print("数组转置：")
    print(array_one.T)

 修改数组维度

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

函数名称参数说明
expand_dims(arr, axis)arr：输入数组 axis：新轴插入的位置在指定位置插入新的轴(相对于结果数组而言)，从而扩展数组的维度
squeeze(arr, axis)arr：输入数的组 axis：取值为整数或整数元组，用于指定需要删除的维度所在轴，指定的维度值必须为 1 ，否则将会报错，若为 None，则删除数组维度中所有为 1 的项删除数组中维度为 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)

适应广播操作

# 创建一个一维数组
a = np.array([1, 2, 3])
​
# 创建一个标量
b = 2
​
# 扩展 a 的维度
c = np.expand_dims(a, axis=0)
print(c)
# 输出:
# [[1 2 3]]
​
# 进行广播操作
d = c + b
print(d)
# 输出:
# [[3 4 5]]

移除长度为1的维度

import numpy as np
​
# 创建一个数组
c = np.array([[[1, 2, 3]]])
print(c.shape)  # 输出: (1, 1, 3)
​
# 移除第 0 维
d = np.squeeze(c, axis=0)
print(d)
# 输出:
# [[1 2 3]]
print(d.shape)  # 输出: (1, 3)
​
# 移除第 1 维
e = np.squeeze(c, axis=1)
print(e)
# 输出:
# [[1 2 3]]
print(e.shape)  # 输出: (1, 3)
​
# 移除第 2 维
f = np.squeeze(c, axis=2)
print(f)
# 输出:
# ValueError: cannot select an axis to squeeze out which has size not equal to one
print(f.shape)
import numpy as np
​
# 创建一个数组
g = np.array([[[1, 2, 3]], [[4, 5, 6]]])
print(g.shape)  # 输出: (2, 1, 3)
​
# 移除第 1 维
h = np.squeeze(g, axis=1)
print(h)
# 输出:
# [[1 2 3]
#  [4 5 6]]
print(h.shape)  # 输出: (2, 3)

np.newaxis 是 NumPy 中的一个特殊索引，用于在数组的指定位置插入一个新的轴（维度）。它通常用于将一维数组转换为二维数组，或者在其他情况下增加数组的维度。

import numpy as np
​
# 创建一个一维数组
arr = np.array([1, 2, 3, 4])
print("原始数组:", arr)
​
# 使用 np.newaxis 在行上插入新轴
arr_row = arr[np.newaxis, :]
print("行向量:", arr_row)
​
# 使用 np.newaxis 在列上插入新轴
arr_col = arr[:, np.newaxis]
print("列向量:", arr_col)
​
#输出：
原始数组: [1 2 3 4]
行向量: [[1 2 3 4]]
列向量: [[1]
         [2]
         [3]
         [4]]

连接数组

函数名称参数说明
hstack(tup)tup：可以是元组，列表，或者numpy数组，返回结果为numpy的数组按水平顺序堆叠序列中数组（列方向）
vstack(tup)tup：可以是元组，列表，或者numpy数组，返回结果为numpy的数组按垂直方向堆叠序列中数组（行方向）

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

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

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

案例：

hstack：

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]]
# 创建两个形状不同的数组，行数不一致
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5], [6], [7]])
print(arr1.shape)   # (2, 2)
print(arr2.shape)   # (3, 1)
​
# 使用 hstack 水平堆叠数组
result = np.hstack((arr1, arr2))
​
print(result)
​
# ValueError: all the input array dimensions except for the concatenation axis must match exactly
# 第一个数组在第0维有2个元素，而第二个数组在第0维有3个元素，因此无法直接连接。

vstack：

# 创建两个一维数组
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
​
# 使用 vstack 垂直堆叠数组
result = np.vstack((arr1, arr2))
​
print(result)
# 输出:
# [[1 2 3]
#  [4 5 6]]
import numpy as np
# 创建两个形状不同的数组，列数一致
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8, 9], [10, 11, 12]])
​
# 使用 vstack 垂直堆叠数组
result = np.vstack((arr1, arr2))
​
print(result)
# 创建两个形状不同的数组，列数不一致
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6, 7], [8, 9, 10]])
​
# 使用 vstack 垂直堆叠数组
result = np.vstack((arr1, arr2))
​
print(result)
# ValueError: all the input array dimensions except for the concatenation axis must match exactly
# 第一个数组在第1维有2个元素，而第二个数组在第1维有3个元素，因此无法直接连接。

分割数组

函数名称参数说明
hsplit(ary, indices_or_sections)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])  # 输出包.0含第3列的子数组
​
​
'''
    vsplit 函数：
        1、将一个数组垂直分割为多个子数组（按行）
        2、ary：原数组
        3、indices_or_sections：按列分割的索引位置
'''
array_one = np.arange(12).reshape(2,6)
print('array_one 原数组：\n', array_one)
array_two = np.vsplit(array_one,[1])
print('vsplit 之后的数组：\n', array_two)
    

 矩阵运算

np.dot

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

  • 对于二维数组（矩阵），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)

向量点积

计算公式为：

$$
a\cdot b=a_{1}b_{1}+a_{2}b_{2}+⋯+a_{n}b_{n}
$$

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

结果不是-2，这是由于浮点数的二进制表示和计算过程中的舍入误差导致的。可以通过四舍五入来近似表示：

det_a = np.round(np.linalg.det(a))

数组元素的增删改查

resize

函数名称参数说明
resize(a, new_shape)a：操作的数组 new_shape：返回的数组的形状，如果元素数量不够，重复数组元素来填充新的形状返回指定形状的新数组
import numpy as np
​
array_one = np.arange(6).reshape(2, 3)
print(array_one)
print('resize 后数组：\n', np.resize(array_one, (3, 4)))
​
# 输出：
# [[0 1 2 3]
#  [4 5 0 1]
#  [2 3 4 5]]

最后一行代码将数组形状修改为(3, 4)，原数组的元素数量不够，则重复原数组的元素填充。

 append

函数名称参数说明
append(arr, values, axis=None)arr：输入的数组 values：向 arr 数组中添加的值，需要和 arr 数组的形状保持一致 axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，若 axis=1 则与其恰好相反在数组的末尾添加值，返回一个一维数组
'''
    append(arr, values, axis=None) 函数：
        1、将元素值添加到数组的末尾，返回一个一维数组
        2、arr：输入的数组
        3、values：向 arr 数组中添加的值，需要和 arr 数组的形状保持一致
        4、axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，若 axis=1 则与其恰好相反
'''
def append_test():
    array_one = np.arange(6).reshape(2,3)
    print('原数组：\n', array_one)
    array_two = np.append(array_one,[[1,1,1],[1,1,1]],axis=None)
    print('append 后数组 axis=None：\n', array_two)
    array_three = np.append(array_one, [[1, 1, 1], [1, 1, 1]], axis=0)
    print('append 后数组 axis=0：\n', array_three)
    array_three = np.append(array_one, [[1, 1, 1], [1, 1, 1]], axis=1)
    print('append 后数组 axis=1：\n', array_three)

insert

函数名称参数说明
insert(arr, obj, values, axis)arr：输入的数组 obj：表示索引值，在该索引值之前插入 values 值 values：要插入的值 axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，若 axis=1 则与其恰好相反沿规定的轴将元素值插入到指定的元素前

：

import numpy as np
​
def insert_test():
    array_one = np.arange(6).reshape(2,3)
    print('原数组：\n', array_one)
    array_two = np.insert(array_one, 1, [6],axis=None)
    print('insert 后数组 axis=None：\n', array_two)
    # 在索引为1的行插入[6],并自动广播
    array_three = np.insert(array_one,1, [6], axis=0)
    print('insert 后数组 axis=0：\n', array_three)
    # 在索引为1的列插入[6],并自动广播
    array_three = np.insert(array_one, 1, [6], axis=1)
    print('insert 后数组 axis=1：\n', array_three)
    
    array_three = np.insert(array_one, 1, [6,7], axis=1)
    print('insert 后数组 axis=1：\n', array_three)
    
    # 在列上插入数组的形状和原数组列的形状不一致
    # ValueError: could not broadcast input array from shape (3,1) into shape (2,1)
    array_three = np.insert(array_one, 1, [6,7,8], axis=1)
    print('insert 后数组 axis=1：\n', array_three)

如果obj为-1，表示插入在倒数第一个元素之前，不是在最后一列。

array_three = np.insert(array_one, -1, [6,7], axis=1)
print('insert 后数组 axis=1：\n', array_three)
​
#输出：
 [[0 1 6 2]
 [3 4 7 5]]

delete

函数名称参数说明
delete(arr, obj, axis)arr：输入的数组 obj：表示索引值，要删除数据的索引 axis：默认为 None，返回的是一维数组；当 axis =0 时，删除指定的行，若 axis=1 则与其恰好相反删掉某个轴上的子数组，并返回删除后的新数组

一维数组：

import numpy as np
​
# 创建一个 NumPy 数组
arr = np.array([1, 2, 3, 4, 5, 6])
​
# 删除索引为 2 和 4 的元素
new_arr = np.delete(arr, [2, 4])
​
print(new_arr)

二维数组：

import numpy as np
​
​
def delete_test():
    array_one = np.arange(6).reshape(2,3)
    print('原数组：\n', array_one)
    array_two = np.delete(array_one,1,axis=None)
    print('delete 后数组 axis=None：\n', array_two)
    array_three = np.delete(array_one,1, axis=0)
    print('delete 后数组 axis=0：\n', array_three)
    array_three = np.delete(array_one, 1, axis=1)
    print('delete 后数组 axis=1：\n', array_three)

argwhere

返回数组中非 0 元素的索引，若是多维数组则返回行、列索引组成的索引坐标

import numpy as np
​
'''
    argwhere(a) 函数：
        1、返回数组中非 0 元素的索引，若是多维数组则返回行、列索引组成的索引坐标
'''
def argwhere_test():
    array_one = np.arange(6).reshape(2,3)
    print('原数组：\n', array_one)
    print('argwhere 返回非0元素索引：\n', np.argwhere(array_one))
    print('argwhere 返回所有大于 1 的元素索引：\n', np.argwhere(array_one > 1))

 unique

函数名称参数说明
unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None)ar：输入的数组 return_index：如果为 True，则返回新数组元素在原数组中的位置（索引） return_inverse：如果为 True，则返回原数组元素在新数组中的位置（逆索引） return_counts：如果为 True，则返回去重后的数组元素在原数组中出现的次数删掉某个轴上的子数组，并返回删除后的新数组

返回唯一元素的索引

import numpy as np
​
# 创建一个 NumPy 数组
arr = np.array([1, 2, 2, 3, 4, 4, 5])
unique_elements, indices = np.unique(arr, return_index=True)
print(unique_elements)
print(indices)

返回唯一元素及其逆索引

mport numpy as np
​
# 创建一个一维数组
arr = np.array([1, 2, 2, 3, 3, 3, 4, 4, 4, 4])
​
# 使用 np.unique 查找唯一元素及其逆索引
unique_elements, inverse_indices = np.unique(arr, return_inverse=True)
​
print(unique_elements)
# 输出:
# [1 2 3 4]
​
print(inverse_indices)
# 输出:
# [0 1 1 2 2 2 3 3 3 3]
# 逆索引数组，表示原始数组中的每个元素在唯一元素数组中的位置。

返回唯一元素的计数

import numpy as np
​
# 创建一个一维数组
arr = np.array([1, 2, 2, 3, 3, 3, 4, 4, 4, 4])
​
# 使用 np.unique 查找唯一元素及其计数
unique_elements, counts = np.unique(arr, return_counts=True)
​
print(unique_elements)
# 输出:
# [1 2 3 4]
​
print(counts)
# 输出:
# [1 2 3 4]

对于多维数组，unique 函数同样适用。默认情况下，unique 函数会将多维数组展平为一维数组，然后查找唯一元素。

arr = np.array([[1, 2], [2, 3], [1, 2]])
​
# 查找数组中的唯一元素
unique_elements = np.unique(arr)
print(unique_elements)

统计函数

amin() 和 amax()

  • 计算数组沿指定轴的最小值与最大值，并以数组形式返回

  • 对于二维数组来说，axis=1 表示沿着水平方向，axis=0 表示沿着垂直方向：'''   numpy.amin() 和 numpy.amax() 函数：       1、计算数组沿指定轴的最小值与最大值，并以数组形式返回       2、对于二维数组来说，axis=1 表示沿着水平方向，axis=0 表示沿着垂直方向 ''' def amin_amax_test():    array_one = np.array([[1,23,4,5,6],[1,2,333,4,5]])    print('原数组元素：\n', array_one)    print('原数组水平方向最小值：\n', np.amin(array_one, axis=1))    print('原数组水平方向最大值：\n', np.amax(array_one, axis=1))    print('原数组垂直方向最小值：\n', np.amin(array_one, axis=0))    print('原数组垂直方向最大值：\n', np.amax(array_one, axis=0))    

输出：

原数组元素：
 [[  1  23   4   5   6]
 [  1   2 333   4   5]]
原数组水平方向最小值：
 [1 1]
原数组水平方向最大值：
 [ 23 333]
原数组垂直方向最小值：
 [1 2 4 4 5]
原数组垂直方向最大值：
 [  1  23 333   5   6]

按1轴求最小值，表示在最内层轴中（每列中）分别找最小值；按1轴求最小值表示在最外层轴中（所有行中按列）找最小值。求最大值类似。

 ptp()

  • 计算数组元素中最值之差值，即最大值 - 最小值

  • 对于二维数组来说，axis=1 表示沿着水平方向，axis=0 表示沿着垂直方向

# 创建一个二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
​
# 使用 np.ptp 计算峰峰值
ptp_value = np.ptp(arr)
​
print(ptp_value)
# 输出:
# 5
​
# 使用 np.ptp 按行计算峰峰值
ptp_values_row = np.ptp(arr, axis=1)
​
# 使用 np.ptp 按列计算峰峰值
ptp_values_col = np.ptp(arr, axis=0)
​
print(ptp_values_row)
# 输出:
# [2 2]
​
print(ptp_values_col)
# 输出:
# [3 3 3]

12.3 median()

Python之numpy详细教程
风口IT猪的成长录
07-02 3万+
Numpy学习笔记Numpy介绍ndarray介绍ndarray与Python原生list运算效率对比ndarray的优势内存块风格ndarray支持并行化运算（向量化运算）效率远高于纯Python代码Numpy安装N维数组-ndarrayarray 创建ndarray的属性ndarray的形状ndarray的类型总结基本操作生成数组的方法生成0和1的数组np.empy()从现有数组生成关于array和asarray的不同生成固定范围的数组np.linspace (start, stop, num, end
python的numpy库使用详解
m0_71559726的博客
04-27 6818
本章介绍python是数组库——numpy的使用。全文14000多字详解，几乎涵盖每个知识点。
NumPy包（上） python笔记扩展
最新发布
正在学习中ing......
10-21 683
NumPy 的全称是“ Numeric Python”，它是 Python 的第三方扩展包，主要用来计算、处理一维或多维数组在数组算术计算方面， NumPy 提供了大量的数学函数NumPy 的底层主要用 C语言编写，因此它能够高速地执行数值计算NumPy 还提供了多种数据结构，这些数据结构能够非常契合的应用在数组和矩阵的运算上。
Numpy库的安装
热门推荐
m0_62589051的博客
11-19 1万+
Numpy库的安装 一、numpy简介 NumPy是一个功能强大的Python库，主要用于对多维数组执行计算。NumPy提供了大量的库函数和操作，可以帮助程序员轻松地进行数值计算。这类数值计算广泛用于以下任务： **机器学习模型：**在编写机器学习算法时，需要对矩阵进行各种数值计算。例如矩阵乘法、换位、加法等。NumPy提供了一个非常好的库，用于简单(在编写代码方面)和快速(在速度方面)计算。NumPy数组用于存储训练数据和机器学习模型的参数。 **图像处理和计算机图形学：**计算机中的图像表示为多维数字数
python数值计算_一文包会，教你如何熟练运用Python数值计算Numpy包
weixin_39800990的博客
12-02 697
对于用Python的朋友来说，在平常的数值计算中肯定会用到一个开源包，没错，它就是大名鼎鼎的Numpy包，全称为Numberical Python，是Python的一种开源的数值计算扩展，Numpy包内部集成了大量的数学函数库，你都可以随手拿来使用，极为方便！好啦，下面咱们就来聊聊这个Numpy包吧！在Python中，如果涉及到第三方包的使用，第一步要做的事情当然是将这个包导入啦！那咱们就看看Nu...
玩数据必备Python库：Numpy使用详解
华章IT官方博客
09-24 2729
作者 | 魏溪含 涂铭 张修鹏来源 | 大数据（ID：hzdashuju）导读：Numpy（Numerical Python的简称）是高性能科学计算和数据分析的基础包，其提供了矩阵运算的...
victorgau#python_investment#numpy補充資料1
07-25
想知道 numpy 有哪些 ufunc ，可以參考官網上面的連結：Available ufuncs統計相關函式參考：Statistics亂數相關函式參考：Ran
Python 使用Numpy对矩阵进行转置的方法
09-19
在Python编程语言中，处理矩阵和数组操作时，Numpy库是一个非常强大的工具。Numpy提供了许多高级功能，包括矩阵的创建、运算以及转置。本文将详细介绍如何使用Numpy库对矩阵进行转置。 首先，让我们理解矩阵转置的...
Numpy练习：Python-Numpy
02-17
在Python编程环境中，Numpy是一个不可或缺的库，尤其对于数据处理和科学计算而言。Numpy提供了高效的多维数组对象，以及一系列用于操作这些数组的方法。本篇将主要围绕Numpy库进行深入探讨，并结合Jupyter Notebook...
Python遍历numpy数组的实例
01-20
在用python进行图像处理时，有时需要遍历numpy数组，下面是遍历数组的方法： [rows, cols] = num.shape for i in range(rows - 1): for j in range(cols-1): print(num[j, i]) 以上这篇Python遍历numpy数组的...
numpy函数库
07-05
本文档为开源的numpy函数库，详细介绍了各种函数的使用方式，方便找不到资源的用户下载。
python扩展库导入方式不推荐使用_只有 Python 扩展库才需要导入以后才能使用其中的对象, Python 标准库不需要导入即可使用其中的所有对象和方法。_学小易找答案...
weixin_39769187的博客
12-08 3120
【判断题】引用第三方requests库后,调用requests.get()函数的返回结果的网页内容是一个Response对象【判断题】Python 字典支持双向索引。Python 集合也支持双向索引。【填空题】7 、设 、 是二阶常系数线性微分方程 的两个线性无关的解,则它的通解为【单选题】以下糖尿病治疗方法中,最基本的治疗方法是( )。【单选题】6 、 若级数 发散,则有 ( )【填空题】已知 ...
import numpy as np_最新Python学习教程（Python学习路线）：Numpy常用用法总结
weixin_39892311的博客
11-27 6994
最新Python学习教程（Python学习路线）：Numpy常用用法总结一、前言玩数据分析、数据挖掘、AI的都知道这个python库用的是很多的，里面包含各种操作，在实际的dataset的处理当中是非常常用的，这里我做一个总结，方便自己看，也方便大家看，我准备做一个非常细致的分类，每个分类有对应的numpy常用用法，以后见到或者用到再一个个慢慢加进来，如果我还用csdn我就会移植update下去。...
numpy库
weixin_44766179的博客
03-25 2419
numpy库的使用 创建数组 x1 = np.array([1, 2, 3], dtype="int8") print(x1) print(x1.dtype) # 数据类型 x2 = np.array(range(1, 10), dtype="int8") print(x2) print(x2.dtype) x3 = np.arange(1, 10, 2, dtype="int8") p...
Python库Numpy 1.9.2源码安装包发布
这个文件针对的是Python编程语言中一个非常重要的扩展库——NumPy的1.9.2版本。 描述中提到的“numpy-1.9.2源码安装包”意味着该压缩包包含了构建和安装NumPy库所需的所有源代码文件。NumPy库是Python中用于数值...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值