一.ndarray数组

（一）numpy.array()

N维数组对象（矩阵），所有元素必须是相同类型
numpy对象分为数组array和矩阵mat，需要与列表list进行区分

二维数组的第一维是列，第二维是行；（3，2）表示在一列上排序第三，一行是排序第二，即第三行第二列

[0,1,2]可以表示一维矩阵，[[0,1,2]]表示二维矩阵1*3

（二）numpy.asarray()

np.array与np.asarray功能是一样的，都是将输入转为矩阵格式。当输入是列表的时候，更改列表的值并不会影响转化为矩阵的值
输入为数组时，np.array是将输入copy过去而np.asarray是将输入cut过去，所以随着输入的改变np.array的输出不变，而np.asarray的输出在变化，并且当我们使用np.asarray改变其类型的时候(输入是float64，改为float32)，这样当输入改变的时候，np.asarray的输出也不会改变。

二.numpy.array()的方法

（一）基本属性

1. .ndim

表示维度个数

2. .dtype

(数据类型对象)属性，表示数据类型

import numpy

data=[[1,2],[3,4],[5,6]]
x=numpy.array(data)

print(x)
#[[1 2],[3 4],[5 6]]
print(x.ndim)
#2
print(x.dtype)
#int32

（二）numpy.shape和numpy.reshape

1.numpy.shape(array) / .shape

用于读取矩阵的长度，表示各维度大小

前者返回值：

当参数array为一个数时，返回空元组；
为一维矩阵时，返回一个数字的元组；
为二维矩阵时，返回行和列组成的元组

后者返回值：看前面的数组array，其他同上，不要“()”

可以认为，一维是最外面的中括号，一维数是最外面中括号内的元素数，二维是第二层，以此类推

import numpy as np

print(np.shape(7))
#()

a=numpy.array([7,8])
print(a.shape)
#(2,)

print(np.shape([[7,8],[1,2],[100,102]]))
#(3, 2)

2.numpy.reshape(array, (newshape)) / .reshape(newshape)

用于在不更改数据的情况下为数组赋予新形状。

参数：
（1）array：需要reshape的数组
（2）newshape：新形状应与原始形状兼容。如果是整数，则结果将是该长度的一维数组。一个形状尺寸可以为-1或其他负数。在这种情况下，该值是根据数组的长度和其余维由系统来推断的。

import numpy as np

a=np.array([[2,3,4],[5,6,7]])
a=np.reshape(a,(3,2))
print(a)
#[[2 3],[4 5],[6 7]]

b=np.array([[2,3,4],[5,6,7]])
b=b.reshape(2,-2)
print(b)
#[[2 3 4],[5 6 7]]

c=b.reshape(-1,2)
print(c)
#[[2 3],[4 5],[6 7]]

说明：

reshape新生成数组和原数组公用一个内存，不管改变哪个都会互相影响

import numpy as np

a=np.array([[1,2],
            [3,4]])
b=a.reshape(1,4)
b*=2

print(a)
#[[2 4]
# [6 8]]
print(b)
#[[2 4 6 8]]

可以同时使用arange和reshape创建一个数组

import numpy as np
print(np.arange(1,6).reshape(5,1))
#[[1]
# [2]
# [3]
# [4]
# [5]]

（三）数据和排序

1.numpy.sum(array,axis,dtype) / .sum(axis,dtype)

求和

参数：
（1）array
（2）axis：维度，缺省为-1
（3）dtype

2.numpy.max(array,axis,dtype) / .max(axis,dtype)

求最大值

3.numpy.min(array,axis,dtype) / .min(axis,dtype)

求最小值

4.numpy.abs(array,axis,dtype) / .abs(axis,dtype)

求绝对值

区分np.min()，np.max()，np.abs()和min()，max()，abs()

5.numpy.average(array,axis,dtype) / .average(axis,dtype)

求平均值

6.numpy.sort(array,axis,dtype) / .sort(axis,dtype)

排序

import numpy as np

vector1=np.array([26,10,15,20])

print(vector1.sum())
#71
print(vector1.max())
#26
print(vector1.min())
#10
print(np.average(vector1))
#17.75
print(np.sort(vector1))
#[10 15 20 26]

vector2=np.array([[35,5,15],
                     [10,25,45],
                     [20,40,30]])

print(vector2)
#[[35  5 15],[10 25 45],[20 40 30]]
print(vector2.max(axis=0))#第一维列取最大值
#[35 40 45]
print(vector2.max(axis=1))#第二维行取最大值
#[35 45 40]
print(vector2.sum(axis=0))#第一维列求和
#[65 70 90]
print(vector2.sum(axis=1))#第二维行求和
#[55 80 90]

（四）ravel和flatten

1.numpy.ravel() / .ravel()

将多维数组转换为一维

返回值：视图（view），会影响原始矩阵

2. .flatten()

将多维数组转换为一维

返回值：拷贝（copy），对拷贝所做的修改不会影响原始矩阵

说明：

只能适用于numpy对象，即array或者mat，普通的list列表是不行的
没有函数numpy.flatten()

import numpy as np

a = np.array([[1, 2],[3, 4]])
b=a.flatten()
b*=2
print(a)
#[[1 2],[3 4]]
print(b)
#[2 4 6 8]

c1=a.ravel()
c2=np.ravel(a)
c1*=2
print(a)
#[[2 4],[6 8]]
print(c1)
#[2 4 6 8]
print(c2)
#[2 4 6 8]

#降维默认行序有限，传入参数‘F’表示列序优先
d=a.ravel('F')
print(d)
#[2 6 4 8]

（五）其他

1.numpy.transpose() / .transpose() / .T

矩阵转置

import numpy as np

x1=np.array([[90,10,15],[20,25,30]])
x2=np.array([[5,10,15],[20,25,30],[90,10,15],[90,10,15]])
x1_x2_1=np.dot(x1,x2.transpose())
x1_x2_2=np.dot(x1,np.transpose(x2))

print(x1_x2_1)
#[[ 775 2500 8425 8425],[ 800 1925 2500 2500]]
print(x1_x2_2)
#[[ 775 2500 8425 8425],[ 800 1925 2500 2500]]

2.numpy.squeeze(array,axis) / .squeeze(array,axis)

从数组的形状中删除单维度条目，即把shape中为1的维度去掉

返回值：维度可能减少的数组

参数：
（1）array：输入的数组
（2）axis：指定需要删除的维度，但是指定的维度必须为单维度，否则将会报错；取值可为None或int或tuple of ints，可选。若axis为空，则删除所有单维度的条目

此函数不会修改原数组

在机器学习和深度学习中，通常算法的结果是可以表示向量的数组（即包含两对或以上的方括号形式[[]]），如果直接利用这个数组进行画图可能显示界面为空。可以利用squeeze()函数将表示向量的数组转换为秩为1的数组

import numpy as np

a=np.array([[1,2,3]])
b=np.squeeze(a)
c=a.squeeze()

print(b)
#[1 2 3]
print(c)
#[1 2 3]

三.一般函数

（一）产生数组

1.等差数组

1.1 numpy.arange(start,end,step)

参数：
（1）start：数值范围的起始点
（2）end：数值范围的终止点，不包括此值
（3）step：数值范围的步长

import numpy as np

print(np.arange(6))
#[0 1 2 3 4 5]
print(np.arange(0,6,2))
#[0 2 4]
print(np.arange(0,6,0.9))
#[0.  0.9 1.8 2.7 3.6 4.5 5.4]

1.2 numpy.linspace(start,stop,num,endpoint,dtype)

参数：
（1）start：数值范围的起始点
（2）stop：数值范围的终止点
（3）num（可选）：结果中的元素数，缺省为50
（4）endpoint（可选）：决定终止值是否被包含在结果数组中，若endpoint=True，结果中包括终止值，反之不包括，缺省为True
（5）dtype（可选）：决定输出数组的数据类型

说明：

numpy.linspace(start=0,stop=100,num=5)	numpy.linspace(0,100,5)
命名参数	位置参数

两者差别：

前者区间左闭右开，后者区间在endpoint=True左闭右闭，在endpoint=False左闭右开

当steps和num指定参数都是整数，arange会返回numpy.int32数据类型，而linspace会返回numpy.float数据类型

import numpy as np

a=np.arange(0,10,step=1)
b=np.arange(0,10,step=1.0)
c=np.linspace(0,10,num=10,endpoint=False)
d=np.linspace(0,10,num=11,endpoint=True)

print(a)
#[0 1 2 3 4 5 6 7 8 9]
print(b)
#[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
print(c)
#[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
print(d)
#[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]

2.常数数组

2.1 numpy.ones(shape,dtype)

生成全1矩阵

参数：
（1）shape：可以是数也可以是元组，表示数组的形状
（2）dtype

import numpy as np

a=np.ones(4)
b=np.ones((2,3,4),dtype=np.int32)

print(a)
#[1. 1. 1. 1.]
print(b)
#[[[1 1 1 1]
#  [1 1 1 1]
#  [1 1 1 1]]
# [[1 1 1 1]
#  [1 1 1 1]
#  [1 1 1 1]]]

2.2 numpy.zeros(shape,dtype)

生成全0矩阵

参数：
（1）shape：可以是数也可以是元组，表示数组的形状
（2）dtype

import numpy as np

a=np.zeros(5)
b=np.zeros((3,4))

print(a)
#[0. 0. 0. 0. 0.]
print(b)
#[[0. 0. 0. 0.]
# [0. 0. 0. 0.]
# [0. 0. 0. 0.]]

2.3 numpy.full(shape, fill_value, dtype)

生成全是同一个元素的矩阵

参数：
（1）shape：可以是数也可以是元组，表示数组的形状
（2）fill_value：填满的值

import numpy as np

a=np.full(2,3)
b=np.full((2,3),4)

print(a)
#[3 3]
print(b)
#[[4 4 4],[4 4 4]]

3.随机数组numpy.random

numpy.random.seed(int)
随机数种子

以下函数的返回值：

当函数括号内没有参数时，则返回一个浮点数或整数
当函数括号内有一个参数时，则返回秩为1的一维数组，不能表示向量和矩阵
当函数括号内有两个及以上参数时，则返回对应维度的数组，能表示向量或矩阵

3.1 numpy.random.rand()

生成在[0,1)区间服从均匀分布的随机小数

参数：即数组形状，缺省时输出1个值

import numpy as np

np.random.seed(2)

a=np.random.rand()
b=np.random.rand(2)
c=np.random.rand(2,3)

print(a)
#0.43599490214200376
print(b)
#[0.02592623 0.54966248]
print(c)
#[[0.43532239 0.4203678  0.33033482]
# [0.20464863 0.61927097 0.29965467]]

3.2 numpy.random.random()

生成在[0,1)区间的随机小数

参数：即数组形状，两个参数以上需要元组形式，缺省时输出1个值

import numpy as np

np.random.seed(1)

a=np.random.random()
b=np.random.random(2)
c=np.random.random((2,3))

print(a)
#0.417022004702574
print(b)
#[7.20324493e-01 1.14374817e-04]
print(c)
#[[0.30233257 0.14675589 0.09233859]
# [0.18626021 0.34556073 0.39676747]]

numpy.random.rand()和numpy.random.random()在使用同样的随机数种子时，似乎会产生同样的随机数，其他函数没有这种情况

3.3 numpy.random.randn()

生成服从（0，1）正态分布的小数

参数：即数组形状，缺省时输出1个值

import numpy as np

np.random.seed(1)

a=np.random.randn()
b=np.random.randn(2)
c=np.random.randn(2,3)
d=4*np.random.randn(3,3,3) + 3 #生成服从均值为3，标准差为4的正态分布的三维数组

print(a)
#1.6243453636632417
print(b)
#[-0.61175641 -0.52817175]
print(c)
#[[-1.07296862  0.86540763 -2.3015387 ]
# [ 1.74481176 -0.7612069   0.3190391 ]]

print(d) #三维数组
#[[[ 2.0025185   8.84843175 -5.24056284]
#  [ 1.71033118  1.46378258  7.53507777]
#  [-1.39956507  2.31028717 -0.51143367]]
# [[ 3.16885499  5.33126085 -1.40247671]
#  [ 7.57889484  6.60636288  5.00997736]
#  [ 6.6034238   0.26508856  2.5084391 ]]
# [[-0.74307774  1.92844768  5.12142187]
#  [ 0.23335699  1.41298589  0.2513092 ]
#  [-0.38082257  0.31501548  2.9493416 ]]]

3.4 numpy.random.randint(*args) / numpy.random.randint(low,high,size,dtype)

生成在一定区间的整数，至少要有一个参数

参数：
（1）*args：三个数字，用于分别对应low，high，size
（2）low（可选）：int or float，生成数值的最小值（包含），缺省为0
（3）high：int or float，生成数值的最大值（不包含）
（4）size（可选）：int or tuple of ints，随机数的尺寸，整数表示生成的数量，元组表示数组的形状，缺省为1，空元组视为1
（5）dtype（可选）：输出的结果类型，缺省为int

import numpy as np

np.random.seed(1)

a=np.random.randint(10) #0到10的一个随机整数
b=np.random.randint(1,10) #1到10的一个随机整数
c=np.random.randint(1,10,10) #1到10的十个随机整数，构成一维数组
d=np.random.randint(10,99,(5,5)) #10到99的二十五个随机整数，构成5*5的二维数组

print(a)
#5
print(b)
#9
print(c)
#[6 1 1 2 8 7 3 5 6 3]
print(d)
#[[94 21 38 39 24]
# [60 78 97 97 96]
# [23 19 17 73 71]
# [32 67 11 10 70]
# [91 18 98 23 57]]

特殊用法：

import numpy as np

np.random.seed(1)

# 可单独指定每个元素的最小值和最大值
# 如果不指定 size 默认根据第一个和第二个参数的长度来决定生成结果的长度
a=np.random.randint([3, 5, 7], 10) #生成3个分别不小于3,5,7的值，都小于10的值
print(a)
#[8 8 7]

b=np.random.randint(1, [3, 5, 10]) #生成3个都不小于1，分别小于3,5,10的值
print(b)
#[1 4 6]

c=np.random.randint([1, 2, 3,], [4, 5, 10]) #生成3个分别不小于1,2,3，分别小于4,5,10的值
print(c)
#[1 2 4]

#生成2*4的数组，其中每一行不小于[1, 3, 5, 7]，第一行都小于10，第二行都小于20
#注意第二个参数里面的每个元素都要用[]，因为它控制的是一整行
d=np.random.randint([1, 3, 5, 7], [[10], [20]])
print(d)
#[[ 8  8  9  9]
# [19  8  7 11]]

#生成4*2的数组，其中，第一行都不小于1，第二行都不小于3，第三行都不小于5，第四行都不小于7，每一行都小于[10,20]
e=np.random.randint([[1],[3],[5],[7]],[10,20])
print(e)
#[[ 3  5]
# [ 4  3]
# [ 6 14]
# [ 8 13]]

当产生二维以上的数组时，numpy.random.rand()和numpy.random.randn()只需要一个小括号()，而numpy.random.random()和numpy.random.randint()需要两个小括号()

3.5 numpy.random.uniform(low, high, size)

生成在一定区间的浮点数

参数：
（1）low：float类型，生成数值的最小值（包含），缺省为0
（2）high：float类型，生成数值的最小值（不包含），缺省为1
（3）size：int或整数元组类型，表示输出数组的形状，缺省时输出1个值

import numpy as np

np.random.seed(1)

a=np.random.uniform()
b=np.random.uniform(2,4,3)
c=np.random.uniform(2,3,(2,4))

print(a)
#0.417022004702574
print(b)
#[3.44064899 2.00022875 2.60466515]
print(c)
#[[2.14675589 2.09233859 2.18626021 2.34556073]
# [2.39676747 2.53881673 2.41919451 2.6852195 ]]

3.6 numpy.random.normal(loc, scale, size)

生成正态分布概率密度随机数

参数：
（1）loc：float，此概率分布的均值，缺省为0.0
（2）scale：float，此概率分布的标准差，缺省为1.0
（3）size：int或整数元组，表示输出数组的形状，缺省时输出1个值

import numpy as np

np.random.seed(1)

a=np.random.normal()
b=np.random.normal(2,4,3)
c=np.random.normal(2,3,(2,4))

print(a)
#1.6243453636632417
print(b)
#[-0.44702565 -0.11268701 -2.29187449]
print(c)
#[[ 4.59622289 -4.90461609  7.23443529 -0.2836207 ]
# [ 2.95711729  1.25188887  6.38632381 -4.18042213]]

特殊用法：

import numpy as np

np.random.seed(1)

loc = [0,2,4,6]
scale = [1,3,5,7]

a=np.random.normal(loc, scale)
b=np.random.normal(loc, scale, size=4)
c=np.random.normal(loc, scale, size=(3,4))
d=np.random.normal(loc, scale, size=(2,3,4))

#输出数组形状最后一维与列表等长，四个表示同时处理四组数据
print(a)
#[ 1.62434536  0.16473076  1.35914124 -1.51078036]
print(b)
#[ 0.86540763 -4.90461609 12.72405882  0.67155169]
print(c)
#[[ 0.3190391   1.25188887 11.31053969 -8.42098497]
# [-0.3224172   0.84783694  9.66884721 -1.69923887]
# [-0.17242821 -0.63357525  4.21106873 10.0797065 ]]
print(d)
#[[[-1.10061918  5.43417113  8.5079536   9.51746037]
#  [ 0.90085595 -0.05118358  3.38554887 -0.55038604]
#  [-0.26788808  3.5910664   0.54169624  3.22272531]]
# [[-0.6871727  -0.53561692  0.64376935  5.91134781]
#  [-1.11731035  2.70324709 12.29901089 11.19430912]
#  [-0.19183555 -0.66288689  0.26420853 17.84718221]]]

3.7 numpy.random.choice(array, size, replace, p)

随机返回指定形状的元素，至少要有一个参数

参数：
（1）array：数组array或列表list或元组tuple，必须一维，取数字的来源
（2）size：int或整数元组，表示输出数组的形状，缺省时输出1个值
（3）replace：布尔值，表示是否可以取相同数字，缺省为True
（4）p：与数组array相对应，要求等长但形式不需要一致，表示取数组array中每个元素的概率，并不是绝对概率0<p<1，而是相对权重，缺省时选取每个元素的概率相同。

import numpy as np

np.random.seed(1)

m=[1,3,5,7,9]
n=(2,4,6,8,10)

a=np.random.choice(m)
b=np.random.choice(m,2)
c=np.random.choice(m,(2,3))
d=np.random.choice(n,(2,3),m)

print(a)
#7
print(b)
#[9 1]
print(c)
#[[3 7 1]
# [1 3 9]]
print(d)
#[[10  4  6]
# [10  6 10]]

x=np.random.choice(m,(2,2),replace=True)
y=np.random.choice(m,(2,2),replace=False)

print(x)
#[[7 9]
# [5 9]]
print(y)
#[[7 9]
# [3 1]]

3.8 numpy.random.shuffle(x)

对给定的数组在第一维上进行重新排列，在原数组上进行，改变自身序列，无返回值。

import numpy as np

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

np.random.shuffle(a)
print(a)
#[[ 9 10 11]
# [ 6  7  8]
# [ 3  4  5]
# [ 0  1  2]]

np.random.shuffle(a)
print(a)
#[[ 9 10 11]
# [ 6  7  8]
# [ 3  4  5]
# [ 0  1  2]]

3.9 numpy.random.permutation(x)

对给定的数组在第一维上进行重新排列，不在原数组上进行，返回新的数组，不改变自身数组

numpy.random.permutation(int)==numpy.random.permutation(numpy.arange(int))

import numpy as np

n=np.random.permutation(10)
print(n)
#[7 9 8 6 2 1 3 5 0 4]

a = np.arange(9).reshape((3, 3))
print(a)
#[[0 1 2]
# [3 4 5]
# [6 7 8]]
b = np.random.permutation(a)
print(a)
#[[0 1 2]
# [3 4 5]
# [6 7 8]]
print(b)
#[[0 1 2]
# [6 7 8]
# [3 4 5]]

（二）维度运算

numpy.newaxis

插入新维度

y=x[:,np.newaxis]效果相当于在最里层中括号内的元素加上一个中括号，y=x[np.newaxis,:]效果相当于在最外层加上一个中括号

import numpy as np

x1=np.arange(3)
print(np.shape(x1))
#(3,)

x2=x1[:,np.newaxis]
print(x2)
#[[0],[1],[2]]
print(np.shape(x2))
#(3, 1)

x3=x1[np.newaxis,:]
print(x3)
#[[0 1 2]]
print(np.shape(x3))
#(1, 3)


vector1=np.array([5,10,15,20])
print(vector1[0:3])
#[ 5 10 15]

vector2=np.array([[5,10,15],[20,25,30],[35,40,45]])

print(vector2[:,1])
#[10 25 40]
print(vector2[:,0:2])
#[[ 5 10],[20 25],[35 40]]
print(vector2[1:3,0:2])
#[[20 25],[35 40]]

（三）元素运算

1.矢量与矢量的常规运算，矢量和标量的运算

前者，形状大小相同的数组键间的运算应用在元素上，对应元素相加减乘除
后者，标量运算应用在每一个元素上

对应元素相乘	对应元素相除
array1*array2	array1/array2
numpy.multiply(array1,array2)	numpy.divide(array1,array2)

import numpy as np

a=np.array([1,2])
b=np.array([3,4])
c1=b+a
c2=b-a
c3=b*a
c4=b/a
d=a*2+b*3

print(c1)
#[4 6]
print(c2)
#[2 2]
print(c3)
#[3 8]
print(c4)
#[3. 2.]
print(d)
#[11 16]


vector1=numpy.array([[2,6,3],[2,1,2]])
vector2=numpy.array([[1,2,3],[4,5,8]])

m1=vector1*vector2
m2=numpy.multiply(vector1,vector2)
print(m1)
#[[ 2 12  9],[ 8  5 16]]
print(m2)
#[[ 2 12  9],[ 8  5 16]]

n1=vector1/vector2
n2=numpy.divide(vector1,vector2)
print(n1)
#[[2.   3.   1.  ],[0.5  0.2  0.25]]
print(n2)
#[[2.   3.   1.  ],[0.5  0.2  0.25]]

2.广播Broadcast

如果形状不同，numpy将会自动兼容。
所谓兼容，要保证两个数组行和列至少有一个相同，且其中一个为一维数组或者秩为1的二维数组

import numpy as np

a=np.array([[1,2],[2,6]])
b1=np.array([1,2])
b2=np.array([[1,2]])
b3=np.array([[[1,2]]])
            
print(a+b1)
#[[2 4],[3 8]]
print(a+b2)
#[[2 4],[3 8]]
print(a+b3)
#[[[2 4],[3 8]]]
print(a*b1)
#[[ 1  4],[ 2 12]]

3.numpy.all()

判断整个数组中的元素的值是否全部满足条件

返回值：如果全部满足条件返回True，否则返回False。

4.numpy.absolute() / numpy.abs()

对数组中的每一个元素求其绝对值

import numpy as np

a=np.array([4,2,3])
b=np.array([1,6,9])
c=b-a
print(c)
#[-3  4  6]

d=np.absolute(c)
print(d)
#[3 4 6]

if numpy.all((d)>1):
    print('yes')
    #yes

5.numpy.floor(array,dtype)

对array中每个元素向下取整

import numpy as np

a=np.array([-1.5,-0.5,0.5,1.5])
b=np.floor(a)
print(b)
#[-2. -1.  0.  1.]

（四）矩阵运算

1.numpy.dot(array1,array2)

矩阵内积

import numpy as np

vector1=np.array([1,2,3]) #1-D array
vector2=np.array([4,5,6])
m=np.dot(vector1,vector2) #计算两个一维矩阵的内积
print(m)
#32

vector3=np.array([[1,2,3],[4,5,6]]) #2-D array
vector4=np.array([[1,2],[3,4],[5,6]])
n=np.dot(vector3,vector4) #计算两个二维矩阵的内积
print(n)
#[[22 28],[49 64]]

2.numpy.outer(array1,array2)

矩阵外积

import numpy as np

vector1=np.array([1,2,3]) #1-D array
vector2=np.array([4,5,6])
m=np.outer(vector1,vector2) #计算两个一维矩阵的内积
print(m)
#[[ 4  5  6]
# [ 8 10 12]
# [12 15 18]]

vector3=np.array([[1,2,3],[4,5,6]]) #2-D array
vector4=np.array([[1,2],[3,4],[5,6]])
n=np.outer(vector3,vector4) #计算两个二维矩阵的内积
print(n)
#[[ 1  2  3  4  5  6]
# [ 2  4  6  8 10 12]
# [ 3  6  9 12 15 18]
# [ 4  8 12 16 20 24]
# [ 5 10 15 20 25 30]
# [ 6 12 18 24 30 36]]

3.numpy.rot90(array,num)

实现矩阵90°角任意倍数的旋转，正数为逆时针，负数为顺时针

import numpy as np

a=np.array([[1,2],
            [3,4]])
b1=np.rot90(a,-1)
b2=np.rot90(a,2)

print(b1)
#[[3 1]
# [4 2]]
print(b2)
#[[4 3]
# [2 1]]

4.numpy.fliplr(array)

矩阵水平镜像翻转

import numpy as np

a=np.array([[1,2],
            [3,4]])
b=np.fliplr(a)

print(b)
#[[2 1]
# [4 3]]

5.numpy.meshgrid(array1,array2)

根据平面点的坐标数组生成坐标矩阵

返回值：一个二元素列表

列表元素分别是点x坐标组成的数组和y坐标组成的数组，该数组有几个元素即代表点有几个

import numpy as np

x=np.linspace(1,3,3)
y=np.linspace(4,5,2)
Z=np.meshgrid(x,y)

print(Z)
#[array([[1., 2., 3.],
#       [1., 2., 3.]]),
# array([[4., 4., 4.],
#       [5., 5., 5.]])]

X,Y=np.meshgrid(x,y)

print(X)
#[[1. 2. 3.],
# [1. 2. 3.]]

print(Y)
#[[4. 4. 4.],
# [5. 5. 5.]]

（五）行列处理

1.numpy.hsplit(array,indices_or_sections)

横着切割数组

参数：
（1）array：被处理的数组
（2）indices_or_sections：索引或节。若为列表，则以列表的元素为索引进行切割；若为正整数，则进行均分，但这个正整数必须能被整除

2.numpy.vsplit(array,indices_or_sections)

竖着切割数组，同上

import numpy as np

np.random.seed(10)

a1=np.floor(10*np.random.random((2,6))) #random会产生0-1的随机数
a2=np.floor(10*np.random.random((6,2))) #a1,a2的元素都是0-9的整型浮点数

print(a1)
#[[7. 0. 6. 7. 4. 2.],
# [1. 7. 1. 0. 6. 9.]]
print(a2)
#[[0. 5.],
# [8. 6.],
# [7. 2.],
# [9. 7.],
# [5. 1.],
# [3. 6.]]

b=np.hsplit(a1,3)
print(b)
#[array([[7., 0.],
#       [1., 7.]]), 
# array([[6., 7.],
#       [1., 0.]]), 
# array([[4., 2.],
#       [6., 9.]])]

b1,b2,b3=np.hsplit(a1,3)

print(b1)
#[[7. 0.]
# [1. 7.]]
print(b2)
#[[6. 7.]
# [1. 0.]]
print(b3)
#[[4. 2.]
# [6. 9.]]

c=np.vsplit(a2,[1,3,5])
print(c)
#[array([[0., 5.]]), 
# array([[8., 6.],
#       [7., 2.]]), 
# array([[9., 7.],
#       [5., 1.]]), 
# array([[3., 6.]])]

c1,c2,c3,c4=np.vsplit(a2,[1,3,5])

print(c1)
#[[0. 5.]]
print(c2)
#[[8. 6.]
# [7. 2.]]
print(c3)
#[[9. 7.]
# [5. 1.]]
print(c4)
#[[3. 6.]]

3.numpy.r_[array1,array2] / numpy.vstack([array1,array2])

在一维上进行拼接
对于一维矩阵，相当于顺序拼接
对于二维矩阵，相当于沿上下的方向顺序竖着拼接，列数必须相等

4.numpy.c_[array1,array2] / numpy.hstack([array1,array2])

在二维上进行拼接
对于一维矩阵，相当于变形为（n，2）的二维矩阵
对于二维矩阵，相当于沿左右的方向顺序横着拼接，行数必须相等

import numpy as np

a=np.arange(1,5).reshape(4,1)
b=np.ones((4,2))

c=np.hstack((a,b))
d=np.c_[a,b]

print(c)
#[[1. 1. 1.]
# [2. 1. 1.]
# [3. 1. 1.]
# [4. 1. 1.]]
print(d)
#[[1. 1. 1.]
# [2. 1. 1.]
# [3. 1. 1.]
# [4. 1. 1.]]

5.numpy.tile(array,shape)

把数组沿各个方向复制

参数：
（1）array
（2）shape：元组，维度必须与array一致，元素均为整数

import numpy as np

a=np.array([[1,2],
            [3,4]])
b=np.tile(a,(2,3))

print(b)
#[[1 2 1 2 1 2]
# [3 4 3 4 3 4]
# [1 2 1 2 1 2]
# [3 4 3 4 3 4]]

6. numpy.stack([array1, … ], axis)

（六）视图view与拷贝copy

b=a：与源数组完全相同，id相同，其任何修改都会影响源数组
c=a[:]，d=a.view()：数组切片是原始数组的视图view，视图上的任何修改都会影响源数组
e=a.copy()：拷贝copy，修改不会影响源数组

Alt

import numpy as np

a=np.arange(4)
print(a)
#[0 1 2 3]

b=a
print(b)
#[0 1 2 3]
print(b is a)
#True
print(id(a))
#2522915940944
print(id(b))
#2522915940944
b*=2
print(id(a))
#2522915940944
print(id(b))
#2522915940944
print(a)
#[0 2 4 6]
print(b)
#[0 2 4 6]


c=a[:]
print(c)
#[0 2 4 6]
print(c is a)
#False
print(id(a))
#2522915940944
print(id(c))
#2522915942000
c*=2
print(a)
#[ 0  4  8 12]
print(c)
#[ 0  4  8 12]

d=a.view()
print(d)
#[ 0  4  8 12]
print(d is a)
#False
print(id(a))
#2522915940944
print(id(d))
#2522915941136
d*=2
print(a)
#[ 0  8 16 24]
print(d)
#[ 0  8 16 24]

e=a.copy()
print(e)
#[ 0  8 16 24]
print(e is a)
#False
print(id(a))
#2522915940944
print(id(e))
#2522915796048
e*=2
print(a)
#[ 0  8 16 24]
print(e)
#[ 0 16 32 48]

四.文件读取

numpy.genfromtxt(fname, dtype, comments, delimiter, autostrip, skipd_header, skip_fonter, converters, missing_values, filling_values, usecols)

默认是按照float格式来读取的，对于不能转换为float类型的数据会读取为nan(not a number)，故应加入参数

参数：
（1）fname：str/list/IO Object等等，表示数据源；文件路径，字符串列表、StringIO对象都可；若以gz结尾，读取时会在加载数据之前自动解压，但较为常见的都是txt文本

IO --> input，output

（2）dtype：dtype，最终数组的数据类型
（3）comments：str，注释标识符，加载时会自动忽略位于注释标识符所在行后面的字符串；
（4）delimiter：str/int/sequence

若delimiter为字符，表示分割符，每一行的元素以分割符进行分割；
若delimiter为字符列表，表示分割符可为多个字符；
若delimiter为整数元组时，代表每一列所在元素最大宽度

import numpy as np
from io import BytesIO

data1 = b"1, 2, 3\n4, 5, 6"
a=np.genfromtxt(BytesIO(data1), delimiter=",")
print(a)
#[[1. 2. 3.]
# [4. 5. 6.]]

data2 = b"  1  2  3\n  4  5 67\n890123  4"
b=np.genfromtxt(BytesIO(data2), delimiter=3) 
print(b)
#[[  1.   2.   3.]
# [  4.   5.  67.]
# [890. 123.   4.]]

data3 = B"123456789\n   4  7 9\n   4567 9"
c=np.genfromtxt(BytesIO(data3), delimiter=(4, 3, 2))
print(c)
#[[1234.  567.   89.]
# [   4.    7.    9.]
# [   4.  567.    9.]]

（5）autostrip：若为True，元素中的空格标识符会被自动删除
（6）skip_header：int，数据加载时跳过文件头部的字符串行数
（7）skip_footer：int，数据加载时跳过文件尾部的字符串行数
（8）converters：variable，可以是字典形式也可以是lambda函数，表示将某一种数据格式转化为另一种数据格式
（9）missing_values：variable，指定数组中的缺失值进行标记
（10）filling_values：variable，指定数组中已标记的缺失值，来替代填充值

举例：
missing_values={0:“N/A”, 1:" “, 2:”???"}, filling_values={0:0,1:0, 2:-999})

（11）usercols：sequence，指定只读取数据中指定的列数， 0表示第一列，-1为最后一列

五.余弦相似度

Alt

||A||表示A的范数，用numpy.linalg.norm()表示，可利用axis实现降维计算

import numpy as np

v1=np.array([1,2,3])
v2=np.array([7,14,5])
result=(np.sum(v1*v2))/(np.linalg.norm(v1)*np.linalg.norm(v2))

print(result)
#0.8132500607904444

以下为计算两个矩阵的余弦相似度：

import numpy

matrix1=numpy.array([[90,10,15],
                     [20,25,30]]) #二维数组2*3
matrix2=numpy.array([[5,10,15],
                     [20,25,30],
                     [90,10,15],
                     [90,10,15]]) #二维数组3*4

matrix1_matrix2=numpy.dot(matrix1,matrix2.T) #计算矩阵乘积，结果为二维数组2*4

matrix1_norm1=numpy.linalg.norm(matrix1,axis=1) #按行取范数，得一维数组1*2
matrix1_norm2=matrix1_norm1[:,numpy.newaxis] #增加维度，变成二维数组2*1

matrix2_norm1=numpy.linalg.norm(matrix2,axis=1) #按行取范数，得一维数组1*4
matrix2_norm2=matrix2_norm1[numpy.newaxis,:] #增加维度，变成二维数组1*4

#余弦相似度
cosine=numpy.divide(matrix1_matrix2,numpy.dot(matrix1_norm2,matrix2_norm2))

print(cosine)
#[[0.45131807 0.62078282 1.         1.        ]
# [0.97463185 1.         0.62078282 0.62078282]]

六.其他

（一）关系操作符可以产生元素为True或False的数组

import numpy as np

a=np.array([1,2,3])
print(a>2)
#[False False  True]
b=np.array([3,4,5])
print(a<b)
#[ True  True  True]


x = np.linspace(-2,2,5)
y = np.linspace(0,4,5)

xx,yy = np.meshgrid(x,y)
z = np.square(xx) - yy>0

print(z)
#[[ True  True False  True  True]
# [ True False False False  True]
# [ True False False False  True]
# [ True False False False  True]
# [False False False False False]]


vector=numpy.array([[5,10,15],[20,25,30],[35,40,45]])
vector==25
#array([[False, False, False],
#       [False,  True, False],
#       [False, False, False]])

（二）标量与数组

numpy.sin(), numpy.cos()

import numpy as np

a1=1
a2=np.sin(a1)
print(a2)
#0.8414709848078965

b1=[1,2]
b2=np.sin(b1)
print(b2)
#[0.84147098 0.90929743]

c1=[[1,2],
    [3,4]]
c2=np.cos(c1)
print(c2)
#[[ 0.54030231 -0.41614684]
# [-0.9899925  -0.65364362]]

以上未完待更新，仅供个人学习，侵权联系删除，如有错误或不足之处可指出，以便改进。

Python--numpy（持续更新）

目录