一、NumPy 是什么

NumPy是Python中科学计算的基础包。它是一个Python库，提供多维数组对象，各种派生对象（如掩码数组和矩阵），以及用于数组快速操作的各种API，有包括数学、逻辑、形状操作、排序、选择、输入输出、离散傅立叶变换、基本线性代数，基本统计运算和随机模拟等等。

NumPy包的核心是 ndarray 对象。它封装了python原生的同数据类型的 n 维数组，为了保证其性能优良，其中有许多操作都是代码在本地进行编译后执行的。

NumPy数组 和 原生Python Array（数组）之间有几个重要的区别：

  • NumPy 数组在创建时具有固定的大小，与Python的原生数组对象（可以动态增长）不同。更改ndarray的大小将创建一个新数组并删除原来的数组。
  • NumPy 数组中的元素都需要具有相同的数据类型，因此在内存中的大小相同。 例外情况：Python的原生数组里包含了NumPy的对象的时候，这种情况下就允许不同大小元素的数组。
  • NumPy 数组有助于对大量数据进行高级数学和其他类型的操作。通常，这些操作的执行效率更高，比使用Python原生数组的代码更少。
  • 越来越多的基于Python的科学和数学软件包使用NumPy数组; 虽然这些工具通常都支持Python的原生数组作为参数，但它们在处理之前会还是会将输入的数组转换为NumPy的数组，而且也通常输出为NumPy数组。换句话说，为了高效地使用当今科学/数学基于Python的工具（大部分的科学计算工具），你只知道如何使用Python的原生数组类型是不够的 – 还需要知道如何使用 NumPy 数组。

矢量化描述了代码中没有任何显式的循环，索引等 – 这些当然是预编译的C代码中“幕后”优化的结果。矢量化代码有许多优点，其中包括：

  • 矢量化代码更简洁，更易于阅读
  • 更少的代码行通常意味着更少的错误
  • 代码更接近于标准的数学符号（通常，更容易正确编码数学结构）
  • 矢量化导致产生更多 “Pythonic” 代码。如果没有矢量化，我们的代码就会被低效且难以阅读的for循环所困扰。

广播是用于描述操作的隐式逐元素行为的术语; 一般来说，在NumPy中，所有操作，不仅仅是算术运算，而是逻辑，位，功能等，都以这种隐式的逐元素方式表现，即它们进行广播。此外，在上面的例子中，a并且b可以是相同形状的多维数组，或者标量和数组，或者甚至是具有不同形状的两个数组，条件是较小的数组可以“扩展”到更大的形状。结果广播明确无误的方式。

NumPy完全支持面向对象的方法，我们再夸奖一次 ndarray 。 我们知道 ndarray 是一个类，拥有许多方法和属性。它的许多方法都由最外层的NumPy命名空间中的函数镜像，允许程序员在他们喜欢的范例中进行编码。这种灵活性使NumPy数组方言和NumPy ndarray 类成为在Python中使用的多维数据交换的 首选 对象。

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。ndarray 对象是用于存放同类型元素的多维数组。ndarray 中的每个元素在内存中都有相同存储大小的区域。

ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。ndarray 数组可以基于 0 – n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。

二、数据类型

NumPy支持比Python更多种类的数字类型。这里显示了哪些可用，以及如何修改数组的数据类型。

支持的原始类型与 C 中的原始类型紧密相关：

Numpy 的类型 C 的类型 描述
np.bool bool 存储为字节的布尔值（True或False）
np.byte signed char 平台定义
np.ubyte unsigned char 平台定义
np.short short 平台定义
np.ushort unsigned short 平台定义
np.intc int 平台定义
np.uintc unsigned int 平台定义
np.int_ long 平台定义
np.uint unsigned long 平台定义
np.longlong long long 平台定义
np.ulonglong unsigned long long 平台定义
np.half / np.float16   半精度浮点数：符号位，5位指数，10位尾数
np.single float 平台定义的单精度浮点数：通常为符号位，8位指数，23位尾数
np.double double 平台定义的双精度浮点数：通常为符号位，11位指数，52位尾数。
np.longdouble long double 平台定义的扩展精度浮点数
np.csingle float complex 复数，由两个单精度浮点数（实部和虚部）表示
np.cdouble double complex 复数，由两个双精度浮点数（实部和虚部）表示。
np.clongdouble long double complex 复数，由两个扩展精度浮点数（实部和虚部）表示。

由于其中许多都具有依赖于平台的定义，因此提供了一组固定大小的别名：

Numpy 的类型 C 的类型 描述
np.int8 int8_t 字节（-128到127）
np.int16 int16_t 整数（-32768至32767）
np.int32 int32_t 整数（-2147483648至2147483647）
np.int64 int64_t 整数（-9223372036854775808至9223372036854775807）
np.uint8 uint8_t 无符号整数（0到255）
np.uint16 uint16_t 无符号整数（0到65535）
np.uint32 uint32_t 无符号整数（0到4294967295）
np.uint64 uint64_t 无符号整数（0到18446744073709551615）
np.intp intptr_t 用于索引的整数，通常与索引相同 ssize_t
np.uintp uintptr_t 整数大到足以容纳指针
np.float32 float  
np.float64 / np.float_ double 请注意，这与内置python float的精度相匹配。
np.complex64 float complex 复数，由两个32位浮点数（实数和虚数组件）表示
np.complex128 / np.complex_ double complex 请注意，这与内置python 复合体的精度相匹配。

NumPy数值类型是dtype（数据类型）对象的实例，每个对象都具有独特的特征。使用后导入NumPy

三、数组

创建数组有5种常规机制：

  1. 从其他Python结构（例如，列表，元组）转换
  2. numpy原生数组的创建（例如，arange、ones、zeros等）
  3. 从磁盘读取数组，无论是标准格式还是自定义格式
  4. 通过使用字符串或缓冲区从原始字节创建数组
  5. 使用特殊库函数（例如，random）

本节不包括复制，连接或以其他方式扩展或改变现有数组的方法。它也不会涵盖创建对象数组或结构化数组。这些都包含在他们自己的章节中。

通常，在Python中排列成array-like结构的数值数据可以通过使用array()函数转换为数组。最明显的例子是列表和元组。有关其使用的详细信息，请参阅array()的文档。一些对象可能支持数组协议并允许以这种方式转换为数组。找出对象是否可以使用array()转换为一个数组numpy 数组的简单方法很简单，只要交互式试一下，看看它是否工作！（Python方式）。

例子：

  1. import numpy as np
  2. x = np.array([2,3,1,0])
  3. x = np.array([2, 3, 1, 0])
  4. x = np.array([[1,2.0],[0,0],(1+1j,3.)]) # note mix of tuple and lists,
  5.     and types
  6. x = np.array([[ 1.+0.j, 2.+0.j], [ 0.+0.j, 0.+0.j], [ 1.+1.j, 3.+0.j]])

Numpy内置了从头开始创建数组的函数：

zeros(shape)将创建一个用指定形状用0填充的数组。默认的dtype是float64。

  1. import numpy as np
  2. np.zeros((2, 3)) array([[ 0., 0., 0.], [ 0., 0., 0.]])

ones(shape)将创建一个用1个值填充的数组。它在所有其他方面与zeros相同。

arange()将创建具有有规律递增值的数组。检查文档字符串以获取有关可以使用的各种方式的完整信息。这里给出几个例子：

  1. import numpy as np
  2. np.arange(10)
  3. array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
  4. np.arange(2, 10, dtype=np.float)
  5. array([ 2., 3., 4., 5., 6., 7., 8., 9.])
  6. np.arange(2, 3, 0.1)
  7. array([ 2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])

请注意，关于用户应该注意的最后用法在arange文档字符串中有一些细微的描述。

linspace() 将创建具有指定数量元素的数组，并在指定的开始值和结束值之间平均间隔。例如：

  1. import numpy as np
  2. np.linspace(1., 4., 6)
  3. array([ 1. ,  1.6,  2.2,  2.8,  3.4,  4. ])

这个创建函数的优点是可以保证元素的数量以及开始和结束点，对于任意的开始，停止和步骤值，arange()通常不会这样做。

indices() 将创建一组数组（堆积为一个更高维的数组），每个维度一个，每个维度表示该维度中的变化。一个例子说明比口头描述要好得多：

  1. import numpy as np
  2. np.indices((3,3))
  3. array([[[0, 0, 0], [1, 1, 1], [2, 2, 2]], [[0, 1, 2], [0, 1, 2], [0, 1, 2]]])

这对于评估常规网格上多个维度的功能特别有用。

一维的数组可以进行索引、切片和迭代操作的，就像 列表 和其他Python序列类型一样。

  1. >>> a = np.arange(10)**3
  2. >>> a
  3. array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729])
  4. >>> a[2]
  5. 8
  6. >>> a[2:5]
  7. array([ 8, 27, 64])
  8. >>> a[:6:2] = -1000    # equivalent to a[0:6:2] = -1000; from start to position 6, exclusive, set every 2nd element to -1000
  9. >>> a
  10. array([-1000,     1, -1000,    27, -1000,   125,   216,   343,   512,   729])
  11. >>> a[ : :-1]                                 # reversed a
  12. array([  729,   512,   343,   216,   125, -1000,    27, -1000,     1, -1000])
  13. >>> for i in a:
  14. ...     print(i**(1/3.))
  15. ...
  16. nan
  17. 1.0
  18. nan
  19. 3.0
  20. nan
  21. 5.0
  22. 6.0
  23. 7.0
  24. 8.0
  25. 9.0

多维的数组每个轴可以有一个索引。这些索引以逗号​​分隔的元组给出：

  1. >>> def f(x,y):
  2. ...     return 10*x+y
  3. ...
  4. >>> b = np.fromfunction(f,(5,4),dtype=int)
  5. >>> b
  6. array([[ 0,  1,  2,  3],
  7.        [10, 11, 12, 13],
  8.        [20, 21, 22, 23],
  9.        [30, 31, 32, 33],
  10.        [40, 41, 42, 43]])
  11. >>> b[2,3]
  12. 23
  13. >>> b[0:5, 1]                       # each row in the second column of b
  14. array([ 1, 11, 21, 31, 41])
  15. >>> b[ : ,1]                        # equivalent to the previous example
  16. array([ 1, 11, 21, 31, 41])
  17. >>> b[1:3, : ]                      # each column in the second and third row of b
  18. array([[10, 11, 12, 13],
  19.        [20, 21, 22, 23]])

当提供的索引少于轴的数量时，缺失的索引被认为是完整的切片:

  1. >>> b[-1]                                  # the last row. Equivalent to b[-1,:]
  2. array([40, 41, 42, 43])

b[i] 方括号中的表达式 i 被视为后面紧跟着 : 的多个实例，用于表示剩余轴。NumPy也允许你使用三个点写为 b[i,...]。

三个点（ ... ）表示产生完整索引元组所需的冒号。例如，如果 x 是rank为5的数组（即，它具有5个轴），则：

  • x[1,2,...] 相当于 x[1,2,:,:,:]，
  • x[...,3] 等效于 x[:,:,:,:,3]
  • x[4,...,5,:] 等效于 x[4,:,:,5,:]。
  1. >>> c = np.array( [[[  0,  1,  2],               # a 3D array (two stacked 2D arrays)
  2. ...                 [ 10, 12, 13]],
  3. ...                [[100,101,102],
  4. ...                 [110,112,113]]])
  5. >>> c.shape
  6. (2, 2, 3)
  7. >>> c[1,...]                                   # same as c[1,:,:] or c[1]
  8. array([[100, 101, 102],
  9.        [110, 112, 113]])
  10. >>> c[...,2]                                   # same as c[:,:,2]
  11. array([[  2,  13],
  12.        [102, 113]])

对多维数组进行 迭代（Iterating） 是相对于第一个轴完成的：

  1. >>> for row in b:
  2. ...     print(row)
  3. ...
  4. [0 1 2 3]
  5. [10 11 12 13]
  6. [20 21 22 23]
  7. [30 31 32 33]
  8. [40 41 42 43]

但是，如果想要对数组中的每个元素执行操作，可以使用flat属性，该属性是数组的所有元素的迭代器：

  1. >>> for element in b.flat:
  2. ...     print(element)
  3. ...
  4. 0
  5. 1
  6. 2
  7. 3
  8. 10
  9. 11
  10. 12
  11. 13
  12. 20
  13. 21
  14. 22
  15. 23
  16. 30
  17. 31
  18. 32
  19. 33
  20. 40
  21. 41
  22. 42
  23. 43

一个数组的形状是由每个轴的元素数量决定的：

  1. >>> a = np.floor(10*np.random.random((3,4)))
  2. >>> a
  3. array([[ 2.,  8.,  0.,  6.],
  4.        [ 4.,  5.,  1.,  1.],
  5.        [ 8.,  9.,  3.,  6.]])
  6. >>> a.shape
  7. (3, 4)

可以使用各种命令更改数组的形状。请注意，以下三个命令都返回一个修改后的数组，但不会更改原始数组：

  1. >>> a.ravel()  # returns the array, flattened
  2. array([ 2.,  8.,  0.,  6.,  4.,  5.,  1.,  1.,  8.,  9.,  3.,  6.])
  3. >>> a.reshape(6,2)  # returns the array with a modified shape
  4. array([[ 2.,  8.],
  5.        [ 0.,  6.],
  6.        [ 4.,  5.],
  7.        [ 1.,  1.],
  8.        [ 8.,  9.],
  9.        [ 3.,  6.]])
  10. >>> a.T  # returns the array, transposed
  11. array([[ 2.,  4.,  8.],
  12.        [ 8.,  5.,  9.],
  13.        [ 0.,  1.,  3.],
  14.        [ 6.,  1.,  6.]])
  15. >>> a.T.shape
  16. (4, 3)
  17. >>> a.shape
  18. (3, 4)

由 ravel() 产生的数组中元素的顺序通常是“C风格”，也就是说，最右边的索引“变化最快”，因此[0,0]之后的元素是[0,1] 。如果将数组重新整形为其他形状，则该数组将被视为“C风格”。NumPy通常创建按此顺序存储的数组，因此 ravel() 通常不需要复制其参数，但如果数组是通过获取另一个数组的切片或使用不常见的选项创建的，则可能需要复制它。还可以使用可选参数指示函数 ravel() 和 reshape()，以使用FORTRAN样式的数组，其中最左边的索引变化最快。

四、广播

广播允许通用功能以有意义的方式处理不具有完全相同形状的输入。

广播的第一个规则是，如果所有输入数组不具有相同数量的维度，则将“1”重复地预先添加到较小数组的形状，直到所有数组具有相同数量的维度。

广播的第二个规则确保沿特定维度的大小为1的数组表现为具有沿该维度具有最大形状的数组的大小。假定数组元素的值沿着“广播”数组的那个维度是相同的。

应用广播规则后，所有数组的大小必须匹配。更多细节可以在广播中找到。

NumPy提供比常规Python序列更多的索引功能。除了通过整数和切片进行索引之外，正如我们之前看到的，数组可以由整数数组和布尔数组索引。

  1. >>> a = np.arange(12)**2                       # the first 12 square numbers
  2. >>> i = np.array( [ 1,1,3,8,5 ] )              # an array of indices
  3. >>> a[i]                                       # the elements of a at the positions i
  4. array([ 1,  1,  9, 64, 25])
  5. >>>
  6. >>> j = np.array( [ [ 3, 4], [ 9, 7 ] ] )      # a bidimensional array of indices
  7. >>> a[j]                                       # the same shape as j
  8. array([[ 9, 16],
  9.        [81, 49]])

当索引数组a是多维的时，单个索引数组指的是第一个维度a。以下示例通过使用调色板将标签图像转换为彩色图像来显示此行为。

  1. >>> palette = np.array( [ [0,0,0],                # black
  2. ...                       [255,0,0],              # red
  3. ...                       [0,255,0],              # green
  4. ...                       [0,0,255],              # blue
  5. ...                       [255,255,255] ] )       # white
  6. >>> image = np.array( [ [ 0, 1, 2, 0 ],           # each value corresponds to a color in the palette
  7. ...                     [ 0, 3, 4, 0 ]  ] )
  8. >>> palette[image]                            # the (2,4,3) color image
  9. array([[[  0,   0,   0],
  10.         [255,   0,   0],
  11.         [  0, 255,   0],
  12.         [  0,   0,   0]],
  13.        [[  0,   0,   0],
  14.         [  0,   0, 255],
  15.         [255, 255, 255],
  16.         [  0,   0,   0]]])

我们还可以为多个维度提供索引。每个维度的索引数组必须具有相同的形状。

  1. >>> a = np.arange(12).reshape(3,4)
  2. >>> a
  3. array([[ 0,  1,  2,  3],
  4.        [ 4,  5,  6,  7],
  5.        [ 8,  9, 10, 11]])
  6. >>> i = np.array( [ [0,1],                        # indices for the first dim of a
  7. ...                 [1,2] ] )
  8. >>> j = np.array( [ [2,1],                        # indices for the second dim
  9. ...                 [3,3] ] )
  10. >>>
  11. >>> a[i,j]                                     # i and j must have equal shape
  12. array([[ 2,  5],
  13.        [ 7, 11]])
  14. >>>
  15. >>> a[i,2]
  16. array([[ 2,  6],
  17.        [ 6, 10]])
  18. >>>
  19. >>> a[:,j]                                     # i.e., a[ : , j]
  20. array([[[ 2,  1],
  21.         [ 3,  3]],
  22.        [[ 6,  5],
  23.         [ 7,  7]],
  24.        [[10,  9],
  25.         [11, 11]]])

当然，我们可以按顺序（比如列表）放入i，j然后使用列表进行索引。

  1. >>> l = [i,j]
  2. >>> a[l]                                       # equivalent to a[i,j]
  3. array([[ 2,  5],
  4.        [ 7, 11]])

但是，我们不能通过放入i和j放入数组来实现这一点，因为这个数组将被解释为索引a的第一个维度。

  1. >>> s = np.array( [i,j] )
  2. >>> a[s]                                       # not what we want
  3. Traceback (most recent call last):
  4.   File "<stdin>", line 1, in ?
  5. IndexError: index (3) out of range (0<=index<=2) in dimension 0
  6. >>>
  7. >>> a[tuple(s)]                                # same as a[i,j]
  8. array([[ 2,  5],
  9.        [ 7, 11]])

使用数组索引的另一个常见用法是搜索与时间相关的系列的最大值：

  1. >>> time = np.linspace(20, 145, 5)                 # time scale
  2. >>> data = np.sin(np.arange(20)).reshape(5,4)      # 4 time-dependent series
  3. >>> time
  4. array([  20.  ,   51.25,   82.5 ,  113.75,  145.  ])
  5. >>> data
  6. array([[ 0.        ,  0.84147098,  0.90929743,  0.14112001],
  7.        [-0.7568025 , -0.95892427, -0.2794155 ,  0.6569866 ],
  8.        [ 0.98935825,  0.41211849, -0.54402111, -0.99999021],
  9.        [-0.53657292,  0.42016704,  0.99060736,  0.65028784],
  10.        [-0.28790332, -0.96139749, -0.75098725,  0.14987721]])
  11. >>>
  12. >>> ind = data.argmax(axis=0)                  # index of the maxima for each series
  13. >>> ind
  14. array([2, 0, 3, 1])
  15. >>>
  16. >>> time_max = time[ind]                       # times corresponding to the maxima
  17. >>>
  18. >>> data_max = data[ind, range(data.shape[1])] # => data[ind[0],0], data[ind[1],1]...
  19. >>>
  20. >>> time_max
  21. array([  82.5 ,   20.  ,  113.75,   51.25])
  22. >>> data_max
  23. array([ 0.98935825,  0.84147098,  0.99060736,  0.6569866 ])
  24. >>>
  25. >>> np.all(data_max == data.max(axis=0))
  26. True

您还可以使用数组索引作为分配给的目标：

  1. >>> a = np.arange(5)
  2. >>> a
  3. array([0, 1, 2, 3, 4])
  4. >>> a[[1,3,4]] = 0
  5. >>> a
  6. array([0, 0, 2, 0, 0])
版权声明：本文为文明老人原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/wmlr/p/16166972.html