Laços de repetição em Python

Um laço de repetição repete um bloco de código. Cada passagem pelo bloco é uma iteração. Um laço while verifica uma condição antes de cada passagem e executa seu corpo enquanto essa condição for verdadeira. Isso é adequado a uma tarefa como “continue somando até o total chegar a 100”.

Início, teste e atualização

Um laço de contagem precisa de um valor inicial, uma condição e uma atualização. O cabeçalho termina com dois-pontos. Indente o corpo com quatro espaços:

n = 3
while n > 0:
    print(n)
    n = n - 1
print("Liftoff!")

A saída é:

3
2
1
Liftoff!

Na primeira verificação, n > 0 é verdadeiro porque n é 3. O Python exibe 3, subtrai 1 e retorna ao cabeçalho. Ele repete com 2 e depois com 1. A atualização torna n igual a 0, então a próxima verificação é falsa. O Python pula o corpo e executa o print final.

A indentação determina o que se repete. As duas linhas indentadas pertencem ao corpo. A última linha está alinhada com while, então é executada uma vez após o laço. Um if verifica sua condição uma vez; while volta a verificá-la após cada execução completa do corpo.

A verificação ocorre no início

Alterar uma variável não interrompe o restante do corpo atual:

n = 1
while n > 0:
    n -= 1
    print("Still in this pass")
print(n)

Isso exibe Still in this pass e depois 0, em linhas separadas. A atualização torna a condição falsa, mas o Python só a verifica quando retorna ao cabeçalho. Começar com n = 0 faria o corpo inteiro ser pulado: um laço while pode ser executado nenhuma vez.

Atualizações abreviadas e valores que mudam

n -= 1 significa n = n - 1. Da mesma forma, count += 1 soma 1, balance *= 1.07 multiplica por 1,07 e n //= 10 substitui n pelo quociente inteiro de sua divisão por 10. O Python não tem operador de incremento: count++ é um erro de sintaxe. Escrever ++count aplica o sinal de mais unário duas vezes e deixa o inteiro inalterado.

Aqui um laço remove um dígito a cada passagem:

n = 472
total = 0
while n > 0:
    total += n % 10
    n //= 10
print(total)

O resto n % 10 é o último dígito. Primeiro, 2 é somado e n passa a ser 47. Em seguida, 7 é somado e n passa a ser 4. Por fim, 4 é somado e n passa a ser 0. A saída é 13. A atualização prepara a próxima passagem e aproxima o laço da saída.

Um laço com meta não precisa ter uma contagem conhecida antecipadamente. Começando com um saldo de 1.000, multiplicá-lo por 1,07 e aumentar um contador de anos até que o saldo chegue a 2.000 leva 11 passagens. Após 10 passagens, o saldo é de aproximadamente 1.967,15; após 11, é de aproximadamente 2.104,85.

As condições podem combinar comparações com and, or e not. O valor lógico em contexto também funciona: para um inteiro, while n: repete enquanto n for diferente de zero. Use uma condição cujo significado seja fácil de acompanhar. Mantenha a indentação consistente com espaços; níveis desalinhados podem lançar IndentationError, e misturar tabulações e espaços pode lançar TabError.

Um laço infinito continua se repetindo sem alcançar uma saída. Você pode ver a mesma saída rolando ou um programa que parece não fazer nada. Para encontrar a causa, acompanhe os valores usados na condição e procure uma saída que possa ser alcançada.

Encontre a atualização

Este laço continua exibindo 3:

n = 3
while n > 0:
    print(n)

O teste permanece verdadeiro porque nada altera n. Adicione n -= 1 dentro do corpo para que os valores 3, 2 e 1 sejam exibidos antes de o laço parar. Colocar essa atualização após o laço não ajuda: o programa não consegue alcançá-la enquanto o laço ainda está em execução.

A direção também importa. Com while n > 0:, uma atualização de n += 1 faz um valor positivo crescer. Os inteiros do Python não voltam ao início em um máximo fixo para fornecer uma saída acidental. Descreva a mudança esperada, como “uma tentativa a menos restante”, e verifique se o código faz essa mudança em cada caminho pelo corpo.

Uma meta pode ser ultrapassada

Uma atualização pode alterar o valor em cada passagem e ainda assim nunca atingir uma meta de igualdade:

n = 1
while n != 10:
    print(n)
    n += 2

Os valores são 1, 3, 5, 7, 9, 11 e assim por diante. Eles são sempre ímpares, então nenhum é igual a 10. Para a tarefa “exiba valores ímpares abaixo de 10”, use while n < 10:. Quando n passa a ser 11, essa condição é falsa. A escolha da comparação deve corresponder ao término da tarefa em um valor ou quando um limite é ultrapassado.

Passos decimais e igualdade exata

Muitas frações decimais são armazenadas aproximadamente como números de ponto flutuante. Somar 0.1 a 0.0 dez vezes resulta em 0.9999999999999999. Portanto, um laço que espera igualdade exata com 1.0 não alcança a parada pretendida.

Quando a tarefa é visitar um conjunto fixo de décimos, conte com inteiros e calcule cada decimal:

for i in range(11):
    x = i / 10
    print(x)

Isso visita 11 valores de 0.0 até 1.0. A contagem de inteiros controla as repetições; o decimal armazenado não decide se o laço deve parar.

Verifique cada caminho pelo corpo

Antes de executar um laço while, localize seus valores iniciais, sua condição e cada instrução que altera esses valores. Verifique se a alteração pode tornar a condição falsa. Se um if pular uma atualização, rastreie esse caminho também. Uma linha temporária como print("n =", n) dentro do corpo pode mostrar um valor que está parado ou se afastando do limite.

Para interromper um programa em execução, pressione Ctrl+C em um terminal ou use o botão de parar ou interromper do editor. Em um terminal, o Python normalmente informa KeyboardInterrupt com um rastreamento de exceção.

Repetição intencional

while True: mantém intencionalmente verdadeira a condição do cabeçalho. Seu corpo usa break para sair do laço quando um evento ocorre, como o usuário inserir “quit”. A saída deve poder ser alcançada. Um laço de entrada pode continuar esperando porque o usuário não pediu para sair; um defeito é um laço cuja lógica torna a saída pretendida impossível.

Um laço de entrada pode coletar uma quantidade desconhecida de dados ou continuar perguntando até que uma resposta seja aceitável. Nos dois casos, a nova entrada deve afetar a próxima decisão de repetir.

Pare em um valor sentinela

Um valor sentinela é uma entrada especial que significa “não há mais dados”. Escolha um valor que não possa ser um item de dados real. Para contagens positivas, 0 pode funcionar; se 0 for uma medição válida, escolha outro sinal de parada.

A leitura inicial obtém o primeiro valor antes de a condição ser verificada:

total = 0
number = int(input("Number (0 to stop): "))
while number != 0:
    total += number
    number = int(input("Number (0 to stop): "))
print("Total:", total)

Para as entradas 4, 7 e 0, o corpo primeiro soma 4 e depois soma 7. Ler 0 torna a próxima condição falsa. O programa exibe Total: 11; ele nunca processa o valor sentinela. Se a primeira entrada for 0, o corpo é executado nenhuma vez e o total permanece 0.

A leitura final dentro do corpo é essencial. Sem ela, o mesmo primeiro valor é processado indefinidamente. O teste também deve ocorrer antes do processamento de um valor recém-lido: caso contrário, um valor sentinela pode ser contado como dado.

Mantenha os tipos compatíveis

input() retorna texto. A string "0" não é igual ao inteiro 0. Converta a entrada numérica com int() antes de compará-la com um valor sentinela numérico, ou mantenha a entrada como texto e compare com uma string como "done". Uma conversão numérica espera uma string numérica válida; uma verificação de intervalo testa o número resultante.

Para uma média, mantenha um contador junto ao total. Com o valor sentinela -1 e as entradas 8, 6, 10 e -1, o total é 24 e a contagem é 3. Divida após o laço para obter 8.0. Se a primeira entrada for -1, a contagem permanece 0, então use if count > 0: antes da divisão. Isso trata um conjunto de dados vazio sem ZeroDivisionError.

Pergunte novamente enquanto uma resposta for inválida

Um laço de validação descreve as respostas inaceitáveis em sua condição:

age = int(input("Age (0-120): "))
while age < 0 or age > 120:
    print("Please enter an age from 0 to 120.")
    age = int(input("Age (0-120): "))
print("Thank you.")

Com 150, -2 e 34, o aviso aparece duas vezes. O valor 34 torna ambas as comparações falsas, então o laço termina. Os extremos 0 e 120 também são aceitos.

A palavra or importa: uma idade é inválida se estiver abaixo do mínimo ou acima do máximo. Escrever age < 0 and age > 120 não rejeitaria nada, pois um número não pode ser as duas coisas.

Para uma resposta de sim ou não, o teste de invalidez é answer != "y" and answer != "n". Uma resposta deve ser diferente das duas strings aceitas para ser rejeitada. Com or, até "y" repetiria o laço porque é diferente de "n". Rastreie uma resposta aceitável e uma inaceitável para verificar uma condição como essa.

As mesmas tarefas podem usar while True com uma leitura no corpo, seguida de um teste de saída e break. Isso coloca a decisão imediatamente após a entrada e evita escrever a leitura duas vezes.

Um laço for visita os itens de uma sequência em ordem. A cada passagem, o Python atribui o próximo item à variável do laço e executa o corpo indentado. Um laço sobre uma sequência costuma ser chamado de laço de repetição definida porque os itens fornecem um conjunto definido de trabalho.

Um item de cada vez

Uma string é uma sequência de caracteres:

for ch in "cat":
    print(ch)

Isso exibe c, a e t em linhas separadas. Espaços e sinais de pontuação também contam como caracteres. A string "hi there" tem oito caracteres, incluindo seu espaço, então visitar cada caractere leva oito passagens.

Uma lista contém uma sequência de valores. Sua forma literal usa colchetes e vírgulas:

scores = [3, 41, 12]
for score in scores:
    print(score * 2)

A saída é 6, 82 e 24, cada um em sua própria linha. score é um número de cada vez, não a lista inteira nem sua posição. Não é necessária uma atualização manual de contador para passar de 3 para 41 e depois para 12.

Use um nome que descreva um item: name em names ou score em scores. Se o corpo nunca precisar do valor atual, _ é um nome comum para essa variável de laço não utilizada.

A atribuição não substitui um item

A variável do laço é uma variável comum. Atribuir um número diferente a ela não substitui o número na lista:

numbers = [1, 2, 3]
for n in numbers:
    n = n * 10
    print(n)
print(numbers)

O corpo exibe 10, 20 e 30. A cada nova iteração, o próximo item original da lista é atribuído a n. A última linha de saída é [1, 2, 3]: a lista em si não mudou. Após o laço, n mantém 30, o último valor atribuído a ele no corpo.

Uma sequência vazia não dá trabalho ao corpo. Com for ch in "":, há zero passagens, e o laço não faz nenhuma atribuição a ch. Não conte com a criação da variável pelo laço quando pode não haver itens.

Pertencimento dentro de um laço

Em um cabeçalho for, in introduz a sequência a visitar. Em uma condição, ele testa o pertencimento e produz True ou False. Esses usos podem funcionar juntos:

vowels = 0
for ch in "education":
    if ch in "aeiou":
        vowels += 1
print(vowels)

Cada caractere é visitado, mas o contador muda apenas para e, u, a, i e o. A saída é 5. O if está indentado dentro do laço, e a atualização do contador está indentada dentro do if.

Esse laço também mostra por que uma variável do laço e um contador têm funções diferentes. ch contém o caractere atual; vowels registra quantos caracteres atenderam à condição até o momento. O contador começa antes do laço para manter seu resultado entre passagens.

Um inteiro isolado não pode fornecer itens: for i in 5: lança TypeError. Para repetir uma ação cinco vezes, escreva for _ in range(5):. A sequência range fornece os passos, mesmo quando o corpo não usa seus valores.

Uma sequência range descreve inteiros igualmente espaçados. Ela é útil para repetir uma tarefa um número definido de vezes, contar de forma crescente ou decrescente e selecionar passos regulares. Seu limite de parada é sempre excluído.

Três formas

Com um argumento, esse argumento é o limite de parada. Com dois, eles são o início e o limite de parada. Com três, o último argumento é o passo somado após cada valor. range(0, 10, 3) visita 0, 3, 6 e 9; o próximo passo chegaria a 12, então ele não é fornecido.

O limite de parada continua excluído mesmo quando um passo poderia chegar exatamente a ele. range(0, 10, 5) fornece apenas 0 e 5. Para o passo positivo padrão de 1 e um limite de parada acima do início, o número de valores fornecidos é o limite de parada menos o início.

Conte regressivamente com um passo negativo

range(5, 0, -1) fornece 5, 4, 3, 2 e 1. Para incluir 0, coloque o limite de parada abaixo dele: range(5, -1, -1) fornece seis valores, terminando em 0.

A direção deve corresponder aos limites. range(5, 0) está vazia porque seu passo padrão é positivo. range(1, 5, -1) também está vazia porque começa abaixo do limite de parada, mas avança para baixo. Sequências range vazias são válidas e causam zero iterações; um passo zero, por outro lado, lança ValueError.

Coloque o último valor necessário dentro do limite

Para somar os inteiros pares de 2 a 20:

total = 0
for n in range(2, 21, 2):
    total += n
print(total)

O limite de parada 21 permite que 20 seja visitado. Os dez valores somam 110, então o programa exibe 110. Usar o limite de parada 20 deixaria 20 de fora e resultaria em 90.

Para uma tabuada, deixe a sequência range fornecer os fatores:

for i in range(1, 11):
    print(7, "x", i, "=", 7 * i)

A primeira linha de saída é 7 x 1 = 7, e a décima é 7 x 10 = 70. Se o próprio número não for usado, for _ in range(3): pode repetir uma mensagem três vezes.

Inspecione uma sequência range e verifique seus argumentos

list(range(2, 6)) produz [2, 3, 4, 5], o que é útil ao verificar os limites. len(range(0, 10, 3)) é 4. Uma sequência range armazena os limites e o passo que a definem, em vez de criar uma lista contendo cada inteiro.

Os argumentos são inteiros, incluindo zero e inteiros negativos: range(-3, 3) visita de -3 a 2. Um número de ponto flutuante como 3.0 é rejeitado com TypeError, mesmo que não tenha parte fracionária. Uma quantidade inserida como texto pode ser convertida primeiro com n = int(input("How many? ")) e depois usada em range(n).

Escolha um laço perguntando o que controla a repetição. Se houver uma sequência de itens a visitar ou uma contagem de repetições, for costuma expressar a tarefa diretamente. Se a próxima repetição depender de uma condição variável ou de uma entrada futura, while coloca essa decisão em seu cabeçalho.

Itens definidos ou uma condição variável

Uma quantidade não precisa ser escrita como literal no programa. Após ler n da entrada, range(n) ainda fornece um conjunto definido de passos. Um laço de repetição indefinida depende de uma condição cujo ponto de parada não é especificado como uma contagem de repetições.

Estimar um número grande de repetições não é adequado para “até terminar”. Um laço sobre range(1000) pode esgotar suas tentativas antes de o usuário terminar, e uma versão sem verificação de saída continuará depois que a tarefa estiver concluída.

Reescreva um laço de contagem

Estes dois laços exibem de 1 a 5, cada número em sua própria linha:

for i in range(1, 6):
    print(i)

i = 1
while i < 6:
    print(i)
    i += 1

Na versão while, o início da sequência range torna-se a inicialização, o limite de parada excluído torna-se a comparação < e o passo torna-se a atualização. O corpo usa i antes dessa atualização. Mover a atualização para antes de print(i) deslocaria os valores exibidos.

A contagem regressiva altera tanto a comparação quanto a atualização:

i = 10
while i > 0:
    print(i)
    i -= 2

Isso exibe 10, 8, 6, 4 e 2, assim como for i in range(10, 0, -2): faria. A sequência range decrescente exclui seu limite de parada, então a condição while correspondente é i > 0.

As duas formas correspondem à tarefa de exibir a contagem; seus valores finais da variável do laço são diferentes. A versão while realiza sua última atualização para 0 antes de parar. A versão for termina após atribuir seu último valor fornecido, 2.

Uma sequência range mantém os limites que recebeu

n = 3
for i in range(n):
    n = 10
    print(i)

Isso ainda exibe 0, 1 e 2. A sequência range foi criada usando 3; atribuir 10 a n não a recria. Um break pode encerrar o laço antecipadamente, mas alterar essa variável separada não altera os números fornecidos pela sequência range.

Um cabeçalho while, por outro lado, avalia sua expressão novamente a cada retorno. Se essa expressão usar n, alterar n no corpo pode mudar quando o laço termina. Quando ambas as formas expressam claramente uma tarefa de contagem, a versão for cuida da passagem entre valores sem uma atualização manual que pode ser esquecida.

break encerra imediatamente o laço mais interno que o contém. O Python pula o restante desse corpo e todas as iterações restantes e continua após o laço. Uma condição dentro do corpo decide quando essa saída antecipada deve ocorrer.

Pare quando o primeiro resultado for encontrado

Busque o primeiro múltiplo de 7 acima de 50:

for n in range(51, 100):
    if n % 7 == 0:
        print(n)
        break

O laço verifica 51, 52, 53, 54, 55 e 56. O resto é zero em 56, então o Python exibe 56 e sai do laço. São necessárias seis iterações, embora a sequência range possa fornecer 49 números. Sem break, o laço também exibiria múltiplos posteriores de 7.

break está indentado dentro do if, então é executado somente para uma correspondência. Se estivesse alinhado com if, seria executado na primeira iteração, independentemente do teste. Um break dentro de um if encerra o laço que contém esse if; ele não encerra apenas o bloco condicional.

Leia uma vez e decida se deve processar

Um laço while True coloca a decisão de saída após a leitura da entrada:

while True:
    line = input("> ")
    if line == "done":
        break
    print(line)
print("Done!")

Para as entradas “hello”, “there” e “done”, as linhas de resposta são:

hello
there
Done!

O valor sentinela é testado antes da linha de processamento. Quando ele aparece, break salta print(line). O print final sem indentação ainda é executado após o laço. Há apenas uma instrução de entrada, pois cada passagem começa lendo uma nova linha.

Um total numérico usa a mesma ordem: inicialize total = 0 antes do laço; leia e converta um número; saia com break se ele for 0; caso contrário, some-o. Para 4, 7 e 0, o total é 11. Processar antes do teste de saída permitiria que o valor sentinela chegasse ao cálculo, o que importa quando o valor de parada pode alterar uma contagem, um produto ou uma média.

Valide no momento da entrada

while True:
    age = int(input("Age: "))
    if 0 <= age <= 120:
        break
    print("Please enter an age from 0 to 120.")
print("Accepted:", age)

A comparação encadeada aceita uma idade de 0 a 120. Ela significa 0 <= age and age <= 120. Um número aceito provoca a saída antes do aviso; um número fora desse intervalo chega ao aviso e depois a outra entrada. Nessa forma, o if descreve uma resposta válida, enquanto um laço de validação controlado pelo cabeçalho descreve uma resposta inválida.

Leia o salto literalmente

Uma instrução após break no mesmo bloco não pode ser executada. Coloque uma mensagem ou um resultado armazenado antes do break quando fizer parte do caso bem-sucedido. Coloque código após o laço quando ele tiver de ser executado tanto após uma saída antecipada quanto após a conclusão normal.

break deve estar dentro de um laço; caso contrário, o Python lança SyntaxError. Vários pontos de saída separados podem tornar um laço mais difícil de acompanhar. Quando uma única condição descreve naturalmente a regra de parada da tarefa, mantê-la no cabeçalho pode tornar o caminho mais fácil de rastrear.

continue pula o restante da iteração atual. O laço permanece ativo: um laço for recebe seu próximo item, e um laço while retorna à sua condição. Isso é útil quando um item não deve receber nenhum dos processamentos que seguem uma verificação.

Pule valores selecionados

total = 0
for n in range(1, 11):
    if n % 3 == 0:
        continue
    total += n
print(total)

A sequência range fornece todos os dez inteiros de 1 a 10. Em 3, 6 e 9, continue pula a adição. A soma dos dez é 55; deixar esses três valores de fora remove 18, então o programa exibe 37.

Continue não remove uma iteração da sequência range. O corpo ainda começa com cada valor, incluindo os pulados. Ele altera quais linhas posteriores são executadas nessa passagem.

Um filtro positivo pode expressar a mesma tarefa. Em um laço sobre [5, -2, 8, -7, 3], if n < 0: continue seguido de print(n) exibe 5, 8 e 3. Colocar o print dentro de if n >= 0: produz a mesma saída. Continue costuma ser útil quando várias linhas de processamento vêm em seguida, pois os itens rejeitados podem sair dessa parte do corpo imediatamente.

Não pule uma atualização de while

i = 0
while i < 5:
    if i == 2:
        continue
    print(i)
    i += 1

Isso exibe 0 e 1 e depois fica preso em 2. Em 2, continue salta para a condição sem alcançar a atualização. A condição permanece verdadeira e o mesmo ramo é seguido novamente.

Para pular a exibição de 2 e ainda avançar, atualize também nesse ramo:

i = 0
while i < 5:
    if i == 2:
        i += 1
        continue
    print(i)
    i += 1

Agora a saída é 0, 1, 3 e 4 em linhas separadas. O caminho que pula a exibição avança de 2 para 3. Cada caminho por esse corpo realiza exatamente uma atualização.

Break, continue e pass

Para um laço sobre [1, 2, 3, 4], suponha que um if n == 2: contenha uma dessas instruções e que print(n) venha depois do if. Break exibe apenas 1. Continue exibe 1, 3 e 4. Pass exibe os quatro valores porque não pula o print.

pass pode preencher um corpo onde o Python exige uma instrução enquanto o código está sendo desenvolvido. Ele não fornece uma atualização nem uma saída: while True: pass continua em execução. Break e continue devem estar dentro de um laço e afetam apenas o laço mais interno que os contém.

Um bloco else pode pertencer a um laço for ou while. Ele é executado uma vez quando o laço termina normalmente: um laço for esgota seus itens ou uma condição while se torna falsa. Ele é pulado quando esse laço termina por meio de break. Leia-o como o caso sem break.

Informe uma busca que não encontrou correspondência

for n in [4, 9, 15, 22]:
    if n % 5 == 0:
        print("First multiple of 5:", n)
        break
else:
    print("No multiple of 5")

O laço chega a 15, exibe First multiple of 5: 15 e é interrompido. O else é pulado. Com [4, 9, 22], o laço usa todos os itens sem ser interrompido e exibe No multiple of 5 uma vez.

O alinhamento é decisivo. O else está alinhado com for, então pertence ao laço. Um else alinhado com o if interno seria executado para cada item sem correspondência, anunciando uma falha antes de a busca terminar.

Uma lista vazia também chega ao else do laço. Não há itens, então o corpo é executado zero vezes e não há break. Da mesma forma, um laço while cuja condição é falsa na primeira verificação executa seu else imediatamente.

Busque um divisor

Um número primo é um inteiro maior ou igual a 2 cujos únicos divisores positivos são 1 e ele mesmo. Busque um divisor entre esses extremos:

n = 29
if n < 2:
    print("Not prime")
else:
    for d in range(2, n):
        if n % d == 0:
            print(n, "is divisible by", d)
            break
    else:
        print(n, "is prime")

Para 29, todos os restos são diferentes de zero e o else do laço exibe 29 is prime. Para 21, o primeiro divisor é 3 e o break pula o else do laço. A verificação externa trata números menores que 2. Sem ela, uma sequência range vazia para 1 chegaria ao else e classificaria 1 incorretamente como primo. Para 2, a sequência range também está vazia, mas a conclusão de que é “primo” está correta.

Tentativas limitadas com while e else

attempts = 0
while attempts < 3:
    guess = input("Password: ")
    if guess == "open sesame":
        print("Welcome!")
        break
    attempts += 1
else:
    print("Too many attempts.")

Um palpite correto executa o break, mesmo na terceira tentativa. Três palpites incorretos elevam o contador a 3; a condição se torna falsa e o else exibe a mensagem de falha. Uma instrução comum após o laço seria executada nos dois casos, então não os distinguiria.

Registre o resultado com uma variável sinalizadora

Uma variável sinalizadora é uma variável booleana que registra se algo aconteceu. Comece com found = False, altere-a para True quando uma correspondência aparecer e execute break. Após o laço, if not found: trata a falha. Isso fornece o mesmo resultado de busca que o else do laço, usando um registro explícito do acontecimento. Escolha uma forma cuja indentação e caminho de saída você consiga explicar com clareza.

Um acumulador mantém um resultado entre iterações. Um contador é um tipo de acumulador que aumenta em 1 cada vez que um evento ocorre. Defina o valor inicial antes do laço, atualize-o dentro dele e use o resultado final depois.

Conte eventos ou some valores

count = 0
for n in [4, 15, 22, 8, 11]:
    if n > 10:
        count += 1
print(count)

O teste é satisfeito por 15, 22 e 11, então a saída é 3. A atualização soma 1 para um item correspondente; somar n totalizaria os valores correspondentes.

Para somar todos os itens, inicialize total = 0, remova o teste if, adicione total += n diretamente no corpo e exiba total depois. Os cinco valores somam 60. Sua média é 60 / 5, que resulta em 12.0; a divisão com / retorna um número de ponto flutuante para esses operandos inteiros.

Para uma média filtrada, atualize o total e a contagem sob a mesma condição:

total = 0
count = 0
for n in [4, 15, 22, 8, 11]:
    if n > 10:
        total += n
        count += 1
if count > 0:
    print(total / count)
else:
    print("No matching values")

Aqui o total selecionado é 48 e a contagem é 3, então a saída é 16.0. Dividir pelo comprimento da lista inteira usaria o grupo errado. A verificação da contagem também trata uma lista vazia ou sem correspondências.

Escolha um valor inicial adequado à operação

Um produto dos inteiros de 1 a 5 começa em 1 e termina em 120. Começá-lo em 0 manteria cada produto em 0.

A acumulação de texto também depende da ordem:

rev = ""
for ch in "stressed":
    rev = ch + rev
print(rev)

Cada novo caractere vai para a frente do texto armazenado, produzindo desserts. Alterar a atualização para rev = rev + ch adiciona caracteres ao final e reconstrói stressed.

Mantenha o resultado entre iterações

Mover total = 0 para dentro de um laço de soma apaga o trabalho anterior em cada passagem. Com [4, 15, 22, 8, 11], reinicializar antes de cada adição deixa apenas 11 no final. Inicialize fora do laço para que a próxima adição use o subtotal anterior.

Um print dentro do corpo mostra o total acumulado após cada atualização: 4, 19, 41, 49 e 60 neste exemplo. Um print após o laço mostra apenas 60. Escolha sua posição de acordo com a saída solicitada.

Para uma lista armazenada simples, sum(values) fornece seu total e len(values) fornece sua contagem. Um laço explícito permite filtrar valores, acompanhar vários resultados juntos ou processar valores conforme chegam pela entrada.

Para encontrar um máximo, mantenha o maior valor encontrado até o momento. Compare cada novo item com o valor armazenado e substitua-o somente quando o novo item for maior. O padrão de mínimo funciona da mesma forma com a comparação invertida.

Comece sem inventar um valor de dados

None é o valor do Python para “nada ainda”. Ele oferece uma maneira clara de o primeiro item se tornar o melhor atual:

largest = None
for n in [12, -3, 25, 7]:
    if largest is None or n > largest:
        largest = n
print(largest)

Os valores armazenados após cada item são 12, 12, 25 e 25. O programa exibe 25. No primeiro item, largest is None é verdadeiro. O or do Python para aí, então não tenta a comparação inválida de um número com None. Nas passagens seguintes, o valor armazenado é um número e a segunda comparação é usada.

Para um mínimo, comece com smallest = None e use smallest is None or n < smallest. A mesma lista produz -3.

Começar um máximo em 0 pode informar um valor que nunca apareceu. Para -5, -2 e -9, nenhum valor ultrapassa 0, então essa versão manteria 0 incorretamente. O máximo é -2. Começar um mínimo em 0 tem o problema correspondente quando todos os itens são positivos.

Se os dados comprovadamente contiverem um item, usar esse primeiro valor como melhor valor inicial também funciona. Funções embutidas cobrem listas armazenadas simples: max([12, -3, 25, 7]) fornece 25 e min([12, -3, 25, 7]) fornece -3. Um laço personalizado pode manter informações relacionadas, como onde o valor ocorreu.

Salve a posição quando o melhor valor mudar

largest = None
best_day = None
day = 0
for temperature in [18, 23, 21, 26, 24]:
    day += 1
    if largest is None or temperature > largest:
        largest = temperature
        best_day = day
print(largest, best_day)

O contador de dias avança para cada item. O melhor dia muda somente quando um novo máximo aparece. A saída final é 26 4, ou seja, uma temperatura de 26 no dia 4. Salvar o dia após o laço salvaria apenas o último dia examinado.

Decida o que fazer em um empate

Para [5, 8, 8, 3], o teste n > largest mantém o primeiro 8 e sua posição, 2 ao contar a partir de 1. Substituir > por >= também atualiza quando há um valor igual, mantendo o último 8 na posição 3. O maior número permanece o mesmo; a posição armazenada é diferente.

Uma lista vazia deixa inalterado o melhor valor inicializado com None. Verifique esse estado antes de informar um número ou fazer cálculos com ele. Isso significa que nenhum item forneceu um melhor valor.

A comparação pode usar uma propriedade de um item. Para manter a palavra mais longa entre “pera”, “banana” e “figo”, compare len(word) com o comprimento da palavra armazenada. “Banana” tem seis caracteres, então vence. Salve a própria palavra quando ela se tornar a melhor para que o resultado identifique o item, não apenas seu comprimento.

Uma busca linear verifica os itens em ordem até encontrar uma correspondência ou esgotar os itens. Uma correspondência pode ser um valor exato, o primeiro item que passa em uma condição ou uma evidência para uma pergunta sobre “pelo menos um” ou “todos”.

Registre o sucesso

names = ["Ana", "Ben", "Chen"]
found = False
for name in names:
    if name == "Ben":
        found = True
        break
if found:
    print("Ben is on the list")
else:
    print("Ben is not on the list")

A variável sinalizadora começa falsa porque nada foi encontrado ainda. A primeira verificação, Ana, deixa-a inalterada. A segunda encontra Ben, torna a variável verdadeira e sai do laço. A saída é Ben is on the list.

A variável sinalizadora registra um acontecimento ao longo de toda a busca. Não a reinicialize a cada item sem correspondência. Se um laço continuar após encontrar Ben e definir found = False ao chegar a Chen, o resultado bem-sucedido será perdido. Da mesma forma, “não encontrado” deve aparecer depois que todas as verificações falharem, não dentro de um else por item que anuncia a falha para Ana antes de Ben ser examinado.

Primeira ou última correspondência

Para [7, 4, 9, 10], o primeiro número par é 4 e o último é 10. Este laço salva o primeiro:

match = None
for n in [7, 4, 9, 10]:
    if n % 2 == 0:
        match = n
        break
print(match)

A saída é 4. Remova o break e cada nova correspondência sobrescreverá a anterior, deixando 10. Se nada corresponder, o valor armazenado permanecerá None. Decida se a tarefa pede existência, o primeiro item, o último item ou uma posição antes de escolher o que armazenar.

Para informar uma posição, mantenha um contador que avance para cada item examinado e salve-o quando houver correspondência. Informe como as posições são numeradas: contar a partir de 1 coloca Chen na posição 3 da lista de nomes; a numeração usual de posições do Python começa em 0.

Pelo menos um precisa de um sucesso; todos precisam de uma falha

Uma busca por “pelo menos um” começa falsa e se torna verdadeira no primeiro item que passa no teste. Ela pode parar aí porque um sucesso responde à pergunta.

Uma busca por “todos” começa verdadeira e se torna falsa na primeira falha:

all_positive = True
for n in [3, 8, -1, 5]:
    if n <= 0:
        all_positive = False
        break
print(all_positive)

O terceiro valor, -1, refuta “todos os valores são positivos”, então a saída é False. Não é necessário inspecionar 5. Zero também falharia porque positivo significa maior que zero. Se não houver itens, a variável sinalizadora permanecerá verdadeira: nenhum contraexemplo apareceu.

Pertencimento exato e condições personalizadas

Para igualdade apenas, "Ben" in names fornece diretamente True ou False. Um laço torna visível o estado variável da busca e permite que o teste expresse uma condição personalizada, como “a primeira palavra com mais de cinco caracteres”.

Comparações de strings são exatas. "ben" é diferente de "Ben", e "Ben " inclui um espaço ao final. Uma busca por uma dessas strings não deve tratar as outras como iguais.

Um laço aninhado é um laço dentro do corpo de outro laço. Para cada iteração externa, o laço interno começa e executa sua tarefa. A variável externa permanece fixa enquanto a variável interna muda.

Construa uma linha de cada vez

for row in range(1, 4):
    for col in range(1, 5):
        print(row * col, end=" ")
    print()

A saída tem estas três linhas, cada uma com um espaço após seu último número:

1 2 3 4 
2 4 6 8 
3 6 9 12 

Primeiro, row é 1, enquanto col assume valores de 1 a 4. Depois row passa a ser 2 e o laço interno começa novamente na coluna 1. Por fim, a linha 3 recebe as mesmas quatro colunas. O corpo interno é executado doze vezes.

end=" " substitui a nova linha usual de print por um espaço. O print() vazio encerra a linha. Ele está dentro do corpo externo, mas fora do corpo interno, então é executado três vezes. Indentá-lo um nível a mais colocaria cada número em sua própria linha. Remover sua indentação encerraria uma linha apenas uma vez, após ambos os laços.

Dê nomes distintos às variáveis dos laços, como row e col. Reutilizar o nome externo dentro do laço interno sobrescreve o valor necessário para identificar a linha atual.

Conte o trabalho

Quando cada passagem externa recebe o mesmo número de passagens internas, multiplique as contagens. Três linhas e quatro colunas resultam em doze execuções internas. Dois laços com 100 passagens cada resultam em 10.000 execuções internas; três níveis resultam em 1.000.000. Portanto, um pequeno aumento em cada limite pode criar muito mais trabalho repetido.

Se o limite interno mudar com a variável externa, some as contagens separadas:

for row in range(1, 5):
    for _ in range(row):
        print("*", end="")
    print()

Isso exibe:

*
**
***
****

Os comprimentos das linhas são 1, 2, 3 e 4, totalizando dez estrelas. Para um padrão com n dessas linhas, o total é $n(n+1)\mathrm{/}2$. Multiplicar quatro por quatro suporia incorretamente que cada linha tem quatro estrelas.

Reinicialize um resultado para cada grupo

Para totalizar cada linha da grade de multiplicação, defina row_total = 0 dentro do laço externo, imediatamente antes do laço interno. Some row * col dentro do corpo interno e exiba row_total após o laço interno. As saídas são 10, 20 e 30.

Inicializar apenas uma vez, antes dos dois laços, mantém também os totais das linhas anteriores. Exibir após cada linha resulta em 10, 30 e 60. Ambas as posições preservam um resultado, mas uma preserva o resultado de uma linha e a outra preserva o total acumulado de toda a grade.

Visite combinações

Dois laços sobre range(1, 7) visitam todos os 36 resultados ordenados para dois dados. O primeiro laço fornece o primeiro dado e o segundo fornece o segundo dado. Uma condição dentro do corpo interno pode contar pares cuja soma é 7. Seis passam: (1, 6), (2, 5), (3, 4), (4, 3), (5, 2) e (6, 1). Inverter um par descreve um resultado ordenado diferente.

Break e continue atuam sobre o laço mais interno que os contém. Em código aninhado, localize esse laço antes de prever o que acontece em seguida. Um break no corpo interno não interrompe por si só o laço externo.

Acompanhe um break interno

for a in range(1, 4):
    for b in range(1, 4):
        if b > a:
            break
        print(a, b)

Em a = 1, o par 1 1 é exibido. Quando b passa a ser 2, o break encerra esse laço interno. O laço externo avança para a = 2 e inicia um novo laço interno com b igual a 1. Ele exibe 2 1 e 2 2 e depois é interrompido quando b é igual a 3. Para a igual a 3, todos os valores de b passam. As seis linhas de saída são:

1 1
2 1
2 2
3 1
3 2
3 3

Pare ambos os laços com um resultado registrado

Uma busca por uma combinação pode usar uma variável sinalizadora e um break em cada nível:

found = False
for a in range(1, 6):
    for b in range(1, 6):
        if a * b == 12:
            found = True
            break
    if found:
        break
if found:
    print(a, b)
else:
    print("No matching pair")

As linhas com a igual a 1 e 2 não têm correspondência. Na linha 3, b chega a 4 e o produto é 12. O break interno encerra o laço de b; a variável sinalizadora faz o break externo ser executado. A saída final é 3 4.

A variável sinalizadora é inicializada antes dos dois laços porque registra um resultado para toda a busca. O if found: externo deve ficar após o laço interno, mas dentro do corpo externo. Sua indentação faz com que ele seja verificado uma vez por linha concluída ou interrompida.

Preserve valores quando a busca continua

Remover apenas o break externo faz a busca continuar nas linhas posteriores. Neste exemplo, uma correspondência posterior é 4 3, mas o laço acaba examinando a linha 5 e termina com a = 5 e b = 5. Exibir as variáveis dos laços então fornece 5 5, não uma correspondência armazenada.

Se a tarefa precisar do último par correspondente, salve best_a = a e best_b = b sempre que ocorrer uma correspondência. Essas variáveis separadas mantêm uma correspondência enquanto as variáveis dos laços continuam mudando. Verifique a variável sinalizadora antes de informá-las quando uma correspondência puder não existir.

Pule um par e mantenha a linha

Um continue dentro do laço interno passa para seu próximo valor interno. Para dois laços que visitam de 1 a 4, if a == b: continue antes do processamento pula quatro pares iguais. Restam doze pares ordenados dos dezesseis originais.

Um if também pode selecionar pares sem saltar. Dois dados têm três pares ordenados cuja soma é 10: (4, 6), (5, 5) e (6, 4). Uma condição dentro do corpo interno os identifica.

Rastreamento significa executar um programa à mão, uma instrução de cada vez, registrando seus valores e sua saída. Uma tabela de rastreamento dá uma coluna a cada variável relevante. Indique se um valor é registrado antes ou depois de uma atualização para que as linhas tenham um significado claro.

Rastreie um laço while

total = 0
i = 1
while i <= 4:
    total = total + i
    i = i + 1
print(total)

Comece com total = 0 e i = 1. Verifique a condição antes de entrar no corpo. Para cada verificação verdadeira, execute a adição antes do incremento:

A próxima verificação é 5 <= 4, que é falsa. Não há uma quinta linha do corpo. O corpo é executado quatro vezes, a condição é verificada cinco vezes e o print após o laço exibe 10 uma vez. Os valores finais são i = 5 e total = 10.

Distinga a verificação que falhou de uma iteração: ela encerra o laço sem executar seu corpo. Se a condição inicial já for falsa, não haverá nenhuma linha do corpo e as variáveis manterão seus valores iniciais.

A ordem das instruções altera o resultado

Se o incremento for movido para antes da adição, cada passagem usará o novo i. As quatro adições passam a ser 2, 3, 4 e 5, resultando em 14. A condição ainda testa i no início, antes desse incremento. Rastrear apenas os valores do cabeçalho deixaria passar qual valor a adição realmente usa.

Quando um corpo contém break ou continue, pare de acompanhar suas linhas restantes assim que o salto ocorrer. Com continue, volte ao cabeçalho ou ao próximo item; com break, prossiga após o laço. Um rastreamento deve seguir esses caminhos, não apenas copiar todas as instruções do corpo em cada linha.

Rastreie caracteres e laços aninhados

Um laço for atribui o próximo item no início de sua passagem:

rev = ""
for ch in "abc":
    rev = ch + rev
print(rev)

O texto armazenado passa a ser "a", depois "ba" e depois "cba". A saída é cba. Registre o texto real, incluindo sua ordem, em vez de escrever apenas que “um caractere foi adicionado”.

Para laços aninhados, use uma linha para cada iteração interna. Registre as duas variáveis dos laços para que o valor externo se repita nas linhas que lhe pertencem. Em um laço com duas linhas e três colunas, os valores de linha são 1, 1, 1, 2, 2, 2, enquanto os valores de coluna são 1, 2, 3, 1, 2, 3.

Produza um rastreamento com print

Um print("i =", i, "total =", total) temporário após as duas atualizações no laço de soma exibe i e total no fim de cada passagem. Colocá-lo antes das atualizações exibe outro momento. Compare a posição do print com os rótulos das colunas da sua tabela. Remova as impressões de diagnóstico após corrigir o código para que não se tornem saída extra do programa.

Para uma pergunta “o que é exibido?”, registre apenas as instruções que realmente exibem algo. Uma variável mudar não é, por si só, uma saída; várias atualizações podem ocorrer antes de um único print final.

Um erro de uma unidade visita um valor a mais ou a menos, ou desloca os valores visitados em uma unidade. Ele costuma vir do limite de parada excluído de uma sequência range, de uma escolha entre < e <= ou do valor inicial de um contador.

Defina os extremos pretendidos

Para somar de 1 a 10, range(1, 10) é curta demais. Ela fornece apenas de 1 a 9, resultando em um total de 45. range(1, 11) inclui 10 e resulta em 55. Para uma sequência range crescente de inteiros com passo 1, use o limite de parada n + 1 para incluir o valor final n.

Para um passo padrão de 1, range(a, b) fornece b - a valores quando b é maior que a. Um break ainda pode encerrar o laço antes que todos sejam usados. Com outros tamanhos de passo, liste o caso pequeno ou use len(range(...)) para verificar a contagem.

A contagem de um laço while depende conjuntamente de seu início, comparação e atualização. Para um inteiro não negativo n, com i += 1 no fim de cada passagem e sem saída antecipada:

Com n igual a 0, os dois primeiros pulam o corpo. O terceiro é executado uma vez com i igual a 0. Esse caso pequeno revela a passagem extra sem rastrear um laço longo.

Limites da contagem regressiva

Começando em 5 e exibindo antes de n -= 1, while n > 0: exibe cinco valores, terminando em 1. Usar n >= 0 exibe seis, terminando em 0. As sequências range decrescentes correspondentes são range(5, 0, -1) e range(5, -1, -1).

Verifique também a ordem. Atualizar um contador antes de usá-lo pode deslocar cada valor mesmo quando o laço tem o número esperado de passagens. Um rastreamento deve registrar o primeiro e o último valor realmente usados pelo cálculo.

Itens e os espaços entre eles

Um erro de contagem de limites confunde contagens de itens com contagens de espaços entre eles. Cinco seções de cerca precisam de seis postes. Cinco números exibidos precisam de apenas quatro separadores entre eles.

for i in range(1, 6):
    print(i, end="-")

Isso exibe 1-2-3-4-5-, incluindo um hífen final indesejado. Cada print adiciona um hífen após um item, até mesmo o último.

Uma correção é exibir o primeiro item separadamente e depois exibir um separador antes de cada item posterior:

print(1, end="")
for i in range(2, 6):
    print("-" + str(i), end="")
print()

A saída é 1-2-3-4-5. O laço exibe quatro trechos de hífen e número, e o print vazio final encerra a linha. Essa versão tem um primeiro item conhecido; um caso geral de dados vazios também deve pular a exibição desse primeiro item.

Verifique a correção com casos pequenos

Anote o primeiro valor, o último valor e a contagem pretendidos antes de alterar o código. Escolha os limites e a comparação correspondentes e rastreie uma execução curta. Verifique zero e um item, além de um caso comum. Zero revela trabalho que deve ser pulado; um revela um separador desnecessário ou uma atualização extra. Altere o limite que causa o erro para que a repetição do código corresponda à tarefa.