从一个整数创建numpy数组

Question

我使用numpy从整数输入创建了一个乘法表。我从整数创建了一个列表，并创建了一个整数形状的数组，但看起来我最终会以非numpy的方式做事。有更多的这种做法吗？

TY

def multiplication_table(n): 
    import numpy as np 
    base = list(range(1, n+1)) 
    array_shell = np.zeros(shape=(n,n), dtype=int) 
    array_shell[0] = base 
    for row in range(1,len(base)): 
     array_shell[row][0] = base[row] 
    for row in range(1, len(base)): 
     for idx in range(1, len(base)): 
      array_shell[row][idx] = base[idx]*array_shell[row][0] 
    return (array_shell) 

my_int = 8 
print(multiplication_table(my_int)) 

Answer 1

下面是一个使用NumPy的强大功能broadcasting一个量化的方法 -

def multiplication_table_vectorized(n): 
    base = np.arange(n)+1 
    return base[:,None]*base 

运行测试 -

In [33]: n = 100 

In [34]: np.allclose(multiplication_table(n),multiplication_table_vectorized(n)) 
Out[34]: True 

In [35]: %timeit multiplication_table(n) 
100 loops, best of 3: 10.1 ms per loop 

In [36]: %timeit multiplication_table_vectorized(n) 
10000 loops, best of 3: 58.9 µs per loop 

解释 -

让我们以玩具为例来解释这里的东西。

In [72]: n = 4 # Small n for toy example 

In [73]: base = np.arange(n)+1 # Same as original: "base = list(range(1, n+1))" 

In [74]: base     # Checkback 
Out[74]: array([1, 2, 3, 4]) 

In [75]: base[:,None] # Major thing happening as we extend base to a 2D array 
         # with all elements "pushed" as rows (axis=0) and thus 
         # creating a singleton dimension along columns (axis=1) 
Out[75]: 
array([[1], 
     [2], 
     [3], 
     [4]]) 

In [76]: base[:,None]*base # Broadcasting happens as elementwise multiplications 
           # take place between 2D extended version of 'base' 
           # and original 'base'. This is our desired output. 

           # To visualize a broadcasting : 
           # |---------> 
           # | 
           # | 
           # | 
           # V 

Out[76]: 
array([[ 1, 2, 3, 4], 
     [ 2, 4, 6, 8], 
     [ 3, 6, 9, 12], 
     [ 4, 8, 12, 16]]) 

有关broadcasting更多信息和示例，没有什么比official docs更好。 Broadcasting是可用于NumPy的最佳矢量化工具之一，允许进行这种自动扩展。

Answer 2

一个“numpyonic”方式来处理，这将是一个矩阵乘法（列向量与行向量）：

base = np.arange(my_int) 
array = base.reshape((my_int,1)) * base