numpy基础（1）

numpy基础（1）

以下教程涉及到的文字均来自于莫烦Python。有一个坑需要避免下：二维数组需要多加一个括号，要不会报错。

numpy属性

• ndim：维度
• shape：行数和列数
• size：元素个数

使用numpy首先要导入模块

import numpy as np #为了方便使用numpy 采用np简写

import numpy as np

if __name__ == '__main__':
    list = ([1, 2, 3],
            [4, 5, 6])
    print(list)
    array = np.array(list)
    # 列表转矩阵
    print(array)
    # 维度
    print(array.ndim)
    # 行数和列数
    print(array.shape)
    # size
    print(array.size)

创建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.        ]])
"""

自己实验可以使用的案例

import numpy as np


if __name__ == '__main__':
    # 一维数组
    a = np.array([2, 23, 4])
    print(a)
    # 指定类型 ,int类型
    a = np.array([2, 23, 4],dtype=np.int32)
    print(a)
    # float类型
    a = np.array([2, 23, 4],dtype=np.float64)
    print(a)
    a = np.array([2, 23, 4],dtype=np.float32)
    print(a)
    # 创建特定数据
    # 2dim ,这里需要注意要用两个括号引起来
    a = np.array(([2, 23, 4], [2, 23, 4]))
    print(a)
    # 1. 创建全是0 ,3row 4col 这里也是需要两个大括号
    a = np.zeros((3, 4))
    print(a)
    # 2 创建全是1 数组，
    a = np.ones((3, 4), dtype=np.int)
    print(a)
    # 3 创建空数组
    a = np.empty((3, 4))
    print(a)
    # 4 用arrange创建连续数组
    a = np.arange(10, 20, 2)
    print(a)
    # 5 reshape改变数据形状
    a = np.arange(12).reshape(3, 4)
    print(a)

numpy 基础1

上述代码中的 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.23651224  0.41900661  0.84869417  0.46456022]
# [ 0.60771087  0.9043845   0.36603285  0.55746074]]

print("sum =",np.sum(a,axis=1))
# sum = [ 1.96877324  2.43558896]

print("min =",np.min(a,axis=0))
# min = [ 0.23651224  0.41900661  0.36603285  0.46456022]

print("max =",np.max(a,axis=1))
# max = [ 0.84869417  0.9043845 ]

自己实验的代码：

import numpy as np


if __name__ == '__main__':
    # a = np.array([10,20,30,40])
    # b = np.arange(4)
    # print(a)
    # print(b)
    #    c = a * b
    # c = b **2  # [0 1 4 9]
    # c = 10 * np.sin(a) [-5.44021111  9.12945251 -9.88031624  7.4511316 ]
    # print(b < 3) [ True  True  True False]
    # print(c)
    # 多维运算
    a = np.array(([1, 1],[0, 1]))
    b = np.arange(4).reshape(2, 2)
    print(a)
    print(b)
    # c_dot = np.dot(a, b)
    c_dot = a.dot(b)  # 建议使用这种，不容易混淆
    print(c_dot)

numpy 基础2

其中的 argmin() 和 argmax() 两个函数分别对应着求矩阵中最小元素和最大元素的索引。相应的，在矩阵的12个元素中，最小值即2，对应索引0，最大值为13，对应索引为11。

如果需要计算统计中的均值，可以利用下面的方式，将整个矩阵的均值求出来：

print(np.mean(A))        # 7.5
print(np.average(A))     # 7.5

仿照着前一节中dot() 的使用法则，mean()函数还有另外一种写法：

print(A.mean())          # 7.5

同样的，我们可以写出求解中位数的函数：

print(A.median())       # 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))    

# [[1 1 1]
#  [1 1 1]
#  [1 1 1]]

该函数计算的便是每一行中后一项与前一项之差。故一个3行4列矩阵通过函数计算得到的矩阵便是3行3列的矩阵。

下面我们介绍一下nonzero()函数：

print(np.nonzero(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]))

这个函数将所有非零元素的行与列坐标分割开，重构成两个分别关于行和列的矩阵。

同样的，我们可以对所有元素进行仿照列表一样的排序操作，但这里的排序函数仍然仅针对每一行进行从小到大排序操作：

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]])

矩阵的转置有两种表示方法：

print(np.transpose(A))    
print(A.T)

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

特别的，在Numpy中具有clip()函数，例子如下：

print(A)
# array([[14,13,12,11]
#        [10, 9, 8, 7]
#        [ 6, 5, 4, 3]])

print(np.clip(A,5,9))    
# array([[ 9, 9, 9, 9]
#        [ 9, 9, 8, 7]
#        [ 6, 5, 5, 5]])

这个函数的格式是clip(Array,Array_min,Array_max)，顾名思义，Array指的是将要被执行用的矩阵，而后面的最小值最大值则用于让函数判断矩阵中元素是否有比最小值小的或者比最大值大的元素，并将这些指定的元素转换为最小值或者最大值。

实际上每一个Numpy中大多数函数均具有很多变量可以操作，你可以指定行、列甚至某一范围中的元素。更多具体的使用细节请记得查阅Numpy官方英文教材。

实验代码

import numpy as np


if __name__ == '__main__':
    A = np.arange(2, 14).reshape(3, 4)
    print(A)
    # 矩阵中最大最小的索引
    print(np.argmin(A))
    # 同上
    print(np.argmax(A))
    # 计算均值
    print(np.mean(A))
    print(np.average(A))
    # 中位数
    print(np.median(A))
    # 累加，n+1 = 前n个数的总和
    print(np.cumsum(A))
    # 累差 , n = n+1 - n
    print(np.diff(A))
    #  nonzero
    print(np.nonzero(A))
    # 排序
    a = np.arange(14, 2, -1).reshape(3, 4)
    # b = np.sort(a)
    print(np.sort(a))
    # 矩阵的转置
    print(np.transpose(a))
    print(a.T)