Tutorial sobre loops em Python

Loop For

Você pode lidar com o loop for da mesma forma que o loop while. Como você provavelmente já imaginou, a parte “for” em “for loop” quer dizer algo que você faz um certo número de vezes.

Se você tiver tudo isso em mente, pode facilmente definir o loop for da seguinte forma:

Um loop for é um conceito de programação que, quando implementado, executa um trecho de código repetidamente “para” um determinado número de vezes, com base em uma sequência.

Ao contrário do loop while, não tem nenhuma condição envolvida - você só precisa executar um trecho de código várias vezes. Em outras palavras, enquanto o loop while continua executando o bloco de código que está dentro dele só até a condição ser e True e, o loop for executa o código que está dentro dele só um número específico de vezes. Esse “número de vezes” é determinado por uma sequência ou uma lista ordenada de coisas.

Você vai aprender mais sobre a diferença entre os loops while e for daqui a pouco, mas, por enquanto, concentre-se nas seguintes partes necessárias para criar um loop for:

• A palavra-chave for
• Uma variável
• A palavra-chave in
• A função range(), que é uma função embutida na biblioteca Python para criar uma sequência de números.
• O código que você quer executar várias vezes

Loops for em Python

# Print "Thank you" 5 times
for number in range(5):
    print("Thank you")

# Thank you
# Thank you
# Thank you
# Thank you
# Thank you

Como você pode ver, os componentes que você viu na seção acima aparecem de novo neste pequeno exemplo de um loop for em Python: a palavra-chave for, a variável number, a palavra-chave in, a função range() e o código que você quer executar várias vezes, print("Thank you").

Não é tão difícil assim, né?

Vamos ver outro exemplo de um loop for, onde você usa duas variáveis para definir seu fluxo de controle:

languages = ['R', 'Python',  'Scala', 'Java', 'Julia']

for index in range(len(languages)):
   print('Current language:', languages[index])

# Current language: R
# Current language: Python
# Current language: Scala
# Current language: Java
# Current language: Julia

Como você pode ver, você começa o loop com a palavra-chave for. Depois, você usa as variáveis index e languages, a palavra-chave in e a função range() pra criar uma sequência de números. Além disso, você vê que também usa a função len() neste caso, já que a lista languages não é numérica. O trecho de código que você quer executar várias vezes é uma instrução de impressão, ou seja, uma instruçã print('Current language :', languages[index]).

No loop acima, você quer dizer que, para cada índice no intervalo len(languages), você quer imprimir a linguagem de programação de ciência de dados. Agora, len(languages) é 5, então a declaração também poderia ser reescrita como:

for index in range(5):
    print('Current language:', languages[index])

# Current language: R
# Current language: Python
# Current language: Scala
# Current language: Java
# Current language: Julia

E isso mais uma vez dá o mesmo resultado!

Enquanto versus loops For em Python

Vamos revisitar o primeiro exemplo de loop while mais uma vez para ver quais são exatamente as diferenças entre os loops while e for. Você já leu acima que a diferença está na condição que está ou não envolvida, mas como isso se reflete no código e como você pode alternar entre as duas?

# Take user input
number = 2  

while number < 5 :
    print("Thank you")
    # Increment `number` by 1
    number = number+1

# Thank you
# Thank you
# Thank you

Você pode usar o loop for para imprimir a mensagem “Obrigado” de um jeito mais controlado:

# Print "Thank you" 3 times
for number in range(3) :  
    print("Thank you")

# Thank you
# Thank you
# Thank you

Viu como foi fácil transformar o loop while num loop for equivalente?

Como funciona, você pergunta? É simples.

Em um loop for, o número inteiro mencionado dentro da função range é o intervalo ou o número de vezes que o controle precisa repetir e executar o código na cláusula do loop for.

Observe que a contagem da função range() começa em 0 e não em 1. Isso quer dizer que, no exemplo acima, a contagem deveria ser 0,1,2 e não 1,2,3. É assim que funciona a contagem de números na memória de um computador. Então, ao criar um loop for, lembre-se sempre de que você precisa considerar a contagem do intervalo a partir de 0 e não de 1.

Dica: isso vale também para listas em Python, por exemplo. Se você quiser saber mais sobre listas Python, dá uma olhada no tutorial das 18 perguntas mais comuns sobre listas Python do DataCamp.

Agora, tem outra diferença interessante entre um loop for e um loop while. Um loop for é mais rápido do que um loop while. Para entender isso, dá uma olhada no exemplo abaixo.

import timeit

# A for loop example
def for_loop():
    for number in range(10000) :  
        # Execute the below code 10000 times
        sum = 3+4
        #print(sum)

timeit.timeit(for_loop)

# 267.0804728891719

import timeit

# A while loop example
def while_loop():
    i =0
    while i<10000:
        sum = 3+4
        #print(sum)
        i+=1

timeit.timeit(while_loop)

# 884.9233417965908

No trecho de código acima, você tem dois loops com cerca de 10.000 iterações. À primeira vista, os dois parecem iguais, até você dar uma olhada nos bastidores e entender como esses dois loops funcionam. Dica: a função timeit() te dá uma ideia do que pode ser a diferença!

Lembre-se: todo código Python é compilado com um compilador C, o que significa que o código que você vê acima é primeiro dividido em códigos de bytes e, em seguida, processado pelo compilador C subjacente.

Quando a execução do loop for no exemplo acima começa, o interpretador Python fala com o compilador C subjacente e, em seguida, cria um objeto lista de tamanho 10000. Depois, ele chama um iterador para tocar no índice de cada um dos 10.000 itens da lista.

Já a execução do loop while não cria nenhum objeto de lista. Na verdade, o compilador C chama o operador de comparação booleano para a condição i<10000 9999 vezes.

Você já pode imaginar que iterar sobre um objeto de lista já criado com 10.000 elementos é mais fácil para o compilador do que realizar uma operação booleana repetidamente 9.999 vezes, o desempenho temporal de um loop for é melhor do que o de um loop while. Isso fica bem claro no tempo de execução: o tempo que o loop for leva pra terminar é bem menor do que o tempo que o loop while precisa pra terminar.

Agora experimente o loop for! Lembre-se de que você quer especificar o intervalo de 0 a 11, já que quer mostrar só os números da sequência até 55, que é o 11º número da sequência.

Loops aninhados

Como você pode ver no exemplo acima, tem uma condição if-else dentro do loop while que permite que você coloque mais condições no seu código.

Espera aí!

Essa não é a única maneira de personalizar seu loop. Você também pode incluir mais alguns loops while dentro do seu código atual, o que é conhecido como loop aninhado. Você pode modificar o exemplo acima para incluir outro loop while, como mostrado abaixo:

# Take user input
number = 2 

# condition of the while loop
while number < 5 :  
    # condition of the nested while loop    
    while number % 2 == 0: 
        print("The number "+ str(number)+" is even")

No exemplo acima, tem outro loop while que tá “aninhado” dentro do loop externo. Esse loop interno faz outra verificação pra ver se o number % (mod) 2 é 0.

Ou seja, ele vê se o número é par e, se for, mostra a mensagem “O número é par”.

Mas tem um porém: se você olhar com atenção, vai ver que, assim como no código anterior, a instrução number=number+1 está faltando dessa vez. Como você não está aumentando a variável número em nenhum lugar, o valor da variável continua o mesmo o tempo todo e o código entra num loop infinito. Isso quer dizer que, uma vez que entra no loop, ele nunca sai e imprime a instrução um monte de vezes porque a variável number sempre vai ser definida como 2. Esse número é, claro, menor que 5 e é um número par.

Agora vamos dar uma olhada em como seria um loop for aninhado:

# Print the below statement 3 times
for number in range(3) :  
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    # Inner loop
    for another_number in range(5):  
        print("****************************")
        print("I am inner loop iteration "+str(another_number))

-------------------------------------------
I am outer loop iteration 0
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4
-------------------------------------------
I am outer loop iteration 1
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4
-------------------------------------------
I am outer loop iteration 2
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4

O código acima é uma versão modificada do primeiro exemplo de loop for. Observe como um segundo loop for é usado dentro do loop externo.

Vá em frente e execute o código.

Você vai ver que o controle entra no primeiro loop for e o valor da variável number é inicializado como 0. A primeira instrução print é impressa e, em seguida, o controle entra no segundo loop for, onde o valor da variável another_number é inicializado como 0. A primeira instrução print no segundo loop for é impressa uma vez.

Agora, o controle volta para o loop for interno mais uma vez e o valor de another_number é inicializado novamente para o próximo inteiro, seguido pela impressão da instrução dentro da função print().

Esse processo continua até que o controle passe pelo final da função range(), que é 5 nesse caso, e então o controle volta para o loop mais externo, inicializa a variável number para o próximo inteiro, imprime a instrução dentro da função print(), visita o loop interno e repete todos os passos acima até que a função range() seja percorrida.

Essa viagem do controle, que começa no loop mais externo, passa pelo loop interno e depois volta para o loop externo, continua até que o controle tenha percorrido toda a faixa, que no seu caso é 3 vezes.

Agora que você já leu algumas explicações sobre loops aninhados, é hora de começar a praticar! Escreva um programa Python para construir o seguinte padrão, usando um loop for aninhado:

break e continue Palavras-chave: Criando loops infinitos

Você pode usar break e continue em qualquer loop que criar. Essas palavras-chave não são só pra quebrar loops infinitos de propósito, mas devem ser usadas com cuidado. Ambas as palavras-chave tornam mais difícil para os outros — incluindo você mesmo, daqui a alguns meses, quando olhar para o seu código — entender o fluxo de controle no loop e onde a condição termina. Além disso, você não precisa usar as palavras-chave break e continue : como você viu até agora, você estava indo muito bem sem elas!

Mas, às vezes, pode ser mais fácil escrever loops infinitos de propósito do que os loops for e while tradicionais que você já viu até agora. Claro, nesses casos, o uso dessas palavras-chave é super recomendado!

Interrompendo e continuando loops while em Python

Felizmente, tem um jeito de sair dessa situação de loop infinito usando a palavra-chave break.

# Take user input
number = 2 

# Condition of the while loop
while number < 5 :  
    # condition of the nested while loop
    while number % 2 == 0:  
        print("The number "+str(number)+" is even")
        break

    number+=1

Quando você executa o código acima, ele não entra mais em um loop infinito.

“Que bruxaria é essa!”, você grita. Eu digo para relaxar, não é bruxaria.

O que rola é que, quando o controle encontra a palavra-chave break, ele entende que precisa sair do loop (no caso, o loop interno) e executa a próxima linha de código. Então, ele sai do loop while interno e vai pro loop externo, continuando a fazer o que faz normalmente até que a condição no loop while externo seja verdadeira.

É bom lembrar que tem que ter uma linha de código depois da palavra-chave break, senão não vai rolar nada. Tenta tirar a linha de código depois da palavra-chave break no exemplo acima e depois executa o código.

E se você colocar a palavra-chave continue depois da instrução break? Você pode seguir o código abaixo:

number = 2 

while number < 5 :
    while number % 2 == 0: 
        print("The number "+str(number)+" is even")
        break

    continue

    number+=1

O código acima é uma versão ligeiramente modificada do exemplo da palavra-chave break.

Quando você rodar o código acima, vai dar de cara com um loop infinito de novo. Antes de começar a arrancar os cabelos de frustração, dá uma olhada mais de perto. Você vai ver que tem uma palavra-chave continue depois da quebra. O que a palavra-chave continue faz é transferir o controle de volta para o loop mais externo antes mesmo que a variável number seja incrementada e, por causa disso, o código entra em um loop infinito.

Interrompendo e continuando loops for

E se você não quisesse executar o loop for interno no exemplo acima para todo o intervalo? Você pode usar uma instrução break de forma parecida com o que fez no caso do loop `while`.

# Print the below statement 3 times
for number in range(3) : 
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    for another_number in range(3):
        print("****************************")
        print("I am inner loop iteration "+str(another_number))
        break

No exemplo acima, a palavra-chave break depois do loop interno diz ao controle para sair do loop interno, e depois disso o controle volta para o loop externo.

Execute o exemplo de código abaixo:

# Print the below statement 3 times
for number in range(3) :  
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    continue
    for another_number in range(3):
        print("****************************")
        print("I am inner loop iteration "+str(another_number))
        break

No código acima, só o loop mais externo é executado e o controle nem toca no loop interno.

“Por quê?”, você pergunta.

Dá uma olhada melhor no código. Tem uma palavra-chave continue logo depois da segunda instrução “print” no loop mais externo. O que ele faz é mandar o controle voltar pro loop for externo e começar tudo de novo, e é por isso que o controle nunca toca no loop interno.

Diferente do loop while, você não precisa de um trecho de código depois da palavra-chave break no loop for. Um loop break sozinho vai funcionar bem dentro de um loop for.

range() versus xrange()

Essas duas funções são parecidas, mas se você estiver usando o Python 3, só vai ter a função range() disponível. No Python 3.x, a função xrange() foi renomeada para range(). Isso quer dizer que, se você tentar usar a função xrange() com o Python 3, vai aparecer um erro de  NameError: name 'xrange' is not defined.

Para entender como essas duas funções são parecidas, dá uma olhada no exemplo a seguir:

# Print the below statement 3 times
for number in range(5,10,2) :  
    print("I am number : "+str(number))

# I am number : 5
# I am number : 7
# I am number : 9

Ao rodar o código acima, você vai ver como o valor da variável number é pulado por um fator de 2, e isso é por causa dos parâmetros na função range().

O primeiro parâmetro nesta função é o parâmetro inicial. É aí que o controle começa a contar. O segundo parâmetro é o parâmetro de parada, que é o ponto onde o controle deve parar, e o último parâmetro é a função de passo, que define o fator pelo qual o controle deve saltar durante a contagem.

Então, no caso acima, o controle começa em 5 e depois percorre o loop até 9, adicionando 2 a cada contagem. Isso quer dizer 5, 5+2=7, 7+2=9.

Você aprendeu como usar a função range() para definir quantas vezes seu código precisa repetir. Agora, no Python 2.x, você também vai encontrar outra maneira de fazer isso, que é com a função xrange(). Execute o código abaixo:

# Print the below statement 3 times
for number in xrange(10) :  
    print("I am number : "+str(number))

I am number : 0
I am number : 1
I am number : 2
I am number : 3
I am number : 4
I am number : 5
I am number : 6
I am number : 7
I am number : 8
I am number : 9

Que diferença você viu na saída do código acima em comparação com a saída do código sem a função xrange()? Sem diferença?

Isso mesmo. Você não vai notar nenhuma diferença no resultado do código.

Então, por que você deve usar a função xrange()? Você vai ver isso mais tarde no tutorial. Primeiro, execute o código abaixo:

print(xrange(10))
print(range(10))

xrange(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Você pode ver que, na saída do código acima, há uma diferença na saída das duas instruções print. Na instrução de impressão, que tem a função xrange(), você imprime o objeto da função xrange(). Isso é diferente na instrução print que tem a função range(): lá, você obtém uma lista de números inteiros de 0 a 9.

Agora, essa é exatamente a diferença entre a função range() e a função xrange().

Quando você define a função range(), uma lista de todo o intervalo é armazenada na RAM e apresentada a você. Mas, quando você define a função xrange(), uma lista não fica guardada na memória. Em vez disso, a função xrange() gera números inteiros em todo o intervalo quando você precisa. Assim, a função xrange() ajuda a economizar memória em sistemas com poucos recursos.

Aprimore suas habilidades em Python!

Parabéns, você chegou ao fim deste tutorial. Agora que você aprendeu a usar loops em Python, vá em frente e pratique. Quanto mais você praticar, melhor!