Condições e ciclos

Comparar e combinar condições

Com nota = 10, a condição nota >= 10 é verdadeira, enquanto com nota = 9 é falsa; a condição escolhe instruções e o ciclo repete-as, podendo alterar o estado, isto é, os valores associados aos nomes, em cada iteração.

==, !=, <, <=, > e >= comparam valores. Para verificar se uma nota está entre 0 e 20, incluindo os extremos, podes escrever 0 <= nota <= 20. Não uses is para comparar números ou texto: is pergunta se tens o mesmo objeto.

not p nega uma condição; p and q exige ambas; p or q exige pelo menos uma. A ordem de precedência é not, and, or, mas parênteses tornam a intenção explícita.

Numa condição, False, None, zero e coleções vazias contam como falso. Os restantes valores destes tipos contam como verdadeiro. Por exemplo, if texto: testa se uma string não está vazia; não testa se contém a palavra "True".

Python avalia and e or com curto-circuito. Em divisor != 0 and total / divisor > 2, a divisão só ocorre quando o divisor é diferente de zero.

Estes operadores devolvem um dos operandos, não necessariamente bool: "" or "sem nome" vale "sem nome". Nas condições iniciais, usa comparações que produzam True ou False.

Escolher um ramo

Uma cadeia if / elif / else escolhe no máximo um ramo, o primeiro cuja condição é verdadeira. Dois if separados podem executar ambos. A indentação define o corpo; usa quatro espaços de forma consistente.

nota = int(input())
if not 0 <= nota <= 20:
    print("inválida")
elif nota >= 10:
    print("aprovado")
else:
    print("reprovado")

A entrada 10 passa a validação e escolhe o segundo ramo, por isso o programa escreve aprovado. Testa 9, 10, 20 e 21 para verificar as fronteiras, onde um > no lugar de >= costuma mudar o resultado.

Ciclos for e a função range

for percorre os elementos de um iterável, um objeto que fornece valores um a um.

range(inicio, fim, passo) fornece inteiros até ao limite fim, que fica excluído. Omitir o início usa 0; omitir o passo usa 1. O passo não pode ser zero.

sum soma os valores de um iterável.

Para somar os quadrados dos inteiros de 1 até n, inicializamos um acumulador com zero e acrescentamos um termo em cada iteração. Para estes números, soma += k * k abrevia soma = soma + k * k: calcula o novo total e volta a associá-lo a soma.

n = int(input())
soma = 0
for k in range(1, n + 1):
    soma += k * k
print(soma)

Depois de tratar k, a soma contém os quadrados de 1 até k. Esta propriedade é um invariante do ciclo e explica o resultado. Se n é zero, não há iterações e a soma vazia vale zero. Para um produto, o valor inicial costuma ser 1, porque multiplicar por zero destruiria o resultado.

Ciclos while e terminação

while testa a condição antes de cada iteração. Pode executar zero vezes. Usa-o quando o fim depende dos dados ou de uma condição que muda durante o cálculo.

n = int(input())
soma = 0
while n > 0:
    soma += n % 10
    n //= 10
print(soma)

n % 10 extrai o último dígito e n // 10 elimina-o; n //= 10 guarda esse quociente em n para avançar para o prefixo seguinte. A tabela acompanha a entrada 3083 passo a passo:

O dígito zero mantém a soma, mas não termina o ciclo: ainda resta o prefixo 3. A paragem depende de n == 0, depois de retirar todos os dígitos.

Para n > 0, o quociente inteiro por 10 é menor que n e continua não negativo, por isso chega a zero. Sem a atualização de n, a condição continuaria verdadeira.

Este algoritmo assume entrada não negativa. Para aceitar inteiros negativos, usa n = abs(n) antes do ciclo. Para a entrada zero, a soma permanece zero, que é o resultado pretendido.

Construir um número a partir dos dígitos

Para inverter um inteiro não negativo sem o converter em texto, retiramos os seus dígitos da direita para a esquerda e colocamo-los no fim de outro inteiro. Em resultado * 10 + digito, multiplicar por 10 abre a posição das unidades; a adição ocupa essa posição com o dígito seguinte.

n = 1204
resultado = 0
while n > 0:
    resultado = resultado * 10 + n % 10
    n //= 10
print(resultado)

A saída é 4021. O estado permite conferir onde fica o zero:

Para 1200, o resultado é 21: zeros à esquerda não fazem parte da representação de um inteiro. Se o contrato exigir conservar quatro posições, precisamos de texto ou de guardar também o comprimento. Para zero, o ciclo não executa e o resultado inicial zero já é correto.

A divisão com resto também permite mudar de base. Para escrever 13 em base 2, as divisões sucessivas produzem os restos 1, 0, 1 e 1. O primeiro resto é o dígito menos significativo, por isso a representação lê-se na ordem inversa, 1101. Conferimos com $1\times2^3+1\times2^2+0\times2+1=13$. Em base b, usamos n % b e n // b, exigindo um inteiro b >= 2.

Sentinelas, break, continue e else

Uma sentinela marca o fim dos dados e não deve ser tratada como uma entrada normal. Se zero termina uma sequência de medições positivas, testa-o antes de o acrescentar à soma.

soma = 0
n = int(input())
while n != 0:
    if n > 0:
        soma += n
    n = int(input())
print(soma)

Com entradas 3, 5 e 0, a soma passa por 0, 3 e 8; o zero termina o ciclo sem ser somado. Sem a leitura nova no fim do corpo, o ciclo repetiria a primeira medição.

break sai do ciclo mais interno. continue passa à próxima iteração; num while, confirma que não salta a atualização necessária à terminação. O else de um ciclo corre quando o percurso termina sem break, mesmo que não tenha havido iterações.

for divisor in range(2, 7):
    if 7 % divisor == 0:
        print("composto")
        break
else:
    print("primo")

O exemplo escreve primo, porque nenhum divisor interrompe o ciclo, e o else está alinhado com for, não com if. Ao alterar 7, altera também o limite se pretenderes testar todos os divisores próprios; a lição de funções separa esse cálculo da entrada.

Escolher o percurso

Percorre valores diretamente quando só precisas deles; usa índices quando precisas de uma posição e enumerate quando precisas de ambos. Num ciclo aninhado, o corpo interior executa para cada valor do exterior.

for linha in range(2):
    for coluna in range(3):
        print(linha, coluna)

Os pares visitados são (0, 0), (0, 1), (0, 2), (1, 0), (1, 1) e (1, 2): seis, não cinco. Se há três linhas e quatro colunas, visitas 12 pares, não sete.