Arrays em Python - Como acessar elementos, linhas e colunas de Arrays e Matrizes

  Agora que já aprendemos a criar os mais diversos tipos de arrays e matrizes, bem como inicializar com vários tipos de valores, vamos aprender o famoso indexing and slicing, em nosso curso de Programação Científica em Python.

Ou seja, vamos ver como acessar e modificar diretamente cada elemento de um array, como selecionar apenas uma parte dele, como dividir em array menores e outras funcionalidades interessantes, que vão facilitar muito nossa vida, principalmente no estudo da análise de dados.

Como acessar elementos de Arrays de uma dimensão

Vamos criar um array de uma dimensão, de 10 elementos. Vejamos o código:

import numpy as np MeuArray = np.arange(10) MeuArray

Saída: 
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Agora, aprenda essa regra:
Em programação, sempre começamos a contar do 0. Não começamos do 1, ok?

Logo, para acessarmos o primeiro elemento, basta escrevermos o nome do array, seguido do parte de colchetes, e dentro destes o índice que você deseja.

Para selecionar o primeiro elemento do array, faça: MeuArray[0]
Para selecionar o segundo elemento do array, faça: MeuArray[1]
Para selecionar o terceiro  elemento do array, faça: MeuArray[2]
...
Para selecionar o último elemento do array, faça: MeuArray[10]

Teste o código:

import numpy as np MeuArray = np.linspace(0,1,11) for i in range(len(MeuArray)): print("Elemento [",i,"]: ", MeuArray[i])

Saída:

Elemento [ 0 ]: 0.0 Elemento [ 1 ]: 0.1 Elemento [ 2 ]: 0.2 Elemento [ 3 ]: 0.3 Elemento [ 4 ]: 0.4 Elemento [ 5 ]: 0.5 Elemento [ 6 ]: 0.6 Elemento [ 7 ]: 0.7 Elemento [ 8 ]: 0.8 Elemento [ 9 ]: 0.9 Elemento [ 10 ]: 1.0

Nele, fizemos o seguinte: chamamos a função linspace(), pedindo para criar um array com elementos de 0 até 1, igualmente espaçados em 11 blocos.

Ou seja, o array terá 11 elementos. Para acessar cada um deles, vamos do índice 0 até o índice 10. Onde o primeiro elemento é representado pela variável MeuArray[0] e o último pela variável float MeuArray[10], pois os arrays criados pela linspace são do tipo float.

Resumindo: se seu vetor Vect tem n elementos, o primeiro é o Vect[0] e o último é o Vect[n-1]

Como acessar elementos de Matrizes (arrays 2D)

Usamos apenas um índice para acessar elementos de um array unidimensional pois...ele tem apenas uma dimensão (a primeira linha). Já em uma matriz, vamos precisar fornecer dois índices (indexes), o da linha e o da coluna.

Por exemplo, vamos criar e exibir a seguinte matriz 3x3:

import numpy as np MeuArray = np.array([ [1,2,3], [4,5,6], [7,8,9] ])

Lembrando que o índice da primeira linha é 0, o da segunda 1 e o da terceira 2.
O índice da primeira coluna é 0, o da segunda coluna é 1 e o da terceira coluna é 2.

Agora a regra dos índices: o primeiro índice se refere a linha e o segundo índice se refere a coluna. Do mesmo jeito que é na Matemática/Álgebra Linear. Colocamos cada índice entre colchetes.

Assim, para acessar o primeiro elemento, da primeira coluna: MeuArray[0][0]
Para acessar o segundo elemento da primeira linha: MeuArray[0][1]
Já para acessar o segundo elemento da primeira coluna: MeuArray[1][0]

O seguinte script exibe todos os elementos da matriz que usamos como exemplos, um por um:

import numpy as np MeuArray = np.array([ [1,2,3], [4,5,6], [7,8,9] ]) for linha in range(3): for coluna in range(3): print("Linha %d e coluna %d: %d" % (linha+1, coluna+1, MeuArray[linha][coluna]))

Saída:

Linha 1 e coluna 1: 1 Linha 1 e coluna 2: 2 Linha 1 e coluna 3: 3 Linha 2 e coluna 1: 4 Linha 2 e coluna 2: 5 Linha 2 e coluna 3: 6 Linha 3 e coluna 1: 7 Linha 3 e coluna 2: 8 Linha 3 e coluna 3: 9

Veja que interessante este script. Para exibir os elementos, usamos dois laços for aninhados. O primeiro, vai pegar da primeira linha (a linha 0) até a terceira linha (linha 2).

Dentro de cada iteração, estamos dentro de cada linha. Então usamos outro for para pegar os elementos de cada coluna, fazendo a variável coluna ir de 0 até 2.

Dentro deste segundo laço, basta irmos imprimindo o número correspondente da linha, da coluna e do valor armazenado em cada elemento da matriz.

Note que somamos o valor 1 para as variáveis linha e coluna, pois para o Python, as linhas e colunas tem índices 0, 1 e 2. Mas, para nós humanos, queremos mostrar as linhas 1, 2 e 3.

Como acessar linhas e colunas de uma matriz

O NumPy também nos permite acessarmos diretamente uma fileira inteira, seja uma linha ou uma coluna. Para isso, vamos usar o operador :, que será melhor explicado no próximo tutorial.

Para imprimir a primeira linha: MeuArray[0, : ] ou apenas MeuArray[0]
Para imprimir a terceira linha : MeuArray[2, : ] ou apenas MeuArray[2]

Para imprimir a primeira coluna: MeuArray[:,0] (a saída é um vetor horizontal)
Para imprimir a segunda coluna, mas na forma de um vetor vertical, faça: MeuArray[ : , [1] ]

Dimensões e números de elementos de um Array

Muitas vezes, vamos precisar escrever programas onde não saberemos exatamente como vai ser o array de dados que iremos receber, portanto temos que aprender técnicas para checar que tipo de informação estamos recebendo.

Por exemplo, para descobrirmos a dimensão de um array, usaremos o atributo ndim. Seja o array unidimensional:

• arr1 = [12, 21, 33]

Se você usar arr1.ndim, ele terá o valor 1, pois esse array é unidimensional (apenas uma linha):

import numpy as np arr1=np.array([21, 12, 33]) print("Dimensão do array arr1: ",arr1.ndim)

Já uma matriz, por exemplo, tem dimensão dois:

import numpy as np arr2=np.array([[21, 12, 33], [11, 22, 23]]) print("Dimensão do array arr2: ",arr2.ndim)

Se quisermos saber, exatamente, o tanto de linhas que possui um array, podemos usar a função interna len() do Python, len(arr). Lembre-se, que para selecionar uma linha qualquer da matriz, como a primeira, usamos o arr[0], logo, se aplicarmos a função len[0] nessa linha (array unidimensional), teremos o número de elementos dele, que é o número de colunas (mesmo número de colunas da matriz), veja:

import numpy as np arr=np.array([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]]) print("Número de linhas: ", len(arr)) print("Número de colunas: ", len(arr[0])) print("Linhas e colunas do array arr: ",arr.shape)

Por fim, podemos usar também o atributo shape, que retorna uma lista com o valor das linhas e colunas. Teste o código acima e veja o resultado. No próximo tutorial, vamos aprender mais sobre shapes (formas de matrizes).

Também pode ser necessário ter o número total de elementos de uma matriz. Para isto, basta acessar o elemento size:

import numpy as np arr=np.array([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]) print("Número total de elementos: ", arr.size)

Lembrando que o número total de elementos de uma matriz nada mais é que o produto do número de linhas pelo número de colunas.

Exercício de Arrays e Matrizes

0. Qual a relação matemática entre len(arr), len(arr[0] e  o atributo size?

1. Crie uma função sum() que recebe um array unidimensional e retorna a soma de seus elementos, usando apenas o atributo size do NumPy.

2. Crie uma função square_matrix(), que verifica se a matriz recebida é quadrada ou não. Matriz quadrada é aquela que o número de linhas é o mesmo do de colunas.

3. Crie uma função chamada trace() que recebe uma matriz quadrada e retorna o seu traço, ou seja, a soma dos elementos da diagonal principal. Lembrando que somente matrizes quadradas possuem traço.

4. Crie uma função sum_matrix() que recebe duas matrizes e retorne uma matriz com a soma destas duas matrizes anteriores. Lembre-se que só podemos somar matrizes que tenham mesmo número de linhas e colunas, seu script deve checar isso antes de somar.

Em nosso livro/apostila/ebook Programação Científica com Python, resolvemos e comentamos todas essas questões, além de fornecer o código completo.

Livro Python Progressivo

Obter livro impresso

Vídeo aula - Tipos de Dados em Python

Nesta vídeo-aula, iremos falar sobre os principais tipos de dados em Python:

• - String: textos e caracteres
• - Números: int, float, binário, hexadecimal
• - Listas
• - Lógicos: booleanos True e False

Bem como para que servem, quais seus propósitos e a importância dos tipos de dados em linguagem de programação Python.

Vídeo aula: Como exibir mensagens de texto na tela

 Nesta vídeo aula de nosso Curso Python Progressivo, vamos te apresentar e ensinar a usar a função print(), para exibir mensagens de texto na tela de seu computador.

NumPy - Como criar e inicializar Arrays em Python

 Neste tutorial, vamos te ensinar como usar a biblioteca NumPy para declarar, inicializar e usar Arrays em Python.

Este tutorial faz parte de nosso curso Programação Científica - Computação Numérica e Data Science com Python.

Como importar o módulo NumPy

Para podermos usar a biblioteca NumPy, a primeira coisa que temos que fazer é...'colocar' ela em nosso código. Ou seja, deixar claro para o Python que iremos usar o módulo numpy, e fazemos isso com o comando import: 

• import numpy

Agora, basta usarmos o nome numpy seguido de um ponto, e em seguida o recurso que você deseja acessar/usar, da biblioteca. Por exemplos, para imprimirmos o valor do número pi:

1. import numpy
2. print(numpy.pi)

Teste sempre nossos exemplos de código. Sempre.

Porém, é bem comum darmos algum 'apelido' para essas bibliotecas, geralmente algum nome mais curto e simples, para evitar ficarmos repetindo um comando maior. Por exemplo, vamos dar o apelido de 'np' para a NumPy:

1. import numpy as np
2. print(np.e)

No exemplo acima, pegamos o valor da constante de Euler, muito usada em logaritmos.

Como criar Arrays a partir de Listas e Tuplas

Vamos usar a função numpy.array() para criar e inicializar nossos arrays com valores específicos. No exemplo a seguir, vamos passar a lista [1, 2, 3]:

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

Saída: [1 2 3]

Agora, vamos primeiro criar uma variável de nome MinhaTupla, colocar uma Tupla contendo strings nela e passar essa variável direto para a função array():

import numpy as np MinhaTupla = ("Python", "Java", "C++") MeuArray = np.array( MinhaTupla ) print(MeuArray)

Saída: ['Python' 'Java' 'C++']

Para criarmos arrays multidimensionais, basta ir separando as sequências (listas ou tuplas) por vírgulas. Por exemplo, vamos criar uma matriz 3x3 de floats:

import numpy as np MeuArray = np.array([ [1.1, 2.4, 5.4], [5.5, 7.6, 8.9], [9.1, 0.0, 2.1] ]) print(MeuArray)

Saída:
[[1.1 2.4 5.4]
 [5.5 7.6 8.9]
 [9.1 0.  2.1]]

Veja que a as três listas estão dentro de um par de colchetes também.

Inicializando Arrays com Zeros e Um

Muitas vezes, em exatas, vamos precisar inicializar vetores e matrizes com alguns números constantes, como 0 e 1.

Por exemplo, se você vai contar algo, precisa que sua variável parta do 0, logo você tem que inicializar ela com zero. Outras vezes, como em Álgebra Linear, podemos querer inicializar uma matriz com todos seus elementos tendo valores 1.

Para isso, usaremos as funções numpy.zeros() e numpy.ones(), respectivamente.
Para isto, basta passarmos as dimensões do array que você quer inicializar.

Por exemplo, um array de valores nulos, com 5 elementos:

import numpy as np MeuArray = np.zeros(5) print(MeuArray)

Já para criar uma matriz de 4x3 preenchidas de valores unitários, fazemos:

import numpy as np MeuArray = np.ones( (4,3) ) print(MeuArray)

Note que colocamos as dimensões dentro de um par de parêntesis.

E se quisermos um array todo preenchido com o valor de Pi, por exemplo?
Muito simples, basta multiplicar o valor de Pi pela função ones():

import numpy as np MeuArray = np.pi * np.ones( 10 ) print(MeuArray)

Note que para inicializar um arrays com valores diferentes de 0 e 1, usamos dois passos: invocar a função zeros() ou ones() e depois multiplicar. É possível fazer isso chamando apenas uma função, a full(), onde primeiro informamos a dimensão de nosso array e em seguida o valor que queremos inicializar todos os elementos.

Por exemplo, uma matriz 2x2 toda inicializada com o valor 2112:

import numpy as np MeuArray = np.full((2,2),2112) print(MeuArray)

arange(): inicializando um array com uma sequência numérica

Temos no módulo NumPy uma função semelhante a função range() do Python, mas para lidarmos de maneira bem eficiente com arrays, é a arange().

Por exemplo, se quisermos um array com os 100 primeiros números inteiros, fazemos simplesmente:

import numpy as np MeuArray = np.arange(100) print(MeuArray)

Saída:
[ 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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99]

Importante notar que, na arange(), ao fornecermos um valor n, o NumPy vai inicializar com os valores de 0 até n-1, ou seja, nunca inclui o número n.

A arange() vai mais além (assim como a range() ). Podemos definir o ponto inicial, o final e o step ou pulo, que os valores vão dar. Por exemplo, para inicializar os elementos de um array com todos os números pares, de 0 até 100 (incluindo este), fazemos: 

import numpy as np MeuArray = np.arange(0,101,2) print(MeuArray)

Saída: [  0   2   4   6   8  10  12  14  16  18  20  22  24  26  28  30  32  34 36  38  40  42  44  46  48  50  52  54  56  58  60  62  64  66  68  70 72  74  76  78  80  82  84  86  88  90  92  94  96  98 100]

linspace(): definindo o número de intervalos da sequência

Se usarmos valores do tipo float (decimais), a arange() irá fazer alguns arredondamentos, o que pode acarretar um problema: não sabermos quantos valores o array terá.

Para contornar isso, temos uma função bem parecida, a linspace(), onde vamos deixar bem claro quantos intervalos teremos:

• numpy.linspace(inicio, fim, numero_termos)

Ou seja, não vamos definir o valor do step e sim o número de intervalos que queremos.
Por exemplo, para termos um array com valores de 0 até 10, divididos em 11 espaçamentos, fazemos:

import numpy as np MeuArray = np.linspace(0, 10, 11)

Saída: array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

Note que, na saída anterior, o valor 10 apareceu. Na linspace(), o elemento final aparece, diferente da arange(). Note também que o resultado da linspace() está em formato float (com casas decimais).
Recomendamos usar a arange() com valores inteiros e a linspace() com valores decimais.

Veja bem, o step na arange() é para você incrementar a sequência de step em step.
O step na linspace() é para você definir quantos intervalos você quer quebrar a sequência (inicio,fim)

Em nossa apostila Programação Científica em Python, vamos te mostrar e explicar o código para produzir o gráfico abaixo, usando a linspace(), de uma função seno, variando de 0 até 2pi:

Como criar array de matrizes

O NumPy também oferece uma vasta de opções para trabalharmos diretamente com matrizes.
Por exemplo, para criar uma matriz identidade de dimensão 5 (ou seja, uma matriz com os elementos da diagonal principal com valor 1 e valor 0 para os demais), usamos a função identity():

import numpy as np matriz = np.identity(5)

Saída:

array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])

Podemos também 'deslocar' essa diagonal de valor, usando a função eye(), que recebe dois argumentos:

1. O primeiro é o da dimensão da matriz
2. O segundo é o argumento k, que é o offset, ou seja, o deslocamento. Se for positivo, subimos essa diagonal de 1's e se for negativo, descemos a diagona de números 1

Por exemplo, uma matriz de dimensão 6 com a diagonal deslocada para a diagonal imediatamente acima:

import numpy as np matriz = np.eye(5,k=1)

Saída:

array([[0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.],
       [0., 0., 0., 0., 0.]])

Agora uma matriz de dimensão 7, com um offset de dois:

import numpy as np matriz = np.eye(7,k=-2)

Saída:

array([[0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0.],
       [1., 0., 0., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0., 0., 0.],
       [0., 0., 1., 0., 0., 0., 0.],
       [0., 0., 0., 1., 0., 0., 0.],
       [0., 0., 0., 0., 1., 0., 0.]])

Também é possível criar uma matriz cuja a diagonal principal recebe uma lista qualquer de valores, para isso bastando usar a função diag(). A dimensão de nossa matriz será a mesma dessa sequência de valores. Por exemplo, uma matriz de dimensão 10 com os números 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9:

import numpy as np matriz = np.diag( np.arange(0,10,1) )

Saída:

array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 2, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 4, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 5, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 6, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 7, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 8, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 9]])

Essa função também aceita um argumento k de offset.

Exercício: que valor devemos passar para a função eye() para que ela seja igual a identity()? Ou seja, para preencher a diagonal principal.

Vídeo aula: O que é preciso para começar a programar em Python ?

 Neste vídeo aula, de nosso curso Python Progressivo, vamos falar sobre:

• O que é necessário para começar a programar em Python ?
• Preciso baixar algo?
• Precisa instalar algum programa ou configurar minha máquina?
• Qual o melhor computador e configuração para se programar em Python
• Onde digito os códigos Python
• IDLE

A biblioteca NumPy – Arrays, Vetores, Arrays Multidimensionais e Matrizes

Neste tutorial, vamos conhecer um pouco mais sobre a biblioteca Numpy, a library mais fundamental do mundo da programação científica, computação numérica e até mesmo da análise de dados.

Vamos aprender o que são e para que servem os arrays, vetores, matrizes e arrays multidimensionais.

Sobre a as origens da biblioteca NumPy

Um dos maiores grupos de praticantes de programação, são as pessoas do meio científico.

Então, sempre que surge uma nova linguagem, uma nova ferramenta, um novo programa ou sistemas, não tenha dúvidas: vários físicos, matemáticos, químicos, engenheiros etc, vão dar uma olhada para ver se aquilo pode ser usado no mundo das ciências.

E não foi diferente com o Python. Aquela linguagem bonita, simples e bem direta, encantou os cientistas.

Em 1995, a comunidade já começou a lançar pacotes voltadas para cálculos numéricos, como o Numarray e o Numeric. Depois, esses dois pacotes e diversas outras funções foram agrupadas e em 2006 foi lançada a primeira versão da NumPy library.

Desde então, se tornou a biblioteca mais usada pela comunidade científica do mundo inteiro, para performar operações em arrays com uma eficiência e versatilidade incrível.

Se seus dados e informações podem ser colocados em um array, então você pode fazer tudo e mais um pouco com eles, usando o NumPy.

O core da biblioteca foi escrito em linguagem C, conhecida por ser extremamente robusta, rápida e poderosa.

Arrays e Vetores em Python

Antes de entrar em mais detalhes sobre a NumPy, vamos relembrar o que são arrays, vetores, matrizes...

O que é um Array

Inicialmente, no estudo da programação, vamos definindo variáveis. Por exemplo, uma variável para armazenar sua nota de Cálculo I. Depois, usamos outra variável para armazenar sua nota de Física I.

Veja que, com esses dois dados já podemos calcular a sua média. Mas, provavelmente você tem mais matérias. Então vamos definir mais variáveis para armazenar suas notas de Introdução a Química, Física Experimental, Programação...veja, já temos 5 variáveis, só para suas notas.

Agora imagina que você precise trabalhar com as notas de todas as pessoas da sua sala, uns 40 alunos. Iria precisar de 200 variáveis. E aí? Vai definir, inicializar e trabalhar com cada uma dessas variáveis, individualmente? Sem chance.

E aí que entram os arrays. Array é um tipo de estrutura de dados, é como se fosse um novo tipo de 'variável', que consegue armazenar, de maneira ordenada, diversas variáveis, do mesmo tipo, de uma vez só.

Imagine uma variável como um espaço na memória do seu computador. Um quadradinho. Um array, é um conjunto 'grudado' desses quadradinhos:

O array é essa fila de bloquinhos, onde cada bloco pode armazenar uma variável. Cada bloco é definido por um índice. O primeiro é sempre 0.
Na imagem acima, temos um array de 6 elementos: o elemento 0, o elemento 1, ...e o elemento 5.

Ou seja, em vez de criar 200 variáveis para armazenar notas (variável do tipo float - números decimais), apenas use um array do tipo float de tamanho 200.

Veja bem, uma variável comum armazena apenas um tipo de informação (um número inteiro, ou um decimal, ou uma string, ou um valor lógico etc). Sempre uma coisa apenas.

Então, um array é uma variável especial que pode armazenar várias informações de uma vez só.

O que é uma matriz ou array multidimensional

No exemplo anterior, das 5 notas dos 40 alunos, teríamos um array de 200 elementos. Ou seja, 1 linha e 200 colunas. É um array de apenas uma dimensão.

Agora imagina que o coordenador do seu curso tenha 4 turmas iguais a sua. Ele ia precisar de 200 variáveis para armazenar as notas da primeira turma, mais 200 para a da segunda turma, mais 200 para a terceira e para a quarta.

Em vez de um array com uma dimensão, de uma linha, seria interessante ele ter um array com 4 linhas. Assim, cada linha representaria uma turma.

Temos então um array multidimensional, do tipo 4 x 200, ou seja, 4 linhas e 200 colunas.

Na imagem acima, temos um array multidimensional do tipo 3x3, 3 linhas e 3 colunas.
É um array 2D (duas dimensões), onde cada linha é um array 1D (de uma dimensão).

Isso te lembra algo, do ensino médio ou de álgebra linear? Sim, amigos. É uma matriz.

O que é um vetor

Ou seja, arrays podem armazenar diversas informações, e em vários formatos (shapes) e dimensões. Eles possuem no mínimo uma linha e uma coluna (array com um elemento só).

Mas podem ter diversas linhas e diversas colunas, como em uma matriz. Mas veja, uma matriz é um elemento bidimensional. Podemos ter arrays com mais dimensões, inclusive.

No exemplo acima, temos 3 matrizes. Cada matriz é do tipo 4x4, e cada elemento dessa matriz é uma lista. É um array multidimensional, de 3 dimensões, do tipo 3x4x4

Já um vetor (vector) é nada mais que um array, mas sempre de uma dimensão apenas. Que se assemelham muito com as listas do Python, que já estudamos vastamente aqui em nosso curso.

Diferença entre lista e vetor

As listas são estrutura de dados heterogêneas, ou seja, você pode criar uma lista com um número inteiro, seguido de um caractere, depois um float, um texto etc.

Você pode agrupar todo tipo de dado que quiser, em uma lista do Python.

Já os arrays, que estudaremos em Computação Científica e Data Science, devem sempre armazenar elementos do mesmo tipo. Ou seja, arrays são homogêneos.

Outra característica, é que os arrays tem tamanhos fixos, definidos no momento de sua criação. Se precisarmos mudar, vamos ter que criar outro array.

Já as listas são dinâmicas, você pode aumentar e reduzir seu tamanho sempre que desejar. São mais flexíveis, porém isso tem seu preço computacional, são mais lentas.

Por conta dessas características mais específicas, os arrays são bem mais rápidos e eficientes, consumindo menos memória e necessitando menos capacidade computacional. Portanto, não é de se estranhar terem sido escolhidos como a base da computação numérica no NumPy

O que é possível fazer com o NumPy

Agora que já entramos em detalhes mais específicos sobre arrays, vetores e matrizes, vamos ver o que é possível fazer com arrays.

Basicamente, vamos aprender a manipular e processar arrays.

Sabe nossa matriz, com as notas? Podemos descobrir a média de cada aluno, de cada turma. Ou podemos descobrir quais foram as médias dele em cada matéria.

Com base nisso, podemos dizer quem tirou acima de 7.0 e passou direto, quem tirou entre 4.0 e 7.0 e vai pra recuperação, e os que reprovaram direto.

E qual turma foi a melhor? Ora, manipulando os arrays para calcular a média de cada sala (lembra que cada linha representa uma turma? Ué, tira a média dos dados de cada linha da matriz).

Podemos 'quebrar' o array multidimensional em outros menores, somente com as notas de cada matéria ou de cada turma.

Podemos também adicionar mais uma linha nesse array, com os dados de uma nova turma. Mas, lembra que dissemos que os arrays tem tamanhos fixos? Como adicionar os dados de mais uma turma?

Nesse caso, criamos uma matriz 5x200, copiamos os dados da matriz antiga 4x200 para esta e em seguida inserimos as informações da quinta linha. Prontinho, um novo array multidimensional.

Isso são apenas algumas operações básicas. Podemos ir bem mais além, e fazer tudo de Álgebra Linear, e até cálculos da transformada de Fourier, em cima destes arrays.

ndarray - O coração da biblioteca NumPy

Em nossa apostila e livro de Programação Científica em Python, falamos sobre os objetos da classe ndarray da NumPy, que são a base de funcionamento dessa biblioteca, que possuem informações cruciais para podermos entender melhor como trabalhar com os arrays para propósitos científicos.

No próximo tutorial, vamos aprender como criar e inicializar arrays dos mais diversos tipos de dados.