Numpy

NumPy 学习笔记

NumPy 是一个 Python 库。

NumPy 用于处理数组。

NumPy 是“Numerical Python”的缩写。
创建一个 NumPy 数组：

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

输出：

[1 2 3 4 5]  
<class 'numpy.ndarray'>

NumPy 介绍

在 Python 中，我们有用于数组目的的列表，但它们的处理速度很慢。

NumPy 旨在提供比传统的 Python 快的列表。

NumPy 中的数组对象称为ndarray，它提供了许多支持功能，使使用变得非常容易。

数组在数据科学中非常频繁地使用，其中速度和资源都非常重要。

数据科学：是计算机科学的一个分支，我们研究如何存储、使用和分析数据以从中获取信息。

与列表不同，NumPy 数组存储在内存中的一个连续位置，因此进程可以非常有效地访问和操作它们。

这种行为在计算机科学中称为参考局部性。

这就是 NumPy 比传统python列表更快的主要原因。此外，它还经过优化，可与最新的 CPU 架构配合使用。

NumPy是一个Python库，部分是用Python编写的，但大多数需要快速计算的部分都是用C或C++编写的。

NumPy 的源代码位于此 github 存储库 Numpy

NumPy 入门

pip install numpy安装numpy

导入 NumPy
import numpy as np

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

print(arr)

NumPy 创建数组

可以将列表、元组或任何类似数组的对象传递到方法中，它将被转换为：ndarray

arr = np.array((1, 2, 3, 4, 5))

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

创建一个值为 42 的 0-D 数组:

arr = np.array(42)

创建一个包含值 1、2、3、4、5 的 1-D 数组：

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

创建一个包含两个数组的 2-D 数组，其值分别为 1,2,3 和 4,5,6：

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

创建一个具有两个二维数组的三维数组:

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

检查数组有多少个维度:

arr.ndim

数组可以具有任意数量的维度。

创建一个具有 5 个维度的数组，并验证它是否具有 5 个维度：

arr = np.array([1, 2, 3, 4], ndmin=5)

print(arr)

print('number of dimensions :', arr.ndim)

[[[[[1 2 3 4]]]]]
number of dimensions : 5

NumPy 数组索引

从以下数组中获取第一个元素：

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

print(arr[0])

二维数组想象成一个包含行和列的表格，其中维度表示行，索引表示列。

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

print('2nd element on 1st row: ', arr[0, 1])

三维数组，访问第一个数组的第二个数组的第三个元素：

arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

print(arr[0, 1, 2])

也和python一样支持负索引

NumPy 数组切片

一维的和python一样
二维的:

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

print(arr[1, 1:4])

输出：

[7 8 9]

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

print(arr[0:2, 2])

输出：

[3 8]

NumPy 数据类型

i - integer
b - boolean
u - unsigned integer
f - float
c - complex float
m - timedelta
M - datetime
O - object
S - string
U - unicode string
V - fixed chunk of memory for other type ( void )

获取数组对象的数据类型：

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

arr = np.array(['apple', 'banana', 'cherry'])

print(arr.dtype)

int32
<U6 (长度不超过6的Unicode字符串)

创建数据类型为字符串的数组：
arr = np.array([1, 2, 3, 4], dtype='S')
print(arr)
print(arr.dtype)

[b'1' b'2' b'3' b'4']
|S1 (长度为1的字符串)

在现有数组上转换数据类型:
arr = np.array([1.1, 2.1, 3.1])
newarr = arr.astype('i')
print(newarr)
print(newarr.dtype)

[1 2 3]
int32

NumPy 数组副本与视图

副本拥有数据，对副本所做的任何更改都不会影响原始数组，并且对原始数组所做的任何更改都不会影响副本。

视图不拥有数据，对视图所做的任何更改都将拥有影响原始数组，对原始数组所做的任何更改都将影响视图。
副本：

arr = np.array([1, 2, 3, 4, 5])
x = arr.copy()

视图：

arr = np.array([1, 2, 3, 4, 5])
x = arr.view()

检查数组是否拥有其数据：

arr = np.array([1, 2, 3, 4, 5])
x = arr.copy()
y = arr.view()

print(x.base)
print(y.base)

输出：

None (如果数组拥有数据，则返回None)
[1 2 3 4 5] (否则，该属性引用原始对象)

NumPy 数组形状

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

print(arr.shape)

输出：

(2, 4) (这意味着数组有 2 个维度， 其中第一个维度有 2 个元素，第二个维度有 4 个元素)

再例：

arr = np.array([1, 2, 3, 4], ndmin=5)

print(arr)
print('shape of array :', arr.shape)

输出：

[[[[[1 2 3 4]]]]]
shape of array : (1, 1, 1, 1, 4)
# 可以说第 5 个维度有 4 个元素

NumPy 数组reshape

即：改变数组的形状。

通过重塑，我们可以添加或删除维度或更改每个维度中的元素数量。

从一维到二维重塑：

将以下具有 12 个元素的一维数组转换为二维数组。

最外层的维度将有 4 个数组，每个数组有 3 个元素：

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])

newarr = arr.reshape(4, 3)

print(newarr)

输出：

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

从一维到三维重塑：

将以下具有 12 个元素的一维数组转换为三维数组。

最外层维度将有 2 个数组，每个数组包含 3 个数组有 2 个元素：

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])

newarr = arr.reshape(2, 3, 2)

print(newarr)

输出：

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

 [[ 7  8]
  [ 9 10]
  [11 12]]]

返回 Copy 还是 View？

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

print(arr.reshape(2, 4).base)

输出：

[1 2 3 4 5 6 7 8]
# 因此它是一个视图。

未知维度

这意味着您不必为其中一个指定确切的数字 Reshape 方法中的尺寸。

传递-1作为值，NumPy 将为您计算这个数字。

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

newarr = arr.reshape(2, 2, -1)

print(newarr)

输出：

[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]

展平数组

意味着将多维数组转换为一维数组。

我们可以用它来做到这一点。reshape(-1)

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

newarr = arr.reshape(-1)

print(newarr)

输出：

[1 2 3 4 5 6]

NumPy 数组迭代

迭代一维数组

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

for x in arr:
    print(x)

输出：

1
2
3

迭代二维数组

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

for x in arr:
    print(x)

输出：

[1 2 3]
[4 5 6]
# 如果我们迭代一个 n 维数组，它将一个接一个地经历 n-1 维。

逐一遍历：

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

for x in arr:
    for y in x:
        print(y)

输出：

迭代以下 3-D 数组的元素：

arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

for x in arr:
    print(x)

输出：

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

使用 nditer（）迭代数组

在基本循环中，遍历数组的每个标量，我们需要使用 n 个for循环，这对于具有非常高维数的数组来说可能很难编写

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

for x in np.nditer(arr):
    print(x)

输出：

使用不同的步长进行迭代

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

for x in np.nditer(arr[:, ::2]):
print(x)

输出：

使用 ndenumerate（）的枚举迭代

枚举意味着逐个提及序列号。

有时我们在迭代时需要元素的相应索引

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

for idx, x in np.ndenumerate(arr):
print(idx, x)

输出：

(0,) 1
(1,) 2
(2,) 3

NumPy 连接数组

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

arr2 = np.array([4, 5, 6])

arr = np.concatenate((arr1, arr2))
#沿行堆叠  arr = np.hstack((arr1, arr2))
print(arr)

输出：

[1 2 3 4 5 6]

沿行连接两个二维数组（axis=1）

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

arr2 = np.array([[5, 6], 
                 [7, 8]])

arr = np.concatenate((arr1, arr2), axis=1)# 沿行
arr1 = np.concatenate((arr1, arr2), axis=0)# 沿列
print(arr)
print(arr1)
# 维数不变

输出：

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

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

使用堆栈函数联接数组

堆叠与串联相同，唯一的区别是堆叠是沿着新轴完成的。

我们可以沿第二个轴连接两个一维数组，这将导致将它们一个放在另一个上
沿列竖着堆叠（axis = 0可以省略）维数+1：

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

arr2 = np.array([4, 5, 6])

arr = np.stack((arr1, arr2), axis=0)  
# axis=0 可以省略
# 等于 arr = np.vstack((arr1, arr2))
print(arr)

输出：

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

沿高度(深度)堆叠：

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

arr2 = np.array([4, 5, 6])

arr = np.stack((arr1, arr2), axis=1)
# arr = np.dstack((arr1, arr2))
print(arr)

输出：

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

NumPy 拆分数组

我们用于拆分数组，我们将要拆分的数组传递给它以及拆分次数。

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

newarr = np.array_split(arr, 3)

print(newarr)

输出：

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

如果数组的元素少于所需的元素，它将相应地从末尾进行调整。

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

newarr = np.array_split(arr, 4)

print(newarr)

输出：

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

访问拆分的数组：

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

newarr = np.array_split(arr, 3)

print(newarr[0])
print(newarr[1])
print(newarr[2])

输出：

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

拆分二维阵列

将二维数组拆分为三个二维数组。

arr = np.array([[1, 2], 
                [3, 4], 
                [5, 6], 
                [7, 8], 
                [9, 10], 
                [11, 12]])

newarr = np.array_split(arr, 3)

print(newarr)

输出：

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

此外，还可以指定要围绕哪个轴进行分割。

下面的示例还返回三个二维数组，但它们沿着深度（axis=1）

arr = np.array([[1, 2, 3], 
                [4, 5, 6], 
                [7, 8, 9], 
                [10, 11, 12], 
                [13, 14, 15], 
                [16, 17, 18]])

newarr = np.array_split(arr, 3, axis=1)
# 沿深度 newarr = np.hsplit(arr, 3)
print(newarr)

输出：

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

NumPy 搜索数组

在数组中搜索特定值，并返回获得匹配项的索引。

若要搜索数组，请使用以下方法。where()

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

x = np.where(arr == 4)
# 查找值为偶数的索引： x = np.where(arr%2 == 0)
# 查找值为奇数的索引： x = np.where(arr%2 == 1)
print(x)

输出：

(array([3, 5, 6], dtype=int64),)

搜索排序

在数组中执行二进制搜索，并返回将插入指定值的索引，以保持搜索顺序。searchsorted()

arr = np.array([6, 7, 8, 9])

x = np.searchsorted(arr, 7)

print(x)

输出：

从右侧搜索：

arr = np.array([6, 7, 8, 9])

x = np.searchsorted(arr, 7, side='right')

print(x)

多个值：

arr = np.array([1, 3, 5, 7])

x = np.searchsorted(arr, [2, 4, 6])

print(x)

输出：

[1 2 3]

NumPy 排序数组

arr = np.array([3, 2, 0, 1])

print(np.sort(arr))

输出：

[0 1 2 3]

对布尔数组进行排序：

arr = np.array([True, False, True])

print(np.sort(arr))

输出：

[False  True  True]

对二维数组进行排序

如果对二维数组使用 sort（）方法，则两个数组都将进行排序：

arr = np.array([[3, 2, 4], [5, 0, 1]])

print(np.sort(arr))

输出：

[[2 3 4]
 [0 1 5]]

NumPy 过滤数组

从现有数组中获取一些元素并创建一个新数组其中称为过滤。

在 NumPy 中，使用布尔索引列表筛选数组。

如果该索引处的值是False，则从筛选数组中排除该元素。

arr = np.array([41, 42, 43, 44])

x = [True, False, True, False]

newarr = arr[x]

print(newarr)

输出：

[41 43]

创建筛选器数组

创建一个仅返回大于 42 的值的筛选器数组：

arr = np.array([41, 42, 43, 44])

filter_arr = []

for element in arr:
    if element > 42: # 根据任务修改这行
        filter_arr.append(True)
    else:
        filter_arr.append(False)

newarr = arr[filter_arr]

print(filter_arr)
print(newarr)

直接从数组创建过滤器

arr = np.array([41, 42, 43, 44])

filter_arr = arr > 42

newarr = arr[filter_arr]

print(filter_arr)
print(newarr)

输出：

[False False  True  True]
[43 44]

NumPy random库-暂略

NumPy 以下介绍ufuncs

ufuncs 代表“通用函数”，它们是 NumPy 函数，对ndarray对象进行操作

ufuncs 用于在 NumPy 中实现矢量化（将迭代语句转换为基于向量的操作称为矢量化。），这比迭代元素要快得多。

由于现代 CPU 针对此类操作进行了优化，因此速度更快。

没有 ufunc，我们可以使用 Python 的内置方法：

x = [1, 2, 3, 4]
y = [4, 5, 6, 7]
z = []

for i, j in zip(x, y):
z.append(i + j)
print(z)

输出：

[5, 7, 9, 11]

使用 ufunc，我们可以使用以下函数：add()

x = [1, 2, 3, 4]
y = [4, 5, 6, 7]
z = np.add(x, y)

print(z)

输出相同

创建自己的 ufunc

要创建自己的 ufunc，您必须定义一个函数，就像您在 Python 中使用普通函数一样，然后使用frompyfunc()方法将其添加到您的 NumPy ufunc 库中。

该方法采用以下参数：frompyfunc()

function- 函数的名称。
inputs- 输入参数（数组）的数量。
outputs- 输出数组的数量。

def myadd(x, y):
    return x+y
# 输入2个，输出1个
myadd = np.frompyfunc(myadd, 2, 1)

print(myadd([1, 2, 3, 4], [5, 6, 7, 8]))

检查函数的类型以检查它是否是 ufunc。

print(type(np.add))

输出：

<class 'numpy.ufunc'>

ufunc 简单算术

加法：上述已说明（np.add()）

减法：

arr1 = np.array([10, 20, 30, 40, 50, 60])
arr2 = np.array([20, 21, 22, 23, 24, 25])

newarr = np.subtract(arr1, arr2)

print(newarr)

输出：

[-10  -1   8  17  26  35]

乘法：

arr1 = np.array([10, 20, 30, 40, 50, 60])
arr2 = np.array([20, 21, 22, 23, 24, 25])

newarr = np.multiply(arr1, arr2)

print(newarr)

输出：

[ 200  420  660  920 1200 1500]

除法：

arr1 = np.array([10, 20, 30, 40, 50, 60])
arr2 = np.array([3, 5, 10, 8, 2, 33])

newarr = np.divide(arr1, arr2)

print(newarr)

输出：

[ 3.33333333  4.          3.          5.         25.          1.81818182]

幂运算：

arr1 = np.array([10, 20, 30, 40, 50, 60])
arr2 = np.array([3, 5, 6, 8, 2, 33])

newarr = np.power(arr1, arr2)

print(newarr)

输出：

[1000 3200000 729000000 6553600000000 2500 0]

求余：

arr1 = np.array([10, 20, 30, 40, 50, 60])
arr2 = np.array([3, 7, 9, 8, 2, 33])

newarr = np.mod(arr1, arr2)
# newarr = np.remainder(arr1, arr2)
print(newarr)

输出：

[1 6 3 0 0 27]

商和余数：

arr1 = np.array([10, 20, 30, 40, 50, 60])
arr2 = np.array([3, 7, 9, 8, 2, 33])

newarr = np.divmod(arr1, arr2)

print(newarr)

输出：

(array([ 3,  2,  3,  5, 25,  1]), array([ 1,  6,  3,  0,  0, 27]))

绝对值：

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

newarr = np.absolute(arr)

print(newarr)

ufunc 四舍五入

截断

删除小数，并返回最接近零的浮点数。trunc()和fix()

arr = np.trunc([-3.1666, 3.6667])
# arr = np.fix([-3.1666, 3.6667])
print(arr)

输出：

[-3.  3.]

四舍五入

如果 >=5，则该函数将前面的数字或十进制递增 1，否则什么都不做。

arr = np.around(3.1666, 2)

print(arr)

输出：

3.17

下取整

将小数四舍五入到最接近的下整数

arr = np.floor([-3.1666, 3.6667])

print(arr)

输出：

[-4.  3.]

上取整

将小数四舍五入到最接近的大整数

arr = np.ceil([-3.1666, 3.6667])

print(arr)

输出：

[-3.  4.]

ufunc log()对数函数

NumPy 提供了在基数 2、e 和 10 上执行对数函数。

log2()

使用该函数在基数 2 处执行日志。log2()

arr = np.arange(1, 10)

print(np.log2(arr))

输出：

[0.         1.         1.5849625  2.         2.32192809 2.5849625
2.80735492 3.         3.169925  ]

log10()

arr = np.arange(1, 10)

print(np.log10(arr))

输出：

[0.         0.30103    0.47712125 0.60205999 0.69897    0.77815125
0.84509804 0.90308999 0.95424251]

自然对数

arr = np.arange(1, 10)

print(np.log(arr))

输出：

[0.         0.69314718 1.09861229 1.38629436 1.60943791 1.79175947
 1.94591015 2.07944154 2.19722458]

在任何基底的log

from math import log
import numpy as np

nplog = np.frompyfunc(log, 2, 1)
# 参数表示2个输入，1个输出
print(nplog(100, 15))

or

def log(base,x):
    return np.log(x)/np.log(base)

输出：

ufunc add()和sum()求和

arr1 = np.array([1, 2, 3])  
arr2 = np.array([1, 2, 3])

前面

newarr = np.add(arr1, arr2)  
# [2 4 6]

是对应求和
下面将 arr1 中的值和 arr2 中的值相加：

newarr = np.sum([arr1, arr2])
# 12
newarr = np.sum([arr1, arr2], axis=1)
# [6 6]

累计求和

例如，[1， 2， 3， 4] 的部分和将是 [1， 1+2， 1+2+3， 1+2+3+4] = [1， 3， 6， 10]

newarr = np.cumsum(arr1)
# [1 3 6]

ufunc prod()乘积

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

x = np.prod(arr)

print(x)

输出：

返回：因为 1*2*3*4 = 2424

求两个数组元素的乘积：

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

x = np.prod([arr1, arr2])
# newarr = np.prod([arr1, arr2], axis=1)

print(x)
# print(newarr)

输出：

返回：因为 1*2*3*4*5*6*7*8 = 40320
# 输出[24 1680]

累计求积

# 例如，[1， 2， 3， 4] 的偏积为 [1， 1*2， 1*2*3， 1*2*3*4] = [1， 2， 6， 24]

arr = np.array([5, 6, 7, 8])

newarr = np.cumprod(arr)

print(newarr)

输出：

[5 30 210 1680]

ufunc diff()

离散差值意味着减去两个连续的元素。

例如，对于 [1， 2， 3， 4]，离散差为 [2-1， 3-2， 4-3] = [1， 1， 1]

可以通过给出参数来重复执行此操作。

arr = np.array([10, 15, 25, 5])

newarr = np.diff(arr)

print(newarr)

输出：

返回：因为 15-10=5、25-15=10 和 5-25=-20[5 10 -20]

计算以下数组的离散差值两次：

arr = np.array([10, 15, 25, 5])

newarr = np.diff(arr, n=2)

print(newarr)

输出：

返回：因为：15-10=5、25-15=10、5-25=-20、10-5=5 和 -20-10=-30[5 -30]

ufunc 查找 LCM（最小公倍数）

num1 = 4
num2 = 6

x = np.lcm(num1, num2)

print(x)

输出：

在阵列中查找 LCM

arr = np.array([3, 6, 9])

x = np.lcm.reduce(arr)

print(x)

输出：

求数组包含从 1 到 10 的所有整数的数组的所有值的 LCM：

arr = np.arange(1, 11)

x = np.lcm.reduce(arr)

print(x)

输出：

ufunc GCD（最大公约数）

num1 = 6
num2 = 9

x = np.gcd(num1, num2)

print(x)

在以下数组中查找所有数字的 GCD：

arr = np.array([20, 8, 32, 36, 16])

x = np.gcd.reduce(arr)

print(x)

输出：

ufunc 三角函数

x = np.sin(np.pi/2)

print(x)

查找 arr 中所有值的正弦值：

arr = np.array([np.pi/2, np.pi/3, np.pi/4, np.pi/5])

x = np.sin(arr)

print(x)

输出：

[1.         0.8660254  0.70710678 0.58778525]

将度数转换为弧度deg2rad()

注意：弧度值为 pi/180 * degree_values。

arr = np.array([90, 180, 270, 360])

x = np.deg2rad(arr)

print(x)

输出：

[1.57079633 3.14159265 4.71238898 6.28318531]

弧度到度rad2deg()

arr = np.array([np.pi/2, np.pi, 1.5*np.pi, 2*np.pi])

x = np.rad2deg(arr)

print(x)

输出：

[ 90. 180. 270. 360.]

寻找角度arcsin()、arccos()、arctan()

x = np.arcsin(1.0)

print(x)

输出：

1.5707963267948966（pi/2）

斜边hypot()

base = 3
perp = 4

x = np.hypot(base, perp)

print(x)

输出：

NumPy 双曲函数暂略

NumPy 集合操作暂略

以上内容，学习地址W3S

以下补充，内容来自菜鸟教程

NumPy 矩阵库

Numpy 转置矩阵

数组.T即可

a = np.arange(12).reshape(3,4)
print ('原数组：')
print (a)
print ('\n')

print ('转置数组：')
print (a.T)

输出：

    原数组：
[[ 0  1  2  3]
[ 4  5  6  7]
[ 8  9 10 11]]


转置数组：
[[ 0  4  8]
[ 1  5  9]
[ 2  6 10]
[ 3  7 11]]

numpy.matlib.empty()

matlib.empty() 函数返回一个趋近于0的矩阵，语法格式为：
numpy.matlib.empty(shape, dtype, order)
参数说明：

shape: 定义新矩阵形状的整数或整数元组
Dtype: 可选，数据类型
order: C（行序优先）或者 F（列序优先）

import numpy.matlib 
import numpy as np

print (np.matlib.empty((2,2)))
# 填充为随机数据

输出：

[[-1.49166815e-154 -1.49166815e-154]
[ 2.17371491e-313  2.52720790e-212]]

numpy.matlib.zeros()

numpy.matlib.zeros() 函数创建一个以 0 填充的矩阵。

import numpy.matlib 
import numpy as np 

print (np.matlib.zeros((2,2)))

输出：

[[0. 0.]
 [0. 0.]]

numpy.matlib.ones()

numpy.matlib.ones()函数创建一个以 1 填充的矩阵。

import numpy.matlib 
import numpy as np 

print (np.matlib.ones((2,2)))

输出：

[[1. 1.]
 [1. 1.]]

numpy.matlib.eye()

numpy.matlib.eye() 函数返回一个矩阵，对角线元素为 1，其他位置为零。

numpy.matlib.eye(n, M,k, dtype)
参数说明：

n: 返回矩阵的行数
M: 返回矩阵的列数，默认为 n
k: 对角线的索引
dtype: 数据类型

import numpy.matlib 
import numpy as np 

print (np.matlib.eye(n =  3, M =  4, k =  0, dtype =  float))

输出：

[[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]]

numpy.matlib.identity()

numpy.matlib.identity() 函数返回给定大小的单位矩阵。

单位矩阵是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为 1，除此以外全都为 0。

import numpy.matlib 
import numpy as np 

# 大小为 5，类型位浮点型
print (np.matlib.identity(5, dtype =  float))

输出：

[[ 1.  0.  0.  0.  0.] 
 [ 0.  1.  0.  0.  0.] 
 [ 0.  0.  1.  0.  0.] 
 [ 0.  0.  0.  1.  0.] 
 [ 0.  0.  0.  0.  1.]]

numpy.matlib.rand()

numpy.matlib.rand() 函数创建一个给定大小的矩阵，数据是随机填充的。

import numpy.matlib 
import numpy as np 

print (np.matlib.rand(3,3))

输出：

[[0.23966718 0.16147628 0.14162   ]
 [0.28379085 0.59934741 0.62985825]
 [0.99527238 0.11137883 0.41105367]]

np.matrix()

import numpy.matlib 
import numpy as np  

i = np.matrix('1,2;3,4')  
print (i)

输出：

[[1  2] 
 [3  4]]

NumPy 线性代数

numpy.dot()

矩阵叉乘

a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(np.dot(a,b))

输出：

[[37  40] 
 [85  92]]
# [[1*11+2*13, 1*12+2*14],[3*11+4*13, 3*12+4*14]]

numpy.vdot()

矩阵点乘求和
点乘是multiply

a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(np.vdot(a,b))

输出：

130
# 1*11 + 2*12 + 3*13 + 4*14 = 130

numpy.inner()

一维数组之间的运算，dot()和inner()没区别，返回一维数组的向量内积

print (np.inner(np.array([1,2,3]),np.array([0,1,0])))
# 等价于 1*0+2*1+3*0

二维数组运算,如果a和b都是形状为(3, 4)的二维数组，那么np.inner(a, b)的结果将会是一个形状为(3, 3)的二维数组

a = np.array([[1,2],[3,4]]) 
b = np.array([[11,12],[13,14]]) 

print (np.inner(a,b))
# 等于print (np.dot(a,b.T))
# 等于print (np.inner(b,a).T)  
#过程如下：
1*11+2*12, 1*13+2*14 
3*11+4*12, 3*13+4*14

numpy.matmul(参考了一个博客)

alt text
如果第一个参数是一维张量，第二个参数是二维张量，那么在一维张量的前面增加一个维度，然后进行矩阵乘法，矩阵乘法结束后移除添加的维度。

a = [-1, 2]
b = [[1, 2], [3, 4]]
print (np.matmul(a,b))
# (,2)和(2,2)=(,2)再去掉第一维

输出：

[5,6]

对于二维数组，它就是矩阵乘法：

a = [[1,0],[0,1]] 
b = [[4,1],[2,2]] 
print (np.matmul(a,b))
# print(np.dot(a,b))

输出：

[[4  1] 
 [2  2]]

如果第一个参数是二维张量（矩阵），第二个参数是一维张量（向量），那么将返回矩阵×向量的积
：

a = [[1,0],[0,1]] 
b = [1,2] 
# [1*1+0*2 , 0*1+1*2]

输出：

[1  2]

再例二维✖二维以上（先升维再广播再矩阵乘法）：

a = np.arange(8).reshape(2,2,2) 
b = np.arange(4).reshape(2,2) 
print (np.matmul(a,b))
# a: [[[0 1]
       [2 3]]
      [[4 5]
       [6 7]]]
#np.matmul(a,b)的计算过程中b为       
# b,(2,2)-->(1,2,2)
#  [[[0 1]
    [2 3]]]
# 之后广播
[[[0 1]
  [2 3]]]
[[[0 1]
  [2 3]]]

输出：

[[[ 2  3]
  [ 6 11]]

 [[10 19]
  [14 27]]]
# 维度为(2,2,2)

numpy.linalg.det()

计算矩阵的行列式

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

print (np.linalg.det(a))

输出：

-2.0

numpy.linalg.solve()

获得矩阵形式的线性方程的解
考虑以下线性方程：

x + y + z = 6

2y + 5z = -4

2x + 5y - z = 27

如果矩阵成为A、X和B，方程变为：

AX = B

或

X = A^(-1)B

例如：
解方程法1(AX = B)：

a = np.array([[1, 2], [3, 5]])
b = np.array([1, 2])
x = np.linalg.solve(a, b)
# 解方程：如[1 2][x y]^-1 =[1 2]^-1
            [3 5]        =

输出：

[-1.  1.]

numpy.linalg.inv()

计算矩阵的乘法逆矩阵（inverse matrix）:设A是数域上的一个n阶矩阵，若在相同数域上存在另一个n阶矩阵B，使得： AB=BA=E ，则我们称B是A的逆矩阵，而A则被称为可逆矩阵。注：E为单位矩阵。

x = np.array([[1,2],[3,4]]) 
y = np.linalg.inv(x) 
print (x)
print (y)
print (np.dot(x,y))

输出：

[[1 2]      # 原始x矩阵
 [3 4]]
[[-2.   1. ]   # x的逆矩阵y
 [ 1.5 -0.5]]
[[1.0000000e+00 0.0000000e+00]
 [8.8817842e-16 1.0000000e+00]]

例如：解方程法2(X = A^(-1)B)：

a = np.array([[1, 2], [3, 5]])
b = np.array([1, 2])
ainv = np.linalg.inv(a)
x = np.dot(ainv, b)

numpy.mean()

print(np.mean(a)) # 计算平均值
print(np.mean(a, axis=0)) # axis=0，计算每一列的均值
print(np.mean(a, axis=1)) # 计算每一行的均值

numpy.sqrt() 返回参数的平方根

numpy.square() 计算数组各元素的平方

numpy.exp() 返回e的幂次方，e是一个常数为2.71828

posted @ 2024-04-09 16:30 denngamin 阅读(27) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Pytorch计算机视觉实战（更新中）

· 3.IP地址规划设计技术

· Python之numpy库（一）

· NumPy科学计算库

· numpy用法总结

阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 三行代码完成国际化适配，妙~啊~
· .NET Core 中如何实现缓存的预热？

公告

昵称： denngamin
园龄： 11个月
粉丝： 1
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

dxlindex

Numpy

NumPy 学习笔记

NumPy 介绍

NumPy 入门

NumPy 创建数组

NumPy 数组索引

NumPy 数组切片

NumPy 数据类型

NumPy 数组副本与视图

NumPy 数组形状

NumPy 数组reshape

从一维到二维重塑：

从一维到三维重塑：

未知维度

展平数组

NumPy 数组迭代

迭代一维数组

迭代二维数组

逐一遍历：

迭代以下 3-D 数组的元素：

使用 nditer（） 迭代数组

使用不同的步长进行迭代

使用 ndenumerate（） 的枚举迭代

NumPy 连接数组

沿行连接两个二维数组 （axis=1）

使用堆栈函数联接数组

NumPy 拆分数组

访问拆分的数组：

拆分二维阵列

NumPy 搜索数组

搜索排序

NumPy 排序数组

对二维数组进行排序

NumPy 过滤数组

创建筛选器数组

直接从数组创建过滤器

NumPy random库-暂略

NumPy 以下介绍ufuncs

创建自己的 ufunc

ufunc 简单算术

减法：

乘法：

除法：

幂运算：

求余：

商和余数：

绝对值：

ufunc 四舍五入

截断

四舍五入

下取整

上取整

ufunc log()对数函数

log2()

log10()

自然对数

在任何基底的log

ufunc add()和sum()求和

累计求和

ufunc prod()乘积

累计求积

ufunc diff()

ufunc 查找 LCM（最小公倍数）

ufunc GCD（最大公约数）

ufunc 三角函数

将度数转换为弧度deg2rad()

弧度到度rad2deg()

寻找角度arcsin()、arccos()、arctan()

斜边hypot()

NumPy 双曲函数暂略

NumPy 集合操作暂略

以上内容，学习地址W3S

以下补充，内容来自菜鸟教程

NumPy 矩阵库

Numpy 转置矩阵

numpy.matlib.empty()

numpy.matlib.zeros()

numpy.matlib.ones()

numpy.matlib.eye()

使用 nditer（）迭代数组

使用 ndenumerate（）的枚举迭代

沿行连接两个二维数组（axis=1）