Python笔记 之 numpy基础

numpy的数据类型

numpy的数据类型实际上是dtype对象的实例，并对应唯一的字符。

类型	说明
bool_	布尔类型 b
int_	默认的整数类型 i
intc	C语言的int类型
intp	用于索引的整数类型
int8	字节（-128 到 127）
int16	整数（）-32768 到 32767）
int32
int64
unit8	无符号整数（0到255） u
unit16	0-65535
unint32
unit64
float_	f
float16	半精度
float32	半精度
float64	双精度
complex_	复数 c

数据类型对象

数据类型对象是用来描述与数组对应的内存区域如何使用，依赖如下几方面

• 数据的类型
• 数据的大小
• 数据的字节顺序
• 结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的部分
• 如果数据类型是子数组，它的形状和数据类型

创建数据类型对象

语法

numpy.dtype(object,align,copy)

dt = np.dtype(np.int32)
print(dt)
int32
print(type(dt))
<class 'numpy.dtype[int32]'>
# 使用数据类型符号
import numpy as np
dt = np.dtype('i4')
print(dt)
int32
print(type(dt))
<class 'numpy.dtype[int32]'>
# 小端法创建
dt = np.dtype(')
print(dt)
int32
print(type(dt))
<class 'numpy.dtype[int32]'>
# 结构化数据类型
student = np.dtype([('name','S20'),('age','i4'),('marks','f4')])
print(student)
[('name', 'S20'), ('age', '), ('marks', ')]
print(type(student))
<class 'numpy.dtype[void]'>

创建Ndarray数组对象

说明

numpy默认ndarray的所有元素的类型是相同的，如果传进来的列表中包含不同的类型，则统一为同一类型，优先级：str>float>int

array()函数

语法

numpy.array(object,dtype=None,copy=True,order=None,subok=False,ndmin=0)

参数	说明
object	数组或嵌套的数列
dtype	数组的数据类型
copy	对象是否需要复制
order	创建数组的样式，C为行方向；F为列方向；A为任意方向
subok	默认返回一个与基类类型一致的数组
ndmin	指定生成数组的最小维度

• 一维数组

import numpy as np
arr = np.array([1,2,3,4,5])
print(arr)
[1 2 3 4 5]
print(type(arr))
<class 'numpy.ndarray'>
# 不同的数据类型
import numpy as np
arr = np.array([1,2,3.0,4,5])
print(arr)
[1. 2. 3. 4. 5.]
print(type(arr))
<class 'numpy.ndarray'>
# dtype参数
import numpy as np
arr = np.array([1,2,3.0,4,5],dtype=np.float64)
print(arr)
[1. 2. 3. 4. 5.]
# 结构化数据类型 
student = np.dtype([('name','S20'),('age','i4'),('marks','f4')])
arr = np.array([('lilei',32,23.5),('zhangsan',34,26.5)],dtype=student)
print(arr)
[(b'lilei', 32, 23.5) (b'zhangsan', 34, 26.5)]

• 二维数组

import numpy as np
arr = np.array([[1,2,3,4,5],[1,2,3,4,5]])
print(arr)
[[1 2 3 4 5]
 [1 2 3 4 5]]
print(type(arr))
<class 'numpy.ndarray'>
# 使用ndmin参数创建二维数组
import numpy as np
arr = np.array([1,2,3.0,4,5],ndmin=2)
print(arr)
[[1. 2. 3. 4. 5.]]

asarray()函数

语法

numpy.asarray(a,dtype=None,order=None)

参数	数据
a	任意形式的输入参数，可以是列表、列表的元祖、元祖、元祖的元祖、元祖的列表、多维数组等
dtype	数据类型
order	创建数组的样式，C为行方向；F为列方向

lst = [1,2,3,4,5]
arr = np.asarray(lst)
print(arr)
[1 2 3 4 5]
arr = np.array(lst)
print(arr)
[1 2 3 4 5]
# dtype参数 
arr = np.asarray(lst,dtype='f4')
print(arr)         
[1. 2. 3. 4. 5.]

empty()函数

语法

numpy.empty(shape,dtype=float,order=‘C’)

参数	说明
shape	数组的形状
dtype	数据类型
order	创建数组的样式，C为行方向；F为列方向

arr = np.empty([3,2],dtype=np.int32)
print(arr)
[[         1          0]
 [1611079840      32766]
 [1610958416      32766]]

zeros()函数

语法

numpy.zeros(shape,dtype=float,order=‘C’)

参数	说明
shape	数组的形状
dtype	数据类型
order	创建数组的样式，C为行方向；F为列方向

arr = np.zeros([3,3],dtype=np.int32)
print(arr)           
[[0 0 0]
 [0 0 0]
 [0 0 0]]

ones()函数

语法

numpy.ones(shape,dtype=float,order=‘C’)

参数	说明
shape	数组的形状
dtype	数据类型
order	创建数组的样式，C为行方向；F为列方向

arr = np.ones([4,4],dtype=np.int32)
print(arr)              
[[1 1 1 1]
 [1 1 1 1]
 [1 1 1 1]
 [1 1 1 1]]

full()函数

语法

numpy.full(shape,fill_value,dtype=float,order=‘C’)

参数	说明
shape	数组的形状
dtype	数据类型
order	创建数组的样式，C为行方向；F为列方向
fill_value	填充的数据

arr = np.full([4,4],5,dtype=np.int32)
print(arr)             
[[5 5 5 5]
 [5 5 5 5]
 [5 5 5 5]
 [5 5 5 5]]

eye()函数

语法

numpy.eye(N,M=None,k=0,dtype=float,order=‘C’)

参数	说明
N	行数
M	列数，默认等于行数
order	创建数组的样式，C为行方向；F为列方向
dtype	数据类型

arr = np.eye(5,dtype='i4')
print(arr)
[[1 0 0 0 0]
 [0 1 0 0 0]
 [0 0 1 0 0]
 [0 0 0 1 0]
 [0 0 0 0 1]]

arange()函数

语法

numpy.arange(start,stop,step,dtype)
作用：根据给定的数据范围重建并返回ndarray对象

参数	说明
start	起始值，默认为0
stop	终止值（不包含）
step	步长，默认为1
dtype	数据类型，如果没有指定，则使用输入数据的类型

arr = np.arange(1,11,1)
print(arr)          
[ 1  2  3  4  5  6  7  8  9 10]

frombuffer()函数

语法

numpy.frombuffer(buffer,dtype=float，count=-1,offset=0)
作用：用于实现动态数组，接收buffer输入参数，以流的形式读入转化成ndarray对象
注意：buffer是字符串时，python3默认str是unicode类型，要转成bytestring在源str前加b

参数	说明
buffer	可以是任意对象，会以流的形式读入
dtype	数据类型，默认float
count	读取的数据量，默认为-1，读取全部数据
offset	读取的起始位置，默认为0

import numpy as np
ss = b'I am a student!'
arr = np.frombuffer(ss,dtype='S1')
print(arr)
[b'I' b' ' b'a' b'm' b' ' b'a' b' ' b's' b't' b'u' b'd' b'e' b'n' b't'
 b'!']
arr = np.frombuffer(ss,dtype='S1',count=5,offset=1)
print(arr)
[b' ' b'a' b'm' b' ' b'a']

fromiter()函数

语法

numpy.fromiter(iterable,dtype，count=-1)
作用：从可迭代对象中建立ndarray对象，返回一维数组

参数	说明
iterable	可迭代对象
dtype	数据类型
count	读取的数据量，默认为-1，读取全部数据

lst = [1,2,3,4,5,6,7,8,9,0]
z= iter(lst)
arr = np.fromiter(z,'f')
print(arr)
[1. 2. 3. 4. 5. 6. 7. 8. 9. 0.]

linspace()函数

语法

numpy.linspace(start,stop，num=50,endpoint=True,retstep=False,dtype=None)
作用：创建一个由等差数据构成的一维数组

参数	说明
start	序列的起始值
stop	序列的终止值，如果endpoint为True，该值包含于数列中
num	要生成的等步长的样本数量，默认为50
endpoint	默认值为True，数量包含stop值，反之不包含
retstep	默认值为False，不显示数组间隔，反之显示
dtype	ndarray的数据类型

arr = np.linspace(1,100,50,retstep=True,dtype='f')
print(arr)
(array([  1.       ,   3.0204082,   5.0408163,   7.0612245,   9.081633 ,
        11.102041 ,  13.122449 ,  15.142858 ,  17.163265 ,  19.183674 ,
        21.204082 ,  23.22449  ,  25.244898 ,  27.265306 ,  29.285715 ,
        31.306122 ,  33.32653  ,  35.34694  ,  37.367348 ,  39.387756 ,
        41.408165 ,  43.42857  ,  45.44898  ,  47.469387 ,  49.489796 ,
        51.510204 ,  53.530613 ,  55.55102  ,  57.57143  ,  59.591835 ,
        61.612244 ,  63.632652 ,  65.65306  ,  67.67347  ,  69.69388  ,
        71.71429  ,  73.734695 ,  75.755104 ,  77.77551  ,  79.79592  ,
        81.81633  ,  83.83673  ,  85.85714  ,  87.87755  ,  89.89796  ,
        91.918365 ,  93.938774 ,  95.95918  ,  97.97959  , 100.       ],
      dtype=float32), 2.020408163265306)

logspace()函数

语法

numpy.logspace(start,stop，num=50,endpoint=True,base=10.0,dtype=None)
作用：创建一个由等比数据构成的一维数组

参数	说明
start	序列的起始值：bass值的start次方
stop	序列的终止值：bass值的stop次方 ，如果endpoint为True，该值包含于数列中
num	要生成的等步长的样本数量，默认为50
endpoint	默认值为True，数量包含stop值，反之不包含
base	对数log的底数，默认值为10
dtype	ndarray的数据类型

arr = np.logspace(0,3,dtype='f')
print(arr)
[   1.           1.1513954    1.3257114    1.526418     1.7575107
    2.0235896    2.3299518    2.6826959    3.0888436    3.5564804
    4.094915     4.714866     5.4286757    6.2505517    7.1968565
    8.2864275    9.540955    10.985412    12.648552    14.563485
   16.76833     19.306978    22.229965    25.59548     29.470516
   33.932217    39.0694      44.984325    51.794746    59.636234
   68.66489     79.06043     91.029816   104.81131    120.67926
  138.94955    159.98587    184.207      212.0951     244.2053
  281.17688    323.74576    372.75937    429.19342    494.17133
  568.98663    655.12854    754.312      868.51135   1000.       ]

random.rand()

语法

rand(d1,d2,d3···dn)
作用：生成【0~1】之间的随机数

• 生成随机数

arr = np.random.rand()
arr
0.2101136804934962

• 一维数组

arr = np.random.rand(5)
arr
array([0.80017135, 0.09763245, 0.34149145, 0.66374943, 0.71660536])

• 二维数组

arr = np.random.rand(3,3)
arr
array([[0.25169259, 0.197381  , 0.92750051],
       [0.95771027, 0.51065463, 0.55729879],
       [0.47657342, 0.25175571, 0.53981685]])

• 三维数组

arr = np.random.rand(3,3,3)
arr
array([[[0.07110459, 0.57833425, 0.09277492],
        [0.32988942, 0.75628637, 0.86015797],
        [0.38282179, 0.79919463, 0.4675072 ]],
       [[0.29955862, 0.63837849, 0.18807644],
        [0.86938199, 0.75789802, 0.77957888],
        [0.69065271, 0.25967256, 0.97590798]],
       [[0.97461211, 0.20865234, 0.47935473],
        [0.14936389, 0.48828664, 0.64011268],
        [0.48681968, 0.58489544, 0.53796064]]])

random.random()

语法

random(size=None)

参数	说明
size	元素个数

• 生成0~1之间的随机数

arr = np.random.random()
arr
0.034734891747696284

• 生成n个元素的一维数组

arr = np.random.random(5)
arr
array([0.42510454, 0.17868096, 0.57754373, 0.30306648, 0.84531497])

random.random()

语法

random(low,high=None,size=None,dtype=‘i’)

参数	说明
low	起始值，包含
high	终止值，不包含
size	元素个数
dtype	数据类型，默认为整型

arr = np.random.randint(0,10,15)
arr
array([5, 4, 2, 6, 3, 1, 4, 1, 2, 8, 3, 3, 8, 0, 2])

random.randn()

语法

randn(d1,d2,···,dn)
作用：返回一个或一组样本，样本符合标准的正态分布。

arr = np.random.randn()
arr
-1.559465438396315
arr = np.random.randn(5)
arr
array([1.52217189, 0.80811319, 1.21221682, 0.28739499, 1.04678488])
arr = np.random.randn(3,3)
arr
array([[-0.78688964, -0.13554007,  0.43446556],
       [-0.06978298, -1.55062061,  0.90859057],
       [ 0.43260579, -0.58706045,  0.22834   ]])

random.normal()

语法

normal(loc=0.0,scale=1.0,size=None)
作用：生成高斯分布的概率密度随机数

参数	说明
loc	概率分布的均值
scale	概率分布的标准差
size	元素的个数

arr = np.random.normal(loc=1,scale=2,size=10)
arr
array([ 1.31931387,  2.60126211, -2.28923232,  0.74115928,  0.55057515,
        3.12566784,  2.98797309,  3.28492276,  0.50632156, -2.85499533])

Ndarray数组属性

Numpy数组的维数称为秩（rank），一维数组的秩为1，二维数组的秩为2，依次类推。
Numpy数组中，每一个线性的数组称为一个轴（axis），也就是维度。轴的数量–秩，就是数组的维度。
很多时候可以声明axis，axis=0表示沿着第0轴进行操作，即对每一列进行操作；axis=1，表示验证第1轴进行操作，即对每一行进行操作。

常用属性

属性	说明
ndim	秩，即轴的数量或者维度的数量
shape	数组的维度，对应矩阵来说n行m列
size	数组的元素数量
dtype	Ndarray对象的元素类型
itemsize	Ndarray对象每个元素的大小，以字节为单位
flags	Ndarray对象的内存信息
real	Ndarray元素的实部
imag	Ndarray元素的虚部
data	包含实际数组元素的缓冲区

arr = np.arange(24)
arr
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19, 20, 21, 22, 23])
arr.reshape((2,3,4))
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],
       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])
arr.reshape((2,3,4)).shape
(2, 3, 4)
arr.reshape((2,3,4)).size
24
arr.reshape((2,3,4)).dtype
dtype('int32')
arr1 = arr.reshape((2,3,4))
arr1 = arr.reshape((2,3,4))
arr1.itemsize
4
arr1.flags
  C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : False
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False

切片及索引

Ndarray对象的内容可以通过索引或者切片来访问和修改，与内置的list切片操作一样。
Ndarray数组可以基于0~n的下标进行索引，切片对象可以通过内置的slice函数，并设置start,stop及step参数进行，从原数组中切割出一个新数组。

• slice函数

arr = np.arange(24)
s = slice(0,12,2)
arr1 = arr[s]
arr1
array([ 0,  2,  4,  6,  8, 10])

• 下标
  一维数组

arr = np.arange(24)
arr[:12]
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
arr[0:12:2]
array([ 0,  2,  4,  6,  8, 10])

二维数组

arr = np.arange(24)
arr.shape=(4,6)
arr
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])
arr1 = arr[:1]
arr1
array([[0, 1, 2, 3, 4, 5]])
arr2 = arr[:1][:2]
arr2
array([[0, 1, 2, 3, 4, 5]])
arr1.ndim
2
arr1 = arr[2]
arr1
array([12, 13, 14, 15, 16, 17])
arr2 = arr[2][:3]
arr2
array([12, 13, 14])

• 省略号
  取对应axis的所有元素。

arr = np.arange(24)
arr.shape=(4,6)
arr
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])
arr[...,2:3]
array([[ 2],
       [ 8],
       [14],
       [20]])
arr[2:3,...]
array([[12, 13, 14, 15, 16, 17]])

高级索引

• 整数数组索引

arr
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])
# 获取下标为 0,0  1,1 2,2 3,3的数据元素
arr[[0,1,2,3],[0,1,2,3]]
array([ 0,  7, 14, 21])

arr
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])
# 获取下标为 0,0 0,2 3,0 3,2的数据元素
rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]])
rows 
array([[0, 0],
       [3, 3]])
cols
array([[0, 2],
       [0, 2]])
arr[rows,cols]
array([[ 0,  2],
       [18, 20]])

• 布尔索引

arr = np.arange(24)
arr.shape=(4,6)
arr
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])
# 偶数
arr[arr%2==0]  
array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22])
arr = np.array([np.nan,1,2,np.nan,3,4])
arr
array([nan,  1.,  2., nan,  3.,  4.])
# 获取数组中为nan的数组
arr[np.isnan(arr)]
array([nan, nan])
# 获取数组中不是nan的数组
arr[~np.isnan(arr)]
array([1., 2., 3., 4.])

广播

是Numpy对不同形状shape的数组进行数值计算的方式，对数组的算术运算通常在相应的元素上进行。

形状相同

如果数组a和数组b形状相同，即满足a.shape==b.shape，那么a+b的结果就是a与b数组对应位元素相加。

a=np.array([1,2,3,4,5])  
b=np.array([10,11,12,13,14])  
c=a+b  
print(c)
[11 13 15 17 19]

形状不同

如果两个数组的维数不同，则元素到元素的操作室不可能的。然而，在Numpy中仍然可以对形状不相似的数组进行操作，因为它拥有广博功能，较小的数组会广播到较大数组的大小，以便使它们的形状可以兼容。

arr = np.arange(24)  
a = arr.reshape((4, 6))  
b = np.array((1, 1, 1, 1, 1, 1))  
print(a)  
print(a + b)
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
[[ 1  2  3  4  5  6]
 [ 7  8  9 10 11 12]
 [13 14 15 16 17 18]
 [19 20 21 22 23 24]]
# 将数组广播得到新数组
bb = np.tile(b,(4,1))
print(bb)
[[1 1 1 1 1 1]
 [1 1 1 1 1 1]
 [1 1 1 1 1 1]
 [1 1 1 1 1 1]]

广播的规则

• 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分通过在前面加1补齐
• 输出数组的形状是输入数组形状的各个维度的最大值
• 如果输入数组的某个维度核输出数组的对应维度的长度相同或者其长度为1是，这个数组是能够用来计算的，否则出错
• 当输入数组的莫哥维度的长度为1时，沿着此维度运算是都用此维度上的第一组值

简单理解

对两个数组，分别比较它们的每一个维度（）若其中一个数组没有当前维度则忽略），满足

• 数组拥有相同的形状
• 当前维度的值相等
• 当前维度的值有一个是1

数组的迭代

numpy.nditer()
它是一个有效的多维数组迭代器，可以用在数组上进行迭代。数组的每个元素可食用python的标准iterator接口来访问。

arr = np.arange(24)  
a = arr.reshape((4, 6))  
for x in np.nditer(a):  
   print(x, end=',')
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,
print(a.T)  
for x in np.nditer(a.T):  
   print(x, end=',')
[[ 0  6 12 18]
 [ 1  7 13 19]
 [ 2  8 14 20]
 [ 3  9 15 21]
 [ 4 10 16 22]
 [ 5 11 17 23]]
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,
b = a.T.copy()  
# b = a.T.copy(order = 'C') 
print(b)  
for x in np.nditer(b):  
   print(x, end=',')
[[ 0  6 12 18] 
 [ 1  7 13 19]
 [ 2  8 14 20]
 [ 3  9 15 21]
 [ 4 10 16 22]
 [ 5 11 17 23]]
0,6,12,18,1,7,13,19,2,8,14,20,3,9,15,21,4,10,16,22,5,11,17,23,
# 列优先遍历
for x in np.nditer(b,order='F'):  
   print(x, end=',')
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,
# 修改数组的值，使其相应位的值均为原值的2倍
for x in np.nditer(b, op_flags=['readwrite']):  
   x *= 2  
   # x[...] *= 2  
   # x[...] = x * 2
print(b)

外部循环

nditer类的构造器拥有flags参数，它可以接收下列值

值	说明
c_index	可以跟踪C顺序的索引
f_index	可以跟踪Fortran顺序的索引
multi_index	每次迭代可以跟踪一种索引类型
external_loop	给出的值是具有多个之的一维数组，而不是零维数组

arr = np.arange(24)  
a = arr.reshape((4, 6))  
arr = np.arange(24)  
a = arr.reshape((4, 6))  
for x in np.nditer(a, flags=['external_loop'], order='F'):  
   print(x)
[ 0  6 12 18]
[ 1  7 13 19]
[ 2  8 14 20]
[ 3  9 15 21]
[ 4 10 16 22]
[ 5 11 17 23]

广播迭代

如果两个数组是可广播的，nditer组合对象能够同时迭代它们。

arr = np.arange(12)  
a = arr.reshape((3, 4))  
b = np.arange(1, 5)  
for x,y in np.nditer([a,b]):  
   print('{}-{}'.format(x,y),end='\t')
0-1	1-2	2-3	3-4	4-1	5-2	6-3	7-4	8-1	9-2	10-3	11-4

修改数组形状

• reshape()
  reshape(shape,order=‘C’)
  | 参数 | 说明 |
  | ----- | -------------------------------------------------- |
  | shape | 形状 |
  | order | C按行，F按列，A按原顺序，k按元素在内存中的出现顺序 |

arr = np.arange(12)  
a = arr.reshape((3, 4))  
print(a)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

• flat
  一个数组元素的迭代器。

arr = np.arange(12)  
a = arr.reshape((3, 4))  
for x in a.flat:  
   print(x,end=',')
0,1,2,3,4,5,6,7,8,9,10,11,

• flatten()
  flatten(order = ‘C’)
  作用：展平的数组元素并拷贝一份，顺序通常是C风格。
  对展平后的数组进行修改，不会更改原数组。
  | 参数 | 说明 |
  | ----- | ---------------------------------------------- |
  | order | C按行，F按列，A原顺序，k元素在内存中的出现顺序 |

arr = np.arange(12)  
a = arr.reshape((3, 4))  
b = a.flatten()  
print(b, end=',')
[ 0  1  2  3  4  5  6  7  8  9 10 11],

• ravel()
  numpy.ravel(order=‘C’)
  作用：展平的数组元素，顺序通常是C风格，返回的是数组视图。
  注意：对展平后的数组进行修改，会更改原数组（order='F’相当于是原数组的拷贝，不会修改原值）。

arr = np.arange(12)  
a = arr.reshape((3, 4))  
b = a.ravel()  
b[3]=0  
print(b, end='\n')  
print(a)
[ 0  1  2  0  4  5  6  7  8  9 10 11]
[[ 0  1  2  0]
 [ 4  5  6  7]
 [ 8  9 10 11]]

翻转数组

• transpose()
  numpy.transpose(a,axes=None )
  作用：对换数组的维度。
  注意：修改会影响原始数组。

arr = np.arange(12)  
a = arr.reshape((3, 4))  
print(a)  
b = np.transpose(a)  
print(b)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

• ndarray.T
  类似numpy.transpose

arr = np.arange(12)  
a = arr.reshape((3, 4))  
print(a)  
b = a.T 
print(b)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

• rollaxis()
  numpy.rollaxis(a,axis,start=0)
  作用：向后滚动特定的轴到一个特定的位置
  | 参数 | 说明 |
  | ----- | ----------------------------------------- |
  | a | 被操纵的数组 |
  | axis | 要向后滚动的轴 |
  | start | 默认为0表示完整的滚动，会滚动到特定的位置 |

arr = np.arange(12)  
a = arr.reshape((3, 4))  
print(a)  
b = np.rollaxis(a, 1)  
print(b)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

• swapaxes()
  numpy.wsapaxes(a,axis1,axis2)
  作用：交换数组的两个轴。

arr = np.arange(12)  
a = arr.reshape((3, 4))  
print(a)  
b = np.swapaxes(a, 1, 0)  
print(b)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

修改数组维度

broadcast()

用于模仿广播的对象，返回一个对象，该对象封装了将一个数组广播到另一个数组的结果。

x = np.array([[1], [2], [4]])  
y = np.arange(4, 7)  
b = np.broadcast(x, y)  
r, c = b.iters  
for i in range(9):  
   print(next(r), next(c))
1 4
1 5
1 6
2 4
2 5
2 6
4 4
4 5
4 6

broadcast()

numpy.broadcast_to(array,shape,subok=False)
作用：将数组广播到新形状。他在原始数组上返回只读视图，它通常不连续。如果新形状不符合Numpy的广播规则，会抛出valueerror。

a = np.arange(1, 5).reshape((1, 4))  
b = np.broadcast_to(a, (4, 4))  
print(b)
[[1 2 3 4]
 [1 2 3 4]
 [1 2 3 4]
 [1 2 3 4]]

expand_dims()

numpy.expand_dims(arr,axis=None )
作用：在指定位置插入新的轴来扩展数组形状。

a = np.arange(1, 5).reshape((2, 2))  
b = np.expand_dims(a, axis=0)  
print(a)  
print(b)
[[1 2]
 [3 4]]
[[[1 2]
  [3 4]]]

squeeze()

numpy.squeeze(arr,axis)
作用：从给定数组的形状中删除size=1的维度。

a = np.arange(1, 10).reshape((3, 3,1, 1))  
b = np.squeeze(a)  
print(a)  
print(b)
[[[[1]]
  [[2]]
  [[3]]]
 [[[4]]
  [[5]]
  [[6]]]
 [[[7]]
  [[8]]
  [[9]]]]
[[1 2 3]
 [4 5 6]
 [7 8 9]]

连接数组

concatenate()

numpy.concatenate((arr1,arr2,…),axis )
作用：用于沿指定轴连接相同形状的多个数组。

a = np.arange(1, 10).reshape((3, 3))  
b = np.arange(11,20).reshape((3, 3))  
print(np.concatenate((a,b),axis=1))
[[ 1  2  3 11 12 13]
 [ 4  5  6 14 15 16]
 [ 7  8  9 17 18 19]]

stack()

numpy.stack(arrays,axis)
作用：连接相同形状的多个数组并生成新的指定轴。

a = np.arange(1, 10).reshape((3, 3))  
b = np.arange(11,20).reshape((3, 3))  
print(np.stack((a,b),axis=0))
[[[ 1  2  3]
  [ 4  5  6]
  [ 7  8  9]]
 [[11 12 13]
  [14 15 16]
  [17 18 19]]]
print(np.stack((a,b),axis=1))
[[[ 1  2  3]
  [11 12 13]]
 [[ 4  5  6]
  [14 15 16]]
 [[ 7  8  9]
  [17 18 19]]]

hstack()

numpy.hstack(arrays)
作用：numpy.stack(arrays,axis)的变体，通过水平堆叠来生成新数组。

a = np.arange(1, 10).reshape((3, 3))  
b = np.arange(11,20).reshape((3, 3))  
print(np.hstack((a,b)))
[[ 1  2  3 11 12 13]
 [ 4  5  6 14 15 16]
 [ 7  8  9 17 18 19]]

vstack()

numpy.vstack(arrays)
作用：numpy.stack(arrays,axis)的变体，通过垂直堆叠来生成新数组。

a = np.arange(1, 10).reshape((3, 3))  
b = np.arange(11,20).reshape((3, 3))  
print(np.vstack((a,b)))
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [11 12 13]
 [14 15 16]
 [17 18 19]]

分隔数组

split()

numpy.split(arr,indices_or_sections,axis=0)
作用：沿着特定的轴将数组分割为子数组。

参数	说明
arr	待分割的数组
indices_or_sections	如果是一个整数就用该数平均切分；如果是一个数组则指定沿轴切分的位置（左开右闭）
axis	指定切分维度，默认为0：横向切分，1：纵向切分

arr = np.arange(16).reshape((4, 4))  
print(arr)  
a = np.split(arr, 4)  
b = np.split(arr, (1, 3))  
print(a)  
print(b)
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]]), array([[12, 13, 14, 15]])]
[array([[0, 1, 2, 3]]), array([[ 4,  5,  6,  7],
       [ 8,  9, 10, 11]]), array([[12, 13, 14, 15]])]

hsplit()

numpy.split(arr,indices_or_sections,axis=0)的变体，沿水平方向切分数组。

arr = np.arange(16).reshape((4, 4))  
a = np.hsplit(arr, (1, 3))  
print(a)
[array([[ 0],
       [ 4],
       [ 8],
       [12]]), array([[ 1,  2],
       [ 5,  6],
       [ 9, 10],
       [13, 14]]), array([[ 3],
       [ 7],
       [11],
       [15]])]

vsplit()

numpy.split(arr,indices_or_sections,axis=0)的变体，沿垂直方向切分数组。

arr = np.arange(16).reshape((4, 4))  
a = np.hsplit(arr, (1, 3))  
print(a)
[array([[0, 1, 2, 3]]), array([[ 4,  5,  6,  7],
       [ 8,  9, 10, 11]]), array([[12, 13, 14, 15]])]

数组元素的添加与删除

resize()

numpy.resize(arr,shape)
作用：返回指定大小的新数组，如果新形状大于原数组会依次取原数组值填充。

arr = np.arange(16).reshape((4, 4))  
a = np.resize(arr, (3, 3))  
b = np.resize(arr, (5, 5))  
print(arr)  
print(a)  
print(b)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
[[0 1 2]
 [3 4 5]
 [6 7 8]]
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15  0  1  2  3]
 [ 4  5  6  7  8]]

append()

numpy.append(arr,values,axis=None)
作用：在数组末尾添加值，追加操作会分配整个数组，并把原数组复制到新数组中，输入的数组维度必须匹配否则将抛出ValueError。

参数	说明
arr	原数组
values	要想arr中添加的值，需要和arr形状相同（除了需要添加的轴）
axis	默认值为None，横向添加，返回总是1维数组。当axis有定义时（0,1），为0是列数相同，为1时行数相同

arr = np.arange(16).reshape((4, 4))  
a = np.append(arr, (16, 17, 18, 19))  
print(a)  
c = np.append(arr, [[16, 17, 18, 19]], axis=0)  
print(c)  
c = np.append(arr, [[16], [17], [18], [19]], axis=1)  
print(c)
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]
 [16 17 18 19]]
[[ 0  1  2  3 16]
 [ 4  5  6  7 17]
 [ 8  9 10 11 18]
 [12 13 14 15 19]]

insert()

numpy.insert(arr,index,values,axis )
作用：在给定索引之前沿指定轴在原数组中插入值。
注意：待插入的值要沿插入方向形状一致，插入后会生成一个新的数组。

参数	说明
arr	原数组
index	待插入的位置
values	要插入的值
axis	待插入的轴，如果不指定数组会被展开为一维数组

arr = np.arange(16).reshape((4, 4))  
a = np.insert(arr, 1, (16, 17, 18, 19))  
print(a)  
b = np.insert(arr, 1, (16, 17, 18, 19), axis=0)  
print(b)  
c = np.insert(arr, 1, (16, 17, 18, 19), axis=1)  
print(c)
[ 0 16 17 18 19  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]
[[ 0  1  2  3]
 [16 17 18 19]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
[[ 0 16  1  2  3]
 [ 4 17  5  6  7]
 [ 8 18  9 10 11]
 [12 19 13 14 15]]

delete()

numpy.delete(arr,index,axis )
作用：返回从原数组删除指定子数组的新数组，如果未提供轴参数则数组将会展开。

arr = np.arange(1, 17).reshape((4, 4))  
a = np.delete(arr, (2, 3))  
print(a)  
b = np.delete(arr, 1, axis=0)  
print(b)  
c = np.delete(arr, 0, axis=1)  
print(c)
[ 1  2  5  6  7  8  9 10 11 12 13 14 15 16]
[[ 1  2  3  4]
 [ 9 10 11 12]
 [13 14 15 16]]
[[ 2  3  4]
 [ 6  7  8]
 [10 11 12]
 [14 15 16]]

unique()

numpy.unique(arr,return_index,return_inverse,return_counts)
作用：去除数组中的重复元素。

参数	说明
arr	输入数组，如果不是一维数组会自动展开
return_index	如果为True，返回新列表元素在旧列表中的位置（下标）列表
return_inverse	如果为True，返回旧列表元素在新列表中的位置（下标）列表
return_counts	如果为True，返回新数组元素在旧数组中出现的次数

arr = np.arange(1, 17).reshape((4, 4))  
a = np.insert(arr, 1, (2, 3, 4, 5), axis=0)  
print(a)  
b = np.unique(a, return_index=True, return_inverse=True, return_counts=True)  
print(b)
[[ 1  2  3  4]
 [ 2  3  4  5]
 [ 5  6  7  8]
 [ 9 10 11 12]
 [13 14 15 16]]
(array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16]), array([ 0,  1,  2,  3,  7,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
      dtype=int64), array([ 0,  1,  2,  3,  1,  2,  3,  4,  4,  5,  6,  7,  8,  9, 10, 11, 12,
       13, 14, 15], dtype=int64), array([1, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int64))

字符串函数

add()

对两个数组元素进行字符串连接。

print(np.char.add(('teacher'), ['student']))  
print(np.char.add(('teacher', 'student'), ['20', '240']))
['teacherstudent']
['teacher20' 'student240']

multiply()

返回数组元素多重连接后的字符串。

print(np.char.multiply(('teacher', 'student'), 5))
['teacherteacherteacherteacherteacher'
 'studentstudentstudentstudentstudent']

center()

将数组元素居中，并用指定字符串在左右进行填充。

print(np.char.center(('teacher', 'student'), 15, fillchar='-'))
['----teacher----' '----student----']

capitalize()

将数组元素首字母转换为大写字母。

print(np.char.capitalize(('teacher', 'student')))
['Teacher' 'Student']

title()

将数组元素每个单词的首字母转换为大写字母。

print(np.char.title(('teacher', 'student')))
['Teacher' 'Student']

lower()

将数组元素每个单词转换为小写。

print(np.char.lower(('Teacher', 'Student')))
['teacher' 'student']

upper()

将数组元素每个单词转换为大写。

print(np.char.upper(('Teacher', 'Student')))
['TEACHER' 'STUDENT']

split()

用指定分隔符将数组元素进行分割。

print(np.char.split(('Teacher', 'Student'),sep='t'))
[list(['Teacher']) list(['S', 'uden', ''])]

join()

用指定连接符将数组元素进行连接。

print(np.char.join(['-', '0'], ['Teacher', 'Student']))
['T-e-a-c-h-e-r' 'S0t0u0d0e0n0t']
print(np.char.join(['-'], ['Teacher', 'Student']))
['T-e-a-c-h-e-r' 'S-t-u-d-e-n-t']

splitlines()

相当于split()指定sep='\n’或者不指定分隔符，用换行符将数组元素进行分割。

print(np.char.splitlines(('Tea\ncher', 'Stud\nent')))
[list(['Tea', 'cher']) list(['Stud', 'ent'])]

strip()

去除数组元素收尾指定的字符。

print(np.char.strip(('-Tea-cher-', '-Stu-dent-'),'-'))
['Tea-cher' 'Stu-dent']

replace()

用指定字符代替数组中元祖的制定字符。

print(np.char.replace(('-Tea-cher-', '-Stu-dent-'), '-', ''))
['Teacher' 'Student']

encode()

对数组元素依次调用str.encode 。

print(np.char.encode(['Teacher', 'Student'], 'utf-8'))
[b'Teacher' b'Student']

encode()

对数组元素依次调用str.decode 。

print(np.char.decode([b'Teacher', b'Student'], 'utf-8'))
['Teacher' 'Student']

数学函数

标准三角函数

• sin()
• cos()
• tan()

a = np.array([0, 30, 45, 60, 90])  
print(np.sin(a * np.pi / 180))  
print(np.cos(a * np.pi / 180))  
print(np.tan(a * np.pi / 180))
[1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
 6.12323400e-17]
[0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
 1.63312394e+16]

反三角函数

返回值为弧度制。

• arcsin()
• arccos()
• arctan()

a = np.array([0, 30, 45, 60, 90])  
s = np.sin(a * np.pi / 180)  
c = np.cos(a * np.pi / 180)  
t = np.tan(a * np.pi / 180)  
print(np.degrees(np.arcsin(s)))  
print(np.degrees(np.arccos(c)))  
print(np.degrees(np.arctan(t)))
[ 0. 30. 45. 60. 90.]
[ 0. 30. 45. 60. 90.]
[ 0. 30. 45. 60. 90.]

around()

numpy.around(arr,decimals=0)
作用：返回指定数组的四舍五入值。

a = np.array([1.11, 2.54, 3.32, 4.50])  
print(np.around(a, decimals=1))
[1.1 2.5 3.3 4.5]

floor()

numpy.floor()
作用：向下取整，返回不大于输入的最大整数。

a = np.array([1.11, 2.54, 3.32, 4.50])  
print(np.floor(a))
[1. 2. 3. 4.]

ceil()

numpy.ceil()
作用：向上取整。

a = np.array([1.11, 2.54, 3.32, 4.50])  
print(np.ceil(a))
[2. 3. 4. 5.]

算术函数

add()

x = np.arange(9, dtype='f').reshape((3, 3))  
y = np.array([10, 10, 10])  
print(np.add(x, y))
# print(x+y)
[[10. 11. 12.]
 [13. 14. 15.]
 [16. 17. 18.]]

subtrack()

x = np.arange(9, dtype='f').reshape((3, 3))  
y = np.array([10, 10, 10])  
print(np.subtract(x, y))
# print(x-y)
[[-10.  -9.  -8.]
 [ -7.  -6.  -5.]
 [ -4.  -3.  -2.]]

multiply()

x = np.arange(9, dtype='f').reshape((3, 3))  
y = np.array([10, 10, 10])  
print(np.multiply(x, y))
# print(x*-*y)
[[ 0. 10. 20.]
 [30. 40. 50.]
 [60. 70. 80.]]

divide()

x = np.arange(9, dtype='f').reshape((3, 3))  
y = np.array([10, 10, 10])  
print(np.divide(x, y))
# print(x/y)
[[0.  0.1 0.2]
 [0.3 0.4 0.5]
 [0.6 0.7 0.8]]

reciprocal()

nu.reciprocal()
作用：对数组的元素单个取倒数。

x = np.arange(1,10, dtype='f').reshape((3, 3))  
print(np.reciprocal(x))
[[1.         0.5        0.33333334]
 [0.25       0.2        0.16666667]
 [0.14285715 0.125      0.11111111]]

power()

numpy.power(base,arr)
作用：将第一个数组的元素做底数，计算第二个数组元数的幂。

x= np.full(10,10)  
y = np.arange(10, dtype='i4')  
print(np.power(x,y))
[         1         10        100       1000      10000     100000
    1000000   10000000  100000000 1000000000]

mod(),remainder()

numpy.mod(arr1,arr2)
numpy.remainder(arr1,arr2)
作用：计算输入数组arr1,arr2对应元素相除后的余数。

x= np.full(10,10)  
y = np.arange(10, dtype='i4')  
print(np.power(x,y))
[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]

统计函数

最值

• amax()
  numpy.amax(arr,axis )
  求数组沿指定轴的最大值。

y = np.arange(10).reshape((2, 5))  
print(y)  
print(np.amax(y))  
print(np.amax(y, axis=1))
[[0 1 2 3 4]
 [5 6 7 8 9]]
9
[4 9]

• amin()
  numpy.amin(arr,axis )
  求数组沿指定轴的最小值。

y = np.arange(10).reshape((2, 5))  
print(y)  
print(np.amin(y))  
print(np.amin(y, axis=1))
[[0 1 2 3 4]
 [5 6 7 8 9]]
0
[0 5]

ptp()

numpy.ptp(arr,axis=None)
作用：计算数组中沿指定轴的最大值与最小值的差。

y = np.arange(10).reshape((2, 5))  
print(y)  
print(np.ptp(y))  
print(np.ptp(y, axis=1))
[[0 1 2 3 4]
 [5 6 7 8 9]]
9
[4 4]

percentile()

numpy.percentile(arr,q,axis)
作用：返回小于观察值指定百分比的数值。

y = np.arange(10).reshape((2, 5))  
print(y)  
print(np.percentile(y, 50,1))
[[0 1 2 3 4]
 [5 6 7 8 9]]
[2. 7.]

median()

numpy.median(arr,axis)
作用：返回数组元素按指定轴的中位数。

y = np.arange(10).reshape((2, 5))  
print(y)  
print(np.median(y, 1))
 [5 6 7 8 9]]
[2. 7.]

mean()

numpy.mean(arr,axis)
作用：返回数组按指定轴的算术平均值。

y = np.arange(10).reshape((2, 5))  
print(y)  
print(np.mean(y, 1))
 [5 6 7 8 9]]
[2. 7.]

average()

numpy.average(arr,weights=None,axis =None,returned=False)
作用：根据在另一个数组中给定的各自的权重计算数组的加权平均值。可以指定一个轴参数，如果没有指定，数组会被展开。

参数	说明
arr	数组
weights	权重数组
axis	轴
returned	是否返回权重的和

x = np.arange(10).reshape((2, 5))  
y = np.arange(10).reshape((2, 5))  
print(x, '\n', y)  
print(np.average(x))  
print(np.average(y, weights=x, axis=0, returned=True))
[[0 1 2 3 4]
 [5 6 7 8 9]] 
 [[0 1 2 3 4]
 [5 6 7 8 9]]
4.5
(array([5.        , 5.28571429, 5.88888889, 6.63636364, 7.46153846]), array([ 5.,  7.,  9., 11., 13.]))

var()

numpy.var(arr)
作用：计算数组的方差。

std()

numpy.std(arr)
作用：计算数组的标准差，标准差是方差的算术平方根。
标准差是一组数据平均值分散程度的一中度量。

y = np.arange(10)  
print(y)  
print(np.var(y))  
print(np.std(y))
[0 1 2 3 4 5 6 7 8 9]
8.25
2.8722813232690143

排序函数

种类	速度	最坏情况	工作空间	稳定性
quicksort快速排序	1	O(n^2)	O	否
mergesort归并排序	2	O(n*log(n))	~n/2	是
heapsort 堆排序	3	O(n*long(n))	O	否

sort()

numpy.sort(arr,axis,kind,order)
作用：返回输入数组的排序副本。

参数	说明
arr	数组
axis	axis=0按列排序，axis=1按行排序，如果没有指定axis数组会被展开
kind	排序算法，默认为quicksort
order	如果数组包含字段，则为要排序的字段

x = np.random.randint(1, 10, 16).reshape((4, 4))  
print(x)  
print(np.sort(x, axis=0))  
student = np.dtype([('name', 'S20'), ('age', 'i1')])  
y = np.array([('Hens', 20), ('Jane', 18), ('King', 22), ('Tom', 17)], dtype=student).reshape((2, 2))  
print(y)  
print(np.sort(y, order='age'))
[[5 1 5 7]
 [1 7 8 6]
 [2 6 5 8]
 [4 8 3 6]]
[[1 1 3 6]
 [2 6 5 6]
 [4 7 5 7]
 [5 8 8 8]]
[[(b'Hens', 20) (b'Jane', 18)]
 [(b'King', 22) (b'Tom', 17)]]
[[(b'Jane', 18) (b'Hens', 20)]
 [(b'Tom', 17) (b'King', 22)]]

argsort()

作用：对输入数组沿给定轴执行间接排序，返回排序后的元素索引数组。
可以使用元素索引数组对输入数据进行排序。

x = np.random.randint(1, 10, 16)  
print(x)  
a = np.argsort(x)  
print(a)  
print(x[a])
[4 8 3 2 8 7 8 9 2 5 3 1 8 8 9 5]
[11  3  8  2 10  0  9 15  5  1  4  6 12 13  7 14]
[1 2 2 3 3 4 5 5 7 8 8 8 8 8 9 9]

lexsort()

作用：给多个数组按指定优先级进行执行间接排序，该函数返回一个索引数组，可以使用他获得排序数组。
注意：排序依据优先级由右及左。

x = np.random.randint(10, 30, 10)  
y = np.random.randint(1, 10, 10)  
z = np.random.randint(1, 10, 10)  
print(x, '\n', y, '\n', z)  
s = np.lexsort((z, y, x))  
print(s)  
for i in s:  
   print('{}-{}-{};'.format(x[i],y[i],z[i]))
[26 23 15 11 23 24 25 28 15 18] 
 [2 2 1 6 5 1 4 8 4 6] 
 [3 4 8 4 1 1 2 4 2 6]
[3 2 8 9 1 4 5 6 0 7]
11-6-4;
15-1-8;
15-4-2;
18-6-6;
23-2-4;
23-5-1;
24-1-1;
25-4-2;
26-2-3;
28-8-4;

msort()

相当于numpy.sort(arr,axis=0)

sort_complex()

作用：对复数按先实部后虚部的顺序进行排序。

partition()

numpy.partition(arr,slice,axis,kind,order)
作用：指定一个slice对数据进行分割，返回分割后的数组（未排序）。

参数	说明
arr	数组
slice	指定进行分割的数组元素的索引，小于指定元素最小值的排在前面，大于指定元素最大值的排在后面，介于指定元素最值之间的排在中间
axis	axis=0按列排序，axis=1按行排序，如果没有指定axis数组会被展开
kind	排序算法，默认为quicksort
order	如果数组包含字段，则为要排序的字段

x = np.random.randint(10, 30, 10)  
print(x)  
a = np.partition(x, (4, 6, 8))  
print(a)
[10 24 27 17 18 24 25 12 11 28]
[12 10 11 17 18 24 24 25 27 28]

argpartition()

numpy.argpartition(arr,max_index,axis,kind,order)
作用：指定一个最值索引对数据进行分割，返回分割后的索引数组（未排序）。

参数	说明
arr	数组
max_index	指定进行分割的最值索引（0代表小值，-1代表最大值），小于指定最值的排在前面，大于指定最值的排在后面
axis	axis=0按列排序，axis=1按行排序，如果没有指定axis数组会被展开
kind	排序算法，默认为quicksort
order	如果数组包含字段，则为要排序的字段

x = np.random.randint(10, 30, 10)  
print(x)  
a = np.argpartition(x, 3)  
print(a)
[26 23 12 17 16 13 19 25 12 19]
[2 8 5 4 3 9 6 7 1 0]

搜索函数

• max()
  numpy.max(arr,axis=None)
  作用：沿指定轴取最大值。

x = np.random.randint(10, 30, 10).reshape((2, 5))  
print(x)  
print(np.max(x, axis=1))
[[28 20 19 11 13]
 [19 29 15 14 19]]
[28 29]

• min()
  numpy.min(arr,axis=None)
  作用：沿指定轴取最小值。

x = np.random.randint(10, 30, 10).reshape((2, 5))  
print(x)  
print(np.min(x, axis=1))
[[25 27 12 25 19]
 [14 16 22 20 27]]
[12 14]

• argmax()
  numpy.argmax(arr,axis=None)
  作用：沿指定轴取最大值的索引。

x = np.random.randint(10, 30, 10).reshape((2, 5))  
print(x)  
print(np.argmax(x, axis=1))
[[22 22 17 23 25]
 [11 28 27 20 14]]
[4 1]

• argmin()
  numpy.argmin(arr,axis=None)
  作用：沿指定轴取最小值的索引。

x = np.random.randint(10, 30, 10).reshape((2, 5))  
print(x)  
print(np.argmin(x, axis=1))
[[22 16 19 18 19]
 [25 22 19 20 15]]
[1 4]

• nonzero()
  作用：返回数组中非0元素的索引。

x = np.random.randint(0, 10, 10).reshape((2, 5))  
print(x)  
print(np.nonzero(x))
[[1 0 4 9 1]
 [4 3 4 1 7]]
(array([0, 0, 0, 0, 1, 1, 1, 1, 1], dtype=int64), array([0, 2, 3, 4, 0, 1, 2, 3, 4], dtype=int64))

• where()
  作用：返回数组中满足指定条件的元素的索引。

x = np.random.randint(0, 10, 10).reshape((2, 5))  
print(x)  
print(np.where(x>5))
[[3 7 6 4 0]
 [8 7 5 0 4]]
(array([0, 0, 1, 1], dtype=int64), array([1, 2, 0, 1], dtype=int64))

• extract()
  作用：从数组中抽取满足指定条件的数组元素。

x = np.random.randint(0, 10, 10).reshape((2, 5))  
print(x)  
condition = np.mod(x, 2) == 0  
print(condition)  
print(np.extract(condition, x))
[[7 8 8 9 4]
 [0 2 2 1 3]]
[[False  True  True False  True]
 [ True  True  True False False]]
[8 8 4 0 2 2]

拷贝

赋值

简单的赋值不会创建数组的样本，它只是获取数组对象的指针，对它的修改会影响原数组。

视图

又可称为浅拷贝，是数据的一个别称或引用，通过该别称或引用可以方便的访问、操作原有数据。

• numpy的切片操作返回元数据的视图

x = np.random.randint(0, 10, 10).reshape((2, 5))  
y = x[(0, 1), 1:]  
print(x, '\n', y)  
y[1, 1] = 100  
print(x, '\n', y)
[[6 4 9 0 7]
 [9 4 4 5 8]] 
 [[4 9 0 7]
 [4 4 5 8]]
[[6 4 9 0 7]
 [9 4 4 5 8]] 
 [[  4   9   0   7]
 [  4 100   5   8]]

• 调用numpy.view()函数
  注意：对视图形状的修改不影响原数组。

x = np.random.randint(0, 10, 10).reshape((2, 5))  
y = x.view()  
print(x, '\n', y)  
y[1, 1] = 100  
y.shape = (5, 2)
print(x, '\n', y)
[[9 4 6 4 5]
 [4 7 7 4 8]] 
 [[9 4 6 4 5]
 [4 7 7 4 8]]
[[  9   4   6   4   5]
 [  4 100   7   4   8]] 
 [[  9   4]
 [  6   4]
 [  5   4]
 [100   7]
 [  4   8]]

副本

又可称为深拷贝，是数据的一个完整拷贝。

• numpy的切片操作返回元数据的视图

x = np.random.randint(0, 10, 10).reshape((2, 5))  
y = x[(0, 1), 1:]  
print(x, '\n', y)  
y[1, 1] = 100  
print(x, '\n', y)
[[6 4 9 0 7]
 [9 4 4 5 8]] 
 [[4 9 0 7]
 [4 4 5 8]]
[[6 4 9 0 7]
 [9 4 4 5 8]] 
 [[  4   9   0   7]
 [  4 100   5   8]]

• 调用dnarray的copy()函数

x = np.random.randint(0, 10, 10).reshape((2, 5))  
y = x.copy()  
print(x, '\n', y)  
y[1, 1] = 99  
print(x, '\n', y)
[[6 0 7 5 9]
 [3 5 2 7 0]] 
 [[6 0 7 5 9]
 [3 5 2 7 0]]
[[6 0 7 5 9]
 [3 5 2 7 0]] 
 [[ 6  0  7  5  9]
 [ 3 99  2  7  0]]

• python序列的切片操作，调用deepcopy()函数

IO函数

numpy可以读取磁盘上的文本数据或者二进制数据。
numpy为ndarray对象引入了一个简单的文本格式：npy。
npy文件用于存储重建ndarray所需的数据、图形、dtype和其他信息。

常用函数	说明
load()或者save()	读写文件数组数据函数，默认情况先数组以未压缩的二进制格式保存在扩展名为.npy的文件中
savez()	将多个数组写入文件，默认情况先数组以未压缩的二进制格式保存在扩展名为.npz的文件中
loadtxt()或者savetxt()	处理正常的文本文件

• numpy.save(file,arr,allow_pickle=True,fix_imports=True)
  作用：将数组保存到以.npy为扩展名的文件中。
  | 参数 | 说明 |
  | ------------ | ------------------------------------------------------------------------------------------------------------------ |
  | file | 文件名 |
  | arr | 数组 |
  | allow_pickle | 允许使用python pickles保存对象数组，python中的pickle用于在保存到磁盘文件或读取文件之前对对象进行序列化或者反序列化 |
  | fix_imports | 为了方便python2读取python3保存的数据 |

x = np.random.randint(0, 10, 10).reshape((2, 5))  
np.save('./logfile/test', x)

• numpy.load(file)
  作用：读取扩展名为.npy的文件。

x = np.load('./logfile/test.npy')  
print(x)
[[4 7 9 3 5]
 [3 0 6 1 3]]

• numpy.savez(file,**args,**kwds)
  作用：将多个数组保存到.npz为扩展名的文件中，可以为数组指定别名，未指定别名的数组按顺序被默认命名为arr_0,arr_1,…。

x = np.random.randint(0, 10, 10).reshape((2, 5))  
y = np.random.randint(0, 10, 10).reshape((2, 5))  
z = np.random.randint(0, 10, 10).reshape((2, 5))  
np.savez('./logfile/test1', x, arr_y=y, arr_z=z)

ret = np.load('./logfile/test1.npz')  
print(ret['arr_y'])

• numpy.savetxt(file,arr,fmt=‘%d’,delimiter=‘,’)
  作用：以简单的文本文件格式存储数据，delimiter参数用来指定分隔符。

x = np.random.randint(0, 10, 10).reshape((2, 5))  
np.savetxt('./logfile/test2', x,fmt='%d',delimiter=',')

• numpy.savetxt(file,dtype=int,delimiter=‘,’)

y = np.loadtxt('./logfile/test2', dtype=int, delimiter=',')  
print(y)
[[6. 4. 0. 1. 6.]
 [6. 6. 9. 9. 0.]]