1.ndarray数据结构
2.创建ndarray
3.ndarray的数据类型
4.数组和标量之间的运算
5.基本的索引
6.通用函数
7.利用数组进行数据处理
8.输入输出
NumPy(Numerical Python的简称)是高性能科学计算和数据分析的基础包。是用python进行数据分析与挖掘的构建基础。
NumPy本身并没有提供多么高级的数据分析功能，理解NumPy数组以及面向数组的计算将有助你更加高效地使用诸如pandas之类的工具。如果你是Python新手，而且只是想用Pandas随便处理一下数据就行，那就跳过此章吧，没关系的。
1.ndarray数据结构
ndarray是NumPy中一种多维数组对象。我们先来看两个实例。
In [3]: array1
Out[3]: array([1, 2, 3, 4, 5, 6, 7, 8])
In [3]:和Out[3]:是Jupyter编辑器的输入输出标志，你可以理解为代码块行号。array1便是一个一维的ndarray对象。我们多看两个：
In [5]: array2
Out[5]: array([[1, 2, 3, 4],
[5, 6, 7, 8]])
array2是一个2 * 4的二维ndarray对象。
In [7]: array3
Out[7]: array([[[1, 2],
[3, 4]],
[[5, 6],
[7, 8]]])
array3是一个2 * 2 * 2的三维ndarray对象。
ndarray是一个通用的同构数据多维容器，其中的所有元素必须是相同类型。每个ndarray都有一个shape(表示各维度大小的对象),一个dtype(数组数据类型对象)和一个ndim(数组纬度的对象)：
In [8]: array3.shape
Out[8]: (2, 2, 2)
In [9]: array3.dtype
Out[9]: dtype('int64')
In [10]: array3.ndim
Out[9]: 3
2.创建ndarray
2.1 NumPy的array函数
创建数组最简单的办法就是array函数，以一个列表的转换为例：
#导入numpy模块
In [10]: import numpy as np
In [11]: data = [1,2,3,4,5,6,7,8]
array1 = np.array(data)
In [12]: array1
Out[12]: array([1, 2, 3, 4, 5, 6, 7, 8])
嵌套列表将会被转化为一个多维数组：
In [13]: data = [[1,2,3,4],[5,6,7,8]]
array2 = np.array(data)
In [14]: array2
Out[14]: array([[1, 2, 3, 4],
[5, 6, 7, 8]])
2.2 NumPy的arange函数
arange函数是python内置函数的数组版：
In [15]: np.arange(10)
Out[15]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
也可以创建一个多维数组：
In [16]: np.arange(10).reshape((2,5))
Out[16]: array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
下面表显示更多的ndarray创建函数：
| 函数 | 说明 |
|---|---|
| array | 将输入数据(列表、元组、数组或其他序列类型)转换为ndarray。要么推断出dtype,要么显示指定dtype。默认直接复制输入数据 |
| asarray | 将输入转化为ndarray,如果输入本身就是一个ndarray就不进行复制 |
| arange | 类似内置的range，但返回的是一个ndarray而不是列表 |
| ones、ones_like | 根据指定的形状和dtype创建一个全1的数组。ones_like以另外一个数组为参数，并根据其形状和dtype创建一个全1数组 |
| zeros、zeros_like | 类似与ones和ones_like,只不过产生的是全0数组 |
| empty、empty_like | 创建新数组，只分配内存空间但不填充任何值 |
| eye、identity | 创建一个正方的N * N单位矩阵(对角线为1，其余为0) |
3.ndarray的数据类型
dtype(数据类型)是一个特殊的对象。数值型的dtype的命名方式相同：一个类型名(如int或float),后面跟一个表示各元素位长的数字。python中的float对象需要占用8个字节(即64位)，因此，该类型在NumPy中就记作float64。
举个例子：
In [18]: array1 = np.array([1,2,3,4], dtype=np.int64)
array1.dtype
Out[18]: dtype('int64')
In [19]: array2 = np.array([1,2,3,4], dtype=np.float64)
array2.dtype
Out[19]: dtype('float64')
4.数组和标量之间的运算
数组很重要，因为它使你不用编写循环即可对数据执行批量运算。这通常就叫做矢量化。大小相等的数组之间的任何算术运算都会将运算应用到元素级：
In [20]: arr = np.array([[1,2,3,4],[5,6,7,8]])
arr
Out[20]: array([[1, 2, 3, 4],
[5, 6, 7, 8]])
In [25]: arr * arr
Out[25]: array([[ 1, 4, 9, 16],
[25, 36, 49, 64]])
In [26]: arr - arr
Out[26]: array([[0, 0, 0, 0],
[0, 0, 0, 0]])
数组与标量的算术运算也会将那个标量值传播到各个元素：
In [27]: arr * 0.5
Out[27]: array([[0.5, 1. , 1.5, 2. ],
[2.5, 3. , 3.5, 4. ]])
不同大小的数组之间的运算叫做广播，本篇不作讲解。
5.基本的索引
NumPy数组的索引是一个内容丰富的主题，因为选取数据的子集或单个元素的方式有很多。
5.1 整数索引
一维数组很简单，从表面上看跟Python列表的功能差不多：
In [30]: arr = np.arange(10)
arr
Out[30]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [33]: arr[3]
Out[33]: 3
对于高维度数组，能做的事情跟多。例如在一个二维数组中，各索引位置上的元素不再是标量而是一维数组：
In [39]: arr2d = np.array([[1,2,3],[4,5,6],[7,8,9]])
arr2d
Out[39]: array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
In [42]: arr2d[1]
Out[42]: array([4, 5, 6])
因此对元素的递归访问可以传入一个逗号隔开的索引列表来选取单个元素。下面两种方法是等价的。
In [43]: arr2d[1,2]
Out[43]: 6
In [44]: arr2d[1][2]
Out[44]: 6
在多维数组中，如果省略了后面的索引，则返回对象是一个维度低一点的ndarray。
举个例子，在一个2 * 2 * 3的三维数组当中：
In [45]: arr3d = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
arr3d
Out[45]: array([[[ 1, 2, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[10, 11, 12]]])
arr3d[0]是一个2 * 3的二维数组：
In [46]: arr3d[0]
Out[46]: array([[1, 2, 3],
[4, 5, 6]])
️在上面所有这些选取数组子集的例子中，返回的数组都是原始数组的视图。这意味着数据不会被复制，视图上的任何修改都会直接反映到源数组上。
举个例子：
In [47]: arr3d[0] = 12
In [48]: arr3d
Out[48]: array([[[12, 12, 12],
[12, 12, 12]],
[[ 7, 8, 9],
[10, 11, 12]]])
️如果你想要得到的是ndarray切片的一份副本而非视图，就需要显示地进行复制操作，例如arr3d[0].copy()
5.2 切片索引
ndarray的切片语法跟Python列表这样的一维对象差不多:
In [56]: arr
Out[56]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [57]: arr[1:5]
Out[57]: array([1, 2, 3, 4])
高维度的数组切片方法更多，你可以在一个轴或多个轴上进行切片。
举个例子：
In [58]: arr2d
Out[58]: array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
In [60]: arr2d[0:2]
Out[60]: array([[1, 2, 3],
[4, 5, 6]])
In [61]: arr2d[:2]
Out[61]: array([[1, 2, 3],
[4, 5, 6]])
上面的两种写法是一样的。
切片是沿着一个轴方向选取元素的，你可以一次传入多个切片，就像传入多个索引那样(用逗号隔开)：
In [62]: arr2d[:2,1:]
Out[62]: array([[2, 3],
[5, 6]])
️'只有冒号'表示选取整个轴。
举个例子：
In [64]: arr2d[:]
Out[64]: array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
In [65]: arr2d[:,1:]
Out[65]: array([[2, 3],
[5, 6],
[8, 9]])
整数索引和切片索引可以混合使用：
In [67]: arr2d[1,1:]
Out[67]: array([5, 6])
️切片索引返回的数组同样是视图，所以对切片索引的赋值操作同样会直接反映到源数组上。
5.3 布尔型索引
布尔型索引在工作中应用的也比较多。我们先来看个例子：
In [69]: names = np.array(['bob','joe','will','bob','will','joe','joe'])
In [70]: names
Out[70]: array(['bob', 'joe', 'will', 'bob', 'will', 'joe', 'joe'], dtype='names是一个存储姓名的数组，下面用numpy.random中的randn函数生成一些正态分布的随机数据：
In [80]: from numpy import random as rd
In [81]: data = rd.randn(7,4) # 正态分布的二维数组
In [82]: data
Out[82]: array([[ 1.28794696, -1.24441459, -1.6059525 , 0.67558219],
[ 0.3389652 , 0.46551851, -0.92335784, -0.3251096 ],
[-0.35415357, -0.49564882, 1.90609574, 0.87519881],
[ 0.04103014, -0.79487102, -0.639076 , -0.9100843 ],
[ 1.20713356, -0.75816968, -0.26561519, -1.04336953],
[ 0.35948109, -0.07867791, 0.02423479, 0.07243965],
[ 2.12471825, 1.24018587, -0.19397075, -0.780955 ]])
假设每个名字都对应data数组中的一行，而我们想要选出对应于名字'bob'的所有行,该怎么做？
和算术运算一样，数组的比较运算(如==)也是矢量化的，因此，对names和字符串'bob'的比较运算将会产生一个布尔型数组：
In [84]: names == 'bob'
Out[84]: array([ True, False, False, True, False, False, False])
这个布尔型数组可以用来索引：
In [85]: data[names == 'bob']
Out[85]: array([[ 1.28794696, -1.24441459, -1.6059525 , 0.67558219],
[ 0.04103014, -0.79487102, -0.639076 , -0.9100843 ]])
️布尔型数组的长度必须跟被索引的轴的长度一致。
如果需要应用多个布尔条件，使用&、|之类的布尔算术运算符即可：
In [103]: mask = (names == 'bob') | (names == 'will')
In [104]: mask
Out[104]: array([ True, False, True, True, True, False, False])
In [105]: data[mask]
Out[105]: array([[ 1.28794696, -1.24441459, -1.6059525 , 0.67558219],
[-0.35415357, -0.49564882, 1.90609574, 0.87519881],
[ 0.04103014, -0.79487102, -0.639076 , -0.9100843 ],
[ 1.20713356, -0.75816968, -0.26561519, -1.04336953]])
️Python关键字and和or在布尔型数组中无效。
同样，布尔型索引可以和整数索引、切片索引混合使用：
In [87]: data[names == 'bob', 3:]
Out[87]: array([[ 0.67558219],
[-0.9100843 ]])
In [88]: data[names == 'bob', 3]
Out[88]: array([ 0.67558219, -0.9100843 ])
️整数索引是会发生降维筛选的，而切片索引和布尔索引不会。
通过布尔型数组设置值是一种经常用到的手段，为了将data中所有的负值都设置为0，我们只需要：
In [107]: data[data < 0] = 0
In [108]: data
Out[108]: array([[1.28794696, 0. , 0. , 0.67558219],
[0.3389652 , 0.46551851, 0. , 0. ],
[0. , 0. , 1.90609574, 0.87519881],
[0.04103014, 0. , 0. , 0. ],
[1.20713356, 0. , 0. , 0. ],
[0.35948109, 0. , 0.02423479, 0.07243965],
[2.12471825, 1.24018587, 0. , 0. ]])
5.4 花式索引
花式索引是一个NumPy的术语，它指的是利用整数数组进行索引。
举个例子：
In [109]: arr = np.empty((8,4))
In [110]: for i in range(8):
arr[i] = i
In [111]: arr
Out[111]: array([[0., 0., 0., 0.],
[1., 1., 1., 1.],
[2., 2., 2., 2.],
[3., 3., 3., 3.],
[4., 4., 4., 4.],
[5., 5., 5., 5.],
[6., 6., 6., 6.],
[7., 7., 7., 7.]])
arr是一个8 * 4的二维数组，为了以特定顺序选取子行，只需要传入一个用于指定顺序的整数列表或ndarray即可：
In [113]: arr[[4,3,0,6]]
Out[113]: array([[4., 4., 4., 4.],
[3., 3., 3., 3.],
[0., 0., 0., 0.],
[6., 6., 6., 6.]])
使用负数索引将会从末尾开始选取行：
In [113]: arr[[-1,-2]]
Out[113]: array([[7., 7., 7., 7.],
[6., 6., 6., 6.]])
按照这样的思路如果我们一次传入多个整数列表是不是返回特定顺序的行和列，但结果并不是这样：
In [115]: arr = np.arange(32).reshape((8,4))
In [116]: arr
Out[116]: 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],
[24, 25, 26, 27],
[28, 29, 30, 31]])
In [117]: arr[[3,1],[3,1]]
Out[117]: array([15, 5])
它返回的是一个一维数组，选出的元素是(3，3),(1，1)。
那怎么才能同时选出特定顺序的行和列呢？一个办法就是使用np.ix_函数，它可以将两个一维整数数组转换为一个用于方形区域的索引器：
In [118]: arr[np.ix_([3,1],[3,1])]
Out[118]: array([[15, 13],
[ 7, 5]])
这就对了，还有另外一种方法：
In [118]: arr[[3,1]][:,[3,1]]
Out[118]: array([[15, 13],
[ 7, 5]])
6.通用函数
ufunc(通用函数)是一种对ndarray中的数据执行元素级运算的函数。
举几个例子：
In [123]: arr = np.arange(12).reshape(3,4)
In [124]: arr
Out[124]: array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
In [125]: np.sqrt(arr) # 计算各元素的平方根
Out[125]: array([[0. , 1. , 1.41421356, 1.73205081],
[2. , 2.23606798, 2.44948974, 2.64575131],
[2.82842712, 3. , 3.16227766, 3.31662479]])
In [126]: np.square(arr) # 计算各元素的平方
Out[126]: array([[ 0, 1, 4, 9],
[ 16, 25, 36, 49],
[ 64, 81, 100, 121]])
以上都是一元ufunc,另外一写ufunc接收2各数组(因此也叫做二元ufunc)，并返回一个新数组：
In [127]: from numpy import random as rd
In [128]: arr1 = rd.randn(4) # 正态分布的一维数组
In [129]: arr1
Out[129]: array([0.20687398, 0.81274684, 0.27283635, 0.23128059])
In [130]: arr2 = rd.randn(4) # 正态分布的一维数组
In [131]: arr2
Out[131]: array([ 0.6324182 , -2.02399605, -0.84640293, -1.03594909])
In [132]: np.maximum(arr1, arr2) # 元素级最大值
Out[132]: array([0.6324182 , 0.81274684, 0.27283635, 0.23128059])
一些一元ufunc:
| 函数 | 说明 |
|---|---|
| abs、fabs | 计算整数、浮点数或复数的绝对值。对于非复数值，可以使用更快的fabs |
| sqrt | 计算各元素的平方根。相当于arr**0.5 |
| square | 计算各元素的平方。相当于arr**2 |
| exp | 计算各元素的指数e^x |
| log、log10、log2、log1p | 分别为自然对数(底数为e)、底数为10的log、底数为2的log、log(1+x) |
| sign | 计算各元素的正负号：1(正数)、0(零)、-1(负数) |
| ceil | 计算各元素的ceiling值，即大于等于该值的最小整数 |
| floor | 计算各元素的floor值，即小于等于该值的最大整数 |
| rint | 将各元素值四舍五入到最接近的整数，保留dtype |
| isnan | 返回一个表示“哪些值是NaN”的布尔型数组 |
️更多一元和二元ufunc请参考官网。
7.利用数组进行数据处理
NumPy数组使你可以将多种数据处理任务表述为简洁的数组表达式。用数组表达式代替循环的做法，通常被称为 矢量化。
7.1 将条件逻辑表达为数组运算
numpy.where函数是三元表达式x if condition else y的矢量化版本。
看个例子：
In [133]: xarr = np.array([1.1,1.2,1.3,1.4,1.5])
In [134]: xarr
Out[134]: array([1.1, 1.2, 1.3, 1.4, 1.5])
In [135]: yarr = np.array([2.1,2.2,2.3,2.4,2.5])
In [136]: yarr
Out[136]: array([2.1, 2.2, 2.3, 2.4, 2.5])
In [137]: cond = np.array([True,False,True,True,False])
In [138]: cond
Out[138]: array([ True, False, True, True, False])
如果我们想要根据cond的值选取xarr和yarr的值：当cond为True时，选取xarr的值，否则从yarr中选取。使用循环比较繁琐且对于大数组的处理速度不是很快。若使用np.where则可以简写为：
In [138]: result = np.where(cond, xarr, yarr)
In [138]: result
Out[138]: array([1.1, 2.2, 1.3, 1.4, 2.5])
np.where的第二个和第三个参数不必是数组，它们都可以是标量值。例如在数据分析中，where通常用于根据一个数组产生一个新的数组。假设有一个由随机数组成的矩阵，你希望将所有正值替换为2，将所有负值替换为-2。若利用np.where则会变得非常简单：
In [141]: from numpy import random as rd
In [142]: arr = rd.randn(4,4)
In [143]: arr
Out[143]: array([[ 0.50943315, 0.86730205, -0.58578168, 0.07091693],
[ 0.10816702, 1.49343972, 0.81776697, 0.81133719],
[-0.01395082, -1.38688598, -0.13255509, 0.5381726 ],
[ 1.12388897, 0.67390186, -0.5794577 , -0.41228758]])
In [144]: np.where(arr > 0, 2, -2) # 正数改为2，负数改为-2
Out[144]: array([[ 2, 2, -2, 2],
[ 2, 2, 2, 2],
[-2, -2, -2, 2],
[ 2, 2, -2, -2]])
In [146]: np.where(arr > 0, 2, arr) # 只将正数改为2
Out[146]: array([[ 2. , 2. , -0.58578168, 2. ],
[ 2. , 2. , 2. , 2. ],
[-0.01395082, -1.38688598, -0.13255509, 2. ],
[ 2. , 2. , -0.5794577 , -0.41228758]])
7.2 数学和统计方法
可以通过数组上的一组数学函数对整个数组或某个轴向的数据进行聚合统计计算。
In [147]: arr = np.arange(12).reshape(3,4)
In [148]: arr
Out[148]: array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
In [149]: arr.mean() # 算术平均数
Out[149]: 5.5
In [150]: arr.sum() # 求和
Out[150]: 66
mean和sum这类的函数还可以接收一个axis参数(用于计算该轴向上的统计值)：
In [153]: arr.sum(axis = 1) # 1代表二维数组中行轴
Out[153]: array([ 6, 22, 38])
In [153]: arr.sum(axis = 0) # 0代表二维数组中列轴
Out[153]: array([12, 15, 18, 21])
下表列出了全部的基本数组统计方法。
| 方法 | 说明 |
|---|---|
| sum | 对数组中全部或某轴向的元素求和。零长度的数组的sum为0 |
| mean | 算术平均数。零长度的数组的mean为NaN |
| std、var | 分别为标准差和方差，自由度可调 |
| min、max | 最大值和最小值 |
| argmin、argmax | 分别为最大和最小元素的索引 |
| cumsum | 所有元素的累计和 |
| sumprod | 所有元素的累计积 |
7.3 用于布尔型数组的方法
在上面的这些方法中，布尔值会被强制转换为1(True)和0(False)。因此，sum经常被用来对布尔型数组中的True值计数：
In [156]: arr = rd.randn(2,5) # 正态分布的二维数组数据
In [157]: arr
Out[157]: array([[ 0.25634557, 0.4367522 , -1.41156838, -0.43382141, -0.14254968],
[-1.45358166, -1.77782062, 0.84003744, -0.11864763, -0.26476296]])
In [158]: (arr > 0).sum() # 正值的数量
Out[158]: 3
这里的sum函数为什么就不是求和呢？其实是有道理的，因为arr > 0结果是一个布尔型数组啊，布尔类型的值怎么求和嘛，对不对。
另外还有两个方法any和all，它们对布尔类型数组非常有用。any用于检查数组中是否存在一个或多个True,而all检查数组中所有的值是否都是True。
举个例子：
In [160]: from numpy import nan as NaN
In [161]: arr = np.array([[1,2,3,4],[5,6,7,NaN]]) # nan代表空值
In [162]: arr
Out[162]: array([[ 1., 2., 3., 4.],
[ 5., 6., 7., nan]])
我们想检测arr中有没有空值，则可以这样做：
In [168]: np.isnan(arr).any() # isnan函数是一个ufunc，返回一个布尔型数组
Out[168]: True
这两个方法也能用于非布尔型数组，所有非0元素都将被当成True。
7.4 排序
跟Python内置的列表类型一样，NumPy数组也可以通过sort方法就地排序：
In [182]: from numpy import random as rd
In [183]: arr = rd.randn(5) # 正态分布的一维数组
In [184]: arr
Out[184]: array([0.76144187, 0.92518998, 1.74213039, 0.8244198 , 1.33964152])
In [185]: arr.sort() # 升序排序
In [186]: arr
Out[186]: array([0.76144187, 0.8244198 , 0.92518998, 1.33964152, 1.74213039])
多维数组可以在任何一个轴向上进行排序，只需将轴编号传给sort即可：
In [198]: arr = rd.randn(3,3) # 正态分布的二维数组
In [199]: arr
Out[199]: array([[-1.09501091, 0.33296923, -0.4430025 ],
[-0.04355405, -0.61911744, -0.65246943],
[-0.38652144, -0.74480079, 0.32569722]])
In [200]: arr.sort(0) # 0代表的是列轴，不写默认也是0，1代表的是行轴
In [201]: arr
Out[201]: array([[-1.09501091, -0.74480079, -0.65246943],
[-0.38652144, -0.61911744, -0.4430025 ],
[-0.04355405, 0.33296923, 0.32569722]])
7.5 去重以及其他集合逻辑
NumPy提供了一些针对一维ndarray的基本逻辑运算。最常用的可能要数np.unique，它用于找出数组中的唯一值并返回以排序的结果：
In [202]: names = np.array(['bob','joe','will','bob','will','joe','joe'])
In [203]: np.unique(names)
Out[203]: array(['bob', 'joe', 'will'], dtype='NumPy中的集合函数请参见下表：
| 方法 | 说明 |
|---|---|
| unique(x) | 计算x中的唯一元素，并返回有序结果 |
| intersect1d(x,y) | 计算x和y中的公共元素，并返回有序结果 |
| union1d(x,y) | 计算x和y的并集，并返回有序结果 |
| in1d(x,y) | 得到一个表示“x的元素是否包含于y” |
| setdiff1d(x,y) | 集合的差，即元素在x中且不在y中 |
| setxor1d(x,y) | 集合的对称差，即存在于一个数组中但不同时存在于两个数组中的元素 |
8. 输入输出
NumPy能够读写磁盘上的文本数据或二进制数据。其实运用更多的是Pandas中的读取磁盘数据到内存。
8.1 将数组以二进制格式保存到磁盘
numpy.save和np.load是读写磁盘数组数据的两个主要函数。
In [204]: arr = arr = np.arange(10).reshape(2,5)
In [205]: np.save('ndarray',arr)
默认情况下，数组是为压缩的原始二进制格式保存在扩展名为.npy的文件中的。
[appl@SZVM-EXlOIT-1-243 dongzhongwei]$ cd numpy_exercises/
[appl@SZVM-EXlOIT-1-243 numpy_exercises]$ ls -l
总用量 44
-rw-r----- 1 appl fspfappl 152 1月 9 20:51 ndarray.npy
-rw-r----- 1 appl fspfappl 39378 1月 9 20:52 Untitled.ipynb
如果文件路径末尾没有扩展名.npy，则该扩展名会被自动加上。然后就可以通过np.load读取磁盘上的数组：
In [205]: np.load('ndarray.npy')
Out[205]: array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
8.2 存取文本文件
存文本文件：
In [206]: np.savetxt('ndarray.txt', arr, delimiter= ',')
[appl@SZVM-EXlOIT-1-243 numpy_exercises]$ cat ndarray.txt
0.000000000000000000e+00,1.000000000000000000e+00,2.000000000000000000e+00,3.000000000000000000e+00,4.000000000000000000e+00
5.000000000000000000e+00,6.000000000000000000e+00,7.000000000000000000e+00,8.000000000000000000e+00,9.000000000000000000e+00
加载文本文件：
In [207]: arr = np.loadtxt('ndarray.txt', delimiter= ',')
In [208]: arr
Out[208]: array([[0., 1., 2., 3., 4.],
[5., 6., 7., 8., 9.]])
️更多有关文件读写的知识，请参阅后续有关Pandas的文章。