目录
np.unique(ar,return_index=False,return_inverse=False,return_counts=False)
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) #输出： 2ndarray.size
--- 指数组中的元素数量
print(a.size) #输出： 8
print(A.size) #输出： 8ndarray.itemsize
--- 指一个数组元素的长度（在多维数组中指一行的长度）
print(a.itemsize) #输出：8
print(A.itemsize) #输出：4ndarray.dtype
--- 指数组元素的类型
print(a.dtype) #输出：int32
print(A.dtype) #输出：int32ndarray中使用便捷函数创建数组
使用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]])'''
138
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
