新手基础
欢迎来到 NumPy 的世界
NumPy 是一个Python 开源库，几乎可以应用于所有的科学和工程领域。在Python 中，它是处理数字型数据的通用标准，也是科学 Python 与PyData 生态系统的核心。从初学者到经验丰富的研究人员，只要是从事新进的科学和工业研究领域，都是NumPy用户。Pandas、SCIPy、Matplotlib、scikit-learn、scikit-image 以及其他需要数据科学包都含有 numpy 的 API 接口。
NumPy 库包括多种数组和矩阵数据结构。提供了一种均一的 n-维数组对象 ndarray及多种相应有效的操作方法。NumPy 在数组结构上可以用于操作多种数学计算。同时也为 Python 提供了一种有效的数据结构，以确保数组和矩阵有效计算，并为高水平数学方法提供了大量可以操作数组和矩阵的库。
安装
如果你已经安装 Python 的话，按照以下方法安装
conda install numpy
pip install numpy如果没有安装 Python，可以使用 anaconda，它是最简单的方法，且具有以下优势：你不需要担心分别安装 NumPy 或者其他的 用于数据分析的Python 包，如 pandas、Scikit-Learn 等，conda 都会处理好
引入 NumPy
import numpy as np“np”是 numpy 的缩写，在使用numpy 时更加易读。
Python 列表与 NumPy 数组区别
NumPy 提供了多种创建数组和操作数组数组的方法。Python 列表是一个列表中可以包含不同的数据类型，而数组的所有元素必须是一致的。如果数组的数据类型不一致，那么计算效率会大大降低。
使用 NumPy 的理由
比起列表，数组有以下优势
- 结构更加紧密
- 运行更加迅速
- 占用内存少：数组存储数据使用的内存更少，并提供了一个指定数据类型的机制，这样可以更加优化代码
- 使用方便
数组是什么
数组是NumPy 库的核心数据结构。数组是由值组成的网格结构，包含原始数据的信息、如何定位元素以及如何解释元素。数组有一个元素网格，可以以多种方式索引数据。这些元素的数据类型都一致，称为dtype 。
检索数组的数据类型有：非负整数的元素、布尔值、数组和整数。
数组的 rank指的是其维度的数量；数组的 shape是一个描述了每个维度大小的整数元组。
可以使用 Python 列表的方式初始化数组，使用巢式列表可以初始化二维及更高维度的数组
a = np.array([1, 2, 3, 4, 5, 6])
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])我们可以使用中括号[]访问数组中的元素，注意索引从 0 开始。
本节涵盖1Darray、2Darray、ndarray、vector、matrix
你可能听说过一个叫 ndarray的数组，他是N-维度数组（N-dilmensional array）的简称。N-维数组就是一个任意维度简单的数据。NumPy 的 ndarray类可以展示矩阵和向量。向量（vector）就是一个一维的数组；矩阵（matrix）是一个二维的数组；对于三维及以上的数组，使用 tensor。
数组的特征
数组通常是一个固定大熊啊的容器，盛放着类型和大小都一致的项目。数组维度和条目的数量都是由其形状决定的。而数组的形状是一个非负整型的数组，对每个维度进行描述。
在 NumPy，维度通常称为“轴”（axes）。一个 2D 的数组长成这样：
[[0., 0., 0.],
[1., 1., 1.]]这个数组有两个轴，第一个轴的长度为 2，第二个轴的长度为 3.
与 Python 其他容器类型一样，数组的内容可以通过索引和切片进行获取和修饰。但不同的是，不同的数组可以有相同的数据，因此，如果修改了一个数组，另一个数组也会随之改变。
在这里阅读更多关于数组属性的信息，并在这里了解有关数组对象的信息。
创建一个基本的数组
本节涵盖np.array(), np.zeros(), np.ones(), np.empty(),np.arange(), np.linspace(),dtype。
np.array()函数
该函数只需创建一个一个列表，然后将其传递到函数中。同时你可以指定列表中的数据类型。详细信息参见：数组对象
import numpy as np a = np.array([1, 2, 3])
创建一个都是 0 的数组
np.zeros(2)
- 创建一个都是 1 的数组
np.ones(2)创建一个空数组
empty函数可以创建一个空数组，内容是根据内存状态随机生产的。empty函数相较于zeros函数的优势就是速度——确保可以迅速填满后续的每个元素np.empty(2)
创建一个序列数组
np.arange(4) np.arange(2,9,2) #第一个元素，第二个元素，步长创建线性数组
np.linspace(0,10,num=5)指定数据类型
数组默认的数据类型为浮点型（np.float64），我们可以通过
dtype这个参数设置数据类型X= np.ones(2,dtype = np.int64)增加删除和排列元素
本节涵盖
np.sort()，np.concatenate()排序
np.sort()函数可以进行简单的排序，在排序是可以指定轴、类型和顺序。
a = np.array([3,5,6,8,9,1,4,7])
array([1, 2, 3, 4, 5, 6, 7, 9])argsort沿着指定的轴间接排序lexsort，这是多个键上的间接稳定排序，searchsorted，它将在排序数组中找到元素，以及partition，这是一种部分类型。
要了解有关数组排序的更多信息，请参阅：sort。
增加
x = np.array([[1, 2], [3, 4]])
y = np.array([[5, 6]])
np.concatenate((x,y))
"""array([[1, 2],
[3, 4],
[5, 6]])"""
np.concatenate((x,y),axis =0)
"""'array([[1, 2],\n [3, 4],\n [5, 6]])'"""
np.concatenate((x,y),axis =1)如果想要删除数组的元素，可以通过索引筛选出所需要的元素并保留。
请参阅：concatenate。
数组的形状和大小
本节涵盖ndarray.ndim，ndarray.size，ndarray.shape
ndarray.ndim：数组轴\维度的数值。
ndarray.size：数组所有元素的综述，是 shape 所有值的乘积。
ndarray.shape：显示一个整数型元组，期内通是数组每个维度的元素个数。假如你有一个 2 行 3 列的 2 维数组，那个该值就是（2,3）。
重塑数组
使用 arr.reshape（）方法可以再不改变数据的情况下创建一个新的形状的数组。当你要用该方法时，生成新数组元素个数需要与原始的一致。
a = np.arange(6)
b = a.reshape(3, 2)
b在使用arr.reshape（）方法时，有几个可选参数
np.reshape(a, newshape=(1, 6), order='C')
# array([[0, 1, 2, 3, 4, 5]])a：为原始数组
newshape ：是目标数组，可以是一个整数或者整型元组。当使用整数时，结果返回该长度的数组。其形状应该与原始形状一致。
order：C读写元素顺序使用 C-like 索引；F表示读写元素顺序使用 Fortran-like顺序；A 表示读写顺序元素时，如果内存中有Fortran-like顺序，使用 F，没有的话使用 C。
更多关于 C 和 Fortran 顺序请参见：NumPy数组内部组织的更多信息。事实上，C 和 F 循序与涉及内存存储的索引相关。在 F 中，当在一个存储在内存的二维数组的元素之间移动时，第一个索引是最快的。当第一个索引在更改时移动到下一行时，矩阵一次存储一列。这就是为什么Fortran被认为是一种列大语言。另一方面，在C中，最后一个指数变化最快。矩阵按行存储，使其成为行主语言。您为C或Fortran做什么取决于保留索引约定是否对数据进行重新排序更重要。
将一维数组转换成二维数组（在一个数组上新增一个维度）
本节涵盖np.newaxis，np.expand_dims。我们可以通过np.newaxis，np.expand_dims两个方法去增加一个数组的维度。
使用np.newaxis时，每使用一次，都会在原来的数组上增加一个维度。即 1 维变 2 维，然后2维变3 维，一次类推。
a = np.array([1,2,3,4,5,6])
a1 = a[np.newaxis,:]
a2 = a[:,np.newaxis]
a.shape#(6,)
a1.shape #(1, 6)
a2.shape #(6, 1)
a2"""array([[1],
[2],
[3],
[4],
[5],
[6]])
"""可以使用np.expand_dims在索引位置新增一个维度：
b = np.expand_dims(a,axis=1)
b
"""array([[1],
[2],
[3],
[4],
[5],
[6]])"""
b.shape#(6,1)
c = np.expand_dims(a,axis=0)
c #array([[1, 2, 3, 4, 5, 6]])
c.shape #(1, 6)更多信息参见newaxis 和expand_dims的expand_dims部分。
索引和切片
ata = np.array([1, 2, 3])
>>> data[1]
2
>>> data[0:2]
array([1, 2])
>>> data[1:]
array([2, 3])
>>> data[-2:]
array([2, 3])
如果您想从数组中选择满足特定条件的值，NumPy非常简单。
a = np.array([[1 , 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]) #选择小于 5 的元素
print(a[a < 5]) #[1 2 3 4]
five_up = (a >= 5)#选择大于 5 的元素
print(a[five_up]) #[ 5 6 7 8 9 10 11 12]
divisible_by_2 = a[a%2==0] # 选择偶数
divisible_by_2#[ 2 4 6 8 10 12]
c = a[(a > 2) & (a < 11)] #选择与\或的条件
c #[ 3 4 5 6 7 8 9 10]
five_up = (a > 5) | (a == 5) # 通过与\或返回布尔值的数组
five_up
"""[[False False False False]
[ True True True True]
[ True True True True]] """
使用np,nonzero（）去选取满足条件的元素:
a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]] )
b = np.nonzero(a<5)
b #(array([0, 0, 0, 0]), array([0, 1, 2, 3]))
c = np.nonzero(a>5)
c #(array([1, 1, 1, 2, 2, 2, 2]), array([1, 2, 3, 0, 1, 2, 3]))
a[b] #array([1, 2, 3, 4]) 作为索引在本例子中，结果返回了一个有数组组成的元组，数组代表每个维度。第一个数组表示满足条件的值所在的行索引，第二个数组表示满足条件的值的列索引。
可以使用 zip 方法生成坐标列表。然后通过迭代方式将其打印出来。
list_of_coordinates= list(zip(b[0], b[1]))
for f in list_of_coordinates:
print(f)
"""(0, 0)
(0, 1)
(0, 2)
(0, 3)"""
a[b]如果所有算是都不满足条件，返回的数组就是空的
d = np.nonzero(a==99)
d #(array([], dtype=int64), array([], dtype=int64))通过已有数据创建一个数组
本节涵盖slicingandindexing，np.vstack()，np.hstack()，np.hsplit()，.view()，copy()
通过一个已有的数组可以轻松创建一个新的数组。
从原来数组的抓取了第三个索引到第八个索引的内容
a = np.array([1,2,3,4,5,6,7,8,9,10])
arr1 = a[3:8]
arr1 #array([4, 5, 6, 7, 8])vstack和 hstack
a1 = np.array([[1, 1],
[2, 2]])
a2 = np.array([[3, 3],
[4, 4]])
a = np.vstack((a1,a2))
b = np.hstack((a1,a2))
a,b
"""(array([[1, 1],
[2, 2],
[3, 3],
[4, 4]]),
array([[1, 1, 3, 3],
[2, 2, 4, 4]]))"""拆分数组：hsplit可以将一个数组拆分成几个小数组。你可以指定等分数组后小数组的数量，或者可以确定确定要拆分列的位置。
x = np.arange(1,25).reshape(2,12)
x
"""array([[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
[13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]])
"""
np.hsplit(x,3)
"""[array([[ 1, 2, 3, 4],
[13, 14, 15, 16]]),
array([[ 5, 6, 7, 8],
[17, 18, 19, 20]]),
array([[ 9, 10, 11, 12],
[21, 22, 23, 24]])]
"""
np.hsplit(x,(3,4)) #3和 4 位切割的位置
"""[array([[ 1, 2, 3],
[13, 14, 15]]),
array([[ 4],
[16]]),
array([[ 5, 6, 7, 8, 9, 10, 11, 12],
[17, 18, 19, 20, 21, 22, 23, 24]])]"""view方法创建
可以使用 view方法创建一个与源数据一样的新数组（浅拷贝方法）。
view是一个重要的 NumPy 概念。像索引和切片操作一样，只要可以，NumPy 函数会返回一个视图。这样可以保存内存且运行速度更快（没有产生数据的复制）。然而，需要注意的是修改 view 创建的数据会造成原始数据的改变。
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
b1 = a[0,:]
b1 #array([1, 2, 3, 4])
b1[0] = 9999
b1#array([9999, 2, 3, 4])
a
"""array([[9999, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])"""copy方法
copy 方法是对原数组的全拷贝，是一种深拷贝。
基本的数组操作
本节涵盖加减、乘法、除法等
假如你创建了两个数据
data = np.array([1,2])
ones = np.ones(2,dtype=int)
#相同结构的元素相加减乘除
data + ones #array([2, 3])
data - ones #array([0, 1])
data * ones #array([1, 2])
data / ones #array([1., 2.])求一个数组内部所有的值之和
a = np.array([1,2,3,4])
a.sum() #10
b = np.array([[1, 1], [2, 2]])
b.sum(axis=0) #array([3, 3])
b.sum(axis =1) #array([2, 4])
b.sum() #6广播
有时候你希望对一个数组（array\vector）和一个数（number\scalar）或者两个不同结构的数组进行操作。比如你的数据信息是以英里为单位，但你希望改成千米。可以进行一下操作：
data = np.array([1.0, 2.0])
data*1.6 #array([1.6, 3.2])NumPy 知道每个元素都应该发生乘法，这个就是广播（broadcasting）。广播是一机制，可以允许 NumPy 在不同形状的数组之间进行操作。但维度必须是可兼容的，如：两个数组的维度一致，或者其中一个是一维的。如果不兼容的话会返回 ValueError报错。
其他数组操作
本节涵盖最大值、最小值、总和、平均值、乘积、标准偏差等。
NumPy 也可以进行聚合函数：min,max，sum，mean求平均值，prod求所有元素的乘积，std标准差。
a = np.array([[0.45053314, 0.17296777, 0.34376245, 0.5510652],
[0.54627315, 0.05093587, 0.40067661, 0.55645993],
[0.12697628, 0.82485143, 0.26590556, 0.56917101]])
a.sum()
a.sum(axis =0)#array([1.12378257, 1.04875507, 1.01034462, 1.67669614])
a.sum(axis=1) #array([1.51832856, 1.55434556, 1.78690428])创建矩阵
矩阵就是一个 2-维数组。
data = np.array([[1, 2], [3, 4], [5, 6]])
data[0, 1]
data[1:3]
'''
array([[3, 4],
[5, 6]])'''
data[0:2, 0] #array([1, 3])
data.max()
data.max(axis=0)
data.max(axis=1)
data.min()
data.sum()
相同形状的矩阵可以进行加减乘除，当一个矩阵只有一行\一列，可进行广播计算。
data1 +data2
data = np.array([[1, 2], [3, 4], [5, 6]])
ones_row = np.array([[1, 10]])
data + ones_row
"""array([[ 2, 12],
[ 4, 14],
[ 6, 16]])"""当NumPy 打印 N-维数组时，最后的轴重复最快，而第一个轴最慢。
当我们需要对一个数组进行初始化时 ，可以使用 ones（）和 zeors（）函数也可使用 random.Generator类。你所需要做的就是将目标元素的个数传进参数。
np.ones(3)
np.zeros(3)
rng = np.random.default_rng(0)
rng.random(3) #array([0.63696169, 0.26978671, 0.04097352])
# 创建二维数组
np.ones((3,2))
np0.zeros((3,2))
rng.random((3,2))更多信息见创建例程。
创建随机数
随机数的生成是许多数值和机器是学习算法的参数和评估的重要组成部分。在人工智能网络中，你是否需要随机初始化权重、将数据拆分成随机集，随机洗牌数据库，可以生成随机数（实际上是可重复的伪随机数据值）是至关重要。
使用 Generator.integers 方法，可一次从低（包括NumPy在内）到高（独家）生成随机整数。你还可以设置关键字endpoint =True，使得数字具有包容性。
rng.integers(5,size=(2,5)) #生产随机0-4 之间实随机数
"""array([[0, 0, 0, 4, 3],
[4, 2, 3, 4, 3]])"""获取唯一条目或者计数值
通过 np.unique可以很容易得到以上数组所有唯一的值，
其中参数 return_index参数可以获得每个唯一值的索引； return_counts参数可以返回每个唯一值的频次。
a = np.array([11, 11, 12, 13, 14, 15, 16, 17, 12, 13, 11, 14, 18, 19, 20])
b = np.unique(a)
b #array([11, 12, 13, 14, 15, 16, 17, 18, 19, 20])
b,indices_list = np.unique(a,return_index=True)
b,indices_list
"""(array([11, 12, 13, 14, 15, 16, 17, 18, 19, 20]),
array([ 0, 2, 3, 4, 5, 6, 7, 12, 13, 14]))"""
b,occurrence_count = np.unique(a,return_counts=True)
occurrence_count #array([3, 2, 2, 2, 1, 1, 1, 1, 1, 1])对于二维数组
a_2d = np.array([[5, 6, 7, 8], [1, 2, 3, 4], [9, 10, 11, 12], [1, 2, 3, 4],[1,2,3,5],[1,2,3,13]])
a_uni = np.unique(a_2d)
a_uni #array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13])
uni_rows = np.unique(a_2d,axis = 0)
uni_rows
"""array([[ 1, 2, 3, 4],
[ 1, 2, 3, 5],
[ 1, 2, 3, 13],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
"""
uni_rows = np.unique(a_2d,axis = 1)
uni_rows
"""array([[ 5, 6, 7, 8],
[ 1, 2, 3, 4],
[ 9, 10, 11, 12],
[ 1, 2, 3, 4],
[ 1, 2, 3, 5],
[ 1, 2, 3, 13]])"""
unique_rows,indices,occurrence_count = np.unique(a_2d,axis =0,return_counts = True,return_index = True)
print(unique_rows)
"""[[ 1 2 3 4]
[ 1 2 3 5]
[ 1 2 3 13]
[ 5 6 7 8]
[ 9 10 11 12]]"""
print(indices)#[1 4 5 0 2]
print(occurrence_count) #[2 1 1 1 1]更多信息请参阅unique。
转置、重置矩阵
本节涵盖arr.reshape()，arr.transpose()，arr.T
转置矩阵是很常见的，NumPy 数组特征 T可完成矩阵转换。
......
有时候，你需要转换一个矩阵的尺寸，比如有时候你有一个模型要求输入形状与你现有的形状不同，这样就需要用 reshape方法了。.transpose()和 .T可以转置矩阵。
a = np.arange(6).reshape(2,3)
a
"""array([[0, 1, 2],
[3, 4, 5]])
"""
b = np.arange(6).reshape(3,2)
b
"""array([[0, 1],
[2, 3],
[4, 5]])
"""
a.transpose()
"""array([[0, 3],
[1, 4],
[2, 5]])"""
b.transpose()
"""array([[0, 2, 4],
[1, 3, 5]])"""反转矩阵
NumPy np.flip()函数可以按照某一轴对矩阵的内容进行反转。使用该函数时，注意你需要反转的数组和周，如果不特指某个周的话，NumPy 会默认按照所有轴进行反转。
#1D
arr = np.array([1,2,3,4,5,6,7])
a_rev = np.flip(arr)
a_rev #array([7, 6, 5, 4, 3, 2, 1])
#2D
arr_2d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
a_rev1 = np.flip(arr_2d)
a_rev1#相当于从头到尾全部颠倒
"""array([[12, 11, 10, 9],
[ 8, 7, 6, 5],
[ 4, 3, 2, 1]])"""
a_rev2 = np.flip(arr_2d,axis=0) #行转置
a_rev2
"""
array([[ 9, 10, 11, 12],
[ 5, 6, 7, 8],
[ 1, 2, 3, 4]])"""
a_ver3 = np.flip(arr_2d,axis =1)
a_ver3
"""array([[ 4, 3, 2, 1],
[ 8, 7, 6, 5],
[12, 11, 10, 9]])"""
arr_2d[:,1] = np.flip(arr_2d[:,1])
arr_2d
"""rray([[ 1, 10, 3, 4],
[ 5, 6, 7, 8],
[ 9, 2, 11, 12]])"""关于flip更多信息。
重塑和扁平化多维数组
本节涵盖.flatten()，ravel()
有两种流行的方法来展平数组：.flatten()和.ravel()。两者的区别是使用ravel()创建的新数组实际上是对父数组的引用（即“视图”）。这意味着对新数组的任何更改也将影响原数组。由于ravel不创建副本，因此内存效率很高。而使用 flatten不会改变原数组。
x = np.array([[1 , 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
x.flatten() #array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
a1 = x.flatten()
a1[0]= 111
a1 #array([111, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
x
"""array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])"""a2 = x.ravel()
a2[0] = 999
a2 #array([999, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
x
"""array([[999, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
"""更多关于flatten请参考 ndarray.flatten ，更多关于ravel 请参考 ravel.
文档帮助
？或？？- help（）
保存和加载 NumPy 对象
本节涵盖np.save，np.savez，np.savetxt，np.load，np.loadtxt
有时，你希望可以保存你的数组到硬盘或者从硬盘加载数组，而不希望每次都重新运行代码。有几种方法可以保存和加载这些对象。loadtxt和savetxt函数可以处理文本文件，用于保存和加载 ndarray；load和save函数用于处理 NumPy 二进制文件，其后缀为.npy;savez可以处理.npz文件。
.npy和.npz文件存储重建ndarray所需的数据、形状、dtype和其他信息，即使该文件位于具有不同架构的另一台机器上，也可以正确检索数组。
如果您想存储单个ndarray对象，请使用np.save将其存储为.npy文件。如果您想将多个ndarray对象存储在一个文件中，请使用npnp.savez将其保存为.npz文件。您还可以使用 savez_compressed压缩 npz 格式将多个数组保存到单个文件中。
x = np.array([[1 , 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
np.save('x',x)
b = np.load('x.npy')
b
"""array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
"""x = np.array([[1 , 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
np.savetxt('x.csv',x)
np.loadtxt('x.csv')avetxt()和loadtxt()函数接受其他可选参数，如页眉、页脚和分隔符。虽然文本文件可以更容易共享，但.npy和.npz文件更小，读取速度更快。如果您需要更复杂的文本文件处理（例如，如果您需要处理包含缺失值的行），您将需要使用genfromtxt函数。
使用 savetxt，您可以指定页眉、页脚、注释等。
在这里了解有关输入和输出例程的更多信息。
导入和导出 CSV 文件
阅读 CSV 最好的方式是 Pandas。
import pandas as pd
x = pd.read_csv('music.csv',header=0).values
x
x = pd.read_csv('music.csv', usecols=['Artist', 'Plays']).values
x
如果你是 NumPy 新手，可能回需要用数组创建一个 pandas 的`DataFrame数据结构，在用 pandas 将其写入到 CSV 文件中。
＃创建数组
a = np.array([[-2.58289208, 0.43014843, -1.24082018, 1.59572603],
[ 0.99027828, 1.17150989, 0.94125714, -0.14692469],
[ 0.76989341, 0.81299683, -0.95068423, 0.11769564],
[ 0.20484034, 0.34784527, 1.96979195, 0.51992837]])
#转化为 pandas 数据
df = pd.DataFrame(a)
#保存为 CSV 问价
df.to_csv('pd.csv')
# 读取 CSV
data = pd.read_csv('pd.csv')
# NumPy 方法保存文件
np.savetxt('np.csv', a, fmt='%.2f', delimiter=',', header='1, 2, 3, 4')使用命令行随时随地读取保存的 CSV。
cat np.vsv使用 text 文本编辑器打开也可以。
更多关于 pandas 信息请参见 pandas 官方文档和 pandas 安装方法.
使用 Matplotlib绘制数组
如果你要对你的数值进行绘图，使用Matplotlib是非常容易的。
a = np.array([2, 1, 5, 7, 4, 6, 8, 14, 10, 9, 18, 20, 22])
import matplotlib.pyplot as plt
%matplotlib inline
plt.plot(a)
plt.show()
x = np.linspace(0, 5, 20)
y = np.linspace(0, 10, 20)
plt.plot(x, y, 'purple') # line
plt.plot(x, y, 'o') # dots
有了 Matplotlib，我们也可以访问大量可视化：
fig = plt.figure()
ax = fig.add_subplot(projection='3d')
X = np.arange(-5, 5, 0.15)
Y = np.arange(-5, 5, 0.15)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)