NumPy教程（Numpy基本操作、Numpy数据处理）Numpy 属性
介绍⼏种 numpy 的属性:
· ndim：维度
· shape：⾏数和列数
· size：元素个数
使⽤numpy⾸先要导⼊模块
import numpy as np
#为了⽅便使⽤numpy 采⽤np简写
列表转化为矩阵：
python array = np.array([[1,2,3],[2,3,4]])
#列表转化为矩阵
print(array)
""" array([[1, 2, 3], [2, 3, 4]]) """
numpy 的⼏种属性
接着我们看看这⼏种属性的结果:
print('number of dim:',array.ndim)# 维度
#number of dim: 2
print('shape :',array.shape)# ⾏数和列数
shape :(2,3)
print('size:',array.size)# 元素个数
size:6
Numpy 创建 array
关键字
· array：创建数组
· dtype：指定数据类型
· zeros：创建数据全为0
· ones：创建数据全为1
· empty：创建数据接近0
· arrange：按指定范围创建数据
· linspace：创建线段
创建数组
a = np.array([2,23,4])# list 1d
print(a)
#[2 23 4]
指定数据 dtype
a = np.array([2,23,4],dtype=np.int)
print(a.dtype)
#int 64
a = np.array([2,23,4],dtype=np.int32)
print(a.dtype)
#int32
a = np.array([2,23,4],dtype=np.float)
print(a.dtype)
#float64
a = np.array([2,23,4],dtype=np.float32)
print(a.dtype)
float32
创建特定数据
a = np.array([[2,23,4],[2,32,4]])# 2d 矩阵 2⾏3列
print(a)
"""
[[ 2 23  4]
[ 2 32  4]]
"""
创建全零数组
a = np.zeros((3,4))# 数据全为0，3⾏4列
"""
array([[ 0.,  0.,  0.,  0.],
[ 0.,  0.,  0.,  0.],
[ 0.,  0.,  0.,  0.]])
"""
创建全⼀数组，同时也能指定这些特定数据的 dtype:
a = np.ones((3,4),dtype = np.int)# 数据为1，3⾏4列
"""
array([[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]])
"""
创建全空数组，其实每个值都是接近于零的数:
a = np.empty((3,4))# 数据为empty，3⾏4列
"""
array([[  0.00000000e+000,  4.94065646e-324,  9.88131292e-324,          1.48219694e-323],
[  1.97626258e-323,  2.47032823e-323,  2.96439388e-323,          3.45845952e-323],
[  3.95252517e-323,  4.44659081e-323,  4.94065646e-323,          5.43472210e-323]])
"""
⽤ arange 创建连续数组:
a = np.arange(10,20,2)# 10-19 的数据，2步长
"""
array([10, 12, 14, 16, 18])
"""
使⽤ reshape 改变数据的形状
a = np.arange(12).reshape((3,4))# 3⾏4列，0到11
"""
array([[ 0,  1,  2,  3],
[ 4,  5,  6,  7],
[ 8,  9, 10, 11]])
"""
⽤ linspace 创建线段型数据:
a = np.linspace(1,10,20)# 开始端1，结束端10，且分割成20个数据，⽣成线段
"""
array([  1.        ,  1.47368421,  1.94736842,  2.42105263,
2.89473684,
3.36842105,  3.84210526,
4.31578947,
4.78947368,
5.26315789,  5.73684211,
6.21052632,
6.68421053,
7.15789474,  7.63157895,
8.10526316,
8.57894737,  9.05263158,  9.52631579,  10.        ])
"""
同样也能进⾏ reshape ⼯作:
a = np.linspace(1,10,20).reshape((5,4))# 更改shape
"""
array([[  1.        ,  1.47368421,  1.94736842,  2.42105263],
[  2.89473684,  3.36842105,  3.84210526,  4.31578947],
[  4.78947368,  5.26315789,  5.73684211,  6.21052632],
[  6.68421053,  7.15789474,  7.63157895,  8.10526316],
[  8.57894737,  9.05263158,  9.52631579,  10.        ]])
"""
Numpy 基础运算1
让我们从⼀个脚本开始了解相应的计算以及表⽰形式 ：
import numpy as np
a=np.array([10,20,30,40])# array([10, 20, 30, 40])
b=np.arange(4)# array([0, 1, 2, 3])
numpy 的⼏种基本运算 ¶
上述代码中的 a 和 b 是两个属性为 array 也就是矩阵的变量，⽽且⼆者都是1⾏4列的矩阵， 其中b矩阵中的元素分别是从0到3。 如果我们想要求两个矩阵之间的减法，你可以尝试着输⼊：
c=a-b  # array([10, 19, 28, 37])
通过执⾏上述脚本，将会得到对应元素相减的结果，即[10,19,28,37]。 同理，矩阵对应元素的相加和相乘也可以⽤类似的⽅式表⽰：
c=a+b  # array([10, 21, 32, 43])
c=a*b  # array([  0,  20,  60, 120])
有所不同的是，在Numpy中，想要求出矩阵中各个元素的乘⽅需要依赖双星符号 **，以⼆次⽅举例，即：
c=b**2# array([0, 1, 4, 9])
另外，Numpy中具有很多的数学函数⼯具，⽐如三⾓函数等，当我们需要对矩阵中每⼀项元素进⾏函数运算时，可以很简便的调⽤它们（以sin函数为例）：
c=10*np.sin(a)
array([-5.44021111,9.12945251,-9.88031624,7.4511316])
除了函数应⽤外，在脚本中对print函数进⾏⼀些修改可以进⾏逻辑判断：
print(b<3)
array([True,True,True,False], dtype=bool)
此时由于进⾏逻辑判断，返回的是⼀个bool类型的矩阵，即对满⾜要求的返回True，不满⾜的返回False。上述程序执⾏后得到的结果是[True True True False]。 需要注意的是，如果想要执⾏是否相等的判断， 依然需要输⼊ == ⽽不是 = 来完成相应的逻辑判断。
上述运算均是建⽴在⼀维矩阵，即只有⼀⾏的矩阵上⾯的计算，如果我们想要对多⾏多维度的矩阵进⾏操作，需要对开始的脚本进⾏⼀些修改：
a=np.array([[1,1],[0,1]])
b=np.arange(4).reshape((2,2))
print(a)
array([[1,1],
[0,1]])
print(b)
array([[0,1],
[2,3]])
此时构造出来的矩阵a和b便是2⾏2列的，其中 reshape 操作是对矩阵的形状进⾏重构， 其重构的形状便是括号中给出的数字。 稍显不同的是，Numpy中的矩阵乘法分为两种， 其⼀是前⽂中的对应元素相乘，其⼆是标准的矩阵乘法运算，即对应⾏乘对应列得到相应元素：
c_dot = np.dot(a,b)
array([[2,4],
[2,3]])
除此之外还有另外的⼀种关于dot的表⽰⽅法，即：
c_dot_2 = a.dot(b)
array([[2,4],
[2,3]])
下⾯我们将重新定义⼀个脚本, 来看看关于 sum(), min(), max()的使⽤：
import numpy as np
a=np.random.random((2,4))
print(a)
array([[0.94692159,0.20821798,0.35339414,0.2805278],
[0.04836775,0.04023552,0.44091941,0.21665268]])
因为是随机⽣成数字, 所以你的结果可能会不⼀样. 在第⼆⾏中对a的操作是令a中⽣成⼀个2⾏4列的矩阵，且每⼀元素均是来⾃从0到1的随机数。 在这个随机⽣成的矩阵中，我们可以对元素进⾏求和以及寻极值的操作，具体如下：
np.sum(a)# 4.4043622002745959
np.min(a)# 0.23651223533671784
np.max(a)# 0.90438450240606416
对应的便是对矩阵中所有元素进⾏求和，寻最⼩值，寻最⼤值的操作。 可以通过print()函数对相应
值进⾏打印检验。
如果你需要对⾏或者列进⾏查运算，就需要在上述代码中为 axis 进⾏赋值。 当axis的值为0的时候，将会以列作为查单元， 当axis的值为1的时候，将会以⾏作为查单元。
为了更加清晰，在刚才的例⼦中我们继续进⾏查：
print("a =",a)
a =[[0.236512240.419006610.848694170.46456022]
[0.607710870.90438450.366032850.55746074]]
print("sum =",np.sum(a,axis=1))
sum=[1.968773242.43558896]
print("min =",np.min(a,axis=0))
min=[0.236512240.419006610.366032850.46456022]
print("max =",np.max(a,axis=1))
max=[0.848694170.9043845]
Numpy 基础运算2
通过上⼀节的学习，我们可以了解到⼀部分矩阵中元素的计算和查操作。然⽽在⽇常使⽤中，对应元素的索引也是⾮常重要的。依然，让我们先从⼀个脚本开始 ：
A = np.arange(2,14).reshape((3,4))
array([[2,3,4,5]
[6,7,8,9]
[10,11,12,13]])
print(np.argmin(A))# 0
print(np.argmax(A))# 11
numpy 的⼏种基本运算
其中的 argmin() 和 argmax() 两个函数分别对应着求矩阵中最⼩元素和最⼤元素的索引。相应的，在矩阵的12个元素中，最⼩值即2，对应索引0，最⼤值为13，对应索引为11。
如果需要计算统计中的均值，可以利⽤下⾯的⽅式，将整个矩阵的均值求出来：
an(A))# 7.5
print(np.average(A))# 7.5
仿照着前⼀节中dot()的使⽤法则，mean()函数还有另外⼀种写法：
an())# 7.5
同样的，我们可以写出求解中位数的函数：
dian())# 7.5
另外，和matlab中的cumsum()累加函数类似，Numpy中也具有cumsum()函数，其⽤法如下：
print(np.cumsum(A))
#[2 5 9 14 20 27 35 44 54 65 77 90]
在cumsum()函数中：⽣成的每⼀项矩阵元素均是从原矩阵⾸项累加到对应项的元素之和。⽐如元素9，在cumsum()⽣成的矩阵中序号为3，即原矩阵中2，3，4三个元素的和。
相应的有累差运算函数：
print(np.diff(A))
[[111]
[111]
[111]]
该函数计算的便是每⼀⾏中后⼀项与前⼀项之差。故⼀个3⾏4列矩阵通过函数计算得到的矩阵便是3⾏3列的矩阵。
下⾯我们介绍⼀下nonzero()函数：
o(A))
#(array([0,0,0,0,1,1,1,1,2,2,2,2]),array([0,1,2,3,0,1,2,3,0,1,2,3]))
python 定义数组
这个函数将所有⾮零元素的⾏与列坐标分割开，重构成两个分别关于⾏和列的矩阵。
同样的，我们可以对所有元素进⾏仿照列表⼀样的排序操作，但这⾥的排序函数仍然仅针对每⼀⾏进⾏从⼩到⼤排序操作：
import numpy as np
A = np.arange(14,2,-1).reshape((3,4))
#array([[14, 13, 12, 11],
[10,9,8,7],
[6,5,4,3]])
print(np.sort(A))
array([[11,12,13,14]
[7,8,9,10]
[3,4,5,6]])
矩阵的转置有两种表⽰⽅法：

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。