numpy模块

Numpy是Python中用于科学计算的核心库。它提供了一个高性能的多维数组对象，以及处理这些数组的工具。

1、数组

numpy数组是由相同类型的值组成的网格，并由一组非负整数进行索引。维数为数组的秩;数组的形状是一个整数元组，它给出了数组在每个维度上的大小。

从列表创建数组

import numpy as np

a = np.array([1, 2, 3])   # 通过列表创建一个一维数组
print(type(a))            # 输出 "<class 'numpy.ndarray'>"
print(a.shape)            # 输出 "(3,)"
print(a[0], a[1], a[2])   # 输出 "1 2 3"
a[0] = 5                  # 改变数组中的一个元素
print(a)                  # 输出 "[5, 2, 3]"

b = np.array([[1,2,3],[4,5,6]])    # 通过列表创建一个二维数组
print(b.shape)                     # 输出 "(2, 3)"
print(b[0, 0], b[0, 1], b[1, 0])   # 输出 "1 2 4"

通过函数创建数组

import numpy as np

a = np.zeros((2,2))   # 创建元素全为0的数组
print(a)              # 输出 "[[ 0.  0.]
                      #          [ 0.  0.]]"

b = np.ones((1,2))    # 创建元素全为1的数组
print(b)              # 输出 "[[ 1.  1.]]"

c = np.full((2,2), 7)  # 创建一个常数数组
print(c)               # 数组 "[[ 7.  7.]
                       #          [ 7.  7.]]"

d = np.eye(2)         # 创建一个2*2的单位矩阵
print(d)              # 输出 "[[ 1.  0.]
                      #          [ 0.  1.]]"

e = np.random.random((2,2))  # 创建一个随机矩阵
print(e)                     # 输出 "[[ 0.91940167  0.08143941]
                             #               [ 0.68744134  0.87236687]]"

2、数组索引

切片

使用切片得到的数组与原来的数组维数相同

import numpy as np

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

b = a[:2,1:3]

print(a[0,1]) #输出结果为2
b[0,0] = 77
print(a[0,1]) #输出结果为77

也可以混合整数索引与切片，但这样会得到一个比原来数组维数低的数组

import numpy as np

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

row_1 = a[1,:]
row_2 = a[1:2,:]
print(row_1,row_1.shape) #输出为[5，6，7，8] （4，）
print(row_2,row_2.shape) #输出为[[5，6，7，8]] （1，4）

col_1 = a[:,1]
col_2 = a[:,1:2]
print(col_1,col_1.shape) #输出为[2,6,10] (3,)
print(col_2,col_2.shape) #输出为[[2]
                         #       [6]
                         #       [10]] (3,1)

整数索引

import numpy as np

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

print(a[[0,1,2],[0,1,0]]) #索引数组的0,0 1,1 2,0元素，与下面的索引等价
print(np.array([a[0,0],a[1,1],a[2,0]]))

除此之外，整数索引可以用来实如下功能：对矩阵中的某些特定元素实现计算，如：

import numpy as np

a = np.array([[1,2,3],[4,5,6],[7,8,9]]) #[[1,2,3]
                                        # [4,5,6]
                                        # [7,8,9]]
#创建索引
b = [0,1,2]

print(a[np.arange(3),b])

#实现数组中特定元素的计算
a[np.arange(3),b] += 10
print(a)

#输出结果为
# [[11  2  3]
#  [ 4 15  6]
#  [ 7  8 19]]

布尔索引

通常这类索引用于选取某些符合特定条件的数组元素

import numpy as np

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

bool_idx = (a > 2)   # Find the elements of a that are bigger than 2;
                     # this returns a numpy array of Booleans of the same
                     # shape as a, where each slot of bool_idx tells
                     # whether that element of a is > 2.

print(bool_idx)      # Prints "[[False False]
                     #          [ True  True]
                     #          [ True  True]]"

# We use boolean array indexing to construct a rank 1 array
# consisting of the elements of a corresponding to the True values
# of bool_idx
print(a[bool_idx])  # Prints "[3 4 5 6]"

# We can do all of the above in a single concise statement:
print(a[a > 2])     # Prints "[3 4 5 6]"

3、数据类型

通过arr.dtype可以查看数组的数据类型，也可以在创建数组的时候，通过dtype参数来指定数据的类型，如：

import numpy as np

a = np.array([1.,2,3],dtype = np.float32)
print(a.dtype)

4、数组的数学运算

import numpy as np

x = np.array([[1,2],[3,4]],dtype = np.float64)
y = np.array([[5,6],[7,8]],dtype = np.float64)

#[[6.8 8.0]
# [10.0 12.0]]
#两个输出结果一样
print(x + y)
print(np.add(x,y))

#[[-4.0 -4.0]
# [-4.0 -4.0]]
#两个输出结果一样
print(x - y)
print(np.subtract(x,y))

#[[5.0 12.0]
# [21.0 32.0]]
#两个输出结果一样
print(x * y)
print(np.multiply(x,y))

#[[0.2 0.33333333]
# [0.42857143 0.5]]
#两个输出结果一样
print(x / y)
print(np.divide(x,y))

#[[1. 1.41421356]
# [1.73205081 2.]]
print(np.sqrt(x))

import numpy as np

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

v = np.array([9,10])
w = np.array([11,12])

#向量的内积
#输出结果均为219
print(v.dot(w))
print(np.dot(v,w))

#矩阵与向量的成乘积
#输出结果均为[29 67]
print(x.dot(v))
print(np.dot(x,v))

#矩阵的内积
#输出结果为[[19 22]
#          [43 50]]
print(x.dot(y))
print(np.dot(x,y))

下面是一些数组计算的函数

import numpy as np

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

#计算所有元素的和
print(np.sum(x))

#计算每一列的和
print(np.sum(x,axis=0))

#计算每一行的和
print(np.sum(x,axis=1))

更多的函数说明：点击这里

对数组的数据进行转置或者其他操作：

import numpy as np

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

print(x)
print(x.T)

v = np.array([1,2,3])
print(v)
print(v.T)

更多操作：点击这里

5、广播

数组的加减乘除等运算都是对应元素之间的计算

当数组的形状不一样时，我们可以通过扩展数组来实现计算，这种机制叫做广播

当运算的两个数组形状不相同，numpy自动触发广播机制

我们经常会使用一个较小的数组，对一个较大的数组进行运算，这时广播机制的作用就体现出来了

如：

import numpy as np

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

y = x + v
print(y)
#输出结果为
# [[ 2  2  4]
#  [ 5  5  7]
#  [ 8  8 10]
#  [11 11 13]]

广播机制的原则：

• 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
• 输出数组的形状是输入数组形状的各个维度上的最大值。
• 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
• 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。

更多numpy模块知识，点击这里