Praticando Python: laços for e while

Laços for e while - Laços for e while

Olá, me chamo é André Santana, sou instrutor na escola de Programação.

Audiodescrição: André se identifica como um homem de pele clara, com uma barba cheia e cabelo curto. Ele usa óculos de armação redonda e veste uma camiseta vermelha lisa. Ao fundo, à sua direita, há uma estante decorativa, que exibe diversos itens, e a cena é iluminada por uma suave luz verde e azul.

O que aprenderemos?

Neste curso, exploraremos de forma detalhada o funcionamento dos laços de repetição, adotando uma abordagem prática que nos permitirá compreender cada elemento dessa estrutura.

O que são laços de repetição?

Os laços de repetição são blocos de instrução presentes nas linguagens de programação. No Python, temos dois tipos principais: for e while.

Ambos repetem instruções enquanto uma condição for verdadeira.

Sintaxe do laço for

O laço for executa um bloco de instruções enquanto uma variável é iterável dentro de uma coleção. Ele é útil quando sabemos exatamente quantas iterações desejamos realizar.

for elemento in iterável:

• elemento: cada item individual do iterável que é processado dentro do laço.

• iterável: é uma coleção de valores, como listas, tuplas, dicionários, dentre outros. (:): os dois pontos e a palavra in são obrigatórios

A estrutura básica consiste na palavra reservada for, seguida por um elemento que receberá a variável iterada, e o marcador in, que verifica se o elemento está contido na coleção, armazenando-o para a iteração.

No Python, a ausência de símbolos para delimitar blocos de instrução é substituída pela necessidade de uma indentação correta. Os dois pontos (:) são obrigatórios, indicando que as instruções indentadas serão executadas enquanto a condição se mantiver verdadeira. As coleções iteráveis podem incluir listas, tuplas ou dicionários, que são capazes de armazenar diferentes tipos de dados.

Exemplo de código for

Analisaremos o seguinte exemplo que percorre uma lista de nomes e imprime na tela cada um deles:

nomes = ["Carlos", "Ana", "Pedro", "Maria"]
for nome in nomes:
   print(nome)

Primeiro, criamos uma lista chamada nomes, que contém os nomes: ["Carlos", "Ana", "Pedro", "Maria"]

Em seguida, utilizamos um laço for para percorrer todos os nomes na lista e imprimir cada nome na tela.

O termo "nome" é apenas um identificador que usamos para representar cada elemento da lista enquanto percorremos com o laço for. Você pode substituir "nome" por qualquer outro nome de variável que faça sentido para o seu contexto.

Consideramos uma coleção de nomes: Carlos, Ana, Pedro e Maria, armazenada na variável nomes. A iteração é realizada utilizando a estrutura de repetição for. A cada ciclo, um nome é atribuído à variável nome, que é então exibido no terminal enquanto houver nomes disponíveis na coleção.

Sintaxe do laço while

O laço while é baseado em uma condição que pode mudar conforme a estratégia ou lógica de programação adotada. Ele executa um bloco de instruções enquanto essa condição for verdadeira.

O laço while executa um bloco de código enquanto uma condição especificada for verdadeira. Ele é útil quando você não sabe exatamente quantas iterações serão necessárias, já que a execução depende do resultado da condição a cada iteração.

while condicao:

A condição é qualquer expressão que resulte em um valor booleano (True ou False). Exemplo: while numero < 5:

Como não temos um tamanho definido para a coleção, a condição precisa ser cuidadosamente elaborada. Para a condição do laço de repetição utilizamos operações lógicas de comparação, que retornam um resultado verdadeiro ou falso (em Python, representados como True ou False).

Operadores de comparação

Os operadores de comparação que empregamos estão destacados na tabela a seguir:

Os operadores de comparação são utilizados para comparar valores, retornando True ou False, dependendo da condição estabelecida.

É importante ressaltar que teremos uma comparação e ela sempre será verdadeira ou falsa.

Exemplo de código while

Analisaremos o seguinte exemplo que percorre uma lista de nomes e imprime na tela cada um deles:

contador = 0

while contador < 5:
   print(f"Contador atual: {contador}")
   contador += 1

Definimos uma variável contador com o valor 0. O contador serve para garantir que a condição eventualmente se torne falsa.

O laço while verifica a condição contador < 5. Enquanto essa condição for verdadeira, o bloco de código dentro do while será executado.

Dentro do laço, imprimimos o valor atual do contador e, em seguida, incrementamos contador em 1 com contador += 1. Esse processo se repete até que a condição contador < 5 se torne falsa (ou seja, quando contador chegar a 5).

Por ser um laço de repetição dependente de uma condição (um teste lógico que iremos executar) é fundamental que verifiquemos a condição adequadamente para evitar a ocorrência de loops infinitos.

Analisando o exemplo, iniciamos um contador em zero e usar um laço while que continua executando enquanto o contador for menor que 5. Nesse caso, a operação exibe o valor atual do contador no terminal e o incrementa a cada iteração. Assim, o laço será executado cinco vezes antes de sair do loop e prosseguir com o restante do código. Se não incrementamos o contador, corremos o risco de entrar em um loop infinito.

Loop infinito

Um loop infinito é quando um laço de repetição continua a executar sem parar, porque a condição para sair dele nunca se torna falsa.

contador = 0

while contador < 5:
   print("Contador:", contador)

Neste exemplo, o laço continuará para sempre imprimindo "Contador: 0", porque a condição contador < 5 nunca mudará para falsa. Isso pode ocorrer tanto em laços for quanto while.

Para reforçar, ao esquecermos de inserir o contador o laço de repetição é executado infinitamente por não termos nenhuma condição que o faça parar dado que o incrementador não está sendo executado conforme o esperado no contador.

Break

Para evitar loops infinitos em um laço for, mesmo sem um contador explícito, podemos utilizar a palavra reservada break para interromper a execução:

Mas e se quisermos interromper a execução de um laço antes que ele termine naturalmente? É aí que a instrução break entra em cena. O break permite que você saia imediatamente de um laço, mesmo que a condição para continuar seja verdadeira.

nomes = ["PM3", "Alura", "Latam", "Outros"]

for nome in nomes:
   if nome == "Alura":
       print("Nome encontrado! Saindo do laço.")
       break
   print(nome)

Neste exemplo, o laço irá percorrer os nomes e, ao encontrar "Alura", imprimirá "Nome encontrado! Saindo do laço." e sairá do laço, não imprimindo os nomes que vêm a seguir.

Ao iterar sobre uma coleção de nomes, se encontrarmos o nome "Alura", podemos usar break para parar a repetição mesmo que a condição final não tenha sido atingida.

Vale destacar que o break também é eficaz no contexto de um laço while.

Continue

Outra palavra reservada importante é continue, que permite a execução do laço até que a condição associada a ela seja atendida.

Agora, e se quisermos pular a execução de uma iteração específica do laço, mas continuar com as demais? O continue permite que você pule para a próxima iteração do laço, ignorando o restante do código na iteração atual.

nomes = ["PM3", "Alura", "Latam", "Outros"]

for nome in nomes:
   if nome == "Alura":
       print("Ignorando Alura.")
       continue
   print(f"Nome: {nome}")

Neste exemplo, quando o laço encontra "Alura", ele imprime "Ignorando Alura." e salta a impressão do nome "Alura", continuando com os outros nomes na lista.

Quando encontramos o continue, as instruções subsequentes da iteração atual são ignoradas, mas o laço segue normalmente para a próxima iteração. Assim, o laço retorna ao início, processando o próximo item. Por exemplo, se encontrarmos o nome "Alura", o comando print não será executado, e o laço continuará com o próximo nome, como "Latam".

Funções úteis em laços

Duas funções muito úteis nesse contexto são len(), que retorna o tamanho de uma coleção, e range(), que gera uma coleção de valores numéricos, facilitando a iteração.

len() é utilizada para obter o comprimento de uma lista, string ou outro tipo de coleção. Ela nos permite saber quantas iterações precisamos realizar em um laço.

range() gera uma sequência de números, que é frequentemente utilizada para controlar a iteração em laços for. Com ela, podemos especificar um intervalo de números para iterar, podendo também definir um passo. Por exemplo, range(6) gera os números de 0 a 5, permitindo que o laço for execute cinco vezes.

Por exemplo, ao utilizarmos range(6), criamos uma estrutura que abrange os números de 0 a 5.

Próximos passos

Para complementar nosso estudo, disponibilizamos exercícios sobre os laços for e while, visando uma maior especialização no tema. É importante compartilhar o que aprendemos com a comunidade Dev, utilizando a hashtag #AprendiNaAlura.

Sobre o curso Praticando Python: laços for e while

O curso Praticando Python: laços for e while possui 7 minutos de vídeos, em um total de 13 atividades. Gostou? Conheça nossos outros cursos de em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Laços for e while