NumPy

ndarray 数组在内存中是连续内存块。有两种策略来组织多维数据：一种是 column-major order（Fortran 和 Matlab 采用这种策略），另一种是 row-major order（C 语言中采用这种策略）。如图 1 （摘自 Guide to NumPy, 2.3.1 Contiguous Memory Layout）所示。

ndarray 既支持 C 风格的内存布局，也支持 Fortran 风格的内存布局。 默认为 C 风格，进行转置操作后变为 Fortran 风格的内存布局。

>>> x = np.array([[1, 2, 3], [4, 5, 6]])
>>> x.flags
  C_CONTIGUOUS : True           # 表明x使用的是C风格的内存布局
  F_CONTIGUOUS : False
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  UPDATEIFCOPY : False
>>> y = x.transpose()
>>> y.flags
  C_CONTIGUOUS : False
  F_CONTIGUOUS : True           # 表明y使用的是Fortran风格的内存布局
  OWNDATA : False
  WRITEABLE : True
  ALIGNED : True
  UPDATEIFCOPY : False

对于一维数组，显然既是 C 风格，又是 Fortran 风格的内存布局。

>>> x = np.array([0, 1, 2])     # 一维数组，显然既是C风格，又是Fortran风格的内存布局
>>> x.flags
  C_CONTIGUOUS : True
  F_CONTIGUOUS : True
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  UPDATEIFCOPY : False

假设“1.txt”内容如下。

$ cat 1.txt
0, 1, 2
3, 4, 5

使用 loadtxt 可以把文本文件中的数据加载为 ndarray。如：

>>> import numpy as np
>>> x = np.loadtxt("1.txt", delimiter=",")       # 指定分隔符为逗号，默认使用空格为分隔符
>>> x
array([[ 0.,  1.,  2.],
       [ 3.,  4.,  5.]])

多维数组有多个轴，所以它的下标需要用多个值来表示，NumPy 中采用组元(tuple)表示数组的下标，也就是用逗号分开多个轴的索引。请看下面实例：

>>> import numpy as np
>>> x = np.array([[ 0,  1,  2,  3,  4,  5],
...               [10, 11, 12, 13, 14, 15],
...               [20, 21, 22, 23, 24, 25],
...               [30, 31, 32, 33, 34, 35],
...               [40, 41, 42, 43, 44, 45],
...               [50, 51, 52, 53, 54, 55]])
>>>
>>> x[0]
array([0, 1, 2, 3, 4, 5])
>>> x[1]
array([10, 11, 12, 13, 14, 15])
>>> x[1, 4]                      # 逗号分开。逗号前是0轴索引，逗号后是1轴索引。
14
>>> x[0, 2:5]                    # 逗号分开。逗号前是0轴索引，逗号后是1轴索引。
array([2, 3, 4])
>>> x[1, 2:5]                    # 逗号分开。逗号前是0轴索引，逗号后是1轴索引。
array([12, 13, 14])
>>> x[:, 2]
array([ 2, 12, 22, 32, 42, 52])
>>> x[1:4, 2:6]                  # 逗号分开。逗号前是0轴索引，逗号后是1轴索引。
array([[12, 13, 14, 15],
       [22, 23, 24, 25],
       [32, 33, 34, 35]])
>>> x[1:, 2:6]                   # 逗号分开。逗号前是0轴索引，逗号后是1轴索引。
array([[12, 13, 14, 15],
       [22, 23, 24, 25],
       [32, 33, 34, 35],
       [42, 43, 44, 45],
       [52, 53, 54, 55]])

下面是设置子多维数组元素为同一个数字的例子：

>>> x[1:4, 2:6] = [[100, 100, 100, 100], [100, 100, 100, 100], [100, 100, 100, 100]]
>>> x[1:4, 2:6]
array([[100, 100, 100, 100],
       [100, 100, 100, 100],
       [100, 100, 100, 100]])

当然没必要像上面这么繁琐，使用“Broadcast”（后文有介绍）可以更加简单：

>>> x[1:4, 2:6] = 100                    # 发生Broadcast
>>> x[1:4, 2:6]
array([[100, 100, 100, 100],
       [100, 100, 100, 100],
       [100, 100, 100, 100]])
>>> x[1:4, 2:6] = [100, 100, 100, 100]   # 发生Broadcast
>>> x[1:4, 2:6]
array([[100, 100, 100, 100],
       [100, 100, 100, 100],
       [100, 100, 100, 100]])
>>> x[1:4, 2:6] = [1, 2, 3, 4]           # 发生Broadcast
>>> x[1:4, 2:6]
array([[1, 2, 3, 4],
       [1, 2, 3, 4],
       [1, 2, 3, 4]])

可以使用“整数序列”对数组元素进行存取，这时将使用整数序列中的每个元素作为下标，整数序列可以是 Python 中的列表或者 NumPy 中的数组。 使用整数序列作为下标获得的数组不和原始数组共享数据空间。 例如：

>>> import numpy as np
>>> x = np.array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
>>> y = x[[0, 2, 3]]                    # 使用整数序列 [0, 2, 3] 对数组元素进行存取，相当于以序列中每个元素作为下标进行索引。
>>> y
array([9, 7, 6])
>>> y[0] = 1111                         # 使用整数序列作为下标获得的数组y和原数组x不共享空间。修改y，不会影响到x。
>>> y
array([1111,    7,    6])
>>> x
array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])

下面是多维数组中，使用整数序列索引的例子：

>>> import numpy as np
>>> x = np.array([[ 0,  1,  2,  3,  4,  5],
...               [10, 11, 12, 13, 14, 15],
...               [20, 21, 22, 23, 24, 25],
...               [30, 31, 32, 33, 34, 35],
...               [40, 41, 42, 43, 44, 45],
...               [50, 51, 52, 53, 54, 55]])
>>>
>>> x[2, [1,2,3,5]]           # 第0轴是一个数，第1轴是整数序列 [1,2,3,5]
array([21, 22, 23, 25])
>>> x[2:, [1,2,3,5]]          # 第0轴是一个范围，第1轴是整数序列 [1,2,3,5]
array([[21, 22, 23, 25],
       [31, 32, 33, 35],
       [41, 42, 43, 45],
       [51, 52, 53, 55]])

当使用布尔数组 b 作为下标存取数组 x 中的元素时，将收集数组 x 中所有在数组 b 中对应下标为 True 的元素。 使用布尔数组作为下标获得的数组不和原始数组共享数据空间。 注意这种方式只对应于 NumPy 中的布尔数组，不能使用 Python 中的布尔列表。

>>> import numpy as np
>>> x = np.array([4, 3, 2, 1, 0])
>>> x[np.array([True, False, False, True])]    # 使用布尔数组 np.array([True, False, False, True]) 作为索引，收集数组x中对应下标为True的元素
array([4, 1])
>>> x[[True, False, True, False, False]]       # 如果使用布尔列表 [True, False, True, False, False] 作为索引，则把True当作1, False当作0，按照整数序列方式获取x中的元素
array([3, 4, 3, 4, 4])

NumPy 布尔数组一般不是手工产生，而是使用布尔运算的 Universal Function 函数产生。如：

>>> x = np.random.rand(10)            # 产生长度为10，元素值在(0,1)区间内的随机数的数组
>>> x
array([ 0.31405475,  0.25280231,  0.08440324,  0.27874072,  0.81103738,
        0.19872166,  0.62412707,  0.62278573,  0.94702961,  0.18089782])
>>> x > 0.5                           # > 是Universal Function函数，返回布尔数组
array([False, False, False, False,  True, False,  True,  True,  True, False], dtype=bool)
>>> x[x > 0.5]                        # 使用x>0.5返回的布尔数组收集x中的元素，因此得到的结果是x中所有大于0.5的元素的数组
array([ 0.81103738,  0.62412707,  0.62278573,  0.94702961])

下面是 reshape 的使用实例：

>>> import numpy as np
>>> x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
>>> x.reshape(2, 4)
array([[1, 2, 3, 4],
       [5, 6, 7, 8]])
>>> x.reshape(4, 2)
array([[1, 2],
       [3, 4],
       [5, 6],
       [7, 8]])
>>> x.reshape(2, 2, 2)
array([[[1, 2],
        [3, 4]],
       [[5, 6],
        [7, 8]]])