广播

术语广播是指 NumPy 在算术运算期间处理不同形状的数组的能力。 对数组的算术运算通常在相应的元素上进行。 如果两个阵列具有完全相同的形状，则这些操作被无缝执行。

>>>import numpy as np 
>>>a = np.array([1,2,3,4]) 
>>>b = np.array([10,20,30,40]) 
>>>c = a * b 
>>>c
array([ 10,  40,  90, 160])

如果两个数组的维数不相同，则元素到元素的操作是不可能的。 然而，在 NumPy 中仍然可以对形状不相似的数组进行操作，因为它拥有广播功能。 较小的数组会广播到较大数组的大小，以便使它们的形状可兼容。
如果满足以下规则，可以进行广播：

  1. ndim较小的数组会在前面追加一个长度为 1 的维度。
  2. 输出数组的每个维度的大小是输入数组该维度大小的最大值。
  3. 如果输入在每个维度中的大小与输出大小匹配，或其值正好为 1，则在计算中可它。
  4. 如果输入的某个维度大小为 1，则该维度中的第一个数据元素将用于该维度的所有计算。

如果上述规则产生有效结果，并且满足以下条件之一，那么数组被称为可广播的。

  1. 数组拥有相同形状。
  2. 数组拥有相同的维数，每个维度拥有相同长度，或者长度为 1。
  3. 数组拥有极少的维度，可以在其前面追加长度为 1 的维度，使上述条件成立。
>>>import numpy as np 
>>>a = np.array([[0.0,0.0,0.0],[10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]]) 
>>>b = np.array([1.0,2.0,3.0])  
>>>a
array([[  0.,   0.,   0.],
       [ 10.,  10.,  10.],
       [ 20.,  20.,  20.],
       [ 30.,  30.,  30.]])

>>>b
array([ 1.,  2.,  3.])

>>>a + b
array([[  1.,   2.,   3.],
       [ 11.,  12.,  13.],
       [ 21.,  22.,  23.],
       [ 31.,  32.,  33.]])

python广播运算符 numpy 广播函数_python广播运算符

迭代

NumPy 包包含一个迭代器对象numpy.nditer。 它是一个有效的多维迭代器对象，可以用于在数组上进行迭代。 数组的每个元素可使用 Python 的标准Iterator接口来访问。

1.使用arange()函数创建一个 3X4 数组，并使用nditer对它进行迭代。

>>>import numpy as np
>>>a = np.arange(0,60,5) 
>>>a = a.reshape(3,4)  
>>>a
 array([[ 0,  5, 10, 15],
       [20, 25, 30, 35],
       [40, 45, 50, 55]])
 
>>>for x in np.nditer(a):  
    	print (x),
0 5 10 15 20 25 30 35 40 45 50 55

2.迭代的顺序匹配数组的内容布局，而不考虑特定的排序。 这可以通过迭代上述数组的转置来看到。

>>>import numpy as np 
>>>a = np.arange(0,60,5) 
>>>a = a.reshape(3,4)  
>>>a
array([[ 0,  5, 10, 15],
       [20, 25, 30, 35],
       [40, 45, 50, 55]])
       
>>>b = a.T 
>>>b
 array([[ 0, 20, 40],
       [ 5, 25, 45],
       [10, 30, 50],
       [15, 35, 55]])

>>>for x in np.nditer(b):  
    	print (x),
0 5 10 15 20 25 30 35 40 45 50 55

迭代顺序

如果相同元素使用 F 风格顺序存储，则迭代器选择以更有效的方式对数组进行迭代。

>>>import numpy as np 
>>>a = np.arange(0,60,5) 
>>>a = a.reshape(3,4)  
>>>a
array([[ 0,  5, 10, 15],
       [20, 25, 30, 35],
       [40, 45, 50, 55]])
       
>>>b = a.T 
>>>b
 array([[ 0, 20, 40],
       [ 5, 25, 45],
       [10, 30, 50],
       [15, 35, 55]])

>>>c = b.copy(order='C')  
>>>print c 
array([[ 0, 20, 40],
       [ 5, 25, 45],
       [10, 30, 50],
       [15, 35, 55]])

>>>for x in np.nditer(c):  
    	print (x),  
0 20 40 5 25 45 10 30 50 15 35 55

>>>c = b.copy(order='F')  
>>>c
array([[ 0, 20, 40],
       [ 5, 25, 45],
       [10, 30, 50],
       [15, 35, 55]])

>>>for x in np.nditer(c):  
   		print (x),
0 5 10 15 20 25 30 35 40 45 50 55

可以通过显式提醒，来强制nditer对象使用某种顺序：

>>>import numpy as np 
>>>a = np.arange(0,60,5) 
>>>a = a.reshape(3,4)  
>>>a
array([[ 0,  5, 10, 15],
       [20, 25, 30, 35],
       [40, 45, 50, 55]])

>>>for x in np.nditer(a, order =  'C'):  
   		print (x),  
0 5 10 15 20 25 30 35 40 45 50 55

>>>for x in np.nditer(a, order =  'F'):  
    	print (x),
0 20 40 5 25 45 10 30 50 15 35 55

修改数组的值

nditer对象有另一个可选参数op_flags。 其默认值为只读，但可以设置为读写或只写模式。 这将允许使用此迭代器修改数组元素。

>>>import numpy as np
>>>a = np.arange(0,60,5) 
>>>a = a.reshape(3,4)  
>>>a
array([[ 0,  5, 10, 15],
       [20, 25, 30, 35],
       [40, 45, 50, 55]])

>>>for x in np.nditer(a, op_flags=['readwrite']): 
   			x[...]=2*x 
>>>a
array([[  0,  10,  20,  30],
       [ 40,  50,  60,  70],
       [ 80,  90, 100, 110]])

外部循环

nditer类的构造器拥有flags参数，它可以接受下列值：

序号

参数及描述

1

c_index 可以跟踪 C 顺序的索引

2

f_index 可以跟踪 Fortran 顺序的索引

3

multi-index 每次迭代可以跟踪一种索引类型

4

external_loop 给出的值是具有多个值的一维数组，而不是零维数组

迭代器遍历对应于每列的一维数组。

>>>import numpy as np 
>>>a = np.arange(0,60,5) 
>>>a = a.reshape(3,4)  
>>>a
array([[ 0,  5, 10, 15],
       [20, 25, 30, 35],
       [40, 45, 50, 55]])

>>>for x in np.nditer(a, flags =  ['external_loop'], order =  'F'):  
    		print (x),
array([ 0, 20, 40]),
array([ 5, 25, 45]),
array([10, 30, 50]),
array([15, 35, 55]),

广播迭代

如果两个数组是可广播的，nditer组合对象能够同时迭代它们。 假设数组a具有维度 3X4，并且存在维度为 1X4 的另一个数组b，则使用以下类型的迭代器(数组b被广播到a的大小)。

>>>import numpy as np 
>>>a = np.arange(0,60,5) 
>>>a = a.reshape(3,4)  
>>>a
array([[ 0,  5, 10, 15],
       [20, 25, 30, 35],
       [40, 45, 50, 55]])

>>>b = np.array([1,  2,  3,  4], dtype =  int)  
>>>b 
array([1, 2, 3, 4])

>>>for x,y in np.nditer([a,b]):  
    	print ( "%d:%d"  %  (x,y)),
0:1 5:2 10:3 15:4 20:1 25:2 30:3 35:4 40:1 45:2 50:3 55:4

字节交换

我们已经知道，存储在计算机内存中的数据取决于 CPU 使用的架构。 它可以是小端(最小有效位存储在最小地址中)或大端(最小有效字节存储在最大地址中)。

numpy.ndarray.byteswap()函数在两个表示：大端和小端之间切换。

>>>import numpy as np 
>>>a = np.array([1,  256,  8755], dtype = np.int16)  
>>>a
array([   1,  256, 8755], dtype=int16)
 
>>>map(hex,a)  
['0x1', '0x100', '0x2233']

# byteswap() 函数通过传入 true 来原地交换 
>>>a.byteswap(True)  
array([  256,     1, 13090], dtype=int16)

# 我们可以看到字节已经交换了
>>>map(hex,a)  
['0x100', '0x1', '0x3322']