Python Progressivo

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.

Acessar, selecionar e dividir elementos de arrays

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.

Neste tutorial introdutório de nossa seção de Strings em Python, vamos revisar o que é uma string, o que não é, como usar, acessar seus caracteres e descobrir seu tamanho.

Leia também:

Como Usar Strings

Vamos dar uma relembrada nos conceitos principais de string.

Representamos uma string por:

'algo'
"algo"

Ou seja, qualquer caractere entre aspas simples ou aspas duplas.
É errado fazer: 'algo" ou "algo'

Se começou com simples, termina com simples. Se começa com dupla, termina em aspas duplas.

É possível também usar as dois, para mostrar aspas simples ou dupla num print, por exemplo:
'Curso "Python" Progressivo'

A saída é: Curso "Python" Progressivo
Isso ocorreu porque o Python entende que tudo dentre as aspas simples, era uma string, incluindo as aspas duplas.

Caracteres Especiais em Python

Para representar coisas diferente de texto, número e acentuação, usamos a barra de escape, que nos permite utilizar os seguintes caracteres especiais:

\\ - Exibe uma barra
\' - Exibe a aspa simples
\" - Exibe a aspa dupla
\a - Dá um bipe
\b - Retrocesso
\f - Avanço
\n - Caractere de nova linha (enter)
\r - Carriage return
\t - Tab horizontal
\v - Tab vertical

Acessando caracteres de uma string
Podemos acessar caractere de uma string usando o laço for:

texto = "Curso Python Progressivo"

for caractere in texto:
    print(caractere)

Ou seja, a variável caractere vai assumindo o valor de cada caractere da string texto, um por um e imprimindo.

Para exibir sem a quebra de linha:

texto = "Curso Python Progressivo"

for caractere in texto:
    print(caractere, end='')

Você também pode acessar diretamente caractere por caractere, como se fosse uma lista:
texto[0]='C'
texto[1]='u'
texto[2]='r'
texto[3]='s'
texto[4]='o'
texto[5]=' '
etc

Já o comando:
texto[0:5] imprime 5 caracteres, de posição 0, 1, 2, 3 e 4: 'Curso'

O comando:
texto[:6] - exibe do índice 6 em diante: 'Python Progressivo'

Ou seja: texto[inicio : fim] - é uma string que começa em inicio e termina em fim-1.

Tamanho de uma string: len()

Uma função nativa do Python e bem útil, é a len().
Você chama ela com uma string dentro, e ela te retorna o número de caracteres.

Fazendo:
print( len(texto) ) - retorna o valor 24, pois tem vinte e quatro caracteres.

Concatenar Strings: operador +

Vejam o seguinte código:

texto = "Curso"
print(texto)

texto = texto + " Python Progressivo"
print(texto)

Inserimos a string 'Curso' na variável texto.
Em seguida, fazemos essa variável se igualar com ela mesma MAIS a string " Python Progressivo".

Isso foi feito com sinal de +, é o operador de concatenação, ou seja, vai unir uma string na outra.
O leitor mais atento, vai pensar:

"Mas você disse que strings são imutáveis"

De fato, são.
A variável texto apontava para um endereço de memória que tinha "Curso" lá.
Depois, passou a apontar para outro endereço, que tem a string "Curso Python Progressivo".

A antiga referência vai deixar de ser usada e portanto descartada de imediato pelo Python.