Laço(loop) em Python

Os laços permitem a execução de uma determinada ação com base no cumprimento de uma condição específica. Na linguagem Python, existem os seguintes tipos de laços:

while
for

Ciclo while

O laço while verifica se uma condição é verdadeira e, se for, executa as instruções dentro do laço. Ele possui a seguinte estrutura formal:

while condição:
    instruções

Após a palavra-chave while, é especificada a condição que, enquanto retornar True, o bloco de instruções será executado.

Todas as instruções que pertencem ao laço while devem ser escritas nas linhas seguintes, com uma tabulação em relação ao início da linha onde o while foi declarado.

number = 1

while number < 5:
    print(f"number = {number}")
    number += 1

print("Execução do programa concluída")

Nesse exemplo, o laço while será executado enquanto a variável number for menor que 5.

O bloco do laço é composto por duas instruções:

print(f"number = {number}")
number += 1

Note que ambas possuem tabulação em relação ao início da linha onde o while foi declarado. Isso permite que o Python identifique que elas fazem parte do laço. No laço, primeiro o valor da variável number é exibido e, em seguida, um novo valor é atribuído a ela.

Repare também que a última instrução, print("Execução do programa concluída"), não tem tabulação em relação ao início da linha, o que significa que ela não faz parte do laço while.

O processo do laço pode ser descrito da seguinte forma:

Primeiro, é verificado se o valor da variável number é menor que 5. Como inicialmente number é igual a 1, a condição retorna True, e as instruções do laço são executadas.
As instruções exibem no console a mensagem number = 1. Em seguida, o valor de number é incrementado em 1, passando a ser igual a 2. A execução de um bloco de instruções do laço é chamada de iteração. Assim, a primeira iteração do laço é concluída.
Novamente, a condição number < 5 é verificada. Como number é 2, a condição ainda é verdadeira, então as instruções do laço são executadas mais uma vez.
O laço exibe number = 2 no console e incrementa number para 3, concluindo a segunda iteração.
O processo se repete com number igual a 3, exibindo number = 3 e incrementando o valor para 4, finalizando a terceira iteração.
Na quarta iteração, number = 4 é exibido e number é incrementado para 5.
Agora, a condição number < 5 retorna False, pois number é igual a 5. O laço é finalizado, e as instruções seguintes ao laço while são executadas.

Ao final da execução, o console exibirá:

number = 1
number = 2
number = 3
number = 4
Execução do programa concluída

Bloco else no laço while

Para o laço while, também é possível definir um bloco else, cujas instruções são executadas quando a condição se torna False:

number = 1

while number < 5:
    print(f"number = {number}")
    number += 1
else:
    print(f"number = {number}. O laço foi concluído")

print("Execução do programa concluída")

Neste caso, o laço while verifica a condição e executa suas instruções. Quando a condição se torna False, as instruções do bloco else``são executadas. O blocoelse também deve ter tabulaçãoem relação à estrutura do laço. O console exibirá:

number = 1

while number < 5:
    print(f"number = {number}")
    number += 1
else:
    print(f"number = {number}. O laço foi concluído")

print("Execução do programa concluída")

O bloco else pode ser útil se a condição for False desde o início, permitindo que algumas ações sejam realizadas:

number = 10

while number < 5:
    print(f"number = {number}")
    number += 1
else:
    print(f"number = {number}. O laço foi concluído")

print("Execução do programa concluída")

Neste exemplo, a condição number < 5 já é False desde o início, então o laço não realiza nenhuma iteração e vai diretamente para o bloco else.

Ciclo for

Outro tipo de laço é a estrutura for. Esse laço percorre um conjunto de valores, atribuindo cada valor a uma variável, e dentro do laço podemos realizar várias operações com essa variável. A estrutura formal do laço for é a seguinte:

for variável in conjunto_de_valores:
    instruções

Após a palavra-chave for, é especificada uma variável que receberá os valores. Em seguida, após o operador in, é indicado o conjunto de valores seguido de dois pontos.

Nas linhas subsequentes, são colocadas as instruções do laço, que também devem ter tabulação em relação ao início do laço.

Durante a execução, o Python obtém cada valor do conjunto, um de cada vez, e o atribui à variável. Quando todos os valores do conjunto forem processados, o laço é encerrado.

Por exemplo, podemos usar uma string, que é essencialmente um conjunto de caracteres, como conjunto de valores:

message = "Hello"

for c in message:
    print(c)

Nesse exemplo, a variável c é definida no laço e, após o operador in, a variável message armazena a string "Hello". O laço for percorrerá cada caractere da string message, atribuindo-os à variável c. O bloco do laço consiste em uma única instrução que exibe o valor de c no console. A saída será:

H
e
l
l
o

Frequentemente, o laço for é usado em conjunto com a função embutida range(), que gera uma sequência de números:

for n in range(10):
    print(n, end=" ")

Se a função range receber um único parâmetro, ele indicará o valor máximo do intervalo de números. No exemplo acima, será gerada uma sequência de 0 a 9 (excluindo 10). O resultado no console será:

0 1 2 3 4 5 6 7 8 9

Também é possível passar um valor mínimo para a função range():

for n in range(4, 10):
    print(n, end=" ")

Neste caso, a sequência vai de 4 até 9. O console exibirá:

4 5 6 7 8 9

Além disso, a função range() aceita um terceiro parâmetro que define o incremento:

for n in range(0, 10, 2):
    print(n, end=" ")

Aqui, a sequência vai de 0 até 8, com incrementos de 2. O resultado será:

0 2 4 6 8

Bloco else no laço for

O laço for também pode incluir um bloco else, que será executado após a conclusão do laço:

message = "Hello"

for c in message:
    print(c)
else:
    print(f"Último caractere: {c}. Ciclo concluído")

print("Execução do programa concluída")

Neste exemplo, obtemos o seguinte resultado no console:

H
e
l
l
o
Último caractere: o. Ciclo concluído
Execução do programa concluída

É importante notar que o bloco else tem acesso a todas as variáveis definidas no laço for.

Laços aninhados

Um laço pode conter outro laço dentro de si. Veja o exemplo de uma tabela de multiplicação:

i = 1
j = 1

while i < 10:
    while j < 10:
        print(i * j, end="\t")
        j += 1
    print("\n")
    j = 1
    i += 1

O laço externo while i < 10 será executado 9 vezes, até que a variável i seja igual a 10. Dentro desse laço, o laço interno while j < 10 também será executado 9 vezes, até que j seja igual a 10. Cada iteração do laço interno ocorre dentro de uma iteração do laço externo.

Durante cada iteração do laço interno, o produto de i e j será exibido no console. Após o laço interno ser concluído, j é redefinido para 1, i é incrementado em 1, e o laço externo prossegue para a próxima iteração. O laço interno será executado 81 vezes no total. O resultado será:

1	2	3	4	5	6	7	8	9
2	4	6	8	10	12	14	16	18
3	6	9	12	15	18	21	24	27
4	8	12	16	20	24	28	32	36
5	10	15	20	25	30	35	40	45
6	12	18	24	30	36	42	48	54
7	14	21	28	35	42	49	56	63
8	16	24	32	40	48	56	64	72
9	18	27	36	45	54	63	72	81

Laços for aninhados também podem ser definidos da seguinte maneira:

for c1 in "ab":
    for c2 in "cd":
        print(f"{c1}{c2}")

Neste caso, o laço externo percorre a string "ab" e atribui cada caractere à variável c1. O laço interno percorre a string "cd", atribuindo cada caractere à variável c2, e exibe a combinação de ambos os caracteres. O resultado será:

ac
ad
bc
bd

Saída de laços: break e continue

Para controlar a execução de laços, podemos usar os operadores especiais break e continue. O operador break interrompe a execução do laço, enquanto o continue passa diretamente para a próxima iteração.

O operador break pode ser usado quando uma condição dentro do laço requer a interrupção imediata do laço. Por exemplo:

number = 0

while number < 5:
    number += 1
    if number == 3:    # Se number for igual a 3, saímos do laço
        break
    print(f"number = {number}")

Aqui, o laço while verifica a condição number < 5 e exibe o valor de number no console enquanto number for menor que 5. No entanto, se number for igual a 3, o operador break é acionado e o laço é interrompido. O resultado será:

number = 1
number = 2

Diferentemente de break, o operador continue interrompe apenas a iteração atual e passa para a próxima, sem finalizar o laço. Veja o exemplo modificado:

number = 0

while number < 5:
    number += 1
    if number == 3:    # Se number for igual a 3, passamos para a próxima iteração
        continue
    print(f"number = {number}")

Neste caso, quando number for igual a 3, as instruções após o continue não serão executadas. O resultado será:

number = 1
number = 2
number = 4
number = 5