Tutorial Python Numpy

Nesta lição sobre a biblioteca Python Numpy, veremos como essa biblioteca nos permite gerenciar poderosos objetos de matriz N-dimensional com funções sofisticadas presentes para manipular e operar com essas matrizes. Para concluir esta lição, abordaremos as seguintes seções:

• O que é pacote python numpy?
• Arrays numpy
• Operações diferentes que podem ser feitas em matrizes numpy
• Algumas funções especiais

O que é pacote python numpy?

Simplificando, Numpy significa 'numérico python' e é isso que pretende cumprir, para permitir operações numéricas complexas realizadas em objetos de matriz n-dimensional com muita facilidade e de maneira intuitiva. É a biblioteca principal usada em Computação científica, com funções presentes para realizar operações algébricas lineares e operações estatísticas.

Um dos conceitos mais fundamentais (e atraentes) para Numpy é o uso de objetos de matriz n-dimensional. Podemos pegar essa matriz como apenas um Coleção de linhas e coluna, Assim como um arquivo ms-excel. É possível converter uma lista de python em uma matriz numpy e operar funções sobre ela.

Representação de Array Numpy

Apenas uma nota antes de começar, usamos um ambiente virtual para esta lição que fizemos com o seguinte comando:

Python -M Virtualenv Numpy
fonte numpy/bin/ativação

Depois que o ambiente virtual estiver ativo, podemos instalar a biblioteca Numpy dentro do Env virtual, para que exemplos que criamos a seguir possam ser executados:

pip install numpy

Vemos algo assim quando executamos o comando acima:

Vamos testar rapidamente se o pacote Numpy foi instalado corretamente com o seguinte snippet de código curto:

importar numpy como np
a = np.Array ([1,2,3])
Imprimir (a)

Depois de executar o programa acima, você deve ver a seguinte saída:

Também podemos ter matrizes multidimensionais com Numpy:

multi_dimension = np.Array ([(1, 2, 3), (4, 5, 6)])
Imprimir (multi_dimension)

Isso produzirá uma saída como:

[[1 2 3]
[4 5 6]]

Você também pode usar o Anaconda para executar esses exemplos, o que é mais fácil e é isso que usamos acima. Se você quiser instalá -lo em sua máquina, veja a lição que descreve “como instalar o Anaconda Python no Ubuntu 18.04 LTS ”e compartilhe seu feedback. Agora, vamos avançar para vários tipos de operações que podem ser realizadas com matrizes Python Numpy.

Usando matrizes Numpy em listas de Python

É importante pedir que quando o python já tiver uma estrutura de dados sofisticada para manter vários itens do que por que precisamos? As matrizes numpy são Preferido em listas de Python Devido aos seguintes motivos:

• Conveniente de usar para operações matemáticas e de computação intensiva devido à presença de funções Numpy compatíveis
• Eles são muito mais rápidos, devido à maneira como armazenam dados internamente
• Menos memória

Deixe-nos provar que as matrizes numpy ocupam menos memória. Isso pode ser feito escrevendo um programa Python muito simples:

importar numpy como np
tempo de importação
Importar sistemas
python_list = intervalo (500)
Imprimir (sys.Getsizeof (1) * len (python_list))
numpy_arr = np.ARANGE (500)
Imprimir (Numpy_arr.Tamanho * Numpy_arr.itens mize)

Quando executamos o programa acima, obteremos a seguinte saída:

14000
4000

Isso mostra que a mesma lista de tamanho é Mais de 3 vezes em tamanho quando comparado ao mesmo tamanho de matriz numpy.

Executando operações numpy

Nesta seção, vamos olhar rapidamente sobre as operações que podem ser executadas em matrizes Numpy.

Encontrando dimensões na matriz

Como a matriz Numpy pode ser usada em qualquer espaço dimensional para manter dados, podemos encontrar a dimensão de uma matriz com o seguinte snippet de código:

importar numpy como np
numpy_arr = np.Array ([(1,2,3), (4,5,6)]))
Imprimir (Numpy_arr.ndim)

Veremos a saída como "2", pois esta é uma matriz bidimensional.

Encontrando Datatype de itens na matriz

Podemos usar o Numpy Array para manter qualquer tipo de dados. Vamos agora descobrir o tipo de dados dos dados que uma matriz contém:

outros_arr = np.Array ([('Awe', 'B', 'Cat')])
Imprimir (outros_arr.dtype)
numpy_arr = np.Array ([(1,2,3), (4,5,6)]))
Imprimir (Numpy_arr.dtype)

Usamos diferentes tipos de elementos no trecho de código acima. Aqui está a saída que este script mostrará:

Int64

Isso acontece quando os caracteres são interpretados como caracteres unicode e o segundo é óbvio.

Remodelar itens de uma matriz

Se uma matriz Numpy consistir em 2 linhas e 4 colunas, pode ser remodelada para conter 4 linhas e 2 colunas. Vamos escrever um snippet de código simples para o mesmo:

original = np.Array ([('1', 'b', 'c', '4'), ('5', 'f', 'g', '8')])
Impressão (original)
remodelado = original.remodelar (4, 2)
Imprimir (remodelado)

Quando executarmos o trecho de código acima, obteremos a seguinte saída com as duas matrizes impressas na tela:

[['1' 'B' 'C' '4']
['5' 'f' 'g' '8']]
[['1' 'B']
['C' '4']
['5' 'f']
['g' '8']]

Observe como Numpy cuidou de mudar e associar os elementos para novas linhas.

Operações matemáticas em itens de uma matriz

Realizar operações matemáticas em itens de uma matriz é muito simples. Começaremos escrevendo um snippet de código simples para descobrir o máximo, o mínimo e a adição de todos os itens da matriz. Aqui está o trecho de código:

numpy_arr = np.Array ([(1, 2, 3, 4, 5)]))
Imprimir (Numpy_arr.max ()))
Imprimir (Numpy_arr.min ()))
Imprimir (Numpy_arr.soma())
Imprimir (Numpy_arr.significar())
Imprimir (NP.sqrt (numpy_arr))
Imprimir (NP.std (numpy_arr))

Nas últimas duas operações acima, também calculamos a raiz quadrada e o desvio padrão de cada matriz itens. O trecho acima fornecerá a seguinte saída:

5
1
15
3.0
[[1. 1.41421356 1.73205081 2. 2.23606798]]
1.4142135623730951

Convertendo listas de Python em matrizes numpy

Mesmo se você estiver usando listas de Python em seus programas existentes e não deseja alterar todo esse código, mas ainda deseja fazer uso de matrizes numpy em seu novo código, é bom saber que podemos converter facilmente um python Liste para uma matriz Numpy. Aqui está um exemplo:

# Crie 2 novas listas de altura e peso
altura = [2.37, 2.87, 1.52, 1.51, 1.70, 2.05]
peso = [91.65, 97.52, 68.25, 88.98, 86.18, 88.45]
# Crie 2 matrizes numpy a partir da altura e peso
np_height = np.Array (altura)
np_weight = np.Array (peso)

Só para verificar, agora podemos imprimir o tipo de uma das variáveis:

Imprimir (tipo (np_height))

E isso vai mostrar:

Agora podemos realizar operações matemáticas sobre todos os itens de uma só vez. Vamos ver como podemos calcular o IMC do povo:

# Calcule IMC
BMI = np_weight / np_height ** 2
# Imprima o resultado
Impressão (IMC)

Isso mostrará o IMC de todas as pessoas calculadas em termos de elemento:

[16.31682957 11.8394056 29.54033934 39.02460418 29.8200692 21.04699584]

Não é fácil e útil? Podemos até filtrar dados facilmente com uma condição no lugar de um índice dentro de suportes quadrados:

IMC [IMC> 25]

Isso vai dar:

Array ([29.54033934, 39.02460418, 29.8200692])

Crie sequências e repetições aleatórias com Numpy

Com muitos recursos presentes no Numpy para criar dados aleatórios e organizá -los de forma obrigatória, as matrizes Numpy são muitas vezes usadas na geração de dados de teste em muitos lugares, incluindo fins de depuração e teste. Por exemplo, se você deseja criar uma matriz de 0 a n, podemos usar o Arange (observe o único 'r') como o snippet dado:

Imprimir (NP.ARANGE (5))

Isso retornará a saída como:

[0 1 2 3 4]

A mesma função pode ser usada para fornecer um valor mais baixo, para que a matriz comece a partir de outros números que 0:

Imprimir (NP.ARANGE (4, 12))

Isso retornará a saída como:

[4 5 6 7 8 9 10 11]

Os números não precisam ser contínuos, eles podem pular uma etapa de correção como:

Imprimir (NP.Arange (4, 14, 2))

Isso retornará a saída como:

[4 6 8 10 12]

Também podemos obter os números em uma ordem decrescente com um valor negativo de pular:

Imprimir (NP.Arange (14, 4, -1))

Isso retornará a saída como:

[14 13 12 11 10 9 8 7 6 5]

É possível financiar N números entre x e y com espaço igual com o método Linspace, aqui está o trecho de código para o mesmo:

NP.linspace (start = 10, stop = 70, num = 10, dtype = int)

Isso retornará a saída como:

Array ([10, 16, 23, 30, 36, 43, 50, 56, 63, 70])

Observe que os itens de saída não estão igualmente espaçados. Numpy faz o possível para fazer isso, mas você não precisa confiar nele como ele faz o arredondamento.

Por fim, vejamos como podemos gerar um conjunto de sequência aleatória com Numpy, que é uma das funções mais usadas para fins de teste. Passaremos uma série de números para Numpy, que serão usados ​​como ponto inicial e final para os números aleatórios:

Imprimir (NP.aleatório.Randint (0, 10, tamanho = [2,2])))

O trecho acima cria uma matriz Numpy 2 por 2 por dimensional que conterá números aleatórios entre 0 e 10. Aqui está a saída de amostra:

[[0 4]
[8 3]]

Observe que, pois os números são aleatórios, a saída pode diferir mesmo entre as 2 execuções na mesma máquina.

Conclusão

Nesta lição, analisamos vários aspectos desta biblioteca de computação que podemos usar com o Python para calcular problemas matemáticos simples e complexos que podem surgir em vários casos de uso que o Numpy é uma das bibliotecas de computação mais importantes quando se trata de Engenharia de dados e calculando o DAT numérico, definitivamente uma habilidade que precisamos ter em nosso cinto.

Compartilhe seus comentários sobre a lição no Twitter com @sbmaggarwal e @linuxhint.