Summary  
This chapter covers the use of a while loop to repeat code as long as a condition remains true, shows how updating the loop variable drives the iteration, and warns against infinite loops when the condition never becomes false.

General domain of usage  
Iterating through and printing each element of a list.

Watch this video for a visual walkthrough of how the 'while' loop works in Python. You'll see step-by-step how the loop checks its condition, repeats code, and stops when the condition is no longer true. The video uses the travel destination example from this chapter to show how to print each item in a list using a 'while' loop, highlighting the importance of updating the loop variable and avoiding common mistakes. The flow of the while loop should be presented horisontally.

O loop `while` é utilizado para repetir um bloco de código enquanto uma condição especificada for avaliada como `True`. A condição é verificada no início de cada iteração, e o loop é interrompido quando a condição se torna `False`.
``` python
while condition:
    # Code to execute while the condition is True
```
`condition`: uma expressão booleana que avalia como `True` ou `False`.

Vamos imprimir todos os destinos da `travel_list` um por um.

travel_list = ['Monako', 'Luxemburg', 'Liverpool', 'Barcelona', 'Munchen']

# Initialize the index
i = 0

# Print each destination using a while loop
while i < len(travel_list):
    print(travel_list[i])
    i += 1

- A variável `i` começa em `0`, que representa o primeiro índice da `travel_list`;
- O loop while verifica se `i` é menor que o comprimento da lista (`len(travel_list)`). Isso garante que o loop não ultrapasse os limites da lista;
- O loop imprime o destino no índice atual `travel_list[i]`;
- A variável `i` é incrementada em `1` a cada iteração usando `i += 1`;
- Quando `i` se torna igual ao comprimento da lista, a condição é avaliada como `False` e o loop é interrompido.

import unittest
import importlib
import re

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):

    def test_selected_is_declared(self):
        try:
            user_code = importlib.import_module("user_code")
            _dynamic_test(
                self,
                hasattr(user_code, 'selected'),
                "The `selected` list is declared.",
                "Expected `selected` to be declared."
            )
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

    def test_selected_contains_correct_values(self):
        try:
            user_code = importlib.import_module("user_code")
            expected_selected = user_code.countries[:len(user_code.countries) // 2]
            _dynamic_test(
                self,
                user_code.selected == expected_selected,
                "The `selected` list contains the first half of the countries.",
                f"Expected `selected` to be `{expected_selected}`, but got `{user_code.selected}`."
            )
        except AttributeError as e:
            _dynamic_test(self, False, "", f"Missing variable: {e}")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

    def test_while_loop_is_used(self):
        try:
            with open("user_code.py", "r") as file:
                source_code = file.read()
            _dynamic_test(
                self,
                re.search(r"while", source_code) is not None,
                "A while loop is used to select the first half of the countries.",
                "Expected a while loop to be used in the script."
            )
        except FileNotFoundError:
            self.fail("Failed to open `user_code.py`. Make sure the file exists.")

if __name__ == "__main__":
    unittest.main()

test_main.py

Construa confiança no domínio de laços em Python! Comece com os fundamentos dos laços for e while e avance para conceitos avançados como laços aninhados, instruções de controle e condições dinâmicas. Com prática prática e exemplos do mundo real, adquira habilidades para escrever código eficiente, limpo e poderoso. Ideal para iniciantes e para quem deseja aprimorar sua expertise em Python!

Domine a iteração por sequências com o for loop, utilize range() de forma eficaz, explore condições com if/else e controle loops com break e continue. Prepare-se para escrever código eficiente, limpo e prático ao enfrentar desafios envolventes!

Adquira experiência prática com o laço while.
Aprenda a lidar com condições, evitar laços infinitos, controlar o fluxo com break e continue, e até mesmo combinar else com seus laços.
Domine quando utilizar laços while de forma eficaz em cenários do mundo real e aprimore suas habilidades de resolução de problemas.

Aprenda a combinar loops de forma eficaz, utilizar condições if/else e dominar as instruções break e continue para controlar o fluxo. Ao final, você será capaz de resolver problemas complexos com facilidade e precisão.

Otimize seu código Python com compreensões de listas e dicionários. Aprenda a criar listas e dicionários de forma concisa e elegante, melhorando a legibilidade e o desempenho. Domine exemplos práticos e descubra como simplificar tarefas complexas, desde a filtragem até a transformação de dados, tudo em uma única linha de código.

O Primeiro Loop While

Solução