老手根底

欢送来到 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。

1. np.array()函数

   该函数只需创立一个一个列表，而后将其传递到函数中。同时你能够指定列表中的数据类型。详细信息参见：数组对象

   import numpy as np
   a = np.array([1, 2, 3])

2. 创立一个都是 0 的数组

   np.zeros(2)

3. 创立一个都是 1 的数组

np.ones(2)

4. 创立一个空数组

   empty函数能够创立一个空数组，内容是依据内存状态随机生产的。empty函数相较于 zeros函数的劣势就是速度——确保能够迅速填满后续的每个元素

   np.empty(2)

5. 创立一个序列数组

   np.arange(4)
   np.arange(2,9,2) #第一个元素，第二个元素，步长

6. 创立线性数组

   np.linspace(0,10,num=5)

7. 指定数据类型

   数组默认的数据类型为浮点型（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))

更多信息：索引、切片的信息、nonzero。

通过已有数据创立一个数组

本节涵盖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 办法是对原数组的全拷贝，是一种深拷贝。

更多对于 view 和 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]])"""

更多信息请参阅 transpose 和reshape。

反转矩阵

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)

无关 Matplotlib 更多信息，请查看官网文档。无关装置 Matplotlib 的阐明，查看装置局部。