目录
numpy是什么?
ndarray对象
使用array创建数组
array参数
array与asarray的区别
ndarray数组的属性
ndarray.shape
ndarray.ndim
ndarray.size
ndarray.itemsize
ndarray.dtype
ndarray中使用便捷函数创建数组
使用arange创建等差数组(指定步长)
使用linspace创建等差数列(指定数量)
使用logspace创建等比数列
使用ones创建全是1的数组
使用ones_like创建形状相同的全是1的数组
使用zeros创建全是0的数组
使用zeros_like创建形状形同的全是0的数组
使用empty创建未初始化的数组
使用empty_like创建形状相同的未初始化的数组
使用full创建指定值的数组
使用full_like创建形状相同的指定值的数组
ndarray数组本身支持的大量操作和函数
reshape()方法
resize()方法
ndarray.T
flatten()方法
ravel()方法
flatten()与ravel()的区别
astype()方法
tobytes() 或 tostring()
np.unique(ar,return_index=False,return_inverse=False,return_counts=False)
数组中元素间的算术运算
数组间的算术运算
对数组按索引查询
基础索引
神奇索引
布尔索引
条件的组合索引
常用的random随机函数
seed(seed=None)
rand(d0, d1, ..., dn)
numpy是什么?
--- 一个开源的python科学计算库。
--- 使用numpy可以方便的使用数组、矩阵进行计算。
--- 包含线性代数、傅里叶变换、随机数生成等大量函数。
ndarray对象
--- ndarray(全称The N-dimensional array)是存储着相同类型和大小的元素的一维数组或多维数组对象,是numpy的核心数据结构。
--- 与Python的List的区别是,它元素必须是同一种数据类型,这也是Numpy高性能的一个原因。
使用array创建数组
array参数
名称 | 描述 |
object | 数组或嵌套的数列 |
dtype | 数组元素的数据类型,可选 |
copy | 对象是否需要复制,可选 |
order | 创建数组的样式,C为行方向,F为列方向,A为任意方向 |
subok | 默认返回一个与基类类型一致的数组 |
ndmin | 指定生成数组的最小维度 |
--- 创建一维数组:
import numpy as np
a = np.array([1,2,3,4,5,6,7,8])
a #输出:arrry([1,2,3,4,5,6,7,8])
print(a) #输出: [1,2,3,4,5,6,7,8]
--- 创建多维数组:
import numpy as np
A = np.array([
[1,2,3,4]
[5,6,7,8]
])
A '''输出:array([
[1,2,3,4]
[5,6,7,8]
]'''
print(A) #输出 [[1,2,3,4],[[5,6,7,8]]
array与asarray的区别
假设借用已有的数组生成另外的数组时,np.array是对已存在的数组进行深拷贝,而np.asarray则是对已存在的数组进行浅拷贝。
import numpy as np
a = np.array([1,2,3],[4,5,6])
a1 = np.array(a) #对数组a进行深拷贝
a2 = np.asarray(a) #对数组a进行浅拷贝
a[0,0] = 100
a #输出:array([100,2,3],[4,5,6])
a1 #输出:array([1,2,3],[4,5,6])
a2 #输出:array([100,2,3],[4,5,6])
ndarray数组的属性
ndarray.shape
--- 指数组维度的元组
print(a.shape) #输出: (8,)
print(A.shape) #输出: (2,4)
ndarray.ndim
--- 指数组维度
print(a.ndim) #输出: 1
print(A.adim) #输出: 2
ndarray.size
--- 指数组中的元素数量
print(a.size) #输出: 8
print(A.size) #输出: 8
ndarray.itemsize
--- 指一个数组元素的长度(在多维数组中指一行的长度)
print(a.itemsize) #输出:8
print(A.itemsize) #输出:4
ndarray.dtype
--- 指数组元素的类型
print(a.dtype) #输出:int32
print(A.dtype) #输出:int32
ndarray中使用便捷函数创建数组
使用arange创建等差数组(指定步长)
--- np.arange([start,]stop[,step,]dtype=None)
参数说明:
参数 | 描述 |
start | 起始值,默认值0 |
stop | 终止值(不包含) |
step | 步长,默认为1 |
dtype | 返回ndarray的数据类型,如果没有提供,则会使用输入数据的类型 |
import numpy as np
np.arange(10) #输出:array([0,1,2,3,4,5,6,7,8,9])
print(np.arrange(10)) #输出:[0,1,2,3,4,5,6,7,8,9]
np.arange(1,10,2) #输出:array([1,3,5,7,9])
print(np.arange(1,10,2) #输出:[1,3,5,7,9]
使用linspace创建等差数列(指定数量)
--- np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=float)
参数说明:
参数 | 描述 |
start | 序列的起始值 |
stop | 序列的终止值 |
num | 要生成的元素的数量,默认为50 |
endpoint | 序列中是否包含stop的值,默认为True |
retstep | 是否在生成的数组中显示间距(公差),默认为False |
dtype | ndarray的数据类型,默认为float |
import numpy as np
np.linspace(0,99,5) #输出: array([ 0. , 24.75, 49.5 , 74.25, 99. ])
np.linspace(0,99,5,endpoint=False) #输出:array([ 0. , 19.8, 39.6, 59.4, 79.2])
np.linspace(0,99,5,retstep=True) #输出:(array([ 0. , 24.75, 49.5 , 74.25, 99. ]), 24.75)
使用logspace创建等比数列
--- np.logspace(start,stop,num=50,endpoint=True,base=10,dtype=None)
参数说明:
参数 | 描述 |
start | 等比数列开始的幂次方 |
stop | 等比数列结束的幂次方 |
num | 要生成的元素的数量,默认为50 |
endpoint | 序列中是否包含stop的值,默认为True |
base | 幂次方中的底数 |
dtype | ndarray的数据类型,默认为float |
import numpy as np
np.logspace(0,3,4) #输出:array([ 1., 10., 100., 1000.])
np.logspace(0,3,4,endpoint=False) #输出:array([ 1. , 5.62341325, 31.6227766 , 177.827941 ])
np.logspace(0,3,4,base=5) #输出:array([ 1., 5., 25., 125.])
使用ones创建全是1的数组
--- np.ones(shape,dtype=float,order='C')
参数说明:shape:int or tuple of its shape of the new array e.g.,(2,3) or 2. (即数组维度的元组)
参数 | 描述 |
shape | 数组维度的元组 |
dtype | 数据类型,可选,默认为float |
order | 有'C'和'F'两个选项,分别代表行优先和列优先,在计算机内存中的存储元素的顺序,默认为'C' |
from numpy as np
np.ones(10) #输出:array([1.,1.,1.,1.,1.,1.,1.,1.,1.,1.])
np.ones((2,5)) '''输出: array([[1.,1.,1.,1.,1.],
[1.,1.,1.,1.,1.]] '''
使用ones_like创建形状相同的全是1的数组
--- np.ones_like(a,dtype=None,order='K')
参数说明:
参数 | 描述 |
a | 为其他的np.array对象 |
dtype | 数据类型,默认为参数a中元素本身的类型 |
order | 重写结果的内存布局,默认为'K',表示尽可能比配参数a的布局 |
创建一个与参数a形状相同的全是1的数组
import numpy as np
a = np.array([1,2,3,4,5,6,7,8])
A = np.array([[1,2,3,4],
[5,6,7,8]])
np.ones_like(a) #输出: array([1,1,1,1,1,1,1,1]
np.ones_like(A) ''' 输出:array([[1,1,1,1],
[1,1,1,1]]'''
使用zeros创建全是0的数组
--- np.zeros(shape,dtype=float,order='C')
参数说明:与ones函数的参数一致。
import numpy as np
np.zeros(10) #输出:array([0.,0.,0.,0.,0.,0.,0.,0.,0.,0.])
np.zeros((2,3) '''输出:array([[0.,0.,0.],
[0.,0.,0.]]'''
使用zeros_like创建形状形同的全是0的数组
--- np.zeros_like(a,dtype=None,order='K')
参数:K:表示尽可能匹配参数a的布局。
import numpy as np
a = np.array([1,2,3,4,5,6,7,8])
A = np.array([[1,2,3,4],
[5,6,7,8]])
np.zeros_like(a) #输出: array([0,0,0,0,0,0,0,0]
np.zeros_like(A) ''' 输出:array([[0,0,0,0],
[0,0,0,0]]
使用empty创建未初始化的数组
--- np.empty(shape,dtype=float,order='C')
注意:创建数组后,里面的值是未初始化的,可能是随机值,但是不要用!
import numpy as np
np.empty(10) '''输出:array([ 6.46048250e-313, 4.37300893e-308, 1.33360305e+241,
1.71881659e-312, 1.70359515e-269, 1.73315708e-
260,1.73156919e-260, -1.48480832e+188,
1.00000000e+000,3.01874110e-321]) '''
np.empty((2,3)) '''输出:array([[6.95196574e-310, 6.95196574e-310, 0.00000000e+000],
[0.00000000e+000, 6.95196573e-310, 1.36279859e-311]])
使用empty_like创建形状相同的未初始化的数组
--- np.empty_like(a,dtype=None,order='K')
import numpy as np
a = np.array([1,2,3,4,5,6,7,8])
A = np.array([[1,2,3,4],
[5,6,7,8]])
np.empty_like(a) #输出:array([1, 1, 1, 1, 1, 1, 1, 1])
np.empty_like(A) '''输出:array([[1, 1, 1, 1],
[1, 1, 1, 1]])'''
使用full创建指定值的数组
--- np.full(shape,full_vall,dtype=None)
参数说明:
参数 | 描述 |
shape | 数组维度的元组 |
full_value | 数组中元素的值 |
import numpy as np
np.full(10,666) #输出:array([666, 666, 666, 666, 666, 666, 666, 666, 666, 666])
np.full((2,5),555) #输出:array([[555, 555, 555, 555, 555],
[555, 555, 555, 555, 555]])
使用full_like创建形状相同的指定值的数组
--- np.full_like(a,full_value,dtype=None)
import numpy as np
a = np.array([1,2,3,4,5,6,7,8])
A = np.array([[1,2,3,4],
[5,6,7,8]])
np.full_like(a,666) #输出:array([666,666,666,666,666,666,666,666])
np.full_like(A,666) '''输出:array[[666,666,666,666]
[666,666,666,666]])
ndarray数组本身支持的大量操作和函数
reshape()方法
--- reshape(shape,order='C'),用来改变数组维度(有返回值)。
import numpy as np
a = array([1,2,3,4])
A = array([[1,2,3,4],[5,6,7,8]])
a.reshape((2,2)) #输出:array([[1,2],[3,4]])
A.reshape(8) #输出:array([1,2,3,4,5,6,7,8])
使用便捷函数创建的ndarray数组都可以使用此方法。
注意:在转换形状的时候一定要注意数组元素个数的匹配!
resize()方法
resize(new_shape),修改数组本身的形状(无返回值)。
--- 若修改后的数组中的元素个数少于原先未修改数组中的元素个数,则自第一行开始,从左往右依次取数;
--- 若修改后的数组中的元素个数多于原先未修改数组中的元素个数,以数组元素类型为依据,int型则补0,str型补空字符" ",float型补0.,bool型补False。
import numpy as np
a = np.array([[1,2,3,4],
[5,6,7,8]])
b = np.array([[1,2,3,4],
[5,6,7,8]])
a.resize((2,2))
a '''输出:array([[1,2]
[3,4]])'''
b.resize((4,3))
b '''输出:array([[1, 2, 3],
[4, 5, 6],
[7, 8, 0],
[0, 0, 0]])
ndarray.T
--- 数组的转置(有返回值)
import numpy as np
a = np.array([[1,2,3,4],
[5,6,7,8]])
a.T '''输出:array([[1, 5],
[2, 6],
[3, 7],
[4, 8]])'''
flatten()方法
--- 返回折叠为一维的数组副本
import numpy as np
a = np.array([[1,2,3,4]
[5,6,7,8]])
a.flatten() #输出:array([1, 2, 3, 4, 5, 6, 7, 8])
ravel()方法
--- 返回一个扁平数组
import numpy as np
a = np.array([[1,2,3,4]
[5,6,7,8]])
a.ravel() #输出:array([1, 2, 3, 4, 5, 6, 7, 8])
flatten()与ravel()的区别
--- 两者所要实现的功能是一致的,区别在于返回拷贝还是返回试图。
--- flatten() 返回的是一份拷贝,对拷贝的修改不会影响原始矩阵。
--- ravel() 返回的是试图,会影响原始矩阵。
import numpy as np
a = np.array([[1,2,3,4]
[5,6,7,8]])
a.flatten()[0] = 100
a '''输出:array([[1,2,3,4],
[5,6,7,8]])'''
a.ravel()[0] = 100
a '''输出:array([[100,2,3,4],
[5,6,7,8]])'''
astype()方法
--- astype(dtype)
--- 返回数组的副本,强制转换为指定类型。
import numpy as np
A = np.array([[1,2,3,4],
[5,6,7,8]])
A.astype(str) '''输出:array([['1', '2', '3', '4'],
['5', '6', '7', '8']], dtype='<U11')
tobytes() 或 tostring()
--- 构造包含数组中原始数据字节的python字节。
--- 两者没有区别,是同一方法的别名,tostring是为了向后兼容而保留的,推荐使用tobytes().
import numpy as np
A = np.array([[1,2,3,4],
[5,6,7,8]])
A.tobytes()
''' 输出: b'\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00' '''
A.tostring()
'''输出:b'\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00' '''
np.unique(ar,return_index=False,return_inverse=False,return_counts=False)
--- np.unique(ar,return_index=False,return_inverse=False,return_counts=False,后面三个参数为三个可选输出。
--- 数组去重,返回数组中唯一元素升序排序后的一维数组。
参数说明:
参数 | 描述 |
ar | 数组名 |
return_index | 如果为True,返回去重后未排序时的数组的下标,默认为False |
return_inverse | 如果为True,返回可用于重构‘ar’的唯一数组的索引,默认为True |
return_counts | 如果为True,返回每个唯一项在'ar'中出现的次数 |
import numpy as np
A = np.array([[9,2,3,4],
[5,6,7,8],
[12,1,1,1]])
np.unique(A, return_index=True, return_inverse=True, return_counts=True)
'''输出:
(array([1, 2, 3, 4, 5, 6, 7, 8]),
array([0, 1, 2, 6, 4, 5, 3, 7], dtype=int64),
array([0, 1, 2, 6, 4, 5, 3, 7, 7, 7, 7, 7, 6], dtype=int64),
array([1, 1, 1, 1, 1, 1, 2, 5], dtype=int64))'''
数组中元素间的算术运算
import numpy as np
a = np.array([1,2,3,4,5,6,7,8])
#加法运算
a+1 #输出:array([2,3,4,5,6,7,8,9])
#减法运算
a-1 #输出:array([0,1,2,3,4,5,6,7])
#乘法运算
a*2 #输出:array([2,4,6,8,10,12,14,16])
#除法运算
a/2 #输出:array([0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. ])
数组间的算术运算
--- 此种情况需要当两个数组形状相同
import numpy as np
a = np.array([1,2,3,4,5,6,7,8])
b = np.array([1,2,3,4,5,6,7,8])
a+b #输出:array([ 2, 4, 6, 8, 10, 12, 14, 16])
a-b #输出:array([0, 0, 0, 0, 0, 0, 0, 0])
a*b #输出:array([ 1, 4, 9, 16, 25, 36, 49, 64])
a/b #输出:array([1., 1., 1., 1., 1., 1., 1., 1.])
对数组按索引查询
基础索引
--- 一维数组(与python的List一致)
--- 二维数组
import numpy as np
a = np.array([[1,2,3,4],
[5,6,7,8],
[9,10,11,12],
[13,14,15,16]])
#分别用行坐标,列坐标实现行列筛选
#有a[0,0] 和 a[0][0] 两种形式
a[0,0] #输出:1
a[-1,2] #输出:15
#使用单个索引值,是选择索引某行
a[2] #输出array([9,10,11,12])
#索引多行
a[:-2] #输出array([[1,2,3,4],[5,6,7,8]])
#筛选多行,然后筛选多列
a[:2,1:3] #输出:array([[2,3],[6,7]])
#筛选某列
a[:,1] #输出:array([2,6,10,14])
#筛选多列
a[:,1:3] #输出:array([[2,6,10,14],[3,7,11,15]])
--- 对整个切片的修改
import numpy as np
a = np.array([[1,2,3,4],
[5,6,7,8],
[9,10,11,12],
[13,14,15,16]])
a[:2] = 666 '''输出:array([[666,666,666,666],
[666,666,666,666],
[9,10,11,12],
[13,14,15,16]])'''
a[:2,1:3] = 666 '''输出:array([[1,666,666,3,4],
[5,666,666,7,8],
[9,10,11,12],
[13,14,15,16]])'''
神奇索引
--- 使用整数数组作为索引,叫做神奇索引
一维数组
--- 可以根据用作索引的数组的不同维度形式,输出对应维度形式的数组
import numpy as np
a = np.array([12,7,6,5,5,3,2,1])
#将一维数组用作索引,筛选指定位置的元素
a[[2,7,4]] #输出:array([6, 1, 5])
#将二维数组用作索引,筛选指定位置的元素,并以二维数组的形式输出
index1 = np.array([[7,2,4],[1,2,3]]) '''注意:将二维数组用作索引时,不能直接使用
List中的二维列表,需要ndarray数组对象'''
'''输出:array([[1, 6, 5],
[7, 6, 5]])'''
--- 获取数组中最大的前N个数,并按从小到大的顺序排列
import numpy as np
a = np.array([12,7,6,5,5,3,2,1])
#获取数组中最大的前4个数
a[a.argsort()[:-4]] #array([ 5, 6, 7, 12])
二维数组
import numpy as np
A = np.array([[9,2,3,4],
[5,6,7,8],
[12,1,1,1]])
#筛选指定的多行,列可以省略
A[[0,3]] '''输出:array([[ 9, 2, 3, 4],
[12, 1, 1, 1]])'''
#筛选指定的多列,行不能省略
A[:,[1,3]] '''输出:array([[ 9, 2, 3, 4],
[12, 1, 1, 1]]) '''
#同时指定行与列,返回的是所有由具体的行列坐标指定的元素所组成的一维数组
A[[1,2,0,1,1,1,1,1,2],[2,2,1,3,3,3,1,2,3]]
#输出:array([7, 1, 2, 8, 8, 8, 6, 7, 1])
布尔索引
一维数组
import numpy as np
a = np.array([12,7,6,5,5,3,2,1])
a>5 #array([ True, True, True, False, False, False, False, False])
a[a>5] #array([12, 7, 6])
--- 实例:在数组中对满足一定条件的数进行整体修改
import numpy as np
a = np.array([12,7,6,5,5,3,2,1])
#对大于5的数全部重新赋值为5
a[a>5] = 5
a #输出:array([5, 5, 5, 5, 5, 3, 2, 1])
#对大于3的数全部自加20
a[a>3] += 20
a #输出:array([25, 25, 25, 25, 25, 3, 2, 1])
二维数组
import numpy as np
A = np.array([[1,2,3,4],
[5,6,7,8],
[9,10,11,12],
[13,14,15,16,17]])
A>5
'''输出:array([[False, False, False, False],
[False, True, True, True],
[ True, True, True, True],
[ True, True, True, True]])'''
A[A>5]
'''但此时返回的是一维数组
输出: array([ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])'''
--- 实例:以数组的某一列中所有元素为比较对象,筛选出满足一定条件的元素所在的行,或修改改行中所有元素的值
import numpy as np
A = np.array([[1,2,3,4],
[5,6,7,8],
[9,10,11,12],
[13,14,15,16,17]])
#筛选满足条件的指定行
A[:,3]>8 #将筛选出来的某一列进行条件判断,返回的结果是一个一维数组,以此一维数组为索引条件,可以筛选出满足条件的行
'''输出:array([False, False, True, True])'''
A[A[:,3]>8]
'''输出:array([[ 9, 10, 11, 12],
[13, 14, 15, 16]])'''
#修改筛选出来的行中的所有元素
A[A[:,3]>8] = 999
A
'''输出:array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[999, 999, 999, 999],
[999, 999, 999, 999]])
条件的组合索引
import numpy as np
#一维数组的条件组合索引
a = np.array([12,7,6,5,5,3,2,1])
condition = (a%2==0) | (a>5)
a[condition]
#输出: array([12, 7, 6, 2])
#二维数组的条件组合索引,输出结果为一维数组
A = np.array([[1,2,3,4],
[5,6,7,8],
[9,10,11,12],
[13,14,15,16]])
condition1 = (A%2==0) | (A>5)
A[condition1]
#输出:array([ 2, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])
常用的random随机函数
seed(seed=None)
--- 设定随机种子,随机数种子一般是一个整数,只要种子相同,每次生成的随机数序列也相同。
import numpy as np
np.random.seed(44)
a = np.random.rand() #输出:0.8348421486656494
np.random.seed(44)
b = np.random.rand() #输出:0.8348421486656494
#可以看到由于设置的随机数种子相同,生成的随机数也相同
rand(d0, d1, ..., dn)
--- 参数为整数,表示生成数组的形状。
--- 创建一个给定形状的数组,并在' '[0,1)' '上按均匀分布填充随机样本。
import numpy as np
#生成一个随机数
a = np.random.rand() #输出:0.8348421486656494
#生成一个一维的随机数组
b = np.random.rand(4) #输出:array([0.85368225, 0.67560617, 0.03768029, 0.30894783])
c = np.random.rand(3) #输出:array([0.56424949, 0.59407763, 0.68081341])
#生成一个多维的随机数组
d = np.random.rand(4,3)
'''输出:array([[0.63243183, 0.93870249, 0.73711959],
[0.74485551, 0.1088856 , 0.49363527],
[0.86675104, 0.01825511, 0.18290372],
[0.11267988, 0.85329766, 0.04845415]])'''