Esta postagem fornece uma documentação introdutória para começar a usar o NumPy em Python.

# importando numpy para este script python 
import numpy 
# construindo algumas listas e adicionando-as com a biblioteca base do Python 
a = [1,2,3] 
b = [1,2,3] 
a+b

[1, 2, 3, 1, 2, 3]

# declarando um array com numpy 
a_np = numpy.array([1,2,3]) 
# verificando o tipo do array para confirmar se é um 
tipo de array numpy(a_np)

numpy.ndarray

# arrays numpy tem um atributo .dtype, permitindo que você verifique o tipo de dado numpy do array 
a_np.dtype

dtype('int32')

# a_np é do tipo inteiro; vamos tentar atribuir um float 
a_np[0] = 13,33 
a_np

array([13, ​​2, 3])

# arrays numpy possuem um atributo .ndim, permitindo que você veja o número de dimensões do array 
a_np.ndim

1

# arrays numpy também possuem um atributo .size; 
# .size permite que você veja o número de elementos contidos no array 
a_np.size

3

# a matemática torna-se possível por elemento, ao usar arrays numpy 
# -- criando um segundo array numpy para testar algumas operações matemáticas por elemento 
b_np = numpy.array([2,3,4]) 
# adição 
a_np + b_np

matriz([11, -1, -1])

# subtração 
a_np - b_np

matriz([11, -1, -1])

# multiplicação 
a_np * b_np

matriz([26, 6, 12])

# um elevado ao outro 
a_np ** b_np

array([169, 8, 81], dtype=int32)

# divisão 
a_np / b_np

array([6.5, 0.66666667, 0.75])

# módulo; testando a_np modulo 2 
a_np % numpy.array([2,2,2])

array([1, 0, 1], dtype=int32)

# módulo; testando b_np modulo 2 
b_np % numpy.array([2,2,2])

array([0, 1, 0], dtype=int32)

# numpy permite usar "funções universais"; 
# as funções universais funcionam por elementos, com arrays numpy 
# um exemplo é .sin 
numpy.sin(a_np)

array([0.42016704, 0.90929743, 0.14112001])

# outro exemplo é .sqrt 
numpy.sqrt(a_np)

array([3.60555128, 1.41421356, 1.73205081])

# construindo uma tabela de dados 2D usando numpy 
c_np = numpy.array([[1,2,3], 
                   [4,5,6]]) 
c_np

matriz([[1, 2, 3], 
       [4, 5, 6]])

# indexação, ou seja, obtenção do valor armazenado em uma célula definida; 
# aqui: célula na primeira linha, primeira coluna 
c_np[0][0]

1

# aqui: célula na última linha, última coluna 
c_np[-1][-1]

6

# aqui: célula na segunda linha, primeira coluna 
c_np[1][0]

4

# uma maneira alternativa de fazer o 
c_np[1,0] acima

4

# cortando array numpy 1d simples 
# aqui: obtenha o segundo e o terceiro valor em d_np 
d_np = numpy.array([7,9,11]) 
d_np[1:3]

matriz([ 9, 11])

# obtém primeiro e terceiro elemento 
d_np[0:3:2] # from:to:step

matriz([ 7, 11])

# aqui: obtendo todos os outros elementos em d_np 
d_np[::2]

matriz([ 7, 11])

# aqui: obtendo cada terceiro elemento 
d_np[::3]

matriz([7])

# podemos criar um array 1D usando .arange, um método do módulo numpy 
e_np = numpy.arange(0,26) #param1: from; param2: para (último valor excluído) 
e_np

array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 
       17, 18, 19, 20, 21, 22, 23 , 24, 25])

# vamos verificar o tipo de e_np 
type(e_np)

numpy.ndarray

# arrays numpy podem ser remodelados, usando o método numpy .reshape 
f_np = e_np.reshape(2,13) ​​#param1: número de linhas; param2: número de colunas 
f_np

array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 
       [13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]])

# Posso usar .reshape não apenas para criar 2D a partir de 1D; 
# por exemplo, veja isto 
g_np = numpy.array([1,2,3,4,5,6,7,8,9,10,11,12]).reshape(3,2,2) 
g_np

array([[[ 1, 2], 
        [ 3, 4]], 

       [[ 5, 6], 
        [ 7, 8]], 

       [[ 9, 10], 
        [11, 12]]])

# g_np não é 3D; deixe cortar algumas dimensões deste cubo de dados 
# todos os valores nas primeiras direções da segunda dimensão 
g_np[:,0,:]

array([[ 1, 2], 
       [ 5, 6], 
       [ 9, 10]])

# uma célula específica; primeiro em todas as dimensões 
g_np[0,0,0]

1

# uma célula específica; último em todas as dimensões 
g_np[-1,-1,-1]

12

# uma célula específica; SEGUNDO último em todas as dimensões 
g_np[-2,-2,-2]

5

# vamos completar este primeiro tutorial sobre numpy com outro exemplo; 
# Eu crio um array 2d e mostro para você 
exemplo = numpy.array([[1,2,3,4,5], 
                      [1.1,2.2,3.3,4.4,5.5], 
                      [1.11,2.22,3.33,4.44 ,5.55], 
                      [1.111,2.222,3.333,4.444,5.555], 
                      [1.1111,2.2222,3.3333,4.4444,5.5555]]) 
exemplo

array([[1. , 2. , 3. , 4. , 5. ], 
       [1.1 , 2.2 , 3.3 , 4.4 , 5.5 ], 
       [1.11 , 2.22 , 3.33 , 4.44 , 5.55 ], 
       [1.111 , 2.222 , 3.333 , 4.444 , 5.555 ], 
       [1.1111, 2.2222, 3.3333, 4.4444, 5.5555]])

# agora permite acessar os valores 2.2, 4.4, 2.222 e 4.444 - em apenas uma linha de código 
example[1::2,1::2]

array([[2.2, 4.4], 
       [2.222, 4.444]])

# agora alguns exemplos do que acontece quando você 
# copia por referência 
a_np = numpy.array([1,2,3]) 
b_np = a_np[:1] 
b_np

matriz([1])

# alterando o elemento 
b_np b_np[0] = 10000 
b_np

array([10000])

# vamos verificar a_np 
a_np

matriz([10000, 2, 3])

# acima é o efeito de copiar por referência; 
# isso acontece quando cortamos arrays numpy; 
# isso acontece com a lista padrão do python? 
a = [1,2,3] 
b = a[:1] 
b[0] = 1000 
a

[1, 2, 3]

# a cópia por referência não acontece ao fatiar listas padrão em pyhton; 
# se não quisermos copiar por referência, podemos usar o método .copy(), como parte de numpy 
c_np = numpy.array([1,2,3,4,5]) 
d_np = c_np.copy() 
d_np [0] = 10000 
c_np[0] = 99999 
# vamos verificar c_np agora 
print("this is c_np:" + str(c_np))

aqui é c_np:[99999 2 3 4 5]

# e quanto a d_np? 
d_np

matriz([10000, 2, 3, 4, 5])

# copiar com .copy() permite trabalhar com dois objetos, com referências independentes;

Linnart Felkl

Cientista de dados com foco em simulação, otimização e modelagem em R, SQL, VBA e Python