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([维度,行,列]) 全部是0np.ones([维度,行,列]) 全部是1np.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.])

乘积

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

索引 基本索引

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，最后构成了一个新的数组。