Numpy

Numpy 支持大量的数组与矩阵运算.

基础

导入

首先需要导入numpy这个库，一般可以命名为np。

import numpy as np

创建

可以通过array()函数定义数字实例对象。
例如，可以导入一个3行3列的数组：

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

可以创建一个数组，并且设置它的行列。
-1是模糊控制，比如(3,-1)就是三行，列数不固定，根据多少个数字自动判断。如果不能整除就会报错。

w1 = np.arange(12).reshape(3,4)
w1
#array([[ 0,  1,  2,  3],
#       [ 4,  5,  6,  7],
#       [ 8,  9, 10, 11]])
w2 = np.arange(12).reshape(2, 2, 3)
x2
#array([[[ 0,  1,  2],
#        [ 3,  4,  5]],
#
#       [[ 6,  7,  8],
#        [ 9, 10, 11]]])
w3 = np.arange(12).reshape(3,-1)
w3
#array([[ 0,  1,  2,  3],
#       [ 4,  5,  6,  7],
#       [ 8,  9, 10, 11]])

功能	公式
查看维度	a.ndim
查看行列数	a.shape
查看元素类型	a.dtype

特殊数组

特殊

函数	参数
np.zeros	([维度,行,列]) 全部是0
np.ones	([维度,行,列]) 全部是1
np.empty	([维度,行,列])只分配内存空间，不需要填充数值
np.eye	(行,列) 单位矩阵 eye也能创建矩阵，但1的位置是单位矩阵的位置
np.identity	(阶数) 单位矩阵 identity只能创建方阵

np.zeros([2,3])
#array([[0., 0., 0.],
#       [0., 0., 0.]])
np.zeros(2)
#array([0., 0.])

np.ones(3)
# array([1., 1., 1.])

np.empty([2,1,3])
#array([[[0., 0., 0.]],
#
#       [[0., 0., 0.]]])

np.eye(3,2)
#array([[1., 0.],
#       [0., 1.],
#       [0., 0.]])

np.identity(3,2)
#array([[1., 0.],
#       [0., 1.],
#       [0., 0.]])

对角阵diag()

diag(v,k=0)

1. v
   如果v是一维数组，返回以一维数组为对角线元素的矩阵；
   如果v是二维数组，返回对角元素。
2. k
   默认k=0，无影响；
   k>0 : 主对角线上的对角线元素；
   k<0 : 主对角线下的对角线元素。

w = np.arange(16).reshape(4,-1)
np.diag(w)
# array([ 0,  5, 10, 15])
np.diag(w,k=1)
# array([ 1,  6, 11])
np.diag(w,k=-1)
# array([ 4,  9, 14])
w2 = np.arange(5)
np.diag(w2)
#array([[0, 0, 0, 0, 0],
#       [0, 1, 0, 0, 0],
#       [0, 0, 2, 0, 0],
#       [0, 0, 0, 3, 0],
#      [0, 0, 0, 0, 4]])

序列数组

可以用来构建等差/等比序列。

函数	参数
np.arange	(start=0, stop, step=1, dtype)
np.linspace	(start, stop, num=50, endpoint=True, retstep=False, dtype=None);第三个参数默认为True包含stop值，否则不包含。第四个参数如果为 True 时，生成的数组中会显示间距
np.logspace	(np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None))；参数base表示底数

np.arange(5)  
#array([0, 1, 2, 3, 4])
np.linspace(1,10,5)
#array([ 1.  ,  3.25,  5.5 ,  7.75, 10.  ])
np.logspace(2,8,3,base=2)
#array([  4.,  32., 256.])

切片

Numpy数组的切片是原数组的一部分，并非其拷贝。

d = np.array([1,2,3,4,5,6,7,8,9,10])
print(d)
 #  [ 1  2  3  4  5  6  7  8  9 10]
d1 = d[2:5]             #切片
print(d1)
 # [3 4 5]
d2 = np.copy(d[2:5])    #拷贝
d1[1] = 100
print(d)
 # [  1   2   3 100   5   6   7   8   9  10]
d2[2] = 110
print(d)
 # [  1   2   3 100   5   6   7   8   9  10]

索引

基本索引

z=np.arange(8)
zm = slice(2,5,2)
print(z[zm])
# [2 4]

slice可以表示索引。slice(start,stop,step)

切片索引

[ ] 用法和之前相同,也是包括左端点不包括右断点。…可以代表一行或一列。

a=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
a[1:]
#array([[ 5,  6,  7,  8],
#      [ 9, 10, 11, 12]])
a[...,1]  #只找某一列
#array([ 2,  6, 10])

还可以从两个列表中抽取，第一个列表表示行索引，第二个列表表示列索引。

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

同时，索引具有广播机制。即两个列表中的索引数量，自动填充成一样的。例如array[[x1],[y1,y2]] 会自动填充成array[[x1x1],[y1,y2]]

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

数组比列表多了一个列表索引，扩展了列表的功能，广播机制避免重复赋值

整数数组索引

比如希望找到多个位置的数字。可以构造两个列表，第一个代表行，第二个代表列，两个元组必须是相对应的。
例如，需要寻找(0,0) (1,2) (2,3)

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

布尔索引

利用布尔条件进行索引。

a[a>6]
# array([ 7,  8,  9, 10, 11, 12])

花式索引

利用整数数组进行索引，这里的整数数组可以是Numpy数组也可以是Python中列表、元组等可迭代类型。
花式索引根据索引整型数组的值作为目标数组的某个轴的下标来取值。

1. 如果目标是一维数组，那么索引的结果就是对应下标的行;
2. 如果目标是二维数组，那么就是对应位置的元素。

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

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

x[[-3,-1,-2]]
#array([[ 0,  1,  2,  3],
#       [ 8,  9, 10, 11],
#       [ 4,  5,  6,  7]])

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

最后一个需要特殊说明一下。最后一个函数 np.ix_ 可以选择多个索引，并重新组合成新的数组。
例子中也就是，先固定第一个数组的1行，再选择列的2,0,1,3；然后再从第一个数组的2行，选择列的2,0,1,3；最后从第一个数组的最后0行，再选择列的2,0,1,3，最后构成了一个新的数组。

生成随机数

函数	用法
rand	均匀分布的随机数(维度)
randn	标准正态分布的随机数(维度)
randint	随机整数(low,high,size,dtype)

np.random.rand(3,5)
#array([[0.02029698, 0.33924335, 0.22047586, 0.88069056, 0.49557833],
#       [0.84856976, 0.66960322, 0.30048355, 0.3230452 , 0.65647734],
#       [0.33263603, 0.21739191, 0.51125075, 0.99006751, 0.36142488]])
np.random.randn(3,5)
#array([[ 0.36271351, -0.81410065, -1.1630762 ,  0.43639202, -2.22195516],
#       [ 0.40427921, -1.40349563, -0.21728049,  0.22387901,  0.3027725 ],
#       [ 2.85376856,  1.69154093, -1.05399594,  1.00912313, -0.48393383]])
np.random.randint(1,8,10)
#array([3, 1, 2, 7, 4, 2, 4, 7, 1, 2])

矩阵

Numpy函数库中存在两种不同的数据类型（矩阵matrix和数组array）

创建矩阵

mat（）函数 将目标数据的类型转化成矩阵。

mat() 函数与array()函数区别：

1. 所需的数据格式有区别，mat()函数中数据可以为字符串以分号（;）分割或者为列表形式以逗号（，）分割，而array()函数中数据只能为后者形式。
2. 类型不同：用mat函数转换为矩阵后才能进行一些线性代数的操作。

a = np.mat('1 2;3 4')
a
#matrix([[1, 2],
#        [3, 4]])
type(a)
#numpy.matrix
w = np.array([[1,2],[3,4]])
type(w)
# numpy.ndarray

矩阵运算

乘积

np.dot(a,b) 数组 a·b，需要a的列数等于b的行数。
数乘直接就用*号，a和b的列数相同。