NumPy 笔记（超级全！收藏√）

参考链接： Python中的numpy.invert

文章目录

 NumPy 教程NumPy Ndarray 对象NumPy 数据类型数据类型对象 (dtype)

  NumPy 读取数据NumPy 数组属性ndarray.ndimndarray.shapendarray.itemsizendarray.flags

  NumPy 创建数组numpy.emptynumpy.zerosnumpy.ones

  NumPy 从已有的数组创建数组numpy.asarraynumpy.frombuffernumpy.fromiter

  NumPy 从数值范围创建数组numpy.arangenumpy.linspacenumpy.logspace

  NumPy 切片和索引NumPy 高级索引布尔索引花式索引

  NumPy 广播(Broadcast)广播的规则:

  NumPy 迭代数组控制遍历顺序修改数组中元素的值使用外部循环广播迭代

   修改数组形状numpy.reshapenumpy.ndarray.flatnumpy.ndarray.flattennumpy.ravel

   翻转数组numpy.transposenumpy.rollaxisnumpy.swapaxes

   修改数组维度numpy.broadcastnumpy.broadcast_tonumpy.expand_dimsnumpy.squeeze

   连接数组numpy.concatenatenumpy.stacknumpy.hstacknumpy.vstack

   分割数组numpy.splitnumpy.hsplitnumpy.vsplit

   数组元素的添加与删除numpy.resizenumpy.appendnumpy.insertnumpy.deletenumpy.unique

  NumPy 位运算bitwise_andbitwise_orinvertleft_shiftright_shift

  NumPy 字符串函数numpy.char.add()numpy.char.multiply()numpy.char.center()numpy.char.capitalize()numpy.char.title()numpy.char.lower()numpy.char.upper()numpy.char.split()numpy.char.splitlines()numpy.char.strip()numpy.char.join()numpy.char.replace()numpy.char.encode()numpy.char.decode()

  NumPy 数学函数三角函数舍入函数numpy.floor()numpy.ceil()

  NumPy 算术函数numpy.reciprocal()numpy.power()numpy.mod()

  NumPy 统计函数numpy.amin() 和 numpy.amax()numpy.ptp()numpy.percentile()numpy.median()numpy.mean()numpy.average()标准差方差

  NumPy 排序、条件刷选函数numpy.sort()numpy.argsort()numpy.lexsort()msort、sort_complex、partition、argpartitionnumpy.argmax() 和 numpy.argmin()numpy.nonzero()numpy.where()numpy.extract()

  NumPy 字节交换numpy.ndarray.byteswap()

  NumPy 副本和视图无复制视图或浅拷贝副本或深拷贝

   Python append() 与深拷贝、浅拷贝深浅拷贝

  NumPy 矩阵库(Matrix)matlib.empty()numpy.matlib.zeros()numpy.matlib.ones()numpy.matlib.eye()numpy.matlib.identity()numpy.matlib.rand()

  NumPy 线性代数numpy.dot()numpy.vdot()numpy.inner()numpy.matmulnumpy.linalg.det()numpy.linalg.solve()numpy.linalg.inv()

  NumPy IOnumpy.save()numpy.saveznumpy.savetxt()

NumPy 教程 

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。 

NumPy 的前身 Numeric 最早是由 Jim Hugunin 与其它协作者共同开发，2005 年，Travis Oliphant 在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色，并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。 

NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含： 

一个强大的N维数组对象 ndarray广播功能函数整合 C/C++/Fortran 代码的工具线性代数、傅里叶变换、随机数生成等功能 

NumPy Ndarray 对象 

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。 

ndarray 对象是用于存放同类型元素的多维数组。 

ndarray 中的每个元素在内存中都有相同存储大小的区域。 

ndarray 内部由以下内容组成： 

一个指向数据（内存或内存映射文件中的一块数据）的指针。数据类型或 dtype，描述在数组中的固定大小值的格子。一个表示数组形状（shape）的元组，表示各维度大小的元组。一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。 

ndarray 的内部结构: 

跨度可以是负数，这样会使数组在内存中后向移动，切片中 obj[::-1] 或 obj[:,::-1] 就是如此。 

创建一个 ndarray 只需调用 NumPy 的 array 函数即可： 

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

参数说明： 

名称描述object数组或嵌套的数列dtype数组元素的数据类型，可选copy对象是否需要复制，可选order创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）subok默认返回一个与基类类型一致的数组ndmin指定生成数组的最小维度

ndarray 对象由计算机内存的连续一维部分组成，并结合索引模式，将每个元素映射到内存块中的一个位置。内存块以行顺序(C样式)或列顺序(FORTRAN或MatLab风格，即前述的F样式)来保存元素 

NumPy 数据类型 

numpy 支持的数据类型比 Python 内置的类型要多很多，基本上可以和 C 语言的数据类型对应上，其中部分类型对应为 Python 内置的类型。下表列举了常用 NumPy 基本类型。 

名称描述bool_布尔型数据类型（True 或者 False）int_默认的整数类型（类似于 C 语言中的 long，int32 或 int64）intc与 C 的 int 类型一样，一般是 int32 或 int 64intp用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）int8字节（-128 to 127）int16整数（-32768 to 32767）int32整数（-2147483648 to 2147483647）int64整数（-9223372036854775808 to 9223372036854775807）uint8无符号整数（0 to 255）uint16无符号整数（0 to 65535）uint32无符号整数（0 to 4294967295）uint64无符号整数（0 to 18446744073709551615）float_float64 类型的简写float16半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位float32单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位float64双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位complex_complex128 类型的简写，即 128 位复数complex64复数，表示双 32 位浮点数（实数部分和虚数部分）complex128复数，表示双 64 位浮点数（实数部分和虚数部分）

numpy 的数值类型实际上是 dtype 对象的实例，并对应唯一的字符，包括 np.bool_，np.int32，np.float32，等等。 

数据类型对象 (dtype) 

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

数据的类型（整数，浮点数或者 Python 对象）数据的大小（例如， 整数使用多少个字节存储）数据的字节顺序（小端法或大端法）在结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的部分如果数据类型是子数组，它的形状和数据类型 

字节顺序是通过对数据类型预先设定"<“或”>“来决定的。”<“意味着小端法(最小值存储在最小的地址，即低位组放在最前面)。”>"意味着大端法(最重要的字节存储在最小的地址，即高位组放在最前面)。 

dtype 对象是使用以下语法构造的： 

numpy.dtype(object, align, copy)

object - 要转换为的数据类型对象align - 如果为 true，填充字段使其类似 C 的结构体。copy - 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用 

每个内建类型都有一个唯一定义它的字符代码，如下： 

字符对应类型b布尔型i(有符号) 整型u无符号整型 integerf浮点型c复数浮点型mtimedelta（时间间隔）Mdatetime（日期时间）O(Python) 对象S, a(byte-)字符串UUnicodeV原始数据 (void)

NumPy 读取数据 

CSV:Comma-Separated Value,逗号分隔值文件 

显示：表格状态 

源文件：换行和逗号分隔行列的格式化文本,每一行的数据表示一条记录 

由于csv便于展示,读取和写入,所以很多地方也是用csv的格式存储和传输中小型的数据,为了方便教学,我们会经常操作csv格式的文件,但是操作数据库中的数据也是很容易的实现的 

np.loadtxt(fname,dtype=np.float,delimiter=None,skiprows=0,usecols=None,unpack=False)

参数解释frame文件、字符串或产生器，可以是,gz或bz2压缩文件dtype数据类型，可选，CSV的字符串以什么数据类型读入数据，默认 np.floatdelimiter分隔字符串，默认是任何空格，改为 逗号skiprows跳过前x行，一般跳过第一行表头usecols读取指定的列，索引，元组类型unpack如果True，读入属性将分别写入不同数组变量，Flase读入数据只能写入一个数组变量，默认Flase

NumPy 数组属性 

NumPy 数组的维数称为秩（rank），秩就是轴的数量，即数组的维度，一维数组的秩为 1，二维数组的秩为 2，以此类推。 

在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴（axis），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。 

很多时候可以声明 axis。axis=0，表示沿着第 0 轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。 

NumPy 的数组中比较重要 ndarray 对象属性有： 

属性说明ndarray.ndim秩，即轴的数量或维度的数量ndarray.shape数组的维度，对于矩阵，n 行 m 列ndarray.size数组元素的总个数，相当于 .shape 中 n*m 的值ndarray.dtypendarray 对象的元素类型ndarray.itemsizendarray 对象中每个元素的大小，以字节为单位ndarray.flagsndarray 对象的内存信息ndarray.realndarray元素的实部ndarray.imagndarray 元素的虚部ndarray.data包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

ndarray.ndim 

ndarray.ndim 用于返回数组的维数，等于秩。 

ndarray.shape 

ndarray.shape 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示"行数"和"列数"。 

ndarray.shape 也可以用于调整数组大小。 

NumPy 也提供了 reshape 函数来调整数组大小。 

ndarray.itemsize 

ndarray.itemsize 以字节的形式返回数组中每一个元素的大小。 

例如，一个元素类型为 float64 的数组 itemsiz 属性值为 8(float64 占用 64 个 bits，每个字节长度为 8，所以 64/8，占用 8 个字节），又如，一个元素类型为 complex32 的数组 item 属性为 4（32/8）。 

ndarray.flags 

ndarray.flags 返回 ndarray 对象的内存信息，包含以下属性： 

属性描述C_CONTIGUOUS ©数据是在一个单一的C风格的连续段中F_CONTIGUOUS (F)数据是在一个单一的Fortran风格的连续段中OWNDATA (O)数组拥有它所使用的内存或从另一个对象中借用它WRITEABLE (W)数据区域可以被写入，将该值设置为 False，则数据为只读ALIGNED (A)数据和所有元素都适当地对齐到硬件上UPDATEIFCOPY (U)这个数组是其它数组的一个副本，当这个数组被释放时，原数组的内容将被更新

NumPy 创建数组 

ndarray 数组除了可以使用底层 ndarray 构造器来创建外，也可以通过以下几种方式来创建。 

numpy.empty 

numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组： 

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

参数说明： 

参数描述shape数组形状dtype数据类型，可选order有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

注意 − 数组元素为随机值，因为它们未初始化。 

numpy.zeros 

创建指定大小的数组，数组元素以 0 来填充： 

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

参数说明： 

参数描述shape数组形状dtype数据类型，可选order‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组

numpy.ones 

创建指定形状的数组，数组元素以 1 来填充： 

numpy.ones(shape, dtype = None, order = 'C')

参数说明： 

参数描述shape数组形状dtype数据类型，可选order‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组

NumPy 从已有的数组创建数组 

numpy.asarray 

numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个。 

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

参数说明： 

参数描述a任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组dtype数据类型，可选order可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

numpy.frombuffer 

numpy.frombuffer 用于实现动态数组。 

numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。 

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)

 注意：buffer 是字符串的时候，Python3 默认 str 是 Unicode 类型，所以要转成 bytestring 在原 str 前加上 b。 

参数说明： 

参数描述buffer可以是任意对象，会以流的形式读入。dtype返回数组的数据类型，可选count读取的数据数量，默认为-1，读取所有数据。offset读取的起始位置，默认为0。

numpy.fromiter 

numpy.fromiter 方法从可迭代对象中建立 ndarray 对象，返回一维数组。 

numpy.fromiter(iterable, dtype, count=-1)

参数描述iterable可迭代对象dtype返回数组的数据类型count读取的数据数量，默认为-1，读取所有数据

NumPy 从数值范围创建数组 

numpy.arange 

numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象，函数格式如下： 

numpy.arange(start, stop, step, dtype)

根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。 

参数说明： 

参数描述start起始值，默认为0stop终止值（不包含）step步长，默认为1dtype返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

numpy.linspace 

numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的，格式如下： 

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

参数说明： 

参数描述start序列的起始值stop序列的终止值，如果endpoint为true，该值包含于数列中num要生成的等步长的样本数量，默认为50endpoint该值为 true 时，数列中中包含stop值，反之不包含，默认是True。retstep如果为 True 时，生成的数组中会显示间距，反之不显示。dtypendarray 的数据类型

numpy.logspace 

numpy.logspace 函数用于创建一个于等比数列。格式如下： 

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

base 参数意思是取对数的时候 log 的下标。 

参数描述start序列的起始值为：base ** startstop序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中num要生成的等步长的样本数量，默认为50endpoint该值为 true 时，数列中中包含stop值，反之不包含，默认是True。base对数 log 的底数。dtypendarray 的数据类型

NumPy 切片和索引 

ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。 

ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。通过冒号分隔切片参数 start:stop:step 来进行切片操作。 

冒号 : 的解释：如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。如果为 [2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。 

切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的 ndarray。 

NumPy 高级索引 

NumPy 比一般的 Python 序列提供更多的索引方式。除了之前看到的用整数和切片的索引外，数组可以由整数数组索引、布尔索引及花式索引。 

布尔索引 

我们可以通过一个布尔数组来索引目标数组。 

布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。 

~（取补运算符）来过滤 NaN 

花式索引 

花式索引指的是利用整数数组进行索引。 

花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素；如果目标是二维数组，那么就是对应下标的行。 

花式索引跟切片不一样，它总是将数据复制到新数组中。 

 传入顺序索引数组 实例 import numpy as np

x=np.arange(32).reshape((8,4))

print (x[[4,2,1,7]])

 输出结果为： [[16 17 18 19]

 [ 8  9 10 11]

 [ 4  5  6  7]

 [28 29 30 31]]

  传入倒序索引数组 实例 import numpy as np

x=np.arange(32).reshape((8,4))

print (x[[-4,-2,-1,-7]])

 输出结果为： [[16 17 18 19]

 [24 25 26 27]

 [28 29 30 31]

 [ 4  5  6  7]]

  传入多个索引数组（要使用np.ix_） 实例 import numpy as np

x=np.arange(32).reshape((8,4))

print (x[np.ix_([1,5,7,2],[0,3,1,2])])

 输出结果为： [[ 4  7  5  6]

 [20 23 21 22]

 [28 31 29 30]

 [ 8 11  9 10]]

NumPy 广播(Broadcast) 

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

如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。 

当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制。如： 

实例 

import numpy as np

a = np.array([[ 0, 0, 0],

            [10,10,10],

            [20,20,20],

            [30,30,30]])

b = np.array([1,2,3])

print(a + b)

输出结果为： 

[[ 1  2  3]

 [11 12 13]

 [21 22 23]

 [31 32 33]]

下面的图片展示了数组 b 如何通过广播来与数组 a 兼容。 

4x3 的二维数组与长为 3 的一维数组相加，等效于把数组 b 在二维上重复 4 次再运算 

广播的规则: 

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

**简单理解：**对两个数组，分别比较他们的每一个维度（若其中一个数组没有当前维度则忽略），满足： 

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

若条件不满足，抛出 “ValueError: frames are not aligned” 异常。 

NumPy 迭代数组 

NumPy 迭代器对象 numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式。 

迭代器最基本的任务的可以完成对数组元素的访问。 

控制遍历顺序 

for x in np.nditer(a, order='F'):Fortran order，即是列序优先；for x in np.nditer(a.T, order='C'):C order，即是行序优先； 

可以通过显式设置，来强制 nditer 对象使用某种顺序。 

修改数组中元素的值 

nditer 对象有另一个可选参数 op_flags。 默认情况下，nditer 将视待迭代遍历的数组为只读对象（read-only），为了在遍历数组的同时，实现对数组元素值得修改，必须指定 read-write 或者 write-only 的模式。 

使用外部循环 

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

参数描述c_index可以跟踪 C 顺序的索引f_index可以跟踪 Fortran 顺序的索引multi-index每次迭代可以跟踪一种索引类型external_loop给出的值是具有多个值的一维数组，而不是零维数组

广播迭代 

如果两个数组是可广播的，nditer 组合对象能够同时迭代它们。 假设数组 a 的维度为 3X4，数组 b 的维度为 1X4 ，则使用以下迭代器（数组 b 被广播到 a 的大小）。 

Numpy 数组操作 

Numpy 中包含了一些函数用于处理数组，大概可分为以下几类： 

修改数组形状翻转数组修改数组维度连接数组分割数组数组元素的添加与删除 

修改数组形状 

函数描述reshape不改变数据的条件下修改形状flat数组元素迭代器flatten返回一份数组拷贝，对拷贝所做的修改不会影响原始数组ravel返回展开数组

numpy.reshape 

numpy.reshape 函数可以在不改变数据的条件下修改形状，格式如下： numpy.reshape(arr, newshape, order=‘C’) 

arr：要修改形状的数组newshape：整数或者整数数组，新的形状应当兼容原有形状order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘k’ – 元素在内存中的出现顺序。 

numpy.ndarray.flat 

numpy.ndarray.flat 是一个数组元素迭代器。 

numpy.ndarray.flatten 

numpy.ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，格式如下： 

ndarray.flatten(order='C')

参数说明： 

order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘K’ – 元素在内存中的出现顺序。 

numpy.ravel 

numpy.ravel() 展平的数组元素，顺序通常是"C风格"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。 

该函数接收两个参数： 

numpy.ravel(a, order='C')

参数说明： 

order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘K’ – 元素在内存中的出现顺序。 

翻转数组 

函数描述transpose对换数组的维度ndarray.T和 self.transpose() 相同rollaxis向后滚动指定的轴swapaxes对换数组的两个轴

numpy.transpose 

numpy.transpose 函数用于对换数组的维度，格式如下： 

numpy.transpose(arr, axes)

参数说明: 

arr：要操作的数组axes：整数列表，对应维度，通常所有维度都会对换。 

numpy.rollaxis 

numpy.rollaxis 函数向后滚动特定的轴到一个特定位置，格式如下： 

numpy.rollaxis(arr, axis, start)

参数说明： 

arr：数组axis：要向后滚动的轴，其它轴的相对位置不会改变start：默认为零，表示完整的滚动。会滚动到特定位置。 

numpy.swapaxes 

numpy.swapaxes 函数用于交换数组的两个轴，格式如下： 

numpy.swapaxes(arr, axis1, axis2)

arr：输入的数组axis1：对应第一个轴的整数axis2：对应第二个轴的整数 

修改数组维度 

维度描述broadcast产生模仿广播的对象broadcast_to将数组广播到新形状expand_dims扩展数组的形状squeeze从数组的形状中删除一维条目

numpy.broadcast 

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

numpy.broadcast_to 

numpy.broadcast_to 函数将数组广播到新形状。它在原始数组上返回只读视图。 它通常不连续。 如果新形状不符合 NumPy 的广播规则，该函数可能会抛出ValueError。 

numpy.broadcast_to(array, shape, subok)

numpy.expand_dims 

numpy.expand_dims 函数通过在指定位置插入新的轴来扩展数组形状，函数格式如下: 

 numpy.expand_dims(arr, axis)

参数说明： 

arr：输入数组axis：新轴插入的位置 

numpy.squeeze 

numpy.squeeze 函数从给定数组的形状中删除一维的条目，函数格式如下： 

numpy.squeeze(arr, axis)

参数说明： 

arr：输入数组axis：整数或整数元组，用于选择形状中一维条目的子集 

连接数组 

函数描述concatenate连接沿现有轴的数组序列stack沿着新的轴加入一系列数组。hstack水平堆叠序列中的数组（列方向）vstack竖直堆叠序列中的数组（行方向）

numpy.concatenate 

numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组，格式如下： 

numpy.concatenate((a1, a2, ...), axis)

参数说明： 

a1, a2, ...：相同类型的数组axis：沿着它连接数组的轴，默认为 0 

numpy.stack 

numpy.stack 函数用于沿新轴连接数组序列，格式如下： 

numpy.stack(arrays, axis)

参数说明： 

arrays相同形状的数组序列axis：返回数组中的轴，输入数组沿着它来堆叠 

numpy.hstack 

numpy.hstack 是 numpy.stack 函数的变体，它通过水平堆叠来生成数组。 

numpy.vstack 

numpy.vstack 是 numpy.stack 函数的变体，它通过垂直堆叠来生成数组。 

分割数组 

函数数组及操作split将一个数组分割为多个子数组hsplit将一个数组水平分割为多个子数组（按列）vsplit将一个数组垂直分割为多个子数组（按行）

numpy.split 

numpy.split 函数沿特定的轴将数组分割为子数组，格式如下： 

numpy.split(ary, indices_or_sections, axis)

参数说明： 

ary：被分割的数组indices_or_sections：果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）axis：沿着哪个维度进行切向，默认为0，横向切分。为1时，纵向切分 

numpy.hsplit 

numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。 

numpy.vsplit 

numpy.vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同。 

数组元素的添加与删除 

函数元素及描述resize返回指定形状的新数组append将值添加到数组末尾insert沿指定轴将值插入到指定下标之前delete删掉某个轴的子数组，并返回删除后的新数组unique查找数组内的唯一元素

numpy.resize 

numpy.resize 函数返回指定大小的新数组。 

如果新数组大小大于原始大小，则包含原始数组中的元素的副本。 

numpy.resize(arr, shape)

参数说明： 

arr：要修改大小的数组shape：返回数组的新形状 

numpy.append 

numpy.append 函数在数组的末尾添加值。 追加操作会分配整个数组，并把原来的数组复制到新数组中。 此外，输入数组的维度必须匹配否则将生成ValueError。 

append 函数返回的始终是一个一维数组。 

numpy.append(arr, values, axis=None)

参数说明： 

arr：输入数组values：要向arr添加的值，需要和arr形状相同（除了要添加的轴）axis：默认为 None。当axis无定义时，是横向加成，返回总是为一维数组！当axis有定义的时候，分别为0和1的时候。当axis有定义的时候，分别为0和1的时候（列数要相同）。当axis为1时，数组是加在右边（行数要相同）。 

numpy.insert 

numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值。 

如果值的类型转换为要插入，则它与输入数组不同。 插入没有原地的，函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开。 

numpy.insert(arr, obj, values, axis)

参数说明： 

arr：输入数组obj：在其之前插入值的索引values：要插入的值axis：沿着它插入的轴，如果未提供，则输入数组会被展开 

numpy.delete 

numpy.delete 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开。 

Numpy.delete(arr, obj, axis)

参数说明： 

arr：输入数组obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开 

numpy.unique 

numpy.unique 函数用于去除数组中的重复元素。 

numpy.unique(arr, return_index, return_inverse, return_counts)

arr：输入数组，如果不是一维数组则会展开return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数 

NumPy 位运算 

NumPy “bitwise_” 开头的函数是位运算函数。 

NumPy 位运算包括以下几个函数： 

函数描述bitwise_and对数组元素执行位与操作bitwise_or对数组元素执行位或操作invert按位取反left_shift向左移动二进制表示的位right_shift向右移动二进制表示的位

**注：**也可以使用 “&”、 “~”、 “|” 和 “^” 等操作符进行计算。 

bitwise_and 

bitwise_and() 函数对数组中整数的二进制形式执行位与运算。 

位与操作运算规律如下： 

ABAND111100010000

bitwise_or 

bitwise_or()函数对数组中整数的二进制形式执行位或运算。 

位或操作运算规律如下： 

ABOR111101011000

invert 

invert() 函数对数组中整数进行位取反运算，即 0 变成 1，1 变成 0。 

对于有符号整数，取该二进制数的补码，然后 +1。二进制数，最高位为0表示正数，最高位为 1 表示负数。 

看看 ~1 的计算步骤： 

 将1(这里叫：原码)转二进制 ＝ 00000001  按位取反 ＝ 11111110  发现符号位(即最高位)为1(表示负数)，将除符号位之外的其他数字取反 ＝ 10000001  末位加1取其补码 ＝ 10000010  转换回十进制 ＝ -2  

  表达式二进制值（2 的补数）十进制值500000000 00000000 00000000 00000105~511111111 11111111 11111111 11111010-6 

left_shift 

left_shift() 函数将数组元素的二进制形式向左移动到指定位置，右侧附加相等数量的 0。 

right_shift 

right_shift() 函数将数组元素的二进制形式向右移动到指定位置，左侧附加相等数量的 0。 

NumPy 字符串函数 

以下函数用于对 dtype 为 numpy.string_ 或 numpy.unicode_ 的数组执行向量化字符串操作。 它们基于 Python 内置库中的标准字符串函数。 

这些函数在字符数组类（numpy.char）中定义。 

函数描述add()对两个数组的逐个字符串元素进行连接multiply()返回按元素多重连接后的字符串center()居中字符串capitalize()将字符串第一个字母转换为大写title()将字符串的每个单词的第一个字母转换为大写lower()数组元素转换为小写upper()数组元素转换为大写split()指定分隔符对字符串进行分割，并返回数组列表splitlines()返回元素中的行列表，以换行符分割strip()移除元素开头或者结尾处的特定字符join()通过指定分隔符来连接数组中的元素replace()使用新字符串替换字符串中的所有子字符串decode()数组元素依次调用str.decodeencode()数组元素依次调用str.encode

numpy.char.add() 

numpy.char.add() 函数依次对两个数组的元素进行字符串连接。 

numpy.char.multiply() 

numpy.char.multiply() 函数执行多重连接。 

numpy.char.center() 

numpy.char.center() 函数用于将字符串居中，并使用指定字符在左侧和右侧进行填充。 

numpy.char.capitalize() 

numpy.char.capitalize() 函数将字符串的第一个字母转换为大写。 

numpy.char.title() 

numpy.char.title() 函数将字符串的每个单词的第一个字母转换为大写。 

numpy.char.lower() 

numpy.char.lower() 函数对数组的每个元素转换为小写。它对每个元素调用 str.lower。 

numpy.char.upper() 

numpy.char.upper() 函数对数组的每个元素转换为大写。它对每个元素调用 str.upper。 

numpy.char.split() 

numpy.char.split() 通过指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格。 

numpy.char.splitlines() 

numpy.char.splitlines() 函数以换行符作为分隔符来分割字符串，并返回数组。 

\n，\r，\r\n 都可用作换行符。 

numpy.char.strip() 

numpy.char.strip() 函数用于移除开头或结尾处的特定字符。 

numpy.char.join() 

numpy.char.join() 函数通过指定分隔符来连接数组中的元素或字符串。 

numpy.char.replace() 

numpy.char.replace() 函数使用新字符串替换字符串中的所有子字符串。 

numpy.char.encode() 

numpy.char.encode() 函数对数组中的每个元素调用 str.encode 函数。 默认编码是 utf-8，可以使用标准 Python 库中的编解码器。 

numpy.char.decode() 

numpy.char.decode() 函数对编码的元素进行 str.decode() 解码。 

NumPy 数学函数 

NumPy 包含大量的各种数学运算的函数，包括三角函数，算术运算的函数，复数处理函数等。 

三角函数 

NumPy 提供了标准的三角函数：sin()、cos()、tan()。 

arcsin，arccos，和 arctan 函数返回给定角度的 sin，cos 和 tan 的反三角函数。 

这些函数的结果可以通过 numpy.degrees() 函数将弧度转换为角度。 

舍入函数 

numpy.around() 函数返回指定数字的四舍五入值。 

numpy.around(a,decimals)

参数说明： 

a: 数组decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置 

numpy.floor() 

numpy.floor() 返回小于或者等于指定表达式的最大整数，即向下取整。 

numpy.ceil() 

numpy.ceil() 返回大于或者等于指定表达式的最小整数，即向上取整。 

NumPy 算术函数 

NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。 

需要注意的是数组必须具有相同的形状或符合数组广播规则。 

此外 Numpy 也包含了其他重要的算术函数。 

numpy.reciprocal() 

numpy.reciprocal() 函数返回参数逐元素的倒数。如 1/4 倒数为 4/1。 

numpy.power() 

numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。 

numpy.mod() 

numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。 

NumPy 统计函数 

NumPy 提供了很多统计函数，用于从数组中查找最小元素，最大元素，百分位标准差和方差等。 函数说明如下： 

numpy.amin() 和 numpy.amax() 

numpy.amin() 用于计算数组中的元素沿指定轴的最小值。 

numpy.amax() 用于计算数组中的元素沿指定轴的最大值。 

numpy.ptp() 

numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。 

numpy.percentile() 

百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。 函数numpy.percentile()接受以下参数。 

numpy.percentile(a, q, axis)

参数说明： 

a: 输入数组q: 要计算的百分位数，在 0 ~ 100 之间axis: 沿着它计算百分位数的轴 

首先明确百分位数： 

第 p 个百分位数是这样一个值，它使得至少有 p% 的数据项小于或等于这个值，且至少有 (100-p)% 的数据项大于或等于这个值。 

举个例子：高等院校的入学考试成绩经常以百分位数的形式报告。比如，假设某个考生在入学考试中的语文部分的原始分数为 54 分。相对于参加同一考试的其他学生来说，他的成绩如何并不容易知道。但是如果原始分数54分恰好对应的是第70百分位数，我们就能知道大约70%的学生的考分比他低，而约30%的学生考分比他高。这里的 p = 70。 

numpy.median() 

numpy.median() 函数用于计算数组 a 中元素的中位数（中值） 

numpy.mean() 

numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。 

算术平均值是沿轴的元素的总和除以元素的数量。 

numpy.average() 

numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。 

该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。 

加权平均值即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数。 

考虑数组[1,2,3,4]和相应的权重[4,3,2,1]，通过将相应元素的乘积相加，并将和除以权重的和，来计算加权平均值。 

加权平均值 = (1*4+2*3+3*2+4*1)/(4+3+2+1)

标准差 

标准差是一组数据平均值分散程度的一种度量。 

标准差是方差的算术平方根。 

标准差公式如下： 

std = sqrt(mean((x - x.mean())**2))

如果数组是 [1，2，3，4]，则其平均值为 2.5。 因此，差的平方是 [2.25,0.25,0.25,2.25]，并且其平均值的平方根除以 4，即 sqrt(5/4) ，结果为 1.1180339887498949。 

方差 

统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())** 2)。 

换句话说，标准差是方差的平方根。 

NumPy 排序、条件刷选函数 

NumPy 提供了多种排序的方法。 这些排序函数实现不同的排序算法，每个排序算法的特征在于执行速度，最坏情况性能，所需的工作空间和算法的稳定性。 下表显示了三种排序算法的比较。 

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

numpy.sort() 

numpy.sort() 函数返回输入数组的排序副本。函数格式如下： 

numpy.sort(a, axis, kind, order)

参数说明： 

a: 要排序的数组axis: 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序， axis=0 按列排序，axis=1 按行排序kind: 默认为’quicksort’（快速排序）order: 如果数组包含字段，则是要排序的字段 

numpy.argsort() 

numpy.argsort() 函数返回的是数组值从小到大的索引值。 

numpy.lexsort() 

numpy.lexsort() 用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。 

这里举一个应用场景：小升初考试，重点班录取学生按照总成绩录取。在总成绩相同时，数学成绩高的优先录取，在总成绩和数学成绩都相同时，按照英语成绩录取…… 这里，总成绩排在电子表格的最后一列，数学成绩在倒数第二列，英语成绩在倒数第三列。 

msort、sort_complex、partition、argpartition 

函数描述msort(a)数组按第一个轴排序，返回排序后的数组副本。np.msort(a) 相等于 np.sort(a, axis=0)。sort_complex(a)对复数按照先实部后虚部的顺序进行排序。partition(a, kth[, axis, kind, order])指定一个数，对数组进行分区argpartition(a, kth[, axis, kind, order])可以通过关键字 kind 指定算法沿着指定轴对数组进行分区

numpy.argmax() 和 numpy.argmin() 

numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引。 

numpy.nonzero() 

numpy.nonzero() 函数返回输入数组中非零元素的索引。 

numpy.where() 

numpy.where() 函数返回输入数组中满足给定条件的元素的索引。 

numpy.extract() 

numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。 

NumPy 字节交换 

在几乎所有的机器上，多字节对象都被存储为连续的字节序列。字节顺序，是跨越多字节的程序对象的存储规则。 

**大端模式：**指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；这和我们的阅读习惯一致。**小端模式：**指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低。 

例如在 C 语言中，一个类型为 int 的变量 x 地址为 0x100，那么其对应地址表达式&x的值为 0x100。且x的四个字节将被存储在存储器的 0x100, 0x101, 0x102, 0x103位置。 

numpy.ndarray.byteswap() 

numpy.ndarray.byteswap() 函数将 ndarray 中每个元素中的字节进行大小端转换。 

NumPy 副本和视图 

副本是一个数据的完整的拷贝，如果我们对副本进行修改，它不会影响到原始数据，物理内存不在同一位置。 

视图是数据的一个别称或引用，通过该别称或引用亦便可访问、操作原有数据，但原有数据不会产生拷贝。如果我们对视图进行修改，它会影响到原始数据，物理内存在同一位置。 

视图一般发生在： 

1、numpy 的切片操作返回原数据的视图。2、调用 ndarray 的 view() 函数产生一个视图。 

副本一般发生在： 

Python 序列的切片操作，调用deepCopy()函数。调用 ndarray 的 copy() 函数产生一个副本。 

无复制 

简单的赋值不会创建数组对象的副本。 相反，它使用原始数组的相同id()来访问它。 id()返回 Python 对象的通用标识符，类似于 C 中的指针。 

此外，一个数组的任何变化都反映在另一个数组上。 例如，一个数组的形状改变也会改变另一个数组的形状。 

视图或浅拷贝 

ndarray.view() 方会创建一个新的数组对象，该方法创建的新数组的维数更改不会更改原始数据的维数。使用切片创建视图修改数据会影响到原始数组。 

副本或深拷贝 

ndarray.copy() 函数创建一个副本。 对副本数据进行修改，不会影响到原始数据，它们物理内存不在同一位置。 

Python append() 与深拷贝、浅拷贝 

深浅拷贝 

在 Python 中，对象赋值实际上是对象的引用。当创建一个对象，然后把它赋给另一个变量的时候，Python 并没有拷贝这个对象，而只是拷贝了这个对象的引用，我们称之为浅拷贝。 

在 Python 中，为了使当进行赋值操作时，两个变量互补影响，可以使用 copy 模块中的 deepcopy 方法，称之为深拷贝。 

append() 函数 

当 list 类型的对象进行 append 操作时，实际上追加的是该对象的引用。 

id() 函数：返回对象的唯一标识，可以类比成该对象在内存中的地址。 

>>>alist = [] >>> num = [2] >>> alist.append( num ) >>> id( num ) == id( alist[0] ) True 

如上例所示，当 num 发生变化时(前提是 id(num) 不发生变化），alist 的内容随之会发生变化。往往会带来意想不到的后果，想避免这种情况，可以采用深拷贝解决： 

alist.append( copy.deepcopy( num ) )

PS： id()函数：返回对象的唯一标识，可以类比成该对象在内存中的地址。 

NumPy 矩阵库(Matrix) 

NumPy 中包含了一个矩阵库 numpy.matlib，该模块中的函数返回的是一个矩阵，而不是 ndarray 对象。 

一个

        m

        ×

        n

       m \times n

    m×n 的矩阵是一个由 $ m $ 行（row）列 $ n $（column）元素排列成的矩形阵列。 

矩阵里的元素可以是数字、符号或数学式。 

matlib.empty() 

matlib.empty() 函数返回一个新的矩阵，语法格式为： 

numpy.matlib.empty(shape, dtype, order)

参数说明： 

shape: 定义新矩阵形状的整数或整数元组Dtype: 可选，数据类型order: C（行序优先） 或者 F（列序优先） 

numpy.matlib.zeros() 

numpy.matlib.zeros() 函数创建一个以 0 填充的矩阵。 

numpy.matlib.ones() 

numpy.matlib.ones()函数创建一个以 1 填充的矩阵。 

numpy.matlib.eye() 

numpy.matlib.eye() 函数返回一个矩阵，对角线元素为 1，其他位置为零。 

numpy.matlib.eye(n, M,k, dtype)

参数说明： 

n: 返回矩阵的行数M: 返回矩阵的列数，默认为 nk: 对角线的索引dtype: 数据类型 

numpy.matlib.identity() 

numpy.matlib.identity() 函数返回给定大小的单位矩阵。 

单位矩阵是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为 1，除此以外全都为 0。 

numpy.matlib.rand() 

numpy.matlib.rand() 函数创建一个给定大小的矩阵，数据是随机填充的。 

NumPy 线性代数 

NumPy 提供了线性代数函数库 linalg，该库包含了线性代数所需的所有功能，可以看看下面的说明： 

函数描述dot两个数组的点积，即元素对应相乘。vdot两个向量的点积inner两个数组的内积matmul两个数组的矩阵积determinant数组的行列式solve求解线性矩阵方程inv计算矩阵的乘法逆矩阵

numpy.dot() 

numpy.dot() 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为内积)；对于二维数组，计算的是两个数组的矩阵乘积；对于多维数组，它的通用计算公式如下，即结果数组中的每个元素都是：数组a的最后一维上的所有元素与数组b的倒数第二位上的所有元素的乘积和： dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])。 

numpy.dot(a, b, out=None) 

参数说明： 

a : ndarray 数组b : ndarray 数组out : ndarray, 可选，用来保存dot()的计算结果 

numpy.vdot() 

numpy.vdot() 函数是两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数是多维数组，它会被展开。 

numpy.inner() 

numpy.inner() 函数返回一维数组的向量内积。对于更高的维度，它返回最后一个轴上的和的乘积。 

numpy.matmul 

numpy.matmul 函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。 

另一方面，如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。 

numpy.linalg.det() 

numpy.linalg.det() 函数计算输入矩阵的行列式。 

行列式在线性代数中是非常有用的值。 它从方阵的对角元素计算。 对于 2×2 矩阵，它是左上和右下元素的乘积与其他两个的乘积的差。 

换句话说，对于矩阵[[a，b]，[c，d]]，行列式计算为 ad-bc。 较大的方阵被认为是 2×2 矩阵的组合。 

numpy.linalg.solve() 

numpy.linalg.solve() 函数给出了矩阵形式的线性方程的解。 

考虑以下线性方程： 

x + y + z = 6

2y + 5z = -4

2x + 5y - z = 27

可以使用矩阵表示为： 

如果矩阵成为A、X和B，方程变为： 

AX = B

或

X = A^(-1)B

numpy.linalg.inv() 

numpy.linalg.inv() 函数计算矩阵的乘法逆矩阵。 

逆矩阵（inverse matrix）：设A是数域上的一个n阶矩阵，若在相同数域上存在另一个n阶矩阵B，使得： AB=BA=E ，则我们称B是A的逆矩阵，而A则被称为可逆矩阵。注：E为单位矩阵。 

NumPy IO 

Numpy 可以读写磁盘上的文本数据或二进制数据。 

NumPy 为 ndarray 对象引入了一个简单的文件格式：npy。 

npy 文件用于存储重建 ndarray 所需的数据、图形、dtype 和其他信息。 

常用的 IO 函数有： 

 load() 和 save() 函数是读写文件数组数据的两个主要函数，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npy 的文件中。  savze() 函数用于将多个数组写入文件，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npz 的文件中。  loadtxt() 和 savetxt() 函数处理正常的文本文件(.txt 等)  

numpy.save() 

numpy.save() 函数将数组保存到以 .npy 为扩展名的文件中。 

numpy.save(file, arr, allow_pickle=True, fix_imports=True)

参数说明： 

file：要保存的文件，扩展名为 .npy，如果文件路径末尾没有扩展名 .npy，该扩展名会被自动加上。arr: 要保存的数组allow_pickle: 可选，布尔值，允许使用 Python pickles 保存对象数组，Python 中的 pickle 用于在保存到磁盘文件或从磁盘文件读取之前，对对象进行序列化和反序列化。fix_imports: 可选，为了方便 Pyhton2 中读取 Python3 保存的数据。 

.npy是 Numpy 专用的二进制格式后的数据，可以使用 load() 函数来读取数据就可以正常显示。 

numpy.savez 

numpy.savez() 函数将多个数组保存到以 npz 为扩展名的文件中。 

numpy.savez(file, *args, **kwds)

参数说明： 

file：要保存的文件，扩展名为 .npz，如果文件路径末尾没有扩展名 .npz，该扩展名会被自动加上。args: 要保存的数组，可以使用关键字参数为数组起一个名字，非关键字参数传递的数组会自动起名为 arr_0, arr_1, …　。kwds: 要保存的数组使用关键字名称。 

numpy.savetxt() 

savetxt() 函数是以简单的文本文件格式存储数据，对应的使用 loadtxt() 函数来获取数据。 

np.loadtxt(FILENAME, dtype=int, delimiter=' ')

np.savetxt(FILENAME, a, fmt="%d", delimiter=",")

参数 delimiter 可以指定各种分隔符、针对特定列的转换器函数、需要跳过的行数等。