Operações bitwise do NumPy

Propagação do NumPy é principalmente aplicada pelo NumPy ao lidar com arrays de diferentes formas durante operações aritméticas. Sob o impacto de certas restrições, arrays menores são "propagados" em arrays maiores para que eles tenham formas compatíveis.
Operações do NumPy são geralmente realizadas em arrays de pares individualmente. No caso mais simples, dois arrays devem ter formas completamente idênticas, conforme exemplo a seguir:

　>>> import numpy as np
　>>> a = np.array([1,　2,　3))
　>>> b = np.array([2,　2,　2))
　>>> a　*　b
　array([　2,　4,　6))

quando o cálculo envolve 2 quando as formas de diferentes arrays são diferentes, o numpy aciona automaticamente o mecanismo de propagação. Por exemplo:

　>>> import numpy as np
　>>> a = np.array([[　0,　0,　0],
　　　　　　　　　　　　[10,10,10],
　　　　　　　　　　　　[20,20,20],
　　　　　　　　　　　　[30,30,30]])
　>>> b = np.array([1,2,3))
　>>> print(a　+　b)
　[[　1　2　3]]
　　[11　12　13]]
　　[21　22　23]]
　　[31　32　33]]

a seguir é uma imagem que mostra como o array b se compatibiliza com o array a através da propagação.

4x3 um array bidimensional com comprimento 3 soma de arrays unidimensionais é equivalente a repetir o array b em duas dimensões 4 reexecução:

　>>> import numpy as np
　>>> a = np.array([[　0,　0,　0],
　　　　　　　　　　　　[10,10,10],
　　　　　　　　　　　　[20,20,20],
　　　　　　　　　　　　[30,30,30]])
　>>> b = np.array([1,2,3))
　>>> bb = np.tile(b,　(4,　1))　#　repete as dimensões de b
　>>> print(a　+　bb)
　[[　1　2　3]]
　　[11　12　13]]
　　[21　22　23]]
　　[31　32　33]]

regras gerais de propagação

ao executar em dois arrays, o NumPy compara suas formas elemento a elemento. Ele começa pelo tamanho final e avança. Dois tamanhos são compatíveis quando

eles são iguais, ou
um dos quais é1

Se essas condições não forem atendidas, será lançada a exceção ValueError: operands could not be broadcast together, indicando que os arrays têm formas incompatíveis. O tamanho do array resultante é ao longo de cada eixo de entrada não1tamanho.

o array não precisa ter o mesmo número de dimensões. Por exemplo, se você tiver256x256x3um array de valores RGB e deseja escalar cada cor do imagem para diferentes valores, pode multiplicar a imagem por um array com3um array unidimensional de um valor. De acordo com as regras de propagação, organizar o tamanho do eixo final desses arrays, indicando que são compatíveis:

　Image　(3d　array):　256　x　256　x　3
　Scale　(1d　array):　3
　Result　(3d　array):　256　x　256　x　3

quando qualquer um dos tamanhos comparados for1ao usar outro tamanho. Em outras palavras, o tamanho1tamanho é esticado ou "copia" para corresponder a outro tamanho. No exemplo a seguir, os arrays A e B têm comprimento1eixos, que se expandem para um tamanho maior durante a operação de propagação:

　A　(4d　array):　8　x　1　x　6　x　1
　B　(3d　array):　7　x　1　x　5
　Result　(4d　array):　8　x　7　x　6　x　5

A seguir estão alguns exemplos:

　A　(2d　array):　5　x　4
　B　(1d　array):　1
　Result　(2d　array):　5　x　4
　A　(2d　array):　5　x　4
　B　(1d　array):　4
　Result　(2d　array):　5　x　4
　A　(3d　array):　15　x　3　x　5
　B　(3d　array):　15　x　1　x　5
　Result　(3d　array):　15　x　3　x　5
　A　(3d　array):　15　x　3　x　5
　B　(2d　array):　3　x　5
　Result　(3d　array):　15　x　3　x　5
　A　(3d　array):　15　x　3　x　5
　B　(2d　array):　3　x　1
　Result　(3d　array):　15　x　3　x　5

A seguir estão exemplos de formas não propagadas:

　A　(1d　array):　3
　B　(1d　array):　4　#última dimensão não correspondente
　A　(2d　array):　2　x　1
　B　(3d　array):　8　x　4　x　3　#última dimensão não correspondente

Um exemplo prático de broadcasting:

　>>> import numpy as np
　>>> x = np.arange(4)
　>>> xx = x.reshape(4,1)
　>>> y = np.ones(5)
　>>> z = np.ones(3,4))
　>>> x.shape
　(4,)
　>>> y.shape
　(5,)
　>>> x　+　y
　ValueError: os operandos não puderam ser broadcasted juntos com as formas (4,) (5,)
　>>> xx.shape
　(4,　1)
　>>> y.shape
　(5,)
　>>> (xx　+　y).shape
　(4,　5)
　>>> xx　+　y
　array([[　1.,　1.,　1.,　1.,　1.,]
　　　　　　　　[　2.,　2.,　2.,　2.,　2.,]
　　　　　　　　[　3.,　3.,　3.,　3.,　3.,]
　　　　　　　　[　4.,　4.,　4.,　4.,　4.]])
　>>> x.shape
　(4,)
　>>> z.shape
　(3,　4)
　>>> (x　+　z).shape
　(3,　4)
　>>> x　+　z
　array([[　1.,　2.,　3.,　4.,]
　　　　　　　　[　1.,　2.,　3.,　4.,]
　　　　　　　　[　1.,　2.,　3.,　4.]])

O broadcasting oferece um método conveniente para obter o produto externo (ou qualquer outra operação externa) de dois arrays. A seguir, um exemplo que mostra dois1-Operação de produto externo do array d:

　>>> import numpy as np
　>>> a = np.array([0.0,　10.0,　20.0,　30.0])
　>>> b = np.array([1.0,　2.0,　3.0])
　>>> a[:, np.newaxis]　+　b
　array([[　1.,　2.,　3.,]
　　　　　　　　[　11.,　12.,　13.,]
　　　　　　　　[　21.,　22.,　23.,]
　　　　　　　　[　31.,　32.,　33.]])

aqui newaxisoperador de índice de inserção de um novo eixo a para torná-lo bidimensional 4x1array. Transforme 4x1um array e forma (3,)do bcomposições, que resultam em um 4x3arrays.