No último exercício, imprimi-mos parte da tabela de multiplicação do 12. Mas foi necessário muita dactilografia e mesmo assim não ficou acabada, para acaba-la levaria muito mais tempo (e muito mais na dactilografia).Felizmente Felizmente existe uma forma muito mais cómoda, e é aí que começamos a ver o verdadeiro poder que as linguagens de programação nos oferecem.

Os loops FOR

O proposto aqui é fazer com que a linguagem de programação faça todo o trabalho repetitivo por nós. Ou seja substituir a variável que aumenta, o multiplicando. no Python este seria o aspecto:

>>>for i in range(1,13):
...    print "%d x 12 = %d" % (i, i*12)

Nota 1: Foi precisa a inclusão do range(1,13), para especificar o 13, porque o range(), cria do primeiro ao segundo, mas não incluindo este. Isto pode te parecer um tanto ao quanto bizarro no início, mas existem razões para que seja assim, portanto habitua-te.

Nota 2: O operador for (para) no Python significa para cada operador, pertencentes a uma colecção, na qual ele irá aplicar o código subsequente. Neste caso a colecção é constituída pela lista gerada pelo comando range(). Podes testar isso mesmo se digitares o comando print range(1,13), na prompt do Python..

Nota 3: O comando print esta colocado mais a frente do que o for da linha acima, isso é muito importante porque é assim que o Python fica a saber qual a parte do código a ser repetida. A forma como a colocação se sucede não é muito importante, desde que seja consistente.

Então como é que o programa funciona? A melhor forma de o saber é "entrando" nele.
Em primeiro lugar o Python usa o função range() para criar uma lista de números de 1 a 12.

Depois o Python torna i igual ao primeiro valor da lista, neste caso o 1. então de seguida ele executa a parte do código que se segue, usando os valores de i = 1:

   print "%d x 12 = %d" % (1, 1*12)

O Python depois de isto feito, volta a linha do for e torna o i igual ao segundo valor da lista, desta vez será o 2. Então mais uma vez ele executa a parte do código que se segue, desta vez usando os valores i = 2:

   print "%d x 12 = %d" % (2, 2*12)

Ele irá repetir o mesmo processo até ele ter igualado o i a todos os valores da lista. Quando chegar a esse ponto, ele irá passar para o próximo comando não indentado - mas como neste caso não existem mais comandos o programa para.

Aqui esta o mesmo loop em BASIC:

FOR I = 1 to 12
    PRINT I, " x 12 = ", I*12
NEXT I

Isto é muito mais explicito, e muito mais fácil de ver o que esta acontecendo. Contudo a versão do Python é muito mais flexível, permitindo-nos fazer o loop não só sobre um grupo de números, mas também sobre qualquer outra colecção (por exemplo uma lista de strings)

...E no Tcl

o Tcl usa o for que é comum em muitas linguagens de programação, sendo modelado em C, acaba por ter esta aparência:

for {set i 1} {$i <= 12} {incr i} {
    puts [format "%d x 12 = %d" $i [expr $i*12]]
    }

Nota: Esta construção tem 3 partes:

• a parte inicial: {set i 1} que é executada antes de tudo mais e apenas uma vez,
• uma parte de teste: {$i <= 12} que é executada entes de qualquer iteração e
• uma parte de incrementarão: {incr i} que é executada depois de cada iteração.

Tcl também um foreach (tal qual como o Python) que pode ser aplicado a listas.

Os loops WHILE

O tipo de loops FOR, não são os únicos disponíveis e ainda bem porque, os loops for requerem que nós saibamos de antemão o número de iterações que queremos executar. Então o que acontece quando queremos executar uma tarefa especifica até que algo aconteça, mas não sabemos ao certo o que esse algo vai ser? Por exemplo queremos ler e processar data de um ficheiro, mas não sabemos de antemão quantos itens de data esse ficheiro contem. Portanto havíamos de querer continuar a processar data até que chegássemos ao final o final desse ficheiro. Isso é possível, mas muito difícil de se fazer no nos FOR loops.

Para resolver este tipo de problema temos outro tipo de loops: o WHILE loop. e há-de ser assim no BASIC:

J = 1
WHILE J <= 12 DO
    PRINT J, " x 12 = ", J*12
    J = J + 1
WEND

Isto irá produzir o mesmo resultado que o de há pouco, mas usas o While loop em vez do for. Repara que a While (enquanto), seguido de uma expressão que avalia um valor de boolean (verdadeiro ou falso, lembras-te?). Portanto se a expressão é verdadeira o código é executado, senão o código não é executado.

Como alternativa olharemos agora para a mesma versão em Tcl:

set j  1
while {j <= 12} {
   puts [format "%d x 12 = %s"  $j [expr $j*12]]
   set j [expr $j + 1]
}

Como podes ver a estrutura é semelhante a não ser pelos parêntesis curvos em vez do WEND do BASIC. Mas que confusão é a que esta dentro do loop? lembras-te do format string no Python? Bem , format é o equivalente em Tcl. O $j significa o valor de j (em vez só da letra "j") e o expr apenas diz para calcular o próximo bocado de código como uma expressão. Os parêntesis rectos dizem ao Tcl qual o bocado a ser executado em primeiro lugar. O Tcl é uma linguagem fora do vulgar porque tenta interpretar todo o código, num só fôlego, então se não tivesse o parêntesis rectos ele tentaria imprimir no ecrã a palavra 'expr' e depois iria tentar processar o resto do código, acabando por dar uma mensagem de erro, porque o código não foi escrito para ser lido num só fôlego. Então assim sendo, temos que ser nós a dizer-lhe tudo, temos que lhe dizer como fazer as somas, e que a seguir são as format string, e só depois é que ele deve imprimir os resultados. Confuso? Não te preocupes. Como já tinha dito o Tcl é um a linguagem muito fora do vulgar, com uns poucos pontos a seu favor, e uma mão cheia coisas contra.

Agora vamos dar uma vista de olhos no Python:

>>> j = 1
>>> while j <= 12:
...    print "%d x 12 = %d" % (j, j*12)
...    j = j + 1

Bem, e estas alturas este código já te deve ser muito fácil de interpretar - mas chamo a tua atenção para os dois pontos no final (:) do tanto no while como for, mais acima? Então, para que servem?, Isto é a forma de dizeres ao Python que um bloco de código vem logo a seguir. A maioria das linguagens têm um bloco especial para terminar o código (como o BASIC usa o WEND e o Tcl usa parêntesis) mas no Python é usa a indentação para indicar a estrutura do código. Isto significa que é muito importante fazer a indentação em todas as linhas que estão dentro do loop pela mesma quantidade. Isto aliás é uma óptima forma de trabalho, porque torna o código mais fácil de ler!

Loops mais flexíveis

De volta a nossa tabuada do 12, que tínhamos começado no inicio desta secção. O loop esta óptimo, para quem só quer imprimir a tabela do 12. Mas e quem quiser imprimir os outros valores? Será que podemos modificar o loop, para imprimir a tabela do 7? Esse loop teria este aspecto:

>>> for j in range(1,13):
...    print "%d x 7 = %d" % (j, j*7)

Bom isto significa que tivemos que mudar o 12 para 7 duas vezes, e se quisemos imprimir um outro valor depois do 7, teríamos que mudar outra vez? Não seria melhor se pudessem os entrar apenas o multiplicador desejado?

Isso pode se feito ao substituir os valores que estão na string print por uma outra variável. E depois ajustar a variável convenientemente antes de fazer correr o loop:

>>> multiplicador = 12
>>> for j in range(1,13):
...    print "%d x %d = %d" % (j, multiplicador, j*multiplicador)

Essa é a nossa velha amiga, tabela do 12, mas agora para mudar para a tabela do 7 (também já uma velha conhecida nossa) apenas teríamos que mudar o valor do multiplicador, uma vez.

Nota que aqui combinamos sequências e loops. Primeiro temos um comando simples, multiplicador = 12, seguido em sequência pelo loop for.

Fazer um loop ao loop

Então agora vamos levar as coisas um bocado mais adiante. Supõe que queremos imprimir todas as tabelas do 2 ao 12 (a tabela do 1 não dá pica, muito simples). Tudo que realmente havíamos de precisar de fazer é tornar a variável "multiplicador" como parte de um loop, assim:

>>> for multiplicador in range(2,13):
...    for j in range(1,13):
...       print "%d x %d = %d" % (j, multiplicador, j*multiplicador)

Igualamos o o multiplicador ao primeiro valor da lista (o 2, neste caso) e depois percorremos o segundo loop.
Depois igualamos a variável "multiplicador" ao segundo valor da lista(3), e voltamos a percorrer o segundo loop outra vez, e assim sucessivamente. Esta técnica é conhecida como nesting.

A coisa má deste último exemplo é que as tabelas ficam todas juntas, não havendo separação, é claro que isso pode ser remediado se dissermos ao Python para imprimir uma linha no final de cada tabela, como fazemos isso? Assim:

>>> for multiplicador in range(2,13):
...    for j in range(1,13):
...       print "%d x %d = %d" % (j, multiplicador, j*multiplicador)
...    print "------------------- "

Presta atenção, que o segundo comando print esta alinhado com o segundo "for", tornando-se a segunda declaração na sequência do loop. Lembra-te que a indentação é muito importante no Python.

Experimenta, há ver se consegues, fazer com que o separador em vez de ser uma linha, seja um indicador da tabela que se segue. Dica, provavelmente irás precisar de utilizar a variável multiplicador e um format string. Diverte-te.

Outros loops

Algumas linguagens, fornecem mais tipos de loops, mas de uma forma ou de outra há-de sempre existir uma variante do for e do while. O Modula 2 e o Oberon só têm o While, uma vez que que se pode simular o for no while - como vimos num dos exemplos acima.) Outros loops que poderás encontrar são:

do-while

o Mesmo que o while, só que o teste é executado no final, portanto o loop é executado pelo menos uma vez.

repeat-until

O mesmo que o o do-while, só que com a lógica contraria.

GOTO, JUMP, LOOP etc.

A maioria destes apenas é visto em linguagens mais antigas, o que normalmente fazem é colocar uma "marca" no código e quando necessário, eles literalmente saltam para essa parte do código.