NumPy基础（一）(新手速来！)

2021-08-11 11:09:08 浏览数 (1)

NumPy 是一个为 Python 提供高性能向量、矩阵和高维数据结构的科学计算库。它通过 C 和 Fortran 实现，因此用向量和矩阵建立方程并实现数值计算有非常好的性能。NumPy 基本上是所有使用 Python 进行数值计算的框架和包的基础，例如 TensorFlow 和 PyTorch，构建机器学习模型最基础的内容就是学会使用 NumPy 搭建计算过程。

基础知识

NumPy 主要的运算对象为同质的多维数组，即由同一类型元素（一般是数字）组成的表格，且所有元素通过正整数元组进行索引。在 NumPy 中，维度 (dimension) 也被称之为轴线（axes)。

比如坐标点 [1, 2, 1] 有一个轴线。这个轴上有 3 个点，所以我们说它的长度（length）为 3。而如下数组（array）有 2 个轴线，长度同样为 3。

代码语言：javascript复制
[[ 1., 0., 0.],
[ 0., 1., 2.]]

NumPy 的数组类（array class）叫做 ndarray，同时我们也常称其为数组（array）。注意 numpy.array 和标准 Python 库中的类 array.array 是不同的。标准 Python 库中的类 array.array 只处理一维的数组，提供少量的功能。ndarray 还具有如下很多重要的属性：

代码语言：javascript复制
>>> b = np.array([[1,2,3],[4,5,6]])
>>> b.shape
(2, 3)
  • ndarray.ndim：显示数组的轴线数量（或维度）。
  • ndarray.shape：显示在每个维度里数组的大小。如 n 行 m 列的矩阵，它的 shape 就是（n,m)。
  • ndarray.dtype：显示数组元素的类型。Python 中的标准 type 函数同样可以用于显示数组类型，NumPy 有它自己的类型如：numpy.int32, numpy.int16, 和 numpy.float64，其中「int」和「float」代表数据的种类是整数还是浮点数，「32」和「16」代表这个数组的字节数（存储大小）。
  • ndarray.itemsize：数组中每个元素的字节存储大小。例如元素类型为 float64 的数组，其 itemsize 为 8（=64/8）。
代码语言：javascript复制
>>> import numpy as np
>>> a = np.arange(15).reshape(3, 5)
>>> a
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
>>> a.shape
(3, 5)
>>> a.ndim
2
>>> a.dtype.name
 int64
>>> a.itemsize
8
>>> a.size
15
>>> type(a)
<type  numpy.ndarray >
>>> b = np.array([6, 7, 8])
>>> b
array([6, 7, 8])
>>> type(b)
<type  numpy.ndarray >

创建数组

NumPy 有很多种创建数组的方法。比如，你可以用 Python 的列表（list）来创建 NumPy 数组，其中生成的数组元素类型与原序列相同。

代码语言：javascript复制
>>> import numpy as np
>>> a = np.array([2,3,4])
>>> a
array([2, 3, 4])
>>> a.dtype
dtype( int64 )
>>> b = np.array([1.2, 3.5, 5.1])
>>> b.dtype
dtype( float64 )

一个常见的误差（error）在于调用 array 时使用了多个数值参数，而正确的方法应该是用「[]」来定义一个列表的数值而作为数组的一个参数。

代码语言：javascript复制
>>> a = np.array(1,2,3,4)    # WRONG
>>> a = np.array([1,2,3,4])  # RIGHT

array 将序列中的序列转换为二维的数组，序列中的序列中的序列转换为三维数组，以此类推。

代码语言：javascript复制
>>> b = np.array([(1.5,2,3), (4,5,6)])
>>> b
array([[ 1.5,  2. ,  3. ],
       [ 4. ,  5. ,  6. ]])

数组的类型也可以在创建时指定清楚：

代码语言：javascript复制
>>> b = np.array([(1.5,2,3), (4,5,6)])
>>> c = np.array( [ [1,2], [3,4] ], dtype=complex )
>>> c
array([[ 1. 0.j,  2. 0.j],
       [ 3. 0.j,  4. 0.j]])

一般数组的内部元素初始是未知的，但它的大小是已知的。因此，NumPy 提供了一些函数可以创建有初始数值的占位符数组，这样可以减少不必要的数组增长及运算成本。

函数 zeros 可创建一个内部元素全是 0 的数组，函数 ones 可创建一个内部元素全是 1 的数组，函数 empty 可创建一个初始元素为随机数的数组，具体随机量取决于内存状态。默认状态下，创建数组的数据类型（dtype）一般是 float64。

代码语言：javascript复制
>>> np.zeros( (3,4) )
array([[ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.]])
>>> np.ones( (2,3,4), dtype=np.int16 )   # dtype can also be specified
array([[[ 1, 1, 1, 1],
        [ 1, 1, 1, 1],
        [ 1, 1, 1, 1]],
       [[ 1, 1, 1, 1],
        [ 1, 1, 1, 1],
        [ 1, 1, 1, 1]]], dtype=int16)
>>> np.empty( (2,3) )                    # uninitialized, output may vary
array([[  3.73603959e-262,   6.02658058e-154,   6.55490914e-260],
       [  5.30498948e-313,   3.14673309e-307,   1.00000000e 000]])

为了创建数列，NumPy 提供一个与 range 类似的函数来创建数组：arange。

代码语言：javascript复制
>>> np.arange( 10, 30, 5 )
array([10, 15, 20, 25])
>>> np.arange( 0, 2, 0.3 )                 # it accepts float arguments
array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])

当 arange 使用浮点型参数时，因为浮点精度的有限性，arange 不能判断有需要创建的数组多少个元素。在这种情况下，换成 linspace 函数可以更好地确定区间内到底需要产生多少个数组元素。

代码语言：javascript复制
>>> from numpy import pi
>>> np.linspace( 0, 2, 9 )                 # 9 numbers from 0 to 2
array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ,  1.25,  1.5 ,  1.75,  2.  ])
>>> x = np.linspace( 0, 2*pi, 100 )        # useful to evaluate function at lots of points
>>> f = np.sin(x)

array, zeros, zeros_like, ones, ones_like, empty, empty_like, arange, linspace, numpy.random.rand, numpy.random.randn, fromfunction, fromfile （这些函数也可以创建数组，有时间可以尝试解释）

输出数组

当你输出一个数组时，NumPy 显示这个数组的方式和嵌套列表是相似的。但将数组打印到屏幕需要遵守以下布局：

  • 最后一个轴由左至右打印
  • 倒数第二个轴为从上到下打印
  • 其余的轴都是从上到下打印，且每一块之间都通过一个空行分隔

如下所示，一维数组输出为一行、二维为矩阵、三维为矩阵列表。

代码语言：javascript复制
>>> a = np.arange(6)                         # 1d array
>>> print(a)
[0 1 2 3 4 5]
>>>
>>> b = np.arange(12).reshape(4,3)           # 2d array
>>> print(b)
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
>>>
>>> c = np.arange(24).reshape(2,3,4)         # 3d array
>>> print(c)
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]
 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]

上述使用的 reshape 函数可指定数组的行列数，并将所有元素按指定的维度数排列，详细介绍请看后面章节。在数组的打印中，如果一个数组所含元素数太大，NumPy 会自动跳过数组的中间部分，只输出两边。

代码语言：javascript复制
>>> print(np.arange(10000))
[   0    1    2 ..., 9997 9998 9999]
>>>
>>> print(np.arange(10000).reshape(100,100))
[[   0    1    2 ...,   97   98   99]
 [ 100  101  102 ...,  197  198  199]
 [ 200  201  202 ...,  297  298  299]
 ...,
 [9700 9701 9702 ..., 9797 9798 9799]
 [9800 9801 9802 ..., 9897 9898 9899]
 [9900 9901 9902 ..., 9997 9998 9999]]

如果想要 NumPy 输出整个数组，你可以用 set_printoptions 改变输出设置。

代码语言：javascript复制
>>> np.set_printoptions(threshold=np.nan)
编程算法 numpy python

0 人点赞