O arredondamento preciso de valores numéricos desempenha um papel muito importante em diversas aplicações científicas e de engenharia. No contexto da programação em Python, a biblioteca NumPy se destaca como uma ferramenta poderosa para manipulação eficiente de arrays e cálculos numéricos em geral.

Neste artigo, exploraremos algumas funções de arredondamento numérico disponíveis no NumPy, mostrando alguns exemplos de como empregar essas funções para realizar arredondamentos diversos, incluindo arredondamento de valores de ponto flutuante e para números inteiros.

Ao entender como usar essas funções, será possível otimizar nossos códigos e garantir resultados numericamente estáveis em uma variedade de cenários.

Vamos às funções de arredondamento de valores com NumPy, para Python.

Importar o NumPy

O primeiro passo para usar as funções que serão abordadas é importar a biblioteca NumPy no script que usará as funções de arredondamento (o módulo numpy deve estar instalado previamente; caso não esteja, realize a instalação do NumPy seguindo estas instruções):

import numpy as np

Após importar a biblioteca, vejamos as funções mais importantes para arredondamento de valores numéricos.

1. Função numpy.round

Ou seu alias numpy.around(): Arredonda o valor até uma precisão desejada

Sintaxe

numpy.round(valor,[num_casas_decimais])

Documentação: https://numpy.org/doc/stable/reference/generated/numpy.round.html

Exemplo de uso

# Criar um array de valores a serem arredondados:
valores = np.array([5.0, 6.98, 0.9863, 555, 10.099])
# Podemos usar também uma simples lista (descomentar para testar):
# valores = [5.0, 6.98, 0.9863, 555, 10.099] 
print('Array original:')
print(valores)

print('\nValores arredondados:')
print(np.round(valores, decimals = 2))
print(np.round(valores, decimals = 3))
print(np.around(valores)) # valores são exibidos no formato float64
print(np.around(valores).astype(int)) # converter valores para int antes da exibição (não mostra o ponto)

Resultado:

Array original:
[ 5. 6.98 0.9863 555. 10.099 ]

Valores arredondados:
[ 5. 6.98 0.99 555. 10.1 ]
[ 5. 6.98 0.986 555. 10.099]
[ 5. 7. 1. 555. 10.]
[ 5 7 1 555 10]

2. Função numpy.floor

Arredonda para o maior inteiro menor que o valor de entrada (“tipo” arredonda para baixo).

Retorna o menor inteiro i, tal que i <= valor

Documentação: https://numpy.org/doc/stable/reference/generated/numpy.floor.html

Exemplo

valores = np.array([6.3, 0.786, 55, 10.999, -0.63])
print('Array original:')
print(valores)
print('\nValores arredondados:')
print(np.floor(valores))

Resultado:

Array original:
[ 6.3 0.786 55. 10.999 -0.63 ]
Valores arredondados:
[ 6. 0. 55. 10. -1.]

3. Função numpy.ceil

Arredonda para o inteiro imediatamente maior que valor de entrada (“tipo” arredonda para cima). Essa função retorna o menor número inteiro i, tal que i >= valor

Documentação: https://numpy.org/doc/stable/reference/generated/numpy.ceil.html

Exemplo

valores = np.array([6.3, 0.786, 55, 10.999, -0.63])  # mesmo array usado em np.floor
print('Array original:')
print(valores)
print('\nValores arredondados:')
print(np.ceil(valores))

Resultado:

Array original:
[ 6.3 0.786 55. 10.999 -0.63 ]
Valores arredondados:
[ 7. 1. 55. 11. -0.]

4. Função numpy.trunc

Truncar um valor numérico. Retorna o valor truncado da entrada, elemento a elemento.

O valor truncado do escalar x é o inteiro mais próximo i que está mais próximo de zero do que x. Resumindo, a parte fracionária do valor atribuido é descartada.

O que é truncar?

O verbo “truncar” se refere ao ato de cortar ou remover a parte fracionária de um número, mantendo apenas a parte inteira. A operação de truncamento geralmente é realizada em números de ponto flutuante, onde há uma parte inteira e uma parte decimal. Também é possível aplicar a operação de truncagem em strings, o que não é o caso aqui.

Por exemplo, se tivermos o número de ponto flutuante 7.75 e quisermos truncá-lo para um inteiro, o resultado será 7, pois a parte decimal (0.75) foi removida.

É importante observar que o truncamento difere do arredondamento, onde a parte decimal é arredondada para o inteiro mais próximo. No truncamento, a parte decimal é simplesmente removida, resultando sempre em um número menor ou igual ao número original.

Documentação de numpy.trunc: https://numpy.org/doc/stable/reference/generated/numpy.trunc.html

Exemplo

valores = np.array([6.3, 0.786, 55, 10.999, -0.63])
print('Valores truncados:')
print(np.trunc(valores))

Resultado:

Valores truncados:
[ 6. 0. 55. 10. -0.]

5. Função numpy.fix

Arredonda para o número inteiro mais próximo em direção a zero.

Arredonda um array de pontos flutuantes elemento a elemento para o número inteiro mais próximo de zero. Os valores arredondados são retornados como valores de ponto flutuante.

Documentação: https://numpy.org/doc/stable/reference/generated/numpy.fix.html

Exemplo

valores = np.array([6.3, 0.786, 55, 10.999, -0.63])
print('Valores Arredondados:')
print(np.fix(valores))

Resultado:

Valores Arredondados:
[ 6. 0. 55. 10. -0.]

Conclusão

As funções de arredondamento proporcionadas pela biblioteca NumPy conferem uma grande flexibilidade aos programadores Python ao lidar com operações numéricas. Seja em análises estatísticas, processamento de dados ou simulações complexas, o entendimento aprofundado dessas funções é fundamental para assegurar resultados confiáveis e consistentes.

Neste artigo, trabalhamos com as principais funções de arredondamento do NumPy, com exemplos de códigos simples para melhor entendimento de cada função. Ao incorporar esses conhecimentos em seus projetos, você estará mais preparado para resolver desafios numéricos e obter soluções eficientes e precisas ao criar aplicações com Python.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post 5 Funções de Arredondamento de Valores com NumPy em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O NumPy é uma biblioteca em Python para computação científica, especialmente para cálculos numéricos em larga escala e manipulação de arrays multidimensionais. O nome NumPy é uma abreviação de “Numeric Python” (Python Numérico).

O NumPy oferece uma ampla gama de funções e operações matemáticas, incluindo funções de álgebra linear, transformadas de Fourier, geração de números aleatórios, estatísticas e muito mais.

O módulo também inclui ferramentas para integração com outras linguagens de programação, como C, C++ e Fortran.

Uma das principais vantagens do NumPy é sua capacidade de lidar com grandes quantidades de dados de maneira rápida e eficiente, graças à implementação de operações vetorizadas. Essas operações permitem que cálculos em grandes conjuntos de dados sejam executados de forma eficiente e com menos código.

O NumPy é amplamente utilizado em áreas como ciência de dados, aprendizado de máquina, visão computacional, física, matemática, engenharia e muitas outras áreas que envolvem cálculos numéricos intensivos.

Site oficial do projeto NumPy: https://numpy.org/

O que é um array em NumPy?

Em NumPy, um array é um tipo de objeto que representa uma coleção de elementos homogêneos (ou seja, do mesmo tipo) organizados em uma ou mais dimensões. Esses arrays podem ser de diferentes formas (ou seja, números de dimensões e tamanhos), e cada elemento em um array é indexado por uma tupla de inteiros não negativos.

Por exemplo:

Array de uma dimensão:

1 5 9 3 2 4 2 1 6 5 7 0 8



Array de duas dimensões (três linhas por quatro colunas, 3×4):

1 5 9 3

2 4 2 1

6 5 7 0

Um array em NumPy é semelhante a uma estrutura de lista ou listas encadeadas em Python, mas oferece várias vantagens em relação às listas, incluindo:

• Armazenamento eficiente de dados em memória
• Operações matemáticas e de álgebra linear eficientes em arrays multidimensionais
• Índices e fatiamento mais rápidos para acessar elementos
• Suporte para broadcasting (transmissão) para realizar operações em arrays com diferentes formas

Em suma, os arrays em NumPy são usados para representar dados em muitas áreas diferentes, incluindo processamento de imagens, aprendizado de máquina e ciência de dados em geral.

Para criar arrays em NumPy empregamos a função numpy.array(), que pode aceitar como entrada uma lista, tupla ou outro objeto do tipo array. Veremos 10 exemplos de uso da biblioteca Numpy a seguir.

Tutorial básico de NumPy

1. Como instalar o NumPy

Antes de começar a usar o NumPy, precisamos instalá-lo em seu sistema. Podemos instalar o pacote usando o gerenciador de pacotes pip no terminal ou prompt de comando:

pip install numpy

Se estiver usando o gerenciador conda:

conda install numpy

2. Importar o NumPy

Depois de instalar o NumPy, precisamos importá-lo no script Python para poder usar a biblioteca e suas funções:

import numpy as np

3. Criação de arrays

O NumPy é usado principalmente para trabalhar com arrays multidimensionais. Podemos criar um array NumPy usando a função array():

arr = np.array([1, 2, 3, 4, 5])
print(arr)

Esse código cria um array NumPy unidimensional com os valores [1, 2, 3, 4, 5].

Também podemos criar um array NumPy bidimensional passando uma lista de listas para a função array():

arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr)

Desta forma criamos um array NumPy bidimensional com os valores:

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

4. Acessar elementos de um array

Podemos acessar os elementos de um array NumPy usando seus números de índice, que iniciam em 0:

arr = np.array([1, 2, 3, 4, 5])
print(arr[0]) # 1
print(arr[1]) # 2

Também podemos acessar elementos de um array bidimensional usando índices de linha e coluna:

arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr[0, 0]) # 1
print(arr[0, 1]) # 2
print(arr[1, 0]) # 4

5. Operações em arrays

O NumPy permite realizar operações em arrays de forma rápida e eficiente. Por exemplo, podemos adicionar dois arrays NumPy da seguinte maneira:

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
arr3 = arr1 + arr2
print(arr3) # [5 7 9]

O que ocorre se os arrays tiverem tamanhos (formatos) diferentes, como no exemplo a seguir?

arr1 = np.array([1, 2, 3])

arr2 = np.array([4, 5, 6, 7])

arr3 = arr1 + arr2



print(arr3)

Neste caso, será retornado o erro “ValueError: operands could not be broadcast together with shapes (3,) (4,)“.



Isso significa que os arrays possuem formatos distintos, e por isso não é possível transmitir pares de valores (operandos) para realizar a operação aritmética.

6. Funções matemáticas

O NumPy também oferece muitas funções matemáticas, como por exemplo a função sqrt() para calcular a raiz quadrada de um array, exp() para calcular a exponencial de um array e sin() para calcular o seno de um array:

arr = np.array([1, 2, 3])
print(np.sqrt(arr)) # [1. 1.41421356 1.73205081]
print(np.exp(arr)) # [ 2.71828183 7.3890561 20.08553692]
print(np.sin(arr)) # [0.84147098 0.90929743 0.14112001]

7. Reshape de arrays

Podemos alterar a forma de um array usando a função reshape():

arr = np.array([1, 2, 3, 4, 5, 6])
novo_arr = arr.reshape(2, 3)
print(novo_arr)

Esse código irá criar um novo array bidimensional de formato 2 x 3, a partir de um array unidimensional, com os valores:

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

8. Indexação booleana

Você pode usar indexação booleana para selecionar elementos de um array com base em uma condição:

arr = np.array([1, 2, 3, 4, 5])
bool_arr = arr > 2
print(bool_arr) # [False False True True True]
novo_arr = arr[bool_arr]
print(novo_arr) # [3 4 5]

Isso criará um array booleano com o valor True onde o elemento é maior que 2 e False onde o elemento é menor ou igual a 2. Em seguida, um novo array é criado com base no array booleano, que contém apenas os elementos em que o valor é True.

9. Ordenação de arrays

O NumPy também oferece funções para ordenação de arrays:

arr = np.array([3, 2, 1, 5, 4])
novo_arr = np.sort(arr)
print(novo_arr) # [1 2 3 4 5]

Isso criará um novo array com os valores do array original ordenados em ordem crescente.

10. Operações de matriz

O NumPy também é usado para álgebra linear e pode realizar operações de matriz, como multiplicação de matriz e inversão de matriz:

arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])
novo_arr = np.dot(arr1, arr2)
print(novo_arr)

Neste exemplo é efetuada a multiplicação de matriz entre arr1 e arr2 e criado um novo array:

[[19 22]
 [43 50]]

Neste artigo introduzi de forma básica a biblioteca NumPy para iniciantes. O NumPy oferece muitos outros recursos poderosos para trabalhar com arrays multidimensionais e realizar cálculos numéricos eficientes em Python. Nos próximos tutoriais vamos explorar mais a fundo esses recursos e funções da biblioteca.

O post Introdução à Biblioteca NumPy em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Na lição anterior vimos como criar arrays de até três dimensões em Python usando a biblioteca NumPy. Vimos também como atribuir valores a um array no momento de sua criação.

É possível preencher um array de outras formas, por exemplo com valores específicos ou repetidos, o que pode ser útil em determinadas circunstâncias ou em cálculos especiais, por exemplo, em álgebra linear.

O método mais usual de preenchimento de um array em NumPy consiste em passar valores a partir de uma lista ao criar o array, como vimos na aula anterior. Porém, podemos preencher arrays específicos de outras formas também.

Algumas das formas especiais de preenchimento de arrays incluem:

• Preenchimento com zeros
• Preenchimento com uns
• Preenchimento com outro valor numérico repetido
• Preenchimento a partir de uma faixa de valores
• Preenchimento com números gerados aleatoriamente

Vamos estudar cada uma dessas técnicas a partir de agora.

Preencher array com valores específicos

Com os métodos zeros, ones e full podemos criar arrays preenchidos automaticamente com zeros, uns ou com um valor numérico específico, respectivamente.

Os métodos zeros e ones produzem valores do tipo float64 por padrão, mas podemos alterar o tipo de dado se for necessário.

Vejamos alguns exemplos desses métodos.

# Criar array com 10 elementos iguais a 0
print(np.zeros(10))

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

# Criar array com 15 elementos iguais a 1
print(np.ones(15))

[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

# Criar array com 8 elementos iguais a 12 (int).
# O primeiro argumento corresponde ao número de elementos desejados.
print(np.full(8,12)) 

[12 12 12 12 12 12 12 12]

# Criar array com 10 elementos iguais a 0, do tipo inteiro
print(np.zeros(10, dtype=int))

# Criar array com 15 elementos iguais a 1, do tipo inteiro
print(np.ones(15, dtype=int))

# Criar array com 8 elementos iguais a 12, do tipo ponto flutuante
print(np.full(8,12, dtype=float)) # primeiro argumento: núm. de elementos.

[0 0 0 0 0 0 0 0 0 0]
[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
[12. 12. 12. 12. 12. 12. 12. 12.]

# Criar um array bidimensional 2x5 preenchido com zeros, do tipo inteiro:
print(np.zeros((2, 5),dtype=int))

[[0 0 0 0 0]
 [0 0 0 0 0]]

Criar array a partir de faixas de valores: método arange

Também é possível criar um array  a partir de uma faixa de valores especificada, tanto de números inteiros quanto de números de ponto flutuante.

Para isso usamos os métodos arange e linspace.

Criar array com método arange

# Array de 10 elementos, números de 0 a 9
print(np.arange(10))

[0 1 2 3 4 5 6 7 8 9]

# Array de 10 elementos float, números de 0 a 9
print(np.arange(10.))

[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

Basta usar um ponto . na definição da quantidade de elementos do array e automaticamente a função irá criar números de ponto flutuante em vez de números inteiros.

# Array com valores no intervalo de 5 a 15 (usamos 16, pois o último número é sempre limite superior - 1)
print(np.arange(5,16))

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

# Array com os números pares de 50 até 1
# O terceiro argumento, -2, indica o intervalo de contagem dos valores ("passo").
print(np.arange(50, 1, -2))

[50 48 46 44 42 40 38 36 34 32 30 28 26 24 22 20 18 16 14 12 10  8  6  4  2]

Criar array com método linspace

# Criar array com valores de ponto flutuante com o método linspace. 
print(np.linspace(0.0,2.0,num=5))

[0.  0.5 1.  1.5 2. ]

Os argumentos passados para o método linspace são:

• primeiro argumento: valor inicial
• segundo argumento: valor final
• terceiro argumento (num): quantidade de itens a gerar

Preencher array com valores aleatórios (randômicos)

Podemos criar arrays e preenchê-los com números aleatórios, inteiros ou de ponto flutuante, usando os métodos rand e randint da biblioteca NumPy.

# Criar e preencher array com valores aleatórios

import numpy as np

# Array de 10 elementos entre 0 e 1
a = np.random.rand(10)
print(a)

[0.07418479 0.95672716 0.19361192 0.32394591 0.29980946 0.20812523
 0.92100292 0.49129843 0.78413243 0.07830975]

# Gerar um número aleatório inteiro entre 0 e 8 com random.randint
print('Número aleatório:', np.random.randint(9))

Número aleatório: 3

# Array unidimensional com 10 números aleatórios inteiros entre 1o e 20
b = np.random.randint(10,21,size=10)
print(b)

[13 17 16 16 16 12 18 15 14 12]

# Array bidimensional 3x3
c = np.random.rand(3,3)
print(c)

[[0.56700019 0.56581178 0.47336097]
 [0.5626577  0.75670315 0.8608974 ]
 [0.71296439 0.09674716 0.95800157]]

# Array bidimensional 10x10 com números aleatórios inteiros entre 1 e 100
d = np.random.randint(1,101,size=(10,10))
print(d)

[[ 50  55  74  93  77  42  71  69  44  50]
 [ 13  13  79  50  82  75  91  11  79  26]
 [ 76  47  59  79  20  58  30  20  22  36]
 [ 13  81   9  77  34  21   3  91  21  29]
 [ 88  38  76 100   9  18  20  11  39  94]
 [ 45  23  81  13  59   1  13  44  36  33]
 [ 48  93  82  99  97  39  94  23  41  86]
 [ 17  21  65  52  85  87  15  75  50  75]
 [ 61  35  17  52  71  32  29  61  21  62]
 [ 66  19  78  47  92  23  52  58  81  68]]

É isso aí! Nesta lição aprendemos como preencher um ndarray em NumPy usando métodos variados, que permitem atribuir valores específicos, listas de valores ou valores gerados de forma aleatória ao array.

Aproveite e assista a uma aula em vídeo sobre o preenchimento de arrays em NumPy:

Até a próxima!

O post Como preencher arrays com NumPy (ndarrays) apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Por Fábio dos Reis

O NumPy, (Numerical Python) é uma biblioteca de código aberto criada em 2006, sendo um pacote fundamental extensivamente empregado para computação numérica e científica de alta performance e velocidade em Python.

Escrita em linguagem C, é a implementação de estruturas de dados do tipo arrays preferida em Python, fornecendo um tipo de array de alta performance chamado de ndarray.

As operações sobre arrays do NumPy chegam a ser até duas ordens de magnitude mais rápidas do que om o emprego de listas comuns em Python, o que certamente é uma grande vantagem quando pensamos em grandes volumes de dados a serem manipulados e analisados, por exemplo em aplicações para Big Data e Computação Numérica / Científica.

O NumPy trabalha com um objeto de array especial de N dimensões poderoso chamado de ndarray (N-Dimensional Array / Array de N Dimensões), e possui diversas funções e métodos para sua manipulação, além de ouros tipos de objetos como masked arrays e matrizes, dos quais trataremos futuramente.

Muitas bibliotecas populares e altamente importantes dependem do NumPy para operar, como por exemplo as bibliotecas SciPy (para computação científica), Pandas (Análise de Dados), OpenCV, Scikit-learn e Keras (para Machine Learning / Deep Learning), entre centenas de outras bibliotecas.

Neste tutorial vamos mostrar como criar arrays de uma, duas e três dimensões usando o NumPy.

Módulo NumPy

O módulo NumPy fornece diversas funções para criação e manipulação de arrays. Os elementos em um array podem ser acessados por meio de seus números de índice (posição), e os índices de arrays iniciam sua contagem em 0, de modo que o primeiro elemento armazenado é o elemento de índice 0, o segundo elemento é o elemento de índice 1, e assim por diante.

Para trabalhar com o NumPy devemos importar o módulo correspondente usando a seguinte declaração no início do script:

import numpy as np

Não é obrigatório usar o alias np, mas vamos usá-lo em nossos tutoriais por se tratar de um nome bastante utilizado pela comunidade e recomendado na documentação oficial da biblioteca.

Arrays Unidimensionais com NumPy

Um array de uma dimensão, ou unidimensional, é semelhante a um vetor, que costumamos estudar em lógica de programação. Com o NumPy, podemos criar arrays de uma dimensão com muita facilidade, contendo elementos de um tipo específico.

Podemos criar um array usando o método np.array(), passando para ele uma lista com os elementos que comporão o array.

Vamos criar um array de uma dimensão contendo seis elementos numéricos, a partir de uma lista de valores comum:

# Importar o módulo numpy. Recomenda-se importá-lo como "np",
# de acordo com a documentação oficial, para padronização.
import numpy as np

# Criar um array (objeto ndarray) de nome "números" a partir de
# uma lista de valores com o método np.array()
números = np.array([4,8,16,32,64,128])

# Opcionalmente, podemos especificar o tipo de dado dos objetos
# do array com um segundo parâmetro. Por exemplo, np.int16 significa
# um número inteiro de 16 bits, no intervalo de -32768 a 32767:
# números = np.array([4,8,16,32,64,128], np.int16) # Elementos do tipo Int 16 bits.

# Com a função type podemos ver o tipo do objeto criado
print(type(números))

# Ver o conteúdo do array (valores alinhados à direita, ocupando
# o mesmo número de casas de acordo com o maior número presente)
print(números)

# Ver elementos específicos no array por meio de seus números de índice
# (sempre começando em zero)
print(números[0]); print(números[1]); print(números[2]); print(números[-1])

Resultado:

<class 'numpy.ndarray'>
[  4   8  16  32  64 128]
4
8
16
128

Podemos verificar o tipo dos elementos que compõem o array consultando o atributo dtype

números.dtype
Out: dtype('int32')

Arrays Bidimensionais com NumPy

Costumamos chamar de “matriz” a um array bidimensional (o NumPy possui um objeto específico para matrizes). Podemos criar um array bidimensional com NumPy a partir de uma lista de duas dimensões passada como parâmetro:

# Array bidimensional 2x3
# Cada colchete aninhado representa uma dimensão do array.
# Dois pares de colchetes - [[ ]]- indicam duas dimensões:
x = np.array([[1,2,3],[6,4,2]], np.int16)

# Mostrar a matriz completa
print(x)

# Exibir elementos em posições específicas na matriz:
print(x[0,0]); print(x[0,1]); print(x[0,2]); print(x[0,-1])
print(x[1,0]); print(x[1,1]); print(x[1,2]); print(x[1,-1])

Resultado:

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

É possível trabalhar com linhas ou colunas individuais do array de duas dimensões, usando fatiamento (slicing). Vejamos alguns exemplos:

Colunas inteiras

# Imprimir colunas inteiras
print('Primeira coluna: ', x[:,0]) 
print('Segunda coluna: ', x[:,1])
print('Terceira coluna: ', x[:,2])

Saída:

Primeira coluna: [1 6]
Segunda coluna: [2 4]
Terceira coluna: [3 2]

Linhas Inteiras

# Imprimir linhas inteiras
print('Primeira linha: ', x[0,:])
print('Segunda linha: ', x[1,:])

Saída:

Primeira linha: [1 2 3]
Segunda linha: [6 4 2]

Alguns atributos dos arrays

Podemos determinar o número de dimensões de um array (se é uni, bi ou tridimensional) com o atributo ndim

print(números.ndim)
print(x.ndim)

Dimensões do array números: 1
Dimensões da matriz: 2

E também é possível determinar as dimensões de um array com o atributo shape (tamanho do array)

print('Tamanho do array números: ', números.shape)
print('Tamanho da matriz x: ', x.shape)

Tamanho do array números: (6,)
Tamanho da matriz x: (2, 3)

E ainda o número total de elementos de um array, por meio do atributo size:

print('Total de elementos do array números: ', números.size)
print('Total de elementos da matriz x: ', x.size)

Total de elementos do array números: 6
Total de elementos da matriz x: 6

Outro atributo útil é o atributo itemsize, que permite descobrir o tamanho dos elementos de um array (número de bytes necessário para seu armazenamento).

print(números.itemsize)
print(x.itemsize)

4
4

E o atributo flat permite iterar por um array multidimensional como se ele fosse unidimensional:

for i in x.flat:
    print(i, end=' ')

1 2 3 6 4 2 

O parâmetro end=’ ‘ é usado para mostrar os itens em uma única linha, em vez de um item por linha.

Arrays Tridimensionais com NumPy

Damos o nome genérico de “cubo” a um array de três dimensões, contendo os eixos x, y e z no plano cartesiano. Podemos  criar um array tridimensional (lista de três dimensões) com o NumPy usando o mesmo método usado anteriormente, o método np.array().

# Criar um array tridimensional
# Cada colchete aninhado representa uma dimensão do array.
# Três pares de colchetes - [[[  ]]]- indicam três dimensões:
cubo = np.array([[[1,4,7],[3,5,2]],[[5,6,0],[7,4,1]],[[2,8,8],[0,3,6]]])
print('Array tridimensional:\n ', cubo)

# Visualizar elementos específicos do cubo (array tridimensional):

print('\nItem na posição 0,0,0: ', cubo[0,0,0])
print('Item na posição 1,0,0: ', cubo[1,0,0])
print('Item na posição 2,0,0: ', cubo[2,0,0])

Resultado:

Array tridimensional:
  [[[1 4 7]
  [3 5 2]]

 [[5 6 0]
  [7 4 1]]

 [[2 8 8]
  [0 3 6]]]

Item na posição 0,0,0:  1
Item na posição 1,0,0:  5
Item na posição 2,0,0:  2

Conclusão

É isso aí! Neste tutorial aprendemos a criar arrays usando NumPy n Python, incluindo arrays unidimensionais (“vetor”), arrays bidimensionais (“matriz”) e arrays tridimensionais (“cubo”). 

Na próxima lição vamos estudar métodos para preencher os arrays com valores específicos, e como realizar operações aritméticas e matemáticas sobre os elementos de um array.

Enquanto isso, assista a um vídeo da Bóson Treinamentos sobre arrays com NumPy:

Até!

O post Como criar um array no Python com NumPy apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.