1.array数组
array不同于列表,而是矩阵,运算规则符合矩阵运算,并且所有元素的类型相同,如果不是,会自动向下转换
import numpy as np
a = np.array([[1,2,3,4,5],[5,6,7,8,9]])
# 元素数据类型
a.dtype
>>> dtype('int32')
# 元素个数
a.size
>>> 10
# 数据占据的字节数
a.itemsize
>>> 4
# 矩阵总字节数
a.nbytes
>>> 40
# 矩阵维度
a.shape
>>> (2, 5)
2. 数据结构
复制矩阵
b = a.copy()
>>> array([[1, 2, 3, 4, 5],
[5, 6, 7, 8, 9]])
numpy.arange([start, ]stop, [step, ]dtype=None)
在给定的时间间隔内返回均匀间隔的值。
在半开区间[start, stop)内产生值 (换句话说,包括开始但不包括停止的区间)。对于整数参数,该函数等同于Python内置的 范围函数,但返回一个ndarray而不是一个列表。
当使用非整数步长(如0.1)时,结果往往不一致。这些情况下最好使用linspace。
参数:
start:数字,可选
间隔开始。间隔包括这个值。默认的起始值是0。
stop:数字
间隔结束。间隔不包括此值,但在某些情况下,步骤不是整数,浮点舍入会影响out的长度。
dtype:步长,可选
值之间的间隔。对于任何输出出来,这是两个相邻值之间的距离,进行[I + 1] - 出[I] 。默认步长为1.如果指定了step,则还必须给出start。
dtype:dtype
输出数组的类型。如果没有给出dtype,则从其他输入参数推断数据类型。
返回:
类型:ndarray
数组间距均匀的值。
对于浮点参数,结果的长度是 ceil((stop - start)/ step)。由于浮点溢出,此规则可能导致out的最后一个元素大于stop。
np.arange(0,100,10)
>>> array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
布尔值做索引(布尔矩阵维度一致)
c = np.arange(0,100,10)
mask = np.array([0,0,0,0,0,1,2,3,4,5],dtype=bool)
c[mask]
>>> array([50, 60, 70, 80, 90])
3.数组类型
a = np.array([1,1.,"str"],dtype=object)
a
>>> array([1, 1.0, 'str'], dtype=object)
np.asarray() 重新生成矩阵,不会改变原矩阵,生成一个新矩阵
4.数值运算
- 加法 np.sum()
- 乘法 np.prop() 矩阵各个维度
- 均值 np.mean()
- 标准差 np.std()
- 方差 np.var()
- 最大/最小值索引 np.argmax() np.argmin()
- 最大/最小值 np.max()/np.min()
- 取整 np.round()
- 限制元素的范围 np.clip()
- 找出不为0的索引 np.nonzero()
-
a.clip(2,4) >>> array([[2, 2, 3, 4, 4], [4, 4, 4, 4, 4]])
5.数组排序
默认最后一个轴,默认升序排列
a = np.array([[3,2,3,6,9],[5,6,10,8,9]])
np.sort(a)
>>> array([[ 2, 3, 3, 6, 9],
[ 5, 6, 8, 9, 10]])
np.sort(a,axis=0)
>>> array([[ 3, 2, 3, 6, 9],
[ 5, 6, 10, 8, 9]])
返回索引
np.argsort(a)
>>> array([[1, 0, 2, 3, 4],
[0, 1, 3, 4, 2]], dtype=int64)
找出数值插入的位置
a = np.linspace(0,10,10)
values = np.array([2.1,3.0,7.1])
np.searchsorted(a,values)
>>> array([2, 3, 7], dtype=int64)
指定不同地方不同的排序方式
a = np.array([[2,2,1,3],
[3,4,5,1],
[5,6,1,2],
[0,2,3,5]])
index = np.lexsort([-a[:,0],a[:,2]])
a[index]
>>> array([[5, 6, 1, 2],
[2, 2, 1, 3],
[0, 2, 3, 5],
[3, 4, 5, 1]])
6. 数组形状操作
改变数组形状
a = np.arange(10)
a.shape
>>> (10,)
a.shape = 2,5
a
>>> array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
a.reshape((5,2))
>>> array([[0, 1],
[2, 3],
[4, 5],
[6, 7],
[8, 9]])
增加一个新的维度
b = a[np.newaxis,:]
b.shape
>>> (1, 10)
矩阵压缩
b = b.squeeze()
b.shape
>>> (10,)
矩阵转置
b = b.reshape((2,5))
b = b.transpose()
b.shape
>>> (5, 2)
矩阵拼接
a = np.linspace(0,10,10)
a = a.reshape((5,2))
c = np.concatenate((a,b),axis=1)
c
>>> array([[ 0. , 1.11111111, 0. , 5. ],
[ 2.22222222, 3.33333333, 1. , 6. ],
[ 4.44444444, 5.55555556, 2. , 7. ],
[ 6.66666667, 7.77777778, 3. , 8. ],
[ 8.88888889, 10. , 4. , 9. ]])
np.vstack((a,b))
array([[ 0. , 1.11111111],
[ 2.22222222, 3.33333333],
[ 4.44444444, 5.55555556],
[ 6.66666667, 7.77777778],
[ 8.88888889, 10. ],
[ 0. , 5. ],
[ 1. , 6. ],
[ 2. , 7. ],
[ 3. , 8. ],
[ 4. , 9. ]])
np.hstack((a,b))
array([[ 0. , 1.11111111, 0. , 5. ],
[ 2.22222222, 3.33333333, 1. , 6. ],
[ 4.44444444, 5.55555556, 2. , 7. ],
[ 6.66666667, 7.77777778, 3. , 8. ],
[ 8.88888889, 10. , 4. , 9. ]])
矩阵展平
c.flatten()
>>> array([ 0. , 1.11111111, 0. , 5. , 2.22222222,
3.33333333, 1. , 6. , 4.44444444, 5.55555556,
2. , 7. , 6.66666667, 7.77777778, 3. ,
8. , 8.88888889, 10. , 4. , 9. ])
7.数组生成
np.arange([start, ]stop, [step, ]dtype=None)
- 一个参数时,参数值为终点值,起点取默认值0,步长取默认值1。
- 两个参数时,第一个参数为起点值,第二个参数为终点,步长取默认值1。
- 三个参数时,第一个参数为起点,第二个参数为终点,第三个参数为步长,其中步长支持小数。
返回一个有终点和起点的固定步长的排列(可理解为一个等差数组)。
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
在间隔start和stop之间返回num个均匀间隔的数据。
start: array_like
序列的起始值
stop: array_like
序列的结束值
num: int, optional
要生成的样本数,默认值为50,必须为非负数
endpoint: bool, optional
如果为True,则包含stop
如果为False,则不包含stop
retstep: bool, optional
如果为True,返回('samples', 'step'),其中step是samples之间的间隔
dtype: dtype, optional
输出数组的类型
如果没有给出,将通过start和stop进行推断
永远不会推断为int,即使给定的参数会生成整数数组,也将被推断成float
np.arange(10)=array([0,1,2,3,4,5,6,7,8,9]) np.arange(2,20,2)=array([2,4,6,8,10,12,14,16,18]) np.linspace(0,10,10)代表从0到10取10个数
numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)
在对数尺度上返回间隔均匀的数字。
在线性空间中,序列从base ** start
(以start的幂为基础)开始,并以base ** stop
结束(等比数列)
start :array_like
base ** start
是序列的起始值。
stop :array_like
base ** stop
是序列的最终值,除非endpoint 为False。
在这种情况下,num + 1
值在对数空间的间隔内间隔开,
返回除最后一个(长度为num的序列)外的所有值。
num :integer
, 可选
要生成的样本数。 默认值为50
。
endpoint :boolean
, 可选
如果为true
,则停止是最后一个样本。
否则,不包括在内。 默认值为True
。
base :float
, 可选
日志空间的基础。ln(samples)/ ln(base)
(或log_base(samples)
)中元素之间的步长是一致的。
默认值为10.0
。
dtype :dtype
输出数组的类型。 如果未给出dtype
,则从其他输入参数推断数据类型。
axis :int
, 可选
结果中的轴用于存储样本。 仅当start
或stop
类似于数组时才相关。
默认情况下为(0)
,样本将沿着在开始处插入的新轴。
使用-1
来获得轴的末端。 1.16.0版中的新功能。
np.logspace(0,1,5):以10为底的0次方到1次方等比数列取5个数 np.logspace(0,1,5,base=2)变成以2为底
x,y = np.meshgrid(*xi, **kwargs)
创建网格,x为行,y为列
x = np.linspace(0,10,5)
y = np.linspace(-10,0,5)
g,h = np.meshgrid(x,y)
g,h
>>> (array([[ 0. , 2.5, 5. , 7.5, 10. ],
[ 0. , 2.5, 5. , 7.5, 10. ],
[ 0. , 2.5, 5. , 7.5, 10. ],
[ 0. , 2.5, 5. , 7.5, 10. ],
[ 0. , 2.5, 5. , 7.5, 10. ]]),
array([[-10. , -10. , -10. , -10. , -10. ],
[ -7.5, -7.5, -7.5, -7.5, -7.5],
[ -5. , -5. , -5. , -5. , -5. ],
[ -2.5, -2.5, -2.5, -2.5, -2.5],
[ 0. , 0. , 0. , 0. , 0. ]]))
构建横向量、构建纵向量
np.c_/np.r_
常用数组生成函数
np.zeros()/np.ones() 全为0或者全为1
np.empty() 随机填充
np.fill() 给数组填充值
np.zeros_like()/np.ones_like() 复制维度,用0/1填充
np.identity() 构建单位矩阵
8.数组生成函数
np.mutiply() 矩阵元素相乘
np.dot() 矩阵相乘 x*y也是矩阵相乘,会自动调整维度
np.logical_and,np.logical_or,
9.随机模块
np.random.rand() 随机生成一组数(浮点数0-1)
np.random.randint(10,size=(5,4) ) 随机生成一组整数(左闭右开)
np.random.random_sample() 返回一个0-1的浮点数
np.random.normal() 高斯分布
np.set_printoptions() 设置打印精度
np.random.shuffle() 打乱顺序 np.random.seed()保持数据不变
10.文件操作
%%writefile text.txt
1 2 3 4 5 6
numpy.loadtxt(fname, dtype=, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0)
- fname 文件名
- skiprows 设置skiprows=2, 就会跳过前两行,数据类型设置为字符串.
- comment comments='*', 如果行的开头为*就会跳过该行
- delimiter 可以指定各种分隔符、针对特定列的转换器函数、需要跳过的行数等
- usecols 指定读取的列
- unpack unpack是指会把每一列当成一个向量输出, 而不是合并在一起
- converters 对数据进行预处理的参数,我们可以先定义一个函数, converters={1:func}, 表示第1列使用函数func来进行预处理
11. 数组保存
np.savetxt('data/task.txt', self.task, fmt="%d", delimiter=" ")
data/task.txt:参数为文件路径以及TXT文本名
self.task: 为要保存的数组名
fmt="%d": 为指定保存的文件格式,这里为十进制
delimiter=" "表示分隔符,这里以空格的形式隔开
读写array结构
npy结构
np.load()/np.save()/np.savez() 保存为压缩文件
12.数组填充
ndarray = numpy.pad(array, pad_width, mode, **kwargs)
其中,array表示需要填充的数组;
pad_width表示在各维度的各个方向上想要填补的长度。参数输入方式为: ((before_1, after_1), … (before_N, after_N));
mode表示填充的方式,总共有11种填充模式;
**kwargs表示填充的值,与pad_width相对应。
constant表示连续填充相同的值,每个维度可以分别指定填充值,constant_values=(x, y)时前面用x填充,后面用y填充,缺省值填充0;
edge表示用边缘值填充;
linear_ramp表示用边缘递减的方式填充;
maximum表示最大值填充;
mean表示均值填充;
median表示中位数填充;
minimum表示最小值填充;
reflect表示对称填充;
symmetric表示对称填充;
wrap表示用原数组后面的值填充前面,前面的值填充后面。
np.intersectld() 返回两个数组中相同的元素
设置数组只能读取不能更改
z = np.zeros(5)
z.flags.writeable = False
np.ndenumerate() 枚举
np.bincount() 返回数组中值出现的次数
快速排序
numpy.argpartition(a, kth, axis=- 1, kind='introselect', order=None)
使用 kind 关键字指定的算法沿给定轴执行间接分区。 它以分区顺序沿给定轴返回与该索引数据具有相同形状的索引数组。可以快速查找TOP-K元素
参数
类似数组
要排序的数组。
kthint 或整数序列
要分区的元素索引。
第 k 个元素将处于其最终排序位置,
所有较小的元素将被移动到它之前,
所有较大的元素将被移动到它之后。
分区中所有元素的顺序未定义。
如果提供了第 k 个序列,
它将一次将它们全部划分到它们的排序位置。
axisint 或 None,可选
排序的轴。 默认值为 -1(最后一个轴)。
如果没有,则使用扁平数组。
种类{'introselect'},可选
选择算法。 默认为“内选”
orderstr 或 str 列表,可选
当 a 是定义了字段的数组时,该参数指定先比较哪些字段,
第二个等。单个字段可以指定为字符串,
不需要指定所有字段,
但仍会使用未指定的字段,
在它们出现在 dtype 中的顺序,以打破联系。
返回
index_arrayndarray, int
沿指定轴对 a 进行分区的索引数组。
如果 a 是一维的,则 a[index_array] 产生一个分区的 a。
更一般地说, np.take_along_axis(a, index_array, axis=a)
总是产生分区的 a,
而不管维数如何。
np.all() 判断是否所有元素均相等
np.any() 判断是否有元素相等