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 6numpy.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 = Falsenp.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() 判断是否有元素相等
80
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
