Numpy入门：如何在Python中用于科学计算？
你可以用 NumPy 做很多有趣的事情。
NumPy 是一个运行速度非常快的数学库，主要用于数组计算。它可以让你在
中使用向量和数学矩阵，以及许多用 C 语言实现的底层函数，你还可以体验到从未在原生 Python 上体验过的运行速度。
NumPy 是 Python 在科学计算领域取得成功的关键之一，如果你想通过 Python 学习数据科学或者机器学习，就必须学习 NumPy。我认为 NumPy 的功能很强大，而且入门也不难。
NumPy 的核心是数组（arrays）。具体来说是多维数组（ndarrays），但是我们不用管这些。通过这些数组，我们能以闪电般的速度使用像向量和数学矩阵之类的功能。赶紧捡起你的线性代数吧！（只是开玩笑，其实并不需要很多复杂的数学知识）
# 1D Array
a = np.array([0, 1, 2, 3, 4])
b = np.array((0, 1, 2, 3, 4))
c = np.arange(5)
d = np.linspace(0, 2*np.pi, 5)
print(a) # &&&[0 1 2 3 4]
print(b) # &&&[0 1 2 3 4]
print(c) # &&&[0 1 2 3 4]
print(d) # &&&[ 0.
print(a[3]) # &&&3
上边的代码展示了创建数组的四种不同方式。最基本的方式是传递一个序列给 NumPy 的 array() 函数；你可以传给它任意的序列，不仅仅是我们常见的列表之类的。
注意，当输出的数组中的数值长度不一样的时候，它会自动对齐。这在查看矩阵的时候很有用。数组的索引和 Python 中的列表或其他序列很像。你也可以对它们使用切片，这里我不再演示一维数组的切片，如果你想知道更多关于切片的信息，查看。
上边数组的例子给你展示了如何在 NumPy 中表示向量，接下来我将带你们领略一下怎么表示矩阵和多维数组。
# MD Array,
a = np.array([[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25],
[26, 27, 28 ,29, 30],
[31, 32, 33, 34, 35]])
print(a[2,4]) # &&&25
通过给 array() 函数传递一个列表的列表（或者是一个序列的序列），可以创建二维数组。如果我们想要一个三维数组，那我们就传递一个列表的列表的列表，四维数组就是列表的列表的列表的列表，以此类推。
注意二维数组是如何成行成列排布的（在我们的朋友--空格的帮助下）。如果要索引一个二维数组，只需要引用相应的行数和列数即可。
背后的数学知识
为了更好的理解这些，我们需要来看一下什么是向量和矩阵。
向量是一个有方向和大小的量，通常用来表示速度、加速度和动量等。向量能以多种方式书写，但是我们最有用的方式是把它们写在有 n 个元素的元组里边，比如（1， 4， 6， 9）。这就是它们在 NumPy 中的表示方式。
矩阵和向量很像，除了它是由行和列组成的；更像一个网格（grid）。矩阵中的数值可以用它们所在的行和列来表示。在 NumPy 中，可以像我们前面所做的那样，通过传递序列的序列来创建数组。
多维数组切片
多维数组切片比一维数组要复杂一点，同时它也是你在用 NumPy 的时候经常会用到的。
# MD slicing
print(a[0, 1:4]) # &&&[12 13 14]
print(a[1:4, 0]) # &&&[16 21 26]
print(a[::2,::2]) # &&&[[11 13 15]
[21 23 25]
[31 33 35]]
print(a[:, 1]) # &&&[12 17 22 27 32]
就像你看到的一样，多维数组切片就是要分别在每个维度上切片，并用逗号隔开。在二维数组中，第一个切片的含义是对行切片，第二个切片的含义是对列切片。
值得注意的是，你通过输入数字来指定行和列。上边第一个例子是从数组中选择第 0 行。
下边的这幅图阐明了上边切片的例子的含义。
在使用 NumPy 时，你会想知道数组的某些信息。很幸运，在这个包里边包含了很多便捷的方法，可以给你想要的信息。
# Array properties
a = np.array([[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25],
[26, 27, 28 ,29, 30],
[31, 32, 33, 34, 35]])
print(type(a)) # &&&
print(a.dtype) # &&&int64
print(a.size) # &&&25
print(a.shape) # &&&(5, 5)
print(a.itemsize) # &&&8
print(a.ndim) # &&&2
print(a.nbytes) # &&&200
如你所看，在上边的代码中 NumPy 的数组其实被称为 ndarray。我不知道为什么它被称为 ndarray，如果有人知道请在下边留言！我猜测它是表示 n 维数组（n dimensional array）。
数组的形状（shape）是指它有多少行和列，上边的数组有五行五列，所以他的形状是（5，5）。
'itemsize' 属性是每一个条目所占的字节。这个数组的数据类型是 int64，一个 int64 的大小是 64 比特，8 比特为 1 字节，64 除以 8 就得到了它的字节数，8 字节。
'ndim' 属性是指数组有多少维。这个数组有二维。但是，比如说向量，只有一维。
'nbytes' 属性表示这个数组中所有元素占用的字节数。你应该注意，这个数值并没有把额外的空间计算进去，因此实际上这个数组占用的空间会比这个值大点。
基本操作符
仅仅会赋值、取值和得到一些属性是不能满足你的需求的，有时候你还需要做一些数学运算。你可以利用基本的操作符实现这些，比如 +， -， /，等等。
# Basic Operators
a = np.arange(25)
a = a.reshape((5, 5))
b = np.array([10, 62, 1, 14, 2, 56, 79, 2, 1, 45,
4, 92, 5, 55, 63, 43, 35, 6, 53, 24,
56, 3, 56, 44, 78])
b = b.reshape((5,5))
print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a ** 2)
print(a & b) print(a & b)
print(a.dot(b))
除了 dot() 之外，这些操作符都是对数组进行逐元素运算。比如 (a, b, c) + (d, e, f) 的结果就是 (a+d, b+e, c+f)。它将分别对每一个元素进行配对，然后对它们进行运算。它返回的结果是一个数组。注意，当使用逻辑运算符比如 &&& 和 &&& 的时候，返回的将是一个布尔型数组，这点有一个很好的用处，后边我们会提到。
dot() 函数计算两个数组的点积。它返回的是一个标量（只有大小没有方向的一个值）而不是数组。
背后的数学知识
dot() 函数有时候也称为点积。理解这个函数的最好方法就是看下边它的计算过程。
数组的特定操作符
NumPy 还提供了一些其他很有用的操作符，用于处理数组。
# dot, sum, min, max, cumsum
a = np.arange(10)
print(a.sum()) # &&&45
print(a.min()) # &&&0
print(a.max()) # &&&9
print(a.cumsum()) # &&&[ 0
6 10 15 21 28 36 45]
很明显就能看出 sum()、min() 和 max() 函数的功能：将所有元素加起来，找到最小值和最大值。
cumsum() 函数就不是那么明显了。它像 sum() 那样把所有元素加起来，但是它的实现方式是，第一个元素加到第二个元素上，把结果保存到一个列表里，然后把结果加到第三个元素上，再保存到列表里，依次累加。当遍历完数组中所有元素则结束，返回值为运行数组的总和的列表。
cumsum() 就是一个累加计算并且保存每次累加的结果，返回值就是包含所有累加结果的一个列表。比如 np.array([1, 2, 3, 4, 5]).cumsum() = [1, 3, 6, 10, 15]
花俏的索引
&花俏的索引&是获取数组中我们想要的特定元素的有效方法。
# Fancy indexing
a = np.arange(0, 100, 10)
indices = [1, 5, -1]
b = a[indices]
print(a) # &&&[ 0 10 20 30 40 50 60 70 80 90]
print(b) # &&&[10 50 90]
如你所见，上边的例子中，我们用想获取的索引的序列作为索引。它返回了我们索引的元素。
布尔屏蔽（boolean masking）
布尔屏蔽是一个奇妙的特性，它允许我们根据指定条件获取数组中的元素。
# Boolean masking
import matplotlib.pyplot as plt
a = np.linspace(0, 2 * np.pi, 50)
b = np.sin(a)
plt.plot(a,b)
mask = b &= 0
plt.plot(a[mask], b[mask], 'bo')
mask = (b &= 0) & (a &= np.pi / 2)
plt.plot(a[mask], b[mask], 'go')
plt.show()
上边的代码展示了实现布尔屏蔽。你需要做的就是传递给数组一个与它有关的条件式，然后它就会返回给定条件下为真的值。
上边的例子将会生成下边这幅图：
我们用条件式选择了图中不同的点。蓝色的点（也包含图中的绿点，只是绿点覆盖了蓝点），显示的是值大于零的点。绿点显示的是值大于 0 小于 Pi / 2 的点。
缺省索引是从多维数组的第一维获取索引和切片便捷方法。例如，你有一个数组 a = [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]，那么 a[3] 将会返回数组第一维中索引值为 3 的元素，这里的结果是 4。
# Incomplete Indexing
a = np.arange(0, 100, 10)
c = a[a &= 50]
print(b) # &&&[ 0 10 20 30 40]
print(c) # &&&[50 60 70 80 90]
Where 函数
where() 函数是另外一个根据条件返回数组中的值的有效方法。只需要把条件传递给它，它就会返回一个使得条件为真的元素的列表。
a = np.arange(0, 100, 10)
b = np.where(a & 50)
c = np.where(a &= 50)[0]
print(b) # &&&(array([0, 1, 2, 3, 4]),)
print(c) # &&&[5 6 7 8 9]
这就是 NumPy，不算太难，对吧？当然，这些只是一些基础，NumPy 还有很多其他的功能，如果你已经熟悉了这些基础内容，你可以去探索一下。苹果/安卓/wp
积分 691, 距离下一级还需 109 积分
权限: 自定义头衔, 签名中使用图片
道具: 彩虹炫, 涂鸦板, 雷达卡, 热点灯, 金钱卡, 显身卡, 匿名卡, 抢沙发下一级可获得
权限: 隐身
购买后可立即获得
权限: 隐身
道具: 金钱卡, 彩虹炫, 雷达卡, 热点灯, 涂鸦板
悲催签到天数: 151 天连续签到: 1 天[LV.7]常住居民III
NumPy数组在数值运算方面的效率优于Python提供的list容器。使用NumPy可以在代码中省去很多循环语句，因此其代码比等价的Python代码更为简洁。实践：向量加法假设我们需要对两个向量a和b做加法。以下的纯Python代码可以解决上述问题：def pythonsum(n):
& &a = range(n)
& &b = range(n)
& &for i in range(len(a)):
& && & a = i ** 2
& && & b = i ** 3
& && & c.append(a + b)
& &return c以下是使用NumPy的代码，它同样能够解决问题：def numpysum(n):
& &a = np.arange(n) ** 2
& &b = np.arange(n) ** 3
& &c = a + b
& &return cnumpysum()函数中没有使用for循环。同时，我们使用NumPy中的arange函数来创建包含0~n的整数的NumPy数组。代码中的arange函数前面有一个前缀numpy，表明该函数是从NumPy模块导入的。让我们来看看纯Python代码和NumPy代码是否得到相同的结果：import sys
from datetime import datetime
import numpy as np#省略上面两处代码size = int(sys.argv[1])
start = datetime.now()
c = pythonsum(size)
delta = datetime.now() - start
print &The last 2 elements of the sum&, c[-2:]
print &PythonSum elapsed time in microseconds&, delta.microseconds
start = datetime.now()
c = numpysum(size)
delta = datetime.now() - start
print &The last 2 elements of the sum&, c[-2:]
print &NumPySum elapsed time in microseconds&, delta.microseconds
21:55:54 上传
显然，NumPy代码比等价的纯Python代码运行速度快得多。有一点可以肯定，即不论我们使用NumPy还是Python，得到的结果是一致的。不过，两者的输出结果在形式上有些差异。注意，numpysum()函数的输出不包含逗号。这是为什么呢？显然，我们使用的是NumPy数组，而非Python自身的list容器。
支持楼主：、
购买后，论坛将把您花费的资金全部奖励给楼主，以表示您对TA发好贴的支持
载入中......
[img]http://pic./forum//184005lbzbae6212af7azk.
你好，numpy这个模块怎么安装呢，为什么我export时出现提示：can't&&import multiarray？
利益相关:python 3.6.1+
不用列表解析玩什么list？列表解析分分钟把numpy.narray打爆!成倍吊打!数据越大列表解析的优势越明显!
非得显着你在这里误人子弟!!
  |
  |
  |
  |
  |
  |
如有投资本站或合作意向，请联系（010-）；
邮箱：service@pinggu.org
投诉或不良信息处理：（010-）
论坛法律顾问：王进律师Numpy学习笔记2-创建array的几种方式 - CSDN博客
Numpy学习笔记2-创建array的几种方式
创建array的几种方式：
1、通过python的标准类型转换（如：lists,tuples）
2、通过Munpy固有的一些函数创建对象（如：arange,zones等）
3、通过从磁盘读取数组，或者标准的格式
4、通过字节数组，通过使用字符串或者缓冲区
5、使用特定的库函数，例如：random
下面是常用的几种：
&&& import numpy as np
&&& x = np.float32(1.0)
&&& y = np.int_([1,2,4])
array([1, 2, 4])
&&& z = np.arange(3, dtype=np.uint8)
array([0, 1, 2], dtype=uint8)
np的dtype类型可以被当做函数类使用，用来将python的数据转换成array类型。
numpy.arange
numpy.arange([start,&]stop,&[step,&]dtype=None)
函数&ones&创建一个全1的数组，函数&empty&创建一个内容随机并且依赖与内存状态的数组。默认创建的数组类型(dtype)都是float64。
其它函数array,
zeros, zeros_like, ones, ones_like, empty, empty_like, arange, linspace, rand, randn, fromfunction, fromfile参考手册:
arange( 10,30,5
array([10,15,20,25])
arange( 0,2,0.3
, 0.3,0.6,0.9,1.2,1.5,1.8])
当&arange&使用浮点数参数时，由于有限的浮点数精度，通常无法预测获得的元素个数。因此，最好使用函数&linspace&去接收我们想要的元素个数来代替用range来指定步长。
返回指定范围指定间隔的数组。
numpy.linspace(start,&stop,&num=50,&endpoint=True,&retstep=False,&dtype=None)
参数retstep指定是否返回步进长度，如果为True则返回元组（样本数据，步进长度）
本文已收录于以下专栏：
相关文章推荐
1.函数库的导入
2.基本运算
2.1.求和 .sum()
2.2.求最大值 .max()
2.3.求最小值 .min()
2.4.求平均值 .mean()
2.5.矩阵行求和 .sum(axis=...
安卓常见布局方式
对象——function特别说明
在js中一切都是对象
类（原型对象）其实也是对象，它实际上是Function类的一个实例，通过类我们可以创建自己的对象实例，可以通过下面的代码来说明
文西马龙：http://blog.csdn.net/wenximalong/
对象——function特别说明
1.在js中一切都是对象
2.类（原型对象）其实也是对象，它实际上是Functio...
为了基础的基础package , importpackage mainimport "fmt"func main(){
fmt.Println("Hello World !")
1. 利用反射机制得到java.lang.String类的Class类对象
Class classType = Class.forName("java.lang.String");
2.利用Str...
上一节的kNN算法中，训练样本是直接输入进去的。这一节中，主要介绍如何把txt文本中的训练样本解析为numpy的array数组：
文本数据解析伪代码的流程：
1、打开txt训练文本：
2、利用...
Array Textures 范例来自 OpenGl SuperBible(page 177-182),并做了些改动。
前段时间买了董老师的数据分析与科学计算可视化课程，假期抽时间学习一下。
用于数据分析与科学计算可视化的模块有很多：如statistics提供了一些常用的统计分析的函数，numpy科学计算包作数值计算...
他的最新文章
讲师：何宇健
讲师：董岩
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)Numpy 学习之路（1）——数组的创建 - kool_zhang - 博客园
随笔 - 7, 文章 - 0, 评论 - 2, 引用 - 0
数组是Numpy操作的主要对象，也是python数据分析的主要对象，本系列文章是本人在学习Numpy中的笔记。
文章中以下都基于以下方式的numpy导入：
import numpy as np
from numpy import *
1、普通数组的创建&&np.arange(), np.array(),
(1) arange()建立是顺序数组，函数原型：arange([start,]stop[,step],dtype=None)
其中start参数如果省略，则表示从0开始，默认的dtype为float32
#创建从0-19的一维数组ar_1
ar_1=np.arange(20)
#output: ar_1=array([ 0,
9, 10, 11, 12, 13, 14, 15, 16,17, 18, 19])
#创建11-20,step=2的一维数组ar_2
ar_2=np.arange(11,21,2)
#output:ar_2=array([11, 13, 15, 17, 19])
(2)array()的主要用于创建多维数组，原型为：array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
object : 是一个array_like象，包括list，tuple等__array__定制类可以返回类数组的对象。
dtype：数据类型，默认为可以保存数据的最小类型，可以制定
其他的参数可以通过help来查看，这里就只介绍最常用的
#创建一个2*3的数组，数据类型为int32
ary_1=np.array([[2,2,3],[5,7,3]],dtype=int32)
#output：ary_1=([[2, 2, 3],
[5, 7, 3]], dtype=int32)
#创建一个2*3*3的数组，数据类型默认：
ary_2=np.array([[[3,4,5],[3.3,4.2,4.2],[1.3,2.2,5.8]],[[2.3,1.9,5.7],[4.5,6.7,9.7],[2.2,1.2,7.99]]])
#array([[[ 3.
ary_2.dtype
#output:dtype('float64')，#虽然由int和float， array是以可以保存这些数据的最小数据类型保存，所以是float32#当然也可以通过reshape等方式改变数组的维度，从而获得自己所需要的数组ary_3=np.arange(20,30).reshape(2,5)#output:ary_3#array([[20, 21, 22, 23, 24],#&&&&&& [25, 26, 27, 28, 29]])
&2. 特殊数组的创建：
（1）空数组：empty(),empty_like()
empty(shape[,dtype=None,order=]), 创建一个形状构成为shape的空数组，dtype为数据类型，order为顺序形式：C（C语言）-row-major；F（Fortran）column-major。
empty_like(array)， 依据给定数组(a)的形状和类型返回一个新的空数组。
#创建一个3*3的空数组：
e_1=np.empty([3,3])
#In [89]: print e_1
#填充的数值都是随机的random
#通过empty_like创建与e_1一样形状的空数组
e_2=np.empty_like(e_1)
#In [93]: print e_2
（2）其他特殊数组创建：eye, ones, zeros也有类似的结构，另外还有一个identity函数，用以创建方阵
eye[N,[, M, k, dtype]), N为行数，M为列数（如果不设置默认为N），对角线序列号: 0 对应主对角线；,整数对应upper diagonal,负数对应lower diagonal；
eye_like(array)，创建形状与array一样形状的对角线为1的数组
#创建3*3主对角线为1的方阵：
ey_1=np.eye(3,3,k=0)
print ey_1
#ey_2的对角线uper了一个位置（行）
ey_2=np.eye(3,3,k=1)
pringt ey_2
ones(shape[,dtpe=,order]):按照给定的形状返回一个形状为shape的元素为1的数组
ones_like(a)：返回一个形状跟a一样的元素为1的数组
one_1=np.ones([5,9])
print one_1
#In [99]: print one_1
zeros(shape[,dtype,order]): 按照给定的形状返回一个形状为shape的元素为0的数组
zeros_like(a)：返回一个形状跟a一样的元素为0的数组
zero_1=np.zeros([2,3])
print zero_1
identity(n[,dtype=])返回一个n维的方阵
In [103]: iden
array([[ 1.,
3. 结构体数组
通常，一个数组保存的元素都是同源的，即数组内所有元素都需为同一个类型。在实际的数据分析过程中，尤其是二维spreadsheet式格式的数据，同一行的数据由不同的类型构成。这就需要为这种数据定义一个个性的dtype。dtype实际上是一个类，可以通过赋予参数定义特殊的结构体数组类型。（个人觉得有点类似于SAS中的informat）
#定义一个名称为person的dtype，通过dtype
#一个peson由name,age和weight构成
person=np.dtype([('name',str,20),('age',int32),('weight',float32)])
print person
#[('name', 'S20'), ('age', '&i4'), ('weight', '&f4')]
#就可以创建dtype为person的数组了
student=array([('cnblog',10,12.2),('myBlog',40,30)],dtype=person)
#由于类型规定了参数的个数，所以需要用tuple来创建数组的行数（因为其不可变），否则可能会有一个readable的exception
print student
#[('cnblog', 10, 12.137) ('myBlog', 40, 30.0)]
4. 从文件创建（后续会有专门介绍）Numpy 中文用户指南 3.2 创建数组 - 简书
Numpy 中文用户指南 3.2 创建数组
数组创建的一般机制有五种：
从其它Python的结构转换（如列表和元组）
内置的NumPy数组创建对象（如 arange, ones, zeros以及其它）
从磁盘中读取标准或自定义格式的数据
通过使用字符串或者缓冲区，从原始的字节创建数组
使用特殊的库函数（比如random）
本节不会涉及复制和连接等扩展和转换现有数组的方法，也不会涉及创建对象数组和结构化数组。这些会在它们自己的章节中讲述。
将Python类似数组的对象转换为NumPy数组
通常，Python中排列为数组结构的数值数据可以通过array()函数来转换成数组，典型的例子就是列表和元组。具体使用方法请见array()函数的文档。一些对象也支持数组的协议，并且可以用这种方法转换成数组。辨识一个对象是否能转换为数组，最简单的方法就是在交互式环境中尝试这一方法，看看它是否有效（即Python之道）。
&&& x = np.array([2,3,1,0])
&&& x = np.array([2, 3, 1, 0])
&&& x = np.array([[1,2.0],[0,0],(1+1j,3.)]) # note mix of tuple and lists,
&&& x = np.array([[ 1.+0.j, 2.+0.j], [ 0.+0.j, 0.+0.j], [ 1.+1.j, 3.+0.j]])
内置的NumPy数组创建
NumPy具有从无到有创建数组的内置功能：
zeros(shape) 将创建一个填充为0的指定形状的数组。
&&& np.zeros((2, 3)) array([[ 0., 0., 0.], [ 0., 0., 0.]])
ones(shape) 将创建一个填充为1的数组。在其他所有方面都和zeros相同。
arange()将创建有规律的增量值数组。它的几种用法请见docstring。这里给出几个例子：
&&& np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
&&& np.arange(2, 10, dtype=np.float)
array([ 2., 3., 4., 5., 6., 7., 8., 9.])
&&& np.arange(2, 3, 0.1)
array([ 2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])
请注意，关于最后一个用例，有一些使用技巧，请见arrange的docstring。
linspace()将以指定数量的元素创建数组，并平分开始值和结束值。例如：
&&& np.linspace(1., 4., 6)
array([ 1. ,
这些创建函数的好处是，可以保证元素个数、起始点和结束点，arange()一般不会指定任意的起始值、结束值和步长。
indices()将创建数组的集合（用一维数组来模拟高维数组），每一维都有表示它的变量。一个例子说明比口头描述好得多：
&&& np.indices((3,3))
array([[[0, 0, 0], [1, 1, 1], [2, 2, 2]], [[0, 1, 2], [0, 1, 2], [0, 1, 2]]])
计算规则网格上的高维函数时，这会非常有用。
从磁盘读取数组
这大概是大数组创建的最常见情况。当然，细节取决于磁盘上的数据格式，所以这一节只能给出如何处理各种格式的一般建议。
标准二进制格式
各个领域都有数组数据的标准格式。以下列出了用于读取和返回NumPy数组的已知Python库（也有其它的库可以读取数组并转换为NumPy数组，所以也请看一下最后一节）
HDF5: PyTables
FITS: PyFITS
一些格式不能直接读取，但是不难将其转换为类似PIL库（能够读写许多图像格式，例如jpg、png以及其它）所支持的格式。
普通的ASCII格式
逗号分隔值文件（CSV）被广泛使用（可以被类似Excel的一些程序导入导出）。有一些在python中读取这些文件的方法，例如Python和pylab（Matplotlib的一部分）中的函数。
更通用的ASCII文件可以使用SciPy的IO包来读取。
自定义二进制格式
有多种方法可以使用。如果文件有一个相对简单的格式，那么你可以写一个简单的I/O库并使用numpy fromfile()和tofile()方法直接读写NumPy数组（注意字节顺序！）。如果有一个不错的C/C++库可以用于读取数据，则可以用各种技巧把它封装一下，虽然这可能要耗费一些工作量，也需要更多高级的知识来和C/C++交互。
特殊库的使用
有一些库可以用于生成特殊用途的数组，这样的库不可能全部列举出来。最常见的用法是使用许多数组生成函数来产生带有随机值的数组，以及使用一些生成特殊矩阵（如对角线）的功能函数。
SE@SJTU / /wizardforcel / 人机调律者 / 炼金术士 / 数据忽悠师 / 白帽子 / 见习CTFer / 过气KOL / 供蟾主义 / 精灵训练师 / 专注单身二十年
