目录
- 一.ndarray数组
- 二.numpy.array()的方法
-
- (一)基本属性
- (二)numpy.shape和numpy.reshape
- (三)数据和排序
-
- 1.numpy.sum(array,axis,dtype) / .sum(axis,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)
- 5.numpy.average(array,axis,dtype) / .average(axis,dtype)
- 6.numpy.sort(array,axis,dtype) / .sort(axis,dtype)
- (四)ravel和flatten
- (五)其他
- 三.一般函数
-
- (一)产生数组
-
- 1.等差数组
- 2.常数数组
- 3.随机数组numpy.random
-
- 3.1 numpy.random.rand()
- 3.2 numpy.random.random()
- 3.3 numpy.random.randn()
- 3.4 numpy.random.randint(*args) / numpy.random.randint(low,high,size,dtype)
- 3.5 numpy.random.uniform(low, high, size)
- 3.6 numpy.random.normal(loc, scale, size)
- 3.7 numpy.random.choice(array, size, replace, p)
- 3.8 numpy.random.shuffle(x)
- 3.9 numpy.random.permutation(x)
- (二)维度运算
- (三)元素运算
- (四)矩阵运算
- (五)行列处理
- (六)视图view与拷贝copy
- 四.文件读取
- 五.余弦相似度
- 六.其他
一.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,修改不会影响源数组
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为最后一列
五.余弦相似度
||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]]
以上未完待更新,仅供个人学习,侵权联系删除,如有错误或不足之处可指出,以便改进。