Voltemos aos ciclos: as listas de compreensão

Já vimos antes o que são ciclos e o que são listas, e até podemos usar ciclos para gerar listas como se ilustra no programa seguinte:

lista = [] for i in 'palavra':     lista += [i]

Bem, aproveito para apresentar um novo conjunto de atribuições: as atribuições aumentadas. Estas operações não atribuem um valor a uma variável; em vez disso, alteram o valor dessa variável com o que estiver à direita da atribuição. Uma maneira muito mais simples de explicar isto é a seguinte:

Atribuições aumentadas:
a += b	a = a + b
a -= b	a = a - b
a *= b	a = a * b
a /= b	a = a / b
a //= b	a = a // b
a %= b	a = a % b

Assim, o que está à esquerda é equivalente ao que está à direita. Isto explica a última linha do programa. Vamos então ver o que são afinal essas listas de compreensão. Mais uma vez, um exemplo ilustra melhor o que quero dizer:

lista = [i for i in 'palavra']

Muito bem, o que está aqui faz o mesmo que o programa mais acima! Vamos por partes: o facto de envolver  o i for i in 'palavra' com [] quer dizer que vamos obter uma lista. Se tivéssemos {} ou () poderíamos obter conjuntos ou tuplos, respetivamente. De seguida, as listas de compreensão devem ter uma instrução for, para iterar os vários elementos que irão compor a lista (no caso acima, vai iterar as letras da cadeia de caracteres e colocar cada uma como elemento da lista final). E finalmente, o i antes do for indica o que se vai colocar em cada elemento.
Vamos supor agora que queríamos a lista dos quadrados dos primeiros 10 inteiros:

>>> quad = [i*i for i in range(1,11)] >>> quad [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Repare agora o que ficou no início, i*i em vez de i.
Mas isto pode tornar-se mais complicado:

>>> mult = [i*j for i in [1,2,3] for j in [2,4,6]] >>> mult [2, 4, 6, 4, 8, 12, 6, 12, 18]

Repare que aqui temos dois ciclos e o que vai acontecer é que para cada iteração de i, vai multipicar-se por cada um dos j e preencher um elemento, resultando num total de 9 elementos, para este exemplo.
Um exemplo bastante ilustrativo que vem diretamente da documentação do Python:

>>> matriz = [ ...     [1, 2, 3, 4], ...     [5, 6, 7, 8], ...     [9, 10, 11, 12], ... ] >>> [[linha[i] for linha in matriz] for i in range(4)] [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

O que são aqueles ... à esquerda? É quando o IDLE está a aceitar mais do que uma linha porque deteta que ainda não acabou tudo na primeira linha (o parêntesis reto não fechou). E repare que a matriz é uma lista com 3 listas no seu interior. O que o comando na segunda entrada faz é transpor a matriz: cria 4 listas, e cada lista vai ter os itens i das linhas da matriz. Muito bem pensado, não é?
Vamos complicar ainda mais um bocadinho:

>>> x = [i for i in range(10) if i%3 != 0] >>> x [1, 2, 4, 5, 7, 8]

O que aconteceu aqui? Agora adicionámos uma condição com if, e só se esta se verificar é que o elemento é incluído na lista. No exemplo acima, o número só é introduzido se não for um múltiplo de 3.
E vamos terminar com uma função curiosa:

>>> zip([1,2,3],[4,5,6]) <zip object at 0x0423B2D8> >>> list(zip([1,2,3],[4,5,6])) [(1, 4), (2, 5), (3, 6)] >>> list(zip([1,2,3],[4,5,6],[7,8,9])) [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

Repare como faz uma espécie de transposição...  Na primeira linha serve para demonstrar como o comando zip() cria um objeto; para vermos o seu conteúdo temos de o converter em lista. E o que faz é pegar nos primeiros elementos das listas de argumento e juntá-los em tuplos. Voltaremos a este comando mais tarde!

Comandos condicionais

Olá a quem estiver aí.
Como já deve ter reparado, pouco a pouco vamos aprendendo como construir um programa que faça algo de jeito. Mas o que torna um programa de computador realmente interessante é a capacidade de decidir fazer coisas diferentes de acordo com os dados que lhe fornecemos. E é para isso que existem os comandos condicionais. Vamos supor que queremos que o programa nos pergunte por um número e que veja se é positivo ou negativo:

num = input('Escreve um número: ') if int(num) < 0:     print('O número é negativo') else:     print('O número é positivo')

Muito bem, neste pequeno programa já há muito sumo a espremer! Vamos analisá-lo linha a linha.
Começamos por obter a partir do utilizador uma entrada a partir do teclado, e aqui está a primeira novidade: se escrevermos uma cadeia de caracteres no interior dos parêntesis de input(), esta cadeia vai servir como pergunta.
Se bem se lembra, tudo o que escrevemos para input() é interpretado como uma cadeia de caracteres, e se queremos que seja convertido num número, usamos a função int(), que converte o seu argumento num número inteiro. Assim, na segunda linha temos um comando condicional, que começa com if e de seguida uma condição int(num) < 0. Aqui temos um primeiro exemplo de um operador de comparação, o menor-do-que. O resultado será um booleano, isto é, ou é verdadeiro ou é falso, dependendo do número que foi inserido em num pelo utilizador. De seguida, surgem dois pontos, a indicar que irá ter início um bloco de código, que terá de ser indentado a indicar o que será executado se a condição for verdadeira.
A terceira linha é o bloco de código que é executado, e é um comando print() a escrever que o número é negativo, o que acontece quando a condição em frente de if se verifica. Este bloco de código poderia ter várias linhas, desde que tivessem todas a mesma indentação.
A quarta linha tem o comando opcional else, seguido de dois pontos. É opcional porque poderíamos decidir fazer executar algo apenas quando a condição de if se verificasse. Mas podemos decidir que vai acontecer algo apenas quando não se verificar a condição, definindo um novo bloco.
Finalmente, a última linha é o comando que é executado apenas quando a condição não se verifica.
Agora vamos ver uma variante do programa acima, e espero que consiga adivinhar o que vai acontecer:

num = input('Escreve um número: ') if int(num) < 0:     print('O número é negativo') elif int(num) > 0:     print('O número é positivo') else:     print('O número é zero')

Aqui temos então o comando elif, que não é mais do que uma aglutinação de else if (mas não tente escrever else if, porque não funciona), e que permite analisar várias condições até encontrar uma que seja verificada. Por outras palavras, podemos escrever o número de comandos elif que quisermos (a seguir a um if inicial, claro!), que o Python verifica sequencialmente qual é a primeira condição verdadeira. (Caso seja um programador experimentado, posso desde já adiantar que o Python não tem uma estrutura do género select case, ou switch, pois uma sequência de if ... elif ... elif ... ... else substitui essa estrutura.)
Ok, antes de acabar, vou referir os vários operadores de comparação que existem: > (maior-do-que), < (menor-do-que), == (igual-a; repare que são dois sinais para distinguir de um igual de atribuição de variável), != (diferente-de), >= (maior-ou-igual-a), <= (menor-ou-igual-a). São 6 no total, e já dão para todas as comparações possíveis! E podem comparar-se cadeias de caracteres, inteiros, com casas decimais, ou mesmo booleanos! Toca a experimentar num programa ou mais para ver o que já consegue fazer!