Numpy的入门级使用

最新推荐文章于 2022-03-29 09:22:47 发布
最新推荐文章于 2022-03-29 09:22:47 发布
阅读量245 收藏
点赞数 1
分类专栏： Machine Learning 文章标签： python numpy 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45337431/article/details/106596844
版权

Numpy的使用

一、Array数组简介

# 导包，简化名称
import numpy as np

# 获取版本
np.__version__

'1.18.1'

# 使用np的array
nparr = np.array([i for i in range(10)])
nparr

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

# 查看某个元素
nparr[4]

4

# 修改某个元素值
nparr[4]=12
nparr[4]

12

# np的array默认是64位int型，即使用浮点数依然是自动转为int
# 如果在初始化的时候使用了浮点数，则会转为浮点数
nparr2 = np.array([1, 2, 3.0])
nparr2.dtype

dtype('float64')

二、其他创建np的数组方法

#创建10个值为0的数组/矩阵
np.zeros(10)

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

#默认浮点数
np.zeros(10).dtype

dtype('float64')

# 创建三行五列的矩阵
np.ones(shape=(3,5), dtype=int)

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

# 创建相同指定元素的矩阵，可以省略shape和fill_value
np.full(shape=(3,5), fill_value=10.0)

array([[10., 10., 10., 10., 10.],
       [10., 10., 10., 10., 10.],
       [10., 10., 10., 10., 10.]])

arange循环

# for(i=0;i<20;i+2)
np.arange(0, 20, 2)

array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])

np.arange(2, 17).reshape(3,5)

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

linspace 在指定全闭空间截取等长的指定长度

np.linspace(0, 20, 11)

array([ 0.,  2.,  4.,  6.,  8., 10., 12., 14., 16., 18., 20.])

随机数random

# 在4-8范围内生成3行5列的随机矩阵
np.random.randint(4, 8, size=(3,5))

array([[7, 4, 5, 5, 4],
       [5, 4, 7, 6, 7],
       [5, 5, 7, 7, 7]])

# 指定随机种子，这样可以保证两次生成的随机数一样
np.random.seed(100)
np.random.randint(4, 8, size=(3,5))

array([[4, 4, 7, 7, 7],
       [7, 4, 6, 6, 4],
       [6, 5, 6, 6, 6]])

np.random.seed(100)
np.random.randint(4, 8, size=(3,5))

array([[4, 4, 7, 7, 7],
       [7, 4, 6, 6, 4],
       [6, 5, 6, 6, 6]])

# 生成随机的浮点数，是0-1的均匀分布
np.random.random((4, 8))

array([[0.4527399 , 0.87014264, 0.06368104, 0.62431189, 0.52334774,
        0.56229626, 0.00581719, 0.30742321],
       [0.95018431, 0.12665424, 0.07898787, 0.31135313, 0.63238359,
        0.69935892, 0.64196495, 0.92002378],
       [0.29887635, 0.56874553, 0.17862432, 0.5325737 , 0.64669147,
        0.14206538, 0.58138896, 0.47918994],
       [0.38641911, 0.44046495, 0.40475733, 0.44225404, 0.03012328,
        0.77600531, 0.55095838, 0.3810734 ]])

# 生成符合正态分布的浮点数，比如均值为4，方差为10的浮点数
# 因为生活中很多事物都是符合正态分布的，不如身高，所以有时候需要这样的数据采样
np.random.normal(4, 10, size=(3, 5))

array([[ 9.92575746,  4.37958129,  7.71967572,  7.59753947,  2.59603535],
       [-0.43738512,  9.68770162,  9.38488768, 17.15574179, 18.78978297],
       [ 6.21426255, -7.17894159,  2.1500007 , -0.31187446,  5.42536252]])

#查询具体函数的文档说明 可以使用【help(np.random.normal)】将文档插入notebook
np.random.normal?

三、数组的基本属性

# 定义一维数组x
x = np.arange(10)
x

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

# 定义二维数组X
X = np.arange(15).reshape(3,5)
X

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

# 查询是维度
x.ndim

1

X.ndim

2

# 查询构建情况，即元组情况
x.shape

(10,)

X.shape

(4, 3)

# 获取第一个维度（行维度）数据，即有多少行
X.shape[0]

4

# 元素个数
x.size

10

X.size

12

数据访问

# -1表示最后一个元素
x[-1]

9

# 二维数组访问方式，比如访问第2行第2列元素，注意下标从0开始
X[2,2]

12

# [:5]从头到第5个元素，[5:]从第五个元素到结尾
# [::2]以2为步长访问所有元素
x[::2]

array([0, 2, 4, 6, 8])

# [::-1]倒序访问
x[::-1]

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

# 二维数组访问前两行前两列，进行切片
X[:2, :3]

array([[0, 1, 2],
       [5, 6, 7]])

# 抽出所有的行，选取第三列数据转为一维向量
X[:, 2]

array([ 2,  7, 12])

# 抽出所有的列，选取第2行数据转为一维，就是选取第二行数据
X[1, :]

array([5, 6, 7, 8, 9])

# 获取子矩阵
subX = X[:2, :3]
subX

array([[0, 1, 2],
       [5, 6, 7]])

# 如果修改子矩阵的元素，则原矩阵也会变；反之亦然
# 也就是说子矩阵并未完全脱离原矩阵
subX[0, 2] = 10
subX

array([[ 0,  1, 10],
       [ 5,  6,  7]])

X

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

# 所以，我们需要创建一个完全脱离原矩阵的矩阵
subX = X[:2, :3].copy()
subX

array([[ 0,  1, 10],
       [ 5,  6,  7]])

subX[0,0]=100
subX

array([[100,   1,  10],
       [  5,   6,   7]])

X

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

Reshape改变维度

x1 = np.arange(10)

x1

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

x1.ndim

1

x1.shape

(10,)

# 转为二维，但是没有改变x1本身维度
A = x1.reshape(2, 5)
x1

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

A

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

# 让计算机自己计算另一个维度的元素个数
# 比如指定10行，注意中英文标点符号切换
A.reshape(10,-1)

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

A.reshape(2,-1)

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

合并操作

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

x

array([1, 2, 3])

y

array([3, 2, 1])

z = np.array([7, 7, 7])

# 合并
np.concatenate([x, y, z])

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

# 二维数组合并
A = np.array([[1, 2, 3], [4, 5, 6]])

A

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

# 就是简单的拼接
np.concatenate([A, A])

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

# 根据轴方向进行拼接，比如新的数据是在原有基础上增加了新的属性，而非数据叠加
# 将A和A两个矩阵拼成一个2×6的矩阵，沿着列的维度（即第二个维度拼接）
np.concatenate([A, A], axis=1)

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

# A是一个二维数组，z是一个一维数组，除了将z转为二维进行合并，还有方法
# 即使用vstack，垂直方向自动叠加
# 在里面乘以2，表示堆叠2次
T = np.array([[1, 2, 3], [4, 5, 6]])
t = np.array([7, 7, 7])
np.vstack([T, t]*2)

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

# hstack水平方向叠加，注意：z是一维，这意味着根本不可能水平自动叠加
B = np.full(shape=(2,2), fill_value=22)
np.hstack([A, B])

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

分割

x = np.arange(10)
x

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

# 分割为三段，分别在角标3和7位置进行切割，包头不包尾
# 注意第二个参数必须是数组
x1, x2, x3 = np.split(x, [3, 7])

x1

array([0, 1, 2])

x2

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

x3

array([7, 8, 9])

A = np.arange(16).reshape(4,4)

A

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

# 按照行分开
A1, A2 = np.split(A, [2])

A1

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

A2

array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])

# 按照列分开
A1, A2 = np.split(A, [1], axis=1)

A1

array([[ 0],
       [ 4],
       [ 8],
       [12]])

A2

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

## 同样也有vsplit和hsplit
A1, A2 = np.hsplit(A, [2])

A1

array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]])

A2

array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])

# 主要作用就是处理数据，比如我们需要将前面的特征和最后的标签分开
# -1表示最后一列为基准
X, y = np.hsplit(A, [-1])

X

array([[ 0,  1,  2],
       [ 4,  5,  6],
       [ 8,  9, 10],
       [12, 13, 14]])

y

array([[ 3],
       [ 7],
       [11],
       [15]])

# 处理标签数据，我们将其转为一维向量
# 即将所有行抽出，然后去第一列
y = y[:, 0]
y

array([ 3,  7, 11, 15])

四、数组运算

# 数组乘以常数
L = np.array([1, 2, 3])
L

array([1, 2, 3])

A = 2 * L
A

array([2, 4, 6])

A

array([2, 4, 6])

# 开平方
A = L ** 2
A

array([1, 4, 9], dtype=int32)

# 除法
A = L / 2
A

array([0.5, 1. , 1.5])

# 整除
A = L // 2
A

array([0, 1, 1], dtype=int32)

# 取模
A = L % 2
A

array([1, 0, 1], dtype=int32)

# 同样适用于多维
# abs 绝对值
# cos sin tan 三角函数和反三角函数
# exp 取e自然对数的x次方
# power 去指定数的x次方
# log
# 矩阵与矩阵之间的运算
A = np.arange(4).reshape(2,2)
A

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

B = np.full(fill_value=10, shape=(2,2))
B

array([[10, 10],
       [10, 10]])

# 矩阵之间相加减
# 必须保证矩阵之间可以运算，比如2*2的就不能和3*3的加减乘
A + B

array([[10, 11],
       [12, 13]])

# 矩阵之间相乘（默认是元素一一对应）
# 但这是不对的，数学上的矩阵相乘：
# A的第一行与B的第一列对应元素相乘再求和为第一个结果元素
# 然后A的第一行与B的第二列相乘再求和为第二个结果元素
# B遍历完成，再遍历A的第二行，依次完成，所以使用dot方法
A.dot(B)

array([[10, 10],
       [50, 50]])

# 矩阵转秩，列变行，行变列
A.T

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

向量和矩阵的运算

# 定义向量
v = np.array([1,2])
v

array([1, 2])

# np中的向量和矩阵的加减法原理：
# 将v重复堆叠和矩阵一一样的维度，然后加减
# tile第一个参数表示要堆叠的向量，第二个参数表示在行方向堆叠两次，列一次（相当于不堆叠）
np.tile(v, (2, 1))+A

array([[1, 3],
       [3, 5]])

# 或者使用vstack
np.vstack([v]*A.shape[0])+A

array([[1, 3],
       [3, 5]])

# 一般我们只需要直接使用【+】即可
v+A

array([[1, 3],
       [3, 5]])

# 相乘
v.dot(A)

array([4, 7])

# 如果反过来，则np会自动将向量转为了2*1的矩阵
A.dot(v)

array([2, 8])

求矩阵的逆

A

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

# 逆矩阵其实就是倒数A的逆与A相乘为1
invA = np.linalg.inv(A)
invA

array([[-1.5,  0.5],
       [ 1. ,  0. ]])

invA.dot(A)

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

A.dot(invA)

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

# 这里注意，非方阵不存在逆矩阵
P = np.arange(6).reshape(2,3)
P

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

# 非方阵P不存在逆矩阵，所以会报错
invP = np.linalg.inv(P)
invP

---------------------------------------------------------------------------

LinAlgError                               Traceback (most recent call last)

<ipython-input-197-cea414d9d476> in <module>
----> 1 invP = np.linalg.inv(P)
      2 invP


<__array_function__ internals> in inv(*args, **kwargs)


D:\python\annaconda\lib\site-packages\numpy\linalg\linalg.py in inv(a)
    540     a, wrap = _makearray(a)
    541     _assert_stacked_2d(a)
--> 542     _assert_stacked_square(a)
    543     t, result_t = _commonType(a)
    544 


D:\python\annaconda\lib\site-packages\numpy\linalg\linalg.py in _assert_stacked_square(*arrays)
    211         m, n = a.shape[-2:]
    212         if m != n:
--> 213             raise LinAlgError('Last 2 dimensions of the array must be square')
    214 
    215 def _assert_finite(*arrays):


LinAlgError: Last 2 dimensions of the array must be square

# 但是我们可以求其伪逆矩阵
invP = np.linalg.pinv(P)
invP

array([[-0.77777778,  0.27777778],
       [-0.11111111,  0.11111111],
       [ 0.55555556, -0.05555556]])

P

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

P.dot(invP)

array([[ 1.00000000e+00, -1.11022302e-16],
       [ 2.66453526e-15,  1.00000000e+00]])

聚合操作

# 定义向量，求和
c = np.random.random(100)
c

array([0.67731747, 0.8097996 , 0.44306924, 0.10924103, 0.97039241,
       0.38847984, 0.446539  , 0.19115508, 0.89116032, 0.47422759,
       0.21237979, 0.60914912, 0.51770333, 0.40296099, 0.32301995,
       0.5885746 , 0.38878152, 0.45094951, 0.24692106, 0.5795789 ,
       0.95588068, 0.59444006, 0.28505391, 0.07476922, 0.56237941,
       0.18774368, 0.57311471, 0.13546506, 0.37562767, 0.33001114,
       0.547794  , 0.19797026, 0.25155065, 0.80938403, 0.92580965,
       0.89988772, 0.43454589, 0.02134634, 0.78510132, 0.18258255,
       0.57643742, 0.35635898, 0.76286615, 0.53281217, 0.36405572,
       0.41126815, 0.24624624, 0.11203632, 0.21297768, 0.69958934,
       0.92405496, 0.89076414, 0.35501525, 0.82317797, 0.38149612,
       0.03400909, 0.88722056, 0.4971579 , 0.02616028, 0.8918212 ,
       0.99259084, 0.28025065, 0.44650545, 0.85163306, 0.47433037,
       0.27746328, 0.84165882, 0.19512497, 0.8563142 , 0.30779172,
       0.11482631, 0.23205323, 0.1901128 , 0.89687523, 0.71286647,
       0.27232044, 0.33140446, 0.13344876, 0.47179231, 0.87548878,
       0.65723473, 0.73897465, 0.83128974, 0.78972567, 0.75736278,
       0.5927053 , 0.21856877, 0.48801456, 0.62094638, 0.95552635,
       0.24609705, 0.07953832, 0.49838666, 0.43576678, 0.29923313,
       0.48928621, 0.89216675, 0.50743572, 0.36042688, 0.90388633])

np.sum(c)

49.95480883325486

# 求最大最小值
np.min(c)

0.0213463370361493

# 矩阵
C = np.arange(16).reshape(4,-1)
C

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

# 矩阵求和
np.sum(C)

120

# 沿着第一个（行维度）进行运算，即每一列的和
# 记忆方法：axis=0，将元素压缩到一行
np.sum(C, axis=0)

array([24, 28, 32, 36])

# axis=2,表示压缩到一列
np.sum(C, axis=1)

array([ 6, 22, 38, 54])

# 求内积，依次相乘
np.prod(C)

0

# 求平均值
np.mean(C)

7.5

# 求中位数
np.median(C)

7.5

# 求百分位,q=50表示的就是中位数，100位最大值，0最小，有时候还要取25和75
# 方便观察数据的分布情况
np.percentile(c, q=50)

0.47300995170104476

np.median(c)

0.47300995170104476

for percent in (0, 25, 50, 75, 100):
    print(np.percentile(c, q = percent))

0.0213463370361493
0.27617756624264767
0.47300995170104476
0.758738621791756
0.9925908422814628

# 求方差
np.var(c)

0.07401029029118417

# 求标准差
np.std(c)

0.27204832344858176

索引

d = np.random.normal(0, 1, size=1000000)
d

array([ 0.61285995, -0.9236127 , -0.92116938, ..., -0.4371244 ,
        2.20229359,  0.48357591])

np.min(d)

-4.621589291745685

# 我们想要知道这个最小值的位置，即索引
np.argmin(d)

538778

d = np.arange(16)
d

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

# 乱序处理
np.random.shuffle(d)

d

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

# 排序
np.sort(d)

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

# 二维矩阵
D = np.random.randint(10, size=(4,4))
D

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

# 二维矩阵的排序，sort默认是对每一行进行排序
np.sort(D)

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

# 沿着某个维度排序
np.sort(D, axis=0)

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

d

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

# 索引排序，依然是按照值的大小排序的，不过展示的是索引位置
# 比如原数组，最小的是0，索引为10，所以10在第一个
np.argsort(d)

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

 # 找到一个标点，小于其的放到左侧，大于的放在右侧，但是无序
np.partition(d, 3)

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

# 同样也可以进行标点的索引排序
np.argpartition(d, 3)

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

D

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

np.argsort(D, axis=1)

array([[2, 1, 3, 0],
       [0, 3, 2, 1],
       [2, 1, 0, 3],
       [1, 3, 0, 2]], dtype=int64)

np.partition(D, 3, axis=0)

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

Fancy Indexing

e = np.arange(16)

e

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

# 索引在[3,9)范围内，步长为2的切片
e[3:9:2]

array([3, 5, 7])

# 如果我们想指定访问索引为3，5，8这三个数，不是等间距
# 我们可以将索引存储
indx = [3, 5, 8]
e[indx]

array([3, 5, 8])

# 如果我们存储的索引是一个二维的数组
# 那么结果也会是二维的
index = np.array([[0, 2], [1, 3]])

e[index]

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

E = e.reshape(4, -1)
E

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

# 定义行和列的索引
row = np.array([0, 1, 2])
col = np.array([1, 2, 3])
E[row, col]

array([ 1,  6, 11])

# 前两行的
E[:2, col]

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

# 可以使用boolean值进行选取
col = [True, False, True, True]
E[1:3, col]

array([[ 4,  6,  7],
       [ 8, 10, 11]])

numpy的比较

e

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

e < 3

array([ True,  True,  True, False, False, False, False, False, False,
       False, False, False, False, False, False, False])

E

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

E < 6

array([[ True,  True,  True,  True],
       [ True,  True, False, False],
       [False, False, False, False],
       [False, False, False, False]])

2*E == 24 - 4 * E

array([[False, False, False, False],
       [ True, False, False, False],
       [False, False, False, False],
       [False, False, False, False]])

E != 6

array([[ True,  True,  True,  True],
       [ True,  True, False,  True],
       [ True,  True,  True,  True],
       [ True,  True,  True,  True]])

# 计算小于等于3的个数
np.sum(E <= 3)

4

# 计算小于等于3的非0个数
np.count_nonzero(E <= 3)

4

# 判断是否有含0元素
np.any(E == 0)

True

# 所有元素必须满足条件才返回true
np.all(E >= 1)

False

# 沿着某个方向判断
np.sum(E%2==0, axis=0)

array([4, 0, 4, 0])

# 必须是位运算的与或才能得到数组结果
np.sum((e % 2 == 0) | (e > 10))

11

# 查看满足调节的具体值
# 找到每行最后一个数字可以被3整除的结果
E[E[:,3]%3==0,:]

array([[ 0,  1,  2,  3],
       [12, 13, 14, 15]])
松鼠MaSaKi
关注
专栏目录
零基础，numpy入门教程
04-19
**numpy入门教程** 在Python的世界里，NumPy（Numerical Python）是进行高效数值计算的基石，它提供了强大的数组操作和矩阵运算功能。对于初学者来说，掌握NumPy的基础知识至关重要，因为它为科学计算提供了坚实的...
PyTorch基础学习
qq_42504905的博客
04-19 1809
1.tensor tensor中最常使用的就是FloatTensor和LongTensor，分别代表了浮点数和整型 注意：定义一个张量tensor时，T可以大写可以小写，代表的是同样的意思，但定义整型和浮点数的时候F和T一类的必须要大写 Tensor是类，是FloatTensor的别名。 tensor是函数，可根据 detype指定类别。 两者在生成0维变量时有区别。 一般情况下用tensor即可。 1.1tensor的分类 张量tensor分为0维张量1维张量二维张量和多维张量 0维张量就是标量 a =
Numpy中进行数组数据乘法运算（*号或者np.multiply）
sdgfbhgfj的博客
03-29 1592
Numpy中进行数组数据乘法运算（*号或者np.multiply）
python中数组和矩阵乘法及使用总结
manjhOK的博客
04-20 3万+
Matrix是Array的一个小的分支，包含于Array。所以matrix 拥有array的所有特性。但在数组乘和矩阵乘时,两者各有不同,如果a和b是两个matrices，那么a*b，就是矩阵积如果a,b是数组的话,则a*b是数组的运算1.对数组的操作&gt;&gt;&gt; import numpy as np&gt;&gt;&gt; a=np.array([[1,2,3],[4,5,6],[7...
numpy 模块当中常用统计函数、矩阵、矩阵运算的简单介绍（2）
qq_37925969的博客
11-23 1654
2021.11.23 今天我们来学习numpy 里面的常用统计函数。 重点来看一下标准差和方差。 numpy.amin numpy.amax 分别可以返回numpy 当中指定轴向的最大值和最小值。 numpy.ptp() 返回数组当中最大值和最小值得差 最大值-最小值。 numpy.median 用来计算数组当中的元素的中位数 演示一下 numpy.ptp() import numpy as np arr = np.random.randint(1,100,size=(5,6)) arr array([[
numpy矩阵拼接_NumPy 基础（中篇）
weixin_39622905的博客
12-01 749
3 numpy.array 基本操作import numpy as np np.random.seed(0) x = np.arange(10) xarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])X = np.arange(15).reshape((3, 5)) Xarray([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, ...
Python科学计算之NumPy入门教程
09-21
这是因为NumPy内部使用了高效的C语言实现，并且数组中的所有元素都是相同的数据类型。 #### 二、NumPy数组的基本概念 ##### 1. 创建NumPy数组 - 使用`numpy.array`函数可以创建一个NumPy数组。 ```python import...
Numpy入门与实践（课件）
12-10
Numpy 是 Python 中用于科学计算的核心库...掌握 Numpy 的使用，能够显著提高数据处理的效率和代码的可读性。通过学习 Numpy，开发者可以更好地应对大规模的数值计算任务，为后续的高级数据分析和建模打下坚实的基础。
python-pytorch-opencv-numpy入门程序实操
最新发布
01-14
在`numpy_basic.py`中，你将学习如何创建、操作和索引数组，以及使用广播规则进行元素级运算。NumPy对于处理大量数据尤其有用，是数据分析和机器学习算法的底层工具。 最后，我们转向OpenCV，这是一个强大的计算机...
线性代数矩阵行列式_非平方矩阵的行列式| 使用Python的线性代数
cumubi7552的博客
07-04 1493
线性代数矩阵行列式Prerequisites: 先决条件： Defining a Matrix 定义矩阵 Determinant of a Matrix 矩阵的行列式 Note: Determinant is not defined for a non-square matrix. 注意：未为非正方形矩阵定义行列式。 In linear algebra, the determinant i...
numpy 数组和矩阵的乘法的理解
热门推荐
bbbeoy的专栏
05-20 4万+
1. 当为array的时候，默认d*f就是对应元素的乘积，multiply也是对应元素的乘积，dot（d,f）会转化为矩阵的乘积，  2. 当为mat的时候，默认d*f就是矩阵的乘积，multiply转化为对应元素的乘积，dot（d,f）为矩阵的乘积            3. 混合时候的情况，一般不要混合   混合的时候默认按照矩阵乘法的, multiply转化为对应
numpy数组各种乘法
weixin_30716141的博客
04-18 1525
In [34]: a Out[34]: array([[1, 4], [5, 6]]) In [35]: b Out[35]: array([[4, 1], [2, 2]]) In [36]: np.multiply(a,b) # 对应元素相乘 Out[36]: array([[ 4, 4], ...
python中矩阵乘以常数_python – 用numpy乘以高阶矩阵
weixin_39700063的博客
12-08 4165
您可以使用np.einsum进行操作,因为它可以非常小心地控制哪些轴相乘,哪些相加：>>> np.einsum('ijk,ij->ik', ind, dist)array([[ 0.4, 0.4, 0.4, 0.4],[ 3. , 3. , 3. , 3. ],[ 1. , 1. , 1. , 1. ]])该函数将ind的第一个轴中的条目与dist(下标’...
细说NumPy数组的四种乘法，带你走进向量运算的奇妙世界
Python作业辅导员 - 天元浪子
12-07 2万+
当孔乙己说回字有四样写法的时候，相信各位都是这样的表情吧？但是，如果孔乙己说NumPy数组有四种乘法的时候，各位大约就是这样的表情了吧？实际上，NumPy数组乘法远不止四种。为了在写作和阅读时保持清晰的逻辑和清醒的头脑，本文仅对四种最常见的数组乘法给出详细说明，并用一道数学题来演示向量点乘和叉乘的用法。
python 数组与常数相乘 a = [0]*x 格式含义
weixin_45057374的博客
04-27 4367
参考 https://blog.csdn.net/qq_40549751/article/details/80727884 ```python import sys a = "12352523452334" num = len(a) k = int(num/3) print(k) #[0]是一个str类型，K个str组成sub数组，list类型 sub = [0]*k for i in ran...
python矩阵乘以数_numpy中数组(矩阵)的乘法
weixin_39556853的博客
12-04 4659
我们知道在处理数据的时候，使用矩阵间的运算将会是方便直观的。matlab有先天的优势，算矩阵是它的专长。当然我们用python，经常要用到的可能是numpy这个强大的库。矩阵有两种乘法，点乘和对应项相乘(element-wise product)。在numpy中应该怎么实现呢，看看下面的例子就明白了。## A = B = array([[1, 2],## [3, 4]...
numpy矩阵乘法及数学矩阵算术乘法
Harry_Jack的博客
10-02 1958
一、numpy生成的array对象，在使用*和np.multiply时，是接的两者对象对应位置相乘。 1、矩阵*乘列向量 a=np.array([[1,2],[3,4]]) a array([[1, 2], [3, 4]]) b=np.array([[2],[3]]) b array([[2], [3]]) a*b ans=a*b ans array([[ 2, 4], [ 9, 12]]) 2、矩阵*乘常数 ans=a*2 ans array([[2, 4
Python矩阵运算
qq_31409555的博客
05-17 1501
Python使用NumPy包完成了对N-维数组的快速便捷操作。使用这个包，需要导入numpy。SciPy包以NumPy包为基础，大大的扩展了numpy的能力。建立矩阵matI=np.array([1,2,3],dtype=int) 建立一个一维数组，数据类型是int。也可以不指定数据类型，使用默认。几乎所有的数组建立函数都可以指定数据类型，即dtype的取值。 matII=np.array(
SciPy与NumPy入门指南
在数据科学和机器学习领域，NumPy和SciPy经常一起使用，形成强大的数据处理工具链。它们能够与其它库，如Pandas（用于数据清洗和分析）和Matplotlib（用于数据可视化）无缝集成，构建出完整的数据分析流程。同时，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值