名称	描述
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]])'''

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小桥流水78/article/detail/968860