Programação Essencial |Estruturas de Controle
Loops
“Loop statements” nada mais são do que a automação de processos de múltiplos passos, organizando seqüências de ações e agrupando as partes que precisam ser repetidas. Também uma parte central da programação, a iteração (ou Looping) dá aos computadores muito do seu poder. Eles podem repetir uma seqüência de passos quantas vezes forem necessárias, e repetições apropriadas de passos simples podem resolver problemas complexos.
Em termos gerais, existem dois tipos de “Looping techniques”:
- “For Loops”: são os que executam por um número prescrito de vezes, como controlado por um contador ou um índice.
- “While Loops” e “Repeat Loops”: são baseados no início e verificação de uma condição lógica. A condição é testada no início ou no final da construção do loop.
Vamos dar uma olhada neles:
1) Para Loops
Nesta Estrutura de Controle, as instruções são executadas uma após a outra em uma ordem consecutiva sobre uma seqüência de valores que só é avaliada quando o “Para Loop” é iniciado (nunca reavaliado). Neste caso, o número de iterações é fixo e conhecido antecipadamente.
Se a avaliação da condição em uma variável (que pode assumir valores dentro de uma seqüência especificada) resultar VERDADEIRO, uma ou mais instruções serão executadas seqüencialmente sobre essa seqüência de valores. Uma vez feito o primeiro teste de condição (e resulta VERDADEIRO), a expressão é executada e a condição é avaliada novamente, passando por um processo iterativo. A seção “variável em seqüência” executa este teste em cada valor da seqüência até cobrir o último elemento.
Se a condição não for preenchida e o resultado resultante for FALSO (por exemplo, a parte “variável em seqüência” terminou de passar por todos os elementos da seqüência), o loop termina. Se o teste de condição resulta FALSO na primeira iteração, o “For Loop” nunca é executado.
A sintaxe de “For Loops” é:
Exemplo 1
Para mostrar como “For Loops” funciona, primeiro vamos criar uma sequência concatenando diferentes nomes de frutas para criar uma lista (chamada “fruit_list”):
Usaremos esta lista de frutas como a “sequência” em um “For Loop”, e faremos o “For Loop” executar uma vez uma declaração (imprimir o nome de cada valor) para cada valor fornecido na sequência (as diferentes frutas na lista de frutas):
Desta forma, o resultado do “For Loop” é o seguinte:
## "Apple"
## "Kiwi"
## "Orange"
## "Banana"
OK, então imprimimos o nome de cada valor na lista. Não é um grande negócio, certo? O bom é que o “For Loops” pode ser usado para produzir resultados mais interessantes. Veja o seguinte exemplo.
Exemplo 2
E se quisermos modificar os valores, ou fazer cálculos sequencialmente? Você pode usar “For Loops” para realizar operações matemáticas sequenciais sobre cada valor de um vetor (elementos do mesmo tipo, que neste caso serão numéricos).
Neste caso, o resultado do “For Loop” é:
1
1.414214
1.732051
2
2.236068
2.449490
2.645751
2.828427
3
3.162278
Pode usar qualquer tipo de operador matemático sobre uma sequência numérica, e como veremos mais adiante neste artigo, faça todo o tipo de combinações entre diferentes Estruturas de Controlo para alcançar resultados mais complexos.
2) Enquanto Loops
Em “Enquanto Loops” uma condição é avaliada primeiro, e se o resultado do teste dessa condição for VERDADEIRO, uma ou mais afirmações são repetidamente executadas até que essa condição se torne FALSA.
Não parecido com “If statements”, em que uma condição testada como VERDADEIRA executa uma expressão apenas uma vez e termina, “While Loops” são afirmações iterativas que executam alguma expressão repetidamente até que a condição se torne FALSA. Se a condição nunca se tornar FALSA, o “While Loop” irá continuar para sempre e o programa irá falhar. Ao contrário, se o teste da condição resultar FALSO no início do loop, a expressão nunca será executada.
A sintaxe de “While Loops” é:
Exemplo 1
Vejamos um exemplo. Primeiro vamos criar uma variável (x) e atribuir-lhe o valor de 1. Depois definimos um “While Loop” para testar iterativamente uma condição sobre essa variável até que o teste de condição resulte FALSO:
É assim que funciona: o valor inicial da variável (x) é 1, então quando testamos a condição “a variável (x) é inferior a 10?”, o resultado avalia para VERDADEIRO e a expressão é executada, imprimindo o resultado da variável (x), que no primeiro caso é 1. Mas então algo acontece: a variável (x) é incrementada em 1 antes da função terminar, e na próxima iteração o valor de x será 2,
Esta reatribuição da variável é importante porque eventualmente alcançará a condição FALSA e a saída do loop (valor de x = 10). Não alterar as condições iniciais em um “While Loop” resultará em um loop infinito e uma falha do programa.
Output
1
2
3
4
5
6
7
8
9
Exemplo 2
Tem ouvido falar da seqüência Fibonacci? Esta é uma série de números com a característica de que o próximo número na sequência é encontrado pela soma dos dois números anteriores: 0, 1, 1, 2, 3, 5, 8, 13, 21,… Esta sequência pode ser encontrada em vários fenómenos da natureza, e tem diferentes aplicações em finanças, música, arquitectura, e outras disciplinas.
>
Vamos calculá-la usando um “While Loop”.
Neste caso definimos um valor máximo na série como condição de parada, de modo que o loop imprima a série Fibonacci apenas para números abaixo de 100. Quando um elemento da série (que sempre é) se torna maior que 100, o ciclo do loop termina.
0
1
1
2
3
5
8
13
21
34
55
89
Exemplo 3
Outra forma de gerar a série Fibonacci com um “While Loop” é, em vez de definir o valor máximo da série como uma condição de parada, definindo o número de elementos da série que você quer gerar.
Este “While Loop” acrescenta o próximo elemento da série ao fim do elemento anterior, até chegar a uma condição de parada. Neste caso, quando a série atinge 10 elementos (não importa quais valores), o cilindro do laço termina.
Eliminar
0 1 1 2 3 5 8 13 21 34
3) Repetir Loops
Closamente ligado a “While Loops”, “Repetir Loops” executa declarações iterativamente, mas até que uma condição de parada seja cumprida. Desta forma, as instruções são executadas pelo menos uma vez, não importa qual seja o resultado da condição, e o loop só é encerrado quando determinada condição se torna VERDADEIRA:
A sintaxe de “Repeat Loops” é:
“Repetir Loops” usar “Break statements” como uma condição de paragem. As “Declarações de quebra” são combinadas com o teste de uma condição para interromper ciclos dentro de loops, uma vez que quando o programa atinge uma quebra, ele passará o controle para a instrução imediatamente após o fim do loop (se houver).
“Repetir Loops” será executado para sempre se a condição de quebra não for atendida. Veja estes 2 exemplos
Exemplo 1
Primeiro criamos uma variável (x) e atribuímos-lhe o valor de 5. Depois definimos um “Repeat Loop” para imprimir iterativamente o valor da variável, modificar o valor da variável (aumentá-lo em 1), e testar uma condição sobre essa variável (se for igual a 10) até que o teste de condição resulte VERDADEIRO.
A “condição de quebra” dispara quando a variável (x) atinge 10, e o loop termina.
Output
5
6
7
8
9
Exemplo 2
Agora vamos supor que produzimos uma lista de números aleatórios, para os quais não sabemos a ordem ou sequência de geração.
Neste exemplo vamos usar um “Repeat Loop” para gerar uma sequência de números aleatórios normalmente distribuídos (você pode gerar números aleatórios com qualquer outra distribuição, basta escolher este), e quebrar a sequência uma vez que um desses números seja maior que 1. Como não sabemos quais números virão primeiro, não sabemos quanto tempo a seqüência será: apenas sabemos a condição de quebra.
Primeiro, usamos a instrução “set.seed” para fixar os números aleatórios (gerar sempre os mesmos números aleatórios), e tornar este exemplo reproduzível.
Então iniciamos o “Repeat Loop” gerando um número aleatório normalmente distribuído, imprimindo-o, e verificando se esse número é maior que 1. Somente quando essa condição se torna VERDADEIRA (pode ser com o primeiro número gerado, ou não), o ciclo de loop passará para a instrução de quebra e terminará.
Output
-0.9619334
-0.2925257
0.2587882
-1.152132
0.1957828
0.03012394
0.08541773
1.11661
Isso mostra mais uma vez a importância de definir uma condição de quebra adequada. Se não o fizer, resultará num loop infinito.
Pensamentos Finais
Vimos e explicamos conceitos isoladamente, mas “Estruturas de Controle” podem ser combinadas da forma que você quiser: Loops podem conter vários Loops internos; Condicionais podem conter Loops e Condicionais, as opções são infinitas. (de facto, ao rever “Repeat Loops” descobrimos que os exemplos continham “If statements” aninhados).
Pode desenvolver soluções avançadas apenas combinando as “Estruturas de Controlo” que explicamos neste artigo. Como Minsky afirmou, podemos alcançar resultados complexos como resultado da interação de componentes mais simples. As “Estruturas de Controle” constituem os blocos básicos para a tomada de decisões em computação. Elas alteram o fluxo de programas e nos permitem construir conjuntos complexos de instruções a partir de blocos de construção mais simples.
O meu conselho é: aprenda sobre elas.
Irá facilitar o seu caminho para a codificação e compreensão de programas, e irá ajudá-lo a encontrar novas formas de resolução de problemas.