Numpy
Carregando, aguarde alguns segundos.

3 - UFUNC - Universal FUNCtions

O Numpy é uma biblioteca fundamental para computação científica em Python e oferece uma ampla gama de funções universais (ufuncs), a palavra-chave ufunc é a sigla para "função(ões) universal(is)" e vem do inglês "universal function(s)"que são funções que operam elemento por elemento em arrays Numpy de objetos ndarray, retornando um novo objeto escalar, vetor ou matriz ndarray.

As ufunc são usadas ​​para implementar a vetorização no Numpy, que é muito mais rápido para iterar itens que as coleções nativas do Python, fornecebdo transmissão e métodos adicionais, como reduzir, acumular etc, que são muito úteis para computação de dados vastos.

Aqui está uma lista de algumas das ufuncs mais comuns no Numpy:

  • Aritmética Básica:
    • np.add(x, y) ou x + y: Adição de arrays.
    • np.subtract(x, y) ou x - y: Subtração de arrays.
    • np.multiply(x, y) ou x * y: Multiplicação de arrays.
    • np.divide(x, y) ou x / y: Divisão de arrays.
    • np.floor_divide(x, y) ou x // y: Divisão inteira de arrays.
    • np.mod(x, y) ou x % y: Resto da divisão de arrays.
    • np.power(x, y) ou x ** y: Potência de arrays.
    • np.square(x) ou x ** 2: Eleva ao quadrado um array.
    • np.sqrt(x) ou np.sqrt(x): Raiz quadrada de um array.
    • np.abs(x): Valor absoluto de um array.
  • Funções Trigonométricas:
    • np.sin(x): Seno de um array.
    • np.cos(x): Cosseno de um array.
    • np.tan(x): Tangente de um array.
    • np.arcsin(x): Arco seno de um array.
    • np.arccos(x): Arco cosseno de um array.
    • np.arctan(x): Arco tangente de um array.
    • np.arcsinh(x): Arco seno hiperbólico de um array.
    • np.arccosh(x): Arco cosseno hiperbólico de um array.
    • np.arctanh(x): Arco tangente hiperbólico de um array.
    • np.deg2rad(x): Conversão de graus para radianos.
    • np.rad2deg(x): Conversão de radianos para graus.
  • Funções Exponênciais e Logarítmicas:
    • np.exp(x): Exponencial de um array.
    • np.log(x): Logaritmo natural de um array.
    • np.log10(x): Logaritmo na base 10 de um array.
    • np.log2(x): Logaritmo na base 2 de um array.
    • np.log1p(x): Logaritmo na base 10 de um array.
    • np.expm1(x): Exponencial de um array.
    • np.logaddexp(x, y): Logaritmo aditivo de dois arrays.
    • np.logaddexp2(x, y): Logaritmo aditivo de dois arrays.
    • np.logaddexpm1(x, y): Logaritmo aditivo de dois arrays.
  • Funções de Comparação:
    • np.equal(x, y): Verifica se os elementos de um array são iguais.
    • np.not_equal(x, y): Verifica se os elementos de um array são diferentes.
    • np.less(x, y): Verifica se os elementos de um array são menores.
    • np.greater(x, y): Verifica se os elementos de um array são maiores.
    • np.less_equal(x, y): Verifica se os elementos de um array são menores ou iguais.
    • np.greater_equal(x, y): Verifica se os elementos de um array são maiores ou iguais.
    • np.logical_and(x, y): Verifica se os elementos de um array são verdadeiros.
    • np.logical_or(x, y): Verifica se os elementos de um array são verdadeiros.
    • np.logical_not(x): Verifica se os elementos de um array são falsos.
  • Funções de Agregação:
    • np.sum(x): Soma dos elementos do array.
    • np.prod(x): Produto dos elementos do array.
    • np.cumsum(x): Soma acumulada.
    • np.cumprod(x): Produto acumulado.
    • np.nancumsum(x): Soma acumulada.
    • np.nancumprod(x): Produto acumulado.
    • np.cummin(x): Valor mínimo acumulado.
    • np.cummax(x): Valor máximo acumulado.
    • np.diff(x): Diferença entre os elementos de um array.
    • np.trapz(x): Integral de uma função.
    • np.trapz(x, dx): Integral de uma função.
    • np.ediff1d(x): Diferença entre os elementos de um array.
  • Funções de Álgebra Linear:
    • np.min(x): Valor mínimo dos elementos do array.
    • np.max(x): Valor máximo dos elementos do array.
    • np.argmin(x): Valor mínimo do array.
    • np.argmax(x): Valor máximo do array.
    • np.dot(x, y): Produto escalar de dois arrays.
    • np.cross(x, y): Produto vetorial de dois arrays.
  • Funções de Estatísticas:
    • np.mean(x): Média dos elementos do array.
    • np.median(x): Média dos elementos do array.
    • np.percentile(x, q): Percentil.
    • np.quantile(x, q): Quantil.
    • np.var(x): Variância dos elementos do array.
    • np.std(x): Desvio padrão dos elementos do array.
  • Funções de Arredondamento e Truncamento:
    • np.round(x): Arredonda elementos para o inteiro mais próximo.
    • np.floor(x): Arredonda para baixo.
    • np.ceil(x): Arredonda para cima.

Estas são apenas algumas das ufuncs disponíveis no Numpy. As ufuncs são extremamente úteis para realizar operações eficientes em arrays Numpy, tornando o Numpy uma ferramenta poderosa para computação numérica e análise de dados em Python.

As ufunc também aceita argumentos adicionais, como:

  • where: matriz booleana ou condição que define onde as operações devem ocorrer.
  • dtype: definindo o tipo de retorno dos elementos.
  • out: vetor de saída onde o valor de retorno deve ser copiado.

3.1 - Vetorização

A conversão de instruções iterativas em uma operação baseada em vetor é chamada de vetorização, rocesso mais rápido pois as CPUs modernas são otimizadas para essas operações.

Com as listas nativas do Python são necessárias duas etapas para realizar uma operação vetorizada: criar uma lista e iterar em cada elemento da lista.

Com as listas Numpy só é necessário chamar a função ufunc sem necessitar criar uma lista ou iterar os elementos nos vetores ou matrizes.

A vetorização é um conceito fundamental no Numpy e está diretamente relacionada ao funcionamento eficiente das funções universais (ufuncs). A vetorização permite que as ufuncs do Numpy executem operações em arrays inteiros, em vez de iterar explicitamente sobre os elementos de um array, o que é muito mais lento em Python puro.

Aqui está uma explicação mais detalhada do processo de vetorização das ufuncs no Numpy:

  • Operações Elemento a Elemento: As ufuncs do Numpy são projetadas para operar em arrays inteiros, elemento a elemento. Isso significa que, quando você aplica uma ufunc a um array Numpy, a operação é automaticamente aplicada a cada elemento do array. Por exemplo, quando você usa np.add(x, y) para adicionar dois arrays x e y, o Numpy não precisa de um loop explícito para percorrer os elementos; ele realiza a adição diretamente em cada par de elementos correspondentes.
  • Eficiência Computacional: A vetorização é mais eficiente do que usar loops explícitos em Python, porque as operações são delegadas para implementações otimizadas em C ou Fortran subjacentes ao Numpy. Isso resulta em um desempenho muito melhor, especialmente quando você está lidando com grandes conjuntos de dados ou operações complexas.
  • Clareza de Código: Além da melhoria no desempenho, a vetorização também leva a um código mais claro e conciso. Em vez de escrever loops para iterar pelos elementos de um array, você pode expressar operações matemáticas complexas de forma mais legível e concisa usando ufuncs. Isso torna o código mais fácil de entender e manter.
  • Funcionalidade Broadcasting: Além da vetorização simples, o Numpy também oferece uma funcionalidade chamada "broadcasting". Broadcasting permite que você realize operações entre arrays de diferentes formas e tamanhos de forma compatível, desde que as dimensões sejam compatíveis. Isso simplifica muito o tratamento de casos onde você precisa, por exemplo, adicionar um array 1D a um array 2D.

O exemplo abaixo mostra como utilizar broadcasting para adicionar os elementos de dois vetores Numpy usando a função ufunc np.add:

  • lista 1: [1, 2, 3, 4]
  • lista 2: [4, 5, 6, 7]

Uma maneira de fazer isso é iterar em ambas as listas e, em seguida, somar cada elemento.

Exemplo: sem ufunc, podemos usar o método zip() interno do Python. 

x = [1, 2, 3, 4]
y = [4, 5, 6, 7]
adicao = []

for i in range(0, len(x)):
    adicao.append(x[i] + y[i])

print(f"adicao = {adicao}")

Outra maneira de fazer isso é empacotar os vetores com a função zip iterar em ambas as listas e, em seguida, somar cada elemento.

Exemplo: sem ufunc, podemos usar o método zip() interno do Python. 

x = [1, 2, 3, 4]
y = [4, 5, 6, 7]
adicao = []

print(f"zipado = {list(zip(x, y))}")

for i, j in zip(x, y):
    adicao.append(i + j)

print(f"adicao = {adicao}")

Numpy tem um ufunc para isso, chamado add(x, y) que produzirá o mesmo resultado.

Exemplo: com ufunc, podemos usar a função add(). 

import numpy as np

x = [1, 2, 3, 4]
y = [4, 5, 6, 7]
adicao = np.add(x, y)

print(adicao)

3.2 - Tipo ufunc

Verifique o tipo de uma função para verificar se é um ufunc ou não.

Um ufunc deve retornar ufunc'>.

Exemplo: verifique se uma função é um ufunc. 

import numpy as np
print(type(np.add))

Se não for um ufunc, ele retornará outro tipo, como esta função Numpy integrada para unir dois ou mais arrays:

Exemplo: verifique o tipo de outra função: concatenate(). 

import numpy as np
print(type(np.concatenate))

Se a função não for reconhecida, ela retornará um erro:

Exemplo: verifique o tipo de algo que não existe. Isso produzirá um erro. 

import numpy as np
print(type(np.blahblah))

Para testar se a função é um ufunc em uma instrução if, use o numpy.ufuncvalor (ou np.ufuncse você usar np como um alias para numpy):

Exemplo: use uma instrução if para verificar se a função é ufunc ou não. 

import numpy as np
#
if type(np.add) == np.ufunc:
    print('add é <i>ufunc</i>')
else:
    print('add não é <i>ufunc</i>')

3.3 - Funções matemáticas

As funções matemáticas são classificadas por áreas:

  • Funções Aritméticas
  • Funções de Comparação
  • Funções de Agregação
  • Funções de Álgebra Linear
  • Funções de Estatísticas

3.3.1 - Funções Aritméticas

Você pode usar operadores aritméticos + - * / diretamente entre arrays Numpy, mas esta seção discute uma extensão do mesmo onde temos funções que podem pegar qualquer objeto do tipo array, por exemplo, listas, tuplas etc. e realizar aritmética condicionalmente.

Aritmética Condicionalmente: significa que podemos definir condições onde a operação aritmética deve acontecer.

Todas as funções aritméticas discutidas podem usar o argumento where para especificar uma condição.

Adição np.add()

A função add() soma o conteúdo de duas matrizes e retorna os resultados em uma nova matriz.

Exemplo:

Adicione os valores em matriz1 aos valores em matriz2: 

import numpy as np
matriz1 = np.array([10, 11, 12, 13, 14, 15])
matriz2 = np.array([20, 21, 22, 23, 24, 25])
nova_matriz = np.add(matriz1, matriz2)
print(nova_matriz)

São retornadas as somas de 10 + 20, 11 + 21, 12 + 22 etc.

Subtração np.subtract()

A função subtract() subtrai os valores de uma matriz com os valores de outra matriz e retorna os resultados em uma nova matriz.

Exemplo: subtraia os valores em matriz2 dos valores em matriz1. 

import numpy as np

matriz1 = np.array([10, 20, 30, 40, 50, 60])
matriz2 = np.array([20, 21, 22, 23, 24, 25])

nova_matriz = np.subtract(matriz1, matriz2)

print(nova_matriz)

Soma np.sum()

Qual é a diferença entre soma e adição? A adição é feita entre dois argumentos, enquanto a soma ocorre sobre n elementos.

Exemplo: adicione os valores em matriz1 aos valores em matriz2. 

import numpy as np
matriz1 = np.array([1, 2, 3])
matriz2 = np.array([1, 2, 3])
nova_matriz = np.add(matriz1, matriz2)
print(nova_matriz)

Exemplo: some os valores em matriz1 e matriz2. 

import numpy as np
matriz1 = np.array([1, 2, 3])
matriz2 = np.array([1, 2, 3])
nova_matriz = np.sum([matriz1, matriz2])
print(nova_matriz)
Soma sobre um eixo

Se você especificar axis=1, Numpy somará os números em cada array.

Exemplo: execute a soma na seguinte matriz sobre o 1º eixo. 

import numpy as np
matriz1 = np.array([1, 2, 3])
matriz2 = np.array([1, 2, 3])
nova_matriz = np.sum([matriz1, matriz2], axis=1)
print(nova_matriz)
Soma cumulativa

Soma cumulativa significa adicionar parcialmente os elementos na matriz.

Por exemplo, a soma parcial de [1, 2, 3, 4] seria [1, 1+2, 1+2+3, 1+2+3+4] = [1, 3, 6, 10].

Faça a soma parcial com a cumsum()função.

Exemplo: Execute a soma cumulativa na seguinte matriz. 

import numpy as np
matriz = np.array([1, 2, 3])
nova_matriz = np.cumsum(matriz)
print(nova_matriz)

Produto np.prod()

Para encontrar o produto dos elementos em uma matriz, use a função prod().

Exemplo: encontre o produto dos elementos desta matriz. 

import numpy as np
matriz = np.array([1, 2, 3, 4])
x = np.prod(matriz)
print(x) # 1 * 2 * 3 * 4 = 24

Exemplo: encontre o produto dos elementos de duas matrizes. 

import numpy as np
matriz1 = np.array([1, 2, 3, 4])
matriz2 = np.array([5, 6, 7, 8])
x = np.prod([matriz1, matriz2])
print(x) # 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 = 40320
Produto sobre um eixo

Se você especificar axis=1, Numpy retornará o produto de cada array.

Exemplo: execute a soma na seguinte matriz sobre o 1º eixo. 

import numpy as np
matriz1 = np.array([1, 2, 3, 4])
matriz2 = np.array([5, 6, 7, 8])
nova_matriz = np.prod([matriz1, matriz2], axis=1)
print(nova_matriz)
Produto cumulativo

Produto cumulativo significa tomar o produto parcialmente.

Por exemplo, o produto parcial de [1, 2, 3, 4] é [1, 1*2, 1*2*3, 1*2*3*4] = [1, 2, 6, 24]

Faça a soma parcial com a função cumprod().

Exemplo: pegue o produto cumulativo de todos os elementos para a seguinte matriz. 

import numpy as np
matriz = np.array([5, 6, 7, 8])
nova_matriz = np.cumprod(matriz)
print(nova_matriz)

Diferença np.diff()

Uma diferença discreta significa subtrair dois elementos sucessivos.

Por exemplo, para [1, 2, 3, 4], a diferença discreta seria [2-1, 3-2, 4-3] = [1, 1, 1]

Para encontrar a diferença discreta, use a diff()função.

Exemplo: calcule a diferença discreta da seguinte matriz. 

import numpy as np
matriz = np.array([10, 15, 25, 5])
nova_matriz = np.diff(matriz) # [5 10 -20]
print(nova_matriz)

Retorna [5 10 -20] porque 15 - 10 = 5, 25 - 15 = 10 e 5 - 25 = -20

Podemos realizar esta operação repetidamente dando o parâmetro n.

Por exemplo, para [1, 2, 3, 4], a diferença discreta com n = 2 seria [2-1, 3-2, 4-3] = [1, 1, 1] , então, como n=2, faremos isso mais uma vez, com o novo resultado: [1-1, 1-1] = [0, 0]

Exemplo: calcule a diferença discreta da seguinte matriz duas vezes. 

import numpy as np
matriz = np.array([10, 15, 25, 5])
nova_matriz = np.diff(matriz, n=2)
print(nova_matriz)

Retorna: [5 -30] porque: 15-10=5, 25-15=10 e 5-25=-20 AND 10-5=5 e -20-10=-30

3.3.2 - Funções algébricas

Múltiplos Comuns (MMC e MDC)

Encontrar o MMC (Mínimo Múltiplo Comum) e o MDC (Maior Denominador Comum) é muito comum em matemática.

MMC Mínimo Múltiplo Comum

O Mínimo Múltiplo Comum é o menor número múltiplo comum de ambos os números.

Exemplo: encontre o MMC dos dois números a seguir. 

import numpy as np
num1 = 4
num2 = 6
x = np.lcm(num1, num2)
print(x)

Retorna: 12 porque esse é o menor múltiplo comum de ambos os números (4*3=12 e 6*2=12).

Encontrando MMC em Arrays

Para encontrar o Múltiplo Comum Mínimo de todos os valores em uma matriz, você pode usar o método reduce().

O método reduce() usará o ufunc, neste caso a lcm()função, em cada elemento, e reduzirá o array em uma dimensão.

Exemplo: encontre o MMC dos valores da seguinte matriz. 

import numpy as np
matriz = np.array([3, 6, 9])
x = np.lcm.reduce(matriz)
print(x)

Retorna: 18 porque esse é o menor múltiplo comum de todos os três números (3 * 6 = 18, 6 * 3 = 18 e 9 * 2 = 18).

Exemplo: encontre o MMC de todo um array onde o array contém todos os inteiros de 1 a 10. 

import numpy as np
matriz = np.arange(1, 11)
x = np.lcm.reduce(matriz)
print(x)
MDC Maior Denominador Comum

O MDC (Maior Denominador Comum), também conhecido como MFC (Maior Fator Comum) é o maior número que é um fator comum em um conjunto de números.

Exemplo: encontre o MFC dos dois números a seguir. 

import numpy as np
num1 = 6
num2 = 9
x = np.gcd(num1, num2)
print(x)

Retorna: 3 por ser o número mais alto, ambos os números podem ser divididos por (6/3=2 e 9/3=3).

Encontrando MDC em Arrays

Para encontrar o fator comum mais alto de todos os valores em uma matriz, você pode usar o método reduce().

O método reduce() usará o ufunc, neste caso a gcd()função, em cada elemento, e reduzirá o array em uma dimensão.

Exemplo: encontre o MDC para todos os números na seguinte matriz. 

import numpy as np
matriz = np.array([20, 8, 32, 36, 16])
x = np.gcd.reduce(matriz)
print(x)

Retorna: 4 porque esse é o número mais alto pelo qual todos os valores podem ser divididos.

Logaritmos log(), log2(), log10() e log1p()

Numpy fornece funções para realizar log na base 2, e e 10.

Também exploraremos como podemos obter log para qualquer base criando um ufunc.

Todas as funções de log colocarão -inf ou inf nos elementos se o log não puder ser calculado.

Log na base 2

Use a função log2() para realizar o log na base 2.

Exemplo: encontre log na base 2 de todos os elementos da seguinte matriz. 

import numpy as np
matriz = np.arange(1, 10)
print(np.log2(matriz))

Nota: A função arange(1, 10) retorna uma matriz com números inteiros começando de 1 (incluído) a 10 (não incluído).

Log na base 10

Use a função log10() para calcular o log na base 10.

Exemplo: Encontre log na base 10 de todos os elementos da seguinte matriz. 

import numpy as np
matriz = np.arange(1, 10)
print(np.log10(matriz))
Log natural, ou log na base e

Use a função log() para realizar o log na base e.

Exemplo: encontre log na base e de todos os elementos da seguinte matriz. 

import numpy as np
matriz = np.arange(1, 10)
print(np.log(matriz))
Log em qualquer base

O Numpy não fornece nenhuma função para obter log em qualquer base, portanto, podemos usar a função frompyfunc() junto com a função embutida math.log() com dois parâmetros de entrada e um parâmetro de saída: 

from math import log
import numpy as np
nplog = np.frompyfunc(log, 2, 1)
print(nplog(100, 15))

3.3.3 - Funções trigonométricas

Numpy fornece as ufuncs sin(), cos() e tan() que recebe valores em radianos e produz os valores correspondentes de sin, cos e tan.

Exemplo: encontre o valor do seno de PI/2. 

import numpy as np
x = np.sin(np.pi/2)
print(x)

Exemplo: encontre valores de seno para todos os valores em matriz. 

import numpy as np
matriz = np.array([np.pi/2, np.pi/3, np.pi/4, np.pi/5])
x = np.sin(matriz)
print(x)

Graus para radianos

Por padrão, todas as funções trigonométricas usam radianos como parâmetros, mas podemos converter radianos em graus e vice-versa também no Numpy.

Observação: os valores em radianos são pi/180 * degree_values.

Exemplo: converta todos os valores no seguinte array matriz para radianos. 

import numpy as np
matriz = np.array([90, 180, 270, 360])
x = np.deg2rad(matriz)
print(x)

Radianos para graus

Exemplo: converta todos os valores na seguinte matriz matriz em graus. 

import numpy as np
matriz = np.array([np.pi/2, np.pi, 1.5*np.pi, 2*np.pi])
x = np.rad2deg(matriz)
print(x)

Encontrando ângulos

Encontrar ângulos de valores de seno, cos, tan. Por exemplo, sin, cos e tan inverso (arcsin, arccos, arctan).

Numpy fornece as ufuncs arcsin(), arccos() e arctan() que produzem valores radianos para os valores correspondentes de sin, cos e tan dados.

Exemplo: Encontre o ângulo do arcoseno de 1,0. 

import numpy as np
x = np.arcsin(1.0)
print(x)

Ângulos em matrizes

Exemplo: encontre o ângulo para todos os valores de seno na matriz. 

import numpy as np
matriz = np.array([1, -1, 0.1])
x = np.arcsin(matriz)
print(x)

Hipotenusas

Encontrando hipotenusas usando o teorema de Pitágoras.

Numpy fornece a função hypot() que recebe os valores base e perpendicular e produz hipotenusas com base no teorema de Pitágoras.

Exemplo: encontre as hipotenusas para 4 bases e 3 perpendiculares. 

import numpy as np
base = 3
perp = 4
x = np.hypot(base, perp)
print(x)

Funções Hiperbólicas

Numpy fornece as ufuncs sinh(), cosh() e tanh() que recebem valores em radianos e produz os valores correspondentes sinh, cosh e tanh.

Exemplo: encontre o valor sinh de PI/2. 

import numpy as np
x = np.sinh(np.pi/2)
print(x)

Exemplo: encontre valores cosh para todos os valores em matriz. 

import numpy as np
matriz = np.array([np.pi/2, np.pi/3, np.pi/4, np.pi/5])
x = np.cosh(matriz)
print(x)

Encontrando ângulos

Encontrar ângulos de valores de seno hiperbólico, cos, tan. Por exemplo, sinh, cosh e tanh inverso (arcsinh, arccosh, arctanh).

Numpy fornece ufuncs arcsinh(), arccosh()e arctanh()que produz valores radianos para os valores correspondentes sinh, cosh e tanh fornecidos.

Exemplo: encontre o ângulo de 1,0. 

import numpy as np
x = np.arcsinh(1.0)
print(x)

Ângulos de cada valor em matrizes

Exemplo: encontre o ângulo para todos os valores de tanh na matriz. 

import numpy as np
matriz = np.array([0.1, 0.2, 0.5])
x = np.arctanh(matriz)
print(x)

3.3.4 - Funções de conjunto

Um conjunto em matemática é uma coleção de elementos únicos.

Os conjuntos são usados ​​para operações que envolvem operações frequentes de interseção, união e diferença.

Conjunto de itens únicos

Podemos usar o método unique() do Numpy para encontrar elementos exclusivos de qualquer array.

Por exemplo, crie um array set, mas lembre-se que os arrays set devem ser somente arrays 1-D.

Exemplo: converta a seguinte matriz com elementos repetidos em um conjunto. 

import numpy as np
matriz = np.array([1, 1, 1, 2, 3, 4, 5, 5, 6, 7])
x = np.unique(matriz)
print(x)

Conjunto união

Para encontrar os valores exclusivos de duas matrizes, use o método union1d().

Exemplo: encontre a união das duas matrizes de conjuntos a seguir. 

import numpy as np
matriz1 = np.array([1, 2, 3, 4])
matriz2 = np.array([3, 4, 5, 6])
nova_matriz = np.union1d(matriz1, matriz2)
print(nova_matriz)

Conjunto interseção

Para localizar apenas os valores presentes em ambas as matrizes, use o método intersect1d().

Exemplo: encontre a interseção das duas matrizes de conjuntos a seguir. 

import numpy as np
matriz1 = np.array([1, 2, 3, 4])
matriz2 = np.array([3, 4, 5, 6])
nova_matriz = np.intersect1d(matriz1, matriz2, assume_unique=True)
print(nova_matriz)

Observação: o método intersect1d() recebe um argumento opcional assume_unique, que, se definido como True, pode acelerar a computação. Deve sempre ser definido como True ao lidar com conjuntos.

Conjunto diferença

Para encontrar apenas os valores no primeiro conjunto que NÃO estão presentes no conjunto de segundos, use o método setdiff1d().

Exemplo: encontre a diferença do set1 do set2. 

import numpy as np
set1 = np.array([1, 2, 3, 4])
set2 = np.array([3, 4, 5, 6])
nova_matriz = np.setdiff1d(set1, set2, assume_unique=True)
print(nova_matriz)

Observação: o método setdiff1d() recebe um argumento opcional assume_unique, que, se definido como True, pode acelerar a computação. Deve sempre ser definido como True ao lidar com conjuntos.

Conjunto diferença simétrica

Para encontrar apenas os valores que NÃO estão presentes em AMBOS os conjuntos, use o método setxor1d().

Exemplo: encontre a diferença simétrica do set1 e set2. 

import numpy as np
set1 = np.array([1, 2, 3, 4])
set2 = np.array([3, 4, 5, 6])
nova_matriz = np.setxor1d(set1, set2, assume_unique=True)
print(nova_matriz)

Observação: o método setxor1d() recebe um argumento opcional assume_unique, que, se definido como True, pode acelerar a computação. Deve sempre ser definido como True ao lidar com conjuntos.

3.4 - Funções ufunc próprias

Para criar sua própria ufunc, você precisa definir uma função, como você faz com funções normais em Python, e então adicioná-la à sua biblioteca Numpy ufunc com o método frompyfunc().

O método frompyfunc() recebe os seguintes argumentos:

  • function: o nome da função.
  • inputs: o número de argumentos de entrada (matrizes).
  • outputs: o número de matrizes de saída.

Exemplo: crie seu próprio ufunc para adição. 

import numpy as np

def myadd(x, y):
  return x+y

myadd = np.frompyfunc(myadd, 2, 1)

print(myadd([1, 2, 3, 4], [5, 6, 7, 8]))
Arduino
Coautor
Betobyte
Autor
Autores
||| Áreas ||| Estatística ||| Python ||| Projetos ||| Dicas & Truques ||| Quantum ||| Numpy || Python para Iniciantes || Python Básico || Matplotlib || Numpy || Seaborn || Pandas || Django || Estatística para Cientistas de Dados || Python com ML Básico || Python com ML Básico || Aulas | Introdução (introdução) | Desempenho (Desempenho) | UFUNC (ufunc) | Aleatório (random) |