Listas e ciclos

Na última mensagem já vimos (finalmente!) como se escreve um programa em Python e como se executa. Mas os comandos de que já falámos não são muito versáteis na quantidade de coisas que podemos fazer com eles. Antes de apresentar um novo comando, vou falar de uma estrutura de dados que é preciso compreender antes: a lista.
Uma lista não é mais do que um conjunto de objetos agrupados. Para criar uma lista, experimente:

>>> lista = [1, 2 ,4, 6 ,7] >>> lista [1, 2, 4, 6, 7]

Acabámos de criar uma lista! E pudemos ver o seu conteúdo completo. Mas imaginemos que queremos ver apenas o número 4. Para isso, escrevemos:

>>> lista[2] 4 >>> lista[2:4] [4, 6]

Claro que aproveitei e mostrei como escolher vários elementos da lista. O indexamento dos elementos da lista funciona da mesma maneira que nas cadeias de caracteres: por meio de slicing. E já agora, mostro como se referencia a partir do fim da lista (ou da cadeia de caracteres), independentemente do seu comprimento. Se fizermos:

>>> lista[-3:-1] [4, 6]

Isto é, o elemento mais à direita é representado pelo índice -1, o segundo mais à direita por -2, e por aí diante. E como antes, o primeiro elemento é incluído, e o elemento final não é, na definição do intervalo de slicing. Também podemos decidir que queremos ver a lista do início até dado ponto, ou de dado ponto até ao final, ou mesmo a lista completa:

>>> lista[:3] [1, 2, 4] >>> lista[3:] [ 6, 7] >>> lista[:] [1, 2, 4, 6, 7]

E que mais podemos fazer com listas? Bem, se quisermos, podemos mudar um dado elemento da lista:

>>> lista[2] = 10 >>> lista [1, 2, 10, 6, 7]

Também podemos remover um dado elemento da lista:

>>> del lista[2] = 10 >>> lista [1, 2, 6, 7]

E também podemos adicionar um dado elemento da lista:

>>> lista = lista + [11] >>> lista [1, 2, 6, 7, 11]

E agora, imagine que queria ver todos os elementos da lista um a um. Uma maneira seria escrever várias vezes lista[i], com i a ir de 0 até ao número de elementos menos 1. Mas felizmente existe uma maneira mais fácil. Vamos ver um programa:

nums = [1, 4, 5, 6, 3] for i in nums:     print(i)

Quando executar este programa (ainda se lembra como?), vai obter o seguinte resultado:

1 4 5 6 3

Bem vindo aos ciclos! Em outras linguagens de programação, definem-se ciclos for através de uma variável que vai sendo incrementada sempre da mesma maneira. No Python, o comando for serve para iterar todos os elementos de uma dada lista, um de cada vez. De notar que o que vai ser executado no interior do ciclo for (neste caso, a instrução print) está indentado (aqui está com 4 espaços), pois no Python a definição de blocos internos de código é feita com indentação, ao contrário de outras linguagens, onde se usam chavetas ou outros. Aqui usei 4 espaços, mas pode usar os espaços que quiser, desde que use sempre o mesmo número num dado bloco. Além disso, o início de um bloco é assinalado por dois pontos (:), que está no final da linha que contém o comando for.
E por hoje é tudo.

Print, Input e programar!

Ora cá estamos de novo.
Já vamos na sexta mensagem e na realidade ainda nem percebemos como se escreve um programa. Não desespere: hoje vamos finalmente abordar esse tema e no final já saberemos criar o proverbial programa que saúda o mundo!
Mas antes disso vamos falar de um dos comandos mais importantes em qualquer linguagem: o comando que nos permite visualizar coisas, que em Python é o comando print(). Mais uma diferença entre a versão 2.x e a 3.x: na versão 2.x não se usam os parêntesis, mas deixa-se um espaço entre o comando e o que se vai visualizar. Experimentemos então:

>>> print('Olá mundo!') Olá mundo!

Repare na diferença:

>>> 'Olá mundo!' 'Olá mundo!'

O comando print() apresenta o resultado visível do objeto, e permite a apresentação de textos a partir de um programa, enquanto a inserção direta no '>>>' apresenta o resultado das cadeias com as plicas em volta.

Vamos agora aprender um outro comando, que nos permite obter dados a partir do utilizador:

>>> input() 6 '6'

Agora é que dava jeito que estivesse a experimentar mesmo isto! É que o 6 acima é escrito por si quando escreve o comando input(), isto é, o Python está a pedir-lhe que escreva algo no teclado e que prima RETURN. E repare no resultado: tem plicas. Isto quer dizer que o que quer que seja que escrevemos é interpretado sempre como uma cadeia de caracteres. Mais um parêntesis: na versão 2.x, o input() só aceita valores numéricos, e temos o raw_input() para aceitar cadeias de caracteres. Na versão 3.x, o raw_input() já não existe.
Vamos agora experimentar:

>>> nome = input() Xico >>> nome 'Xico'

Aqui vemos que podemos atribuir o que obtemos através do input() a uma variável, e podemos consultar o seu valor de seguida. Outra maneira de o fazer é:

>>> print(nome) Xico

E se fizermos:

>>> idade = input() 10 >>> print(nome, idade) Xico 10

Atribuímos o valor '10' à variável idade, e de seguida no print() quando inserimos objetos separados por vírgulas, separa-os com um espaço.
Bem, acho que já temos material suficiente para escrever um primeiro programa. Como se faz isto? Bem, agora é que vai ser necessário uma de duas coisas:

• Estar a utilizar o IDLE do Python
• Utilizar um editor de texto como o Notepad do Windows

Se estiver a usar o IDLE, vá à barra de cima, e escolha File > New File, ou então prima CTRL+N. Vai abrir-se uma nova janela intitulada Untitled. Seja nesta janela, ou na janela do Notepad, escreva:

print('Olá, mundo!')

Tanto no IDLE como no Notepad, na barra de cima, escolha Save, e dê um nome ao ficheiro com extensão .py e grave-o onde lhe apetecer (mas memorize onde o gravou!). E já criou o seu primeiro programa! Para o correr, no IDLE, na janela do seu programa escolha Run, e verá o resultado a surigr na janela principal do IDLE. Para ver o resultado criado através do Notepad, terá de abrir uma Command Prompt, ir até ao directório onde gravou o ficheiro .py, e escrever o seu nome em conjunto com a extensão .py. Giro, não é? Foi o seu primeiro programa em Python!

Tipos de variável

Olá mais uma vez.
Vamos lá então voltar às variáveis. Lembra-se daquela diferença entre 6/2 = 3.0 ou 3? Sim, estes resultados têm um tipo diferente: 3.0 é um número de vírgula flutuante (isto é, permite casas decimais), enquanto 3 é um número inteiro. Se experimentarmos:

>>> type(3) <class 'int'> >>> b=2 >>> type(3.0) <class 'float'>

Resultado interessante, não é? A função type() devolve-nos o tipo do valor ou variável que lhe fornecemos: int para inteiro e float para vírgula flutuante. Outra diferença entre a versão 2.x e a 3.x: na versão 2.x, surge: <type 'tipo'>. Mais geralmente, a função type() devolve-nos o tipo (ou classe) de qualquer objeto, e veremos depois o que significa isto.
A principal diferença entre estes tipos de variável prende-se com o modo de armazenamento interno destes valores no computador. Além disso, de um modo geral as operações entre variáveis ou valores do mesmo tipo resulta no mesmo tipo, com a notável exceção da divisão de números inteiros que, como já vimos, em Python 3.0 resulta num número float. De momento, não dá para perceber qual a utilidade entre ter números inteiros ou de vírgula flutuante, mas veremos isso mais tarde, quando falarmos em enumeração.
Já agora, uma curiosidade: o Python permite utilizar também números complexos (ou imaginários). Para representar a parte imaginária, usa-se a letra j (e não a i, a que estamos habituados). Experimente:

>>> (3 + 5j) + (2 - 7j) (5-2j) >>> 3 + 5j + 2 - 7j (5-2j) >>> type(5-2j) <class 'complex'>

Alguns pormenores a ter em atenção: na primeira linha usei parêntesis só por claridade, pois como se percebe na segunda entrada não são necessários. E podemos ver que estes valores são do tipo complex.
Para resumir: operações entre inteiros podem resultar em inteiros ou de vírgula flutuante; entre inteiros e de vírgula flutuante resulta sempre em vírgula flutuante; entre valores em vírgula flutuante e complexos resulta sempre complexos.
Até agora, só vimos números. Mas existem outros tipos de valores: as cadeias de caracteres, que constituem texto. Estas são definidas colocando caracteres entre plicas ('') ou entre aspas (""). Por exemplo:

>>> "Olá mundo!" 'Olá mundo!' >>> letras = 'Olá mundo!' >>> letras 'Olá mundo!' >>> type(letras) <class 'str'>

Ora então o que temos aqui? Vemos que, como sempre, quando colocamos um valor em '>>>', obtermos como resultado esse valor. Embora tenhamos definido a cadeia com aspas, o resultado apareceu com plicas. Isto só muda se inserirmos alguma plica dentro do texto entre aspas. O objetivo de termos duas maneiras de criar as cadeias é para podermos inserir plicas ou aspas dentro do texto de modo mais fácil.
Também podemos criar variáveis com texto, e ver o seu conteúdo. e o tipo destes valores ou variáveis é str, diminutivo de string. Aqui estão mais umas coisas que se podem fazer com as cadeias:

>>> "Olá " + "mundo!" 'Olá mundo!' >>> "Olá! "*5 'Olá! Olá! Olá! Olá! Olá! ' >>> letras = 'abcdef' >>> letras[2] 'c' >>> letras[2:5] 'cde' >>> 'cde'[1] 'd'

Como seria de esperar, podemos concatenar cadeias. O que possivelmente já não estaria à espera é de poder multiplicá-las! Claro que só se pode multiplicar uma cadeia por um inteiro, e o resultado está à vista.
E finalmente, aquela coisa dos parêntesis retos ([]) é chamada de slicing (em português poderia traduzir-se por seccionamento, mas não me soa tão bem...), e pode usar-se com definição de um ou dois números: se usarmos um, vai buscar o caracter que se encontra na posição definida pelo número; mas atenção que a contagem começa com zero!! No exemplo acima, o caracter 'c' é o terceiro de letras, mas fica na posição 2 se contarmos a partir de zero. Quando se usam dois números separados por ':', o primeiro número aponta para a posição do primeiro caracter a incluir, e o segundo número indica qual o caracter onde se para, não incluindo esse. No exemplo acima, 2 é o terceiro caracter e 5 é o sexto ('f'), que já não foi incluído no resultado. A última linha mostra que podemos seccionar diretamente uma cadeia, não precisa de ser uma variável. Mais uma vez, isto não é tudo, e voltaremos a este assunto mais tarde...
E vamos terminar com o último tipo elementar de que falta falar: o booleano. Este só pode assumir dois valores: verdadeiro (True) ou falso (False). Sim, têm de ser com a primeira letra maiúscula.

>>> True True >>> True == False False >>> True != False True >>> type(True) <class 'bool'>

True é um valor com resultado True. Na segunda inserção, estamos a perguntar se True é igual a False, e como não são iguais, o resultado é False. Acabámos de apresentar outro operador: a igualdade (==), que resulta em verdadeiro ou falso. São dois sinais de igual, para não se confundir com a atribuição de variáveis, só com um sinal de igual. Podemos comparar várias coisas, como (mais uma vez) veremos mais tarde. Depois, temos o operador de desigualdade (!=), que verifica se dois objetos são diferentes. Finalmente, mostramos que o tipo destes valores é booleano ('bool').
E por agora chega.

Variáveis em Python

Cá estamos mais uma vez.
Até agora vimos que podemos usar o IDLE do Python como uma calculadora, mas claro que podemos fazer muito mais! Imaginemos que queremos usar sempre o mesmo valor para vários cálculos, por exemplo o valor de π = 3,14159265. Em vez de estarmos sempre a escrever todas estas casas decimais, podemos guardar este valor numa variável. Como? Veja o exemplo:

>>> pi = 3.14159265 >>> pi 3.14159265

O que aconteceu? Criámos uma variável de nome pi à qual atribuímos o valor 3,14159265, colocando o = a seguir ao nome da variável e finalmente o valor que lhe queremos atribuir (os espaços antes e depois do = são opcionais). Depois perguntámos qual o valor da variável ao escrever pi e obtivemos o resultado. Simples, não é? Repare que, se tivéssemos escrito pi antes de lhe atribuir um valor, iria resultar num erro:

>>> Pi Traceback (most recent call last):   File "<pyshell#5>", line 1, in <module>     Pi NameError: name 'Pi' is not defined

Mas, se já definimos pi, porque é que agora deu erro? Repare na diferença, o segundo foi escrito Pi, com letra maiúscula, e não pi. Sim, primeiro detalhe a reter: os nomes das variáveis são sensíveis à capitalização das letras. E quais são os nomes permitidos para variáveis? Bem, só podem conter as letras de a-z, A-Z, algarismos de 0-9 e o traço de sublinhado _; e o nome não pode começar por um algarismo. Assim, os nomes asd_27, _1uif, Python e aSd_27 são permitidos (e todos diferentes), enquanto $ers, 45asdf, perc% ou AAA-R não são permitidos.
E claro que agora podemos fazer cálculos com as variáveis criadas:

>>> pi*2 6.2831853 >>> pi*pi 9.869604378534024 >>> pi = pi + 3 6.14159265

Repare que, na última linha, alterámos o valor de pi ao adicionarmos-lhe 3. Daí o nome variável, porque o seu valor pode variar... que é o que mais acontece quando se programa.
Bem, e se quiséssemos atribuir o mesmo valor a várias variáveis? Uma maneira seria:

>>> a=2 >>> b=2 >>> c=2

Mas o Python tem uma maneira mais fácil de o fazer:

>>> a=b=c=2

Usando a sintaxe acima, atribuiremos de uma só vez o valor 2 a cada uma das três variáveis. Mas e se quisermos atribuir valores diferentes? Podemos fazê-lo do modo seguinte:

>>> um,dois,tres = 1,2,3 >>> dois 2

Assim, se separarmos variáveis com vírgulas e a seguir ao = colocarmos os valores a atribuir também separados por vírgulas, podemos fazer várias atribuições ao mesmo tempo. E se quisermos ver-nos livres de uma variável? Também o podemos fazer com:

>>> del dois >>> dois Traceback (most recent call last):   File "<pyshell#8>", line 1, in <module>     dois NameError: name 'dois' is not defined

Usando o comando del seguido do nome da variável, apagamo-la e perdemos o seu valor. Giro, não é? Mas da próxima vez vamos falar dos vários tipos de variáveis...

Python como uma calculadora

Muito bem, já chegámos até aqui e ainda não fizemos nada realmente em Python... mas hoje vamos finalmente começar a fazer alguma coisa.
Antes de mais, comecemos por abrir o IDLE do Python com: Start > Programas > Python X.x > IDLE (Python X.x).
Deverá aparecer uma janela com o seguinte conteúdo (ou parecido):

Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 25 2016, 22:01:18) [MSC v.1900 32 bit (Intel)] on win32 Type "copyright", "credits" or "license()" for more information. >>>

Muito bem: a seguir ao ">>>" abaixo está a piscar um cursor, que indica onde irão ser escritos os comandos. Experimente escrever "1+1", seguido de ENTER. Deverá aparecer o seguinte:

>>> 1+1 2 >>>

O que é que acabou de acontecer? Bem, perguntámos ao IDLE do Python quanto é 1+1 e ele apresentou o resultado: 2. Ao contrário de outras linguagens, em que temos de usar um comando para pedir para mostrar o resultado (um Print ou um Write, ou algo do género), aqui apenas temos de escrever o que queremos calcular. E surge nova ">>>" para aceitar um novo comando.
Do mesmo modo, os resultados seguintes são de esperar:

>>> 5-2 3 >>> 3*5 15 >>> 6/2 3.0

Assim, ficamos a saber como somar, subtrair, multiplicar (símbolo *) e dividir. Mas atenção! Reparou que 6/2 deu 3.0 e não 3? Bem, aqui surge uma primeira diferença entre o Python 3.x e o Python 2.x: no primeiro, a divisão entre dois números dá sempre como resultado um número com casa decimal, enquanto no Python 2.x o resultado é um número inteiro, ou seja, resulta numa divisão inteira. Por exemplo, em Python 2.x, 6/4 = 1. Se quisermos a divisão exata, teremos de escrever um dos números com casa decimal, do modo seguinte: 6.0/4 = 6/4.0 = 1.5. Voltaremos a isto quando falarmos em tipos de variáveis....
Por outro lado, em Python 3.x, se quisermos a divisão inteira, escrevemos:

>>> 6//4 1 >>> 6%4 2

E o sinal % serve, tanto em 2.x como em 3.x, para calcular o módulo, isto é, o resto da divisão inteira, como o exemplo acima demonstra. Finalmente, um último operador:

>>> 6**4 1296

Este é o operador de potência, isto é, 6*6*6*6 = 6⁴ = 1296. E como seria de esperar, os operadores têm precedência: ** antes de *, / e %, antes de + e -. Claro que podemos usar parêntesis para alterar a ordem em que os cálculos são efetuados:

>>> 1+2*3 7 >>> (1+2)*3 9 >>> 2**1/2 1.0 >>> 2**(1/2) 1.4142135623730951

De notar que, como se ilustra acima, podemos calcular raízes com potências fracionárias, como seria de esperar. Assim, já podemos usar o Python como uma calculadora! E por agora é tudo.