Controle de Fluxo em Python

Introdução

O fluxo de controle (Control Flow) é a ordem na qual instruções individuais, comandos ou chamadas de função são executados ou avaliados. O fluxo de controle de um programa Python é regulado por instruções condicionais, laços (loops) e chamadas de função.

Neste laboratório, você aprenderá os conceitos centrais de controle da execução de programas em Python. Você explorará a lógica condicional usando instruções if, vários operadores, a nova instrução match-case e iteração usando laços while e for. Ao final deste laboratório, você será capaz de escrever programas Python mais dinâmicos e poderosos.

Operadores de Comparação e Booleanos

Nesta etapa, você aprenderá a usar operadores de comparação e booleanos para formar expressões lógicas. Essas expressões são fundamentais para o controle de fluxo, pois avaliam para True ou False, o que determina como o programa prossegue.

Operadores de Comparação

Os operadores de comparação são usados para comparar dois valores. Aqui está uma tabela dos operadores de comparação comuns:

Esses operadores avaliam para True ou False. Por exemplo, 42 == 42 é True, mas 42 == '42' é False porque os tipos (inteiro e string) são diferentes.

Operadores Booleanos

Existem três operadores booleanos: and, or e not. Eles são usados para combinar ou inverter valores booleanos. A ordem de precedência deles é not, depois and, e por último or.

O operador and retorna True somente se ambas as expressões forem verdadeiras. O operador or retorna True se pelo menos uma das expressões for verdadeira. O operador not inverte o valor booleano (not True se torna False).

Misturando Operadores

Você pode combinar operadores de comparação e booleanos para criar expressões lógicas mais complexas.

Nota: Se você não está familiarizado com o uso do WebIDE (semelhante ao VS Code), aprenda primeiro neste laboratório.

Por exemplo:

(4 < 5) and (5 < 6)

Saída:

True

Agora, vamos praticar. Abra o arquivo operators_example.py no explorador de arquivos à esquerda. Adicione o seguinte código ao arquivo. Este código combina múltiplos operadores para avaliar um único resultado booleano.

## operators_example.py
result = 2 + 2 == 4 and not 2 + 2 == 5 and 2 * 2 == 2 + 2
print(result)

Para executar o script, abra um terminal no WebIDE e execute o seguinte comando:

python3 operators_example.py

Você deverá ver a seguinte saída, pois a expressão avalia para True:

True

Instruções If e Operador Ternário

Nesta etapa, você aprenderá a controlar o fluxo do programa com as instruções if, elif e else para executar blocos de código com base em condições específicas. Esta etapa também introduz o operador condicional ternário para escrever expressões condicionais concisas em uma única linha.

As Instruções if, elif e else

• A instrução if executa um bloco de código se sua condição for True.
• A instrução elif (else if) verifica outra condição se as condições if ou elif precedentes forem False.
• A instrução else executa um bloco de código se todas as condições if e elif precedentes forem False.

Aqui está a estrutura básica:

if condition1:
    ## código a ser executado se condition1 for True
elif condition2:
    ## código a ser executado se condition1 for False e condition2 for True
else:
    ## código a ser executado se todas as condições forem False

Operador Condicional Ternário

O operador ternário fornece uma maneira abreviada de escrever instruções simples de if-else em uma única linha. Sua sintaxe é:

<expression1> if <condition> else <expression2>

Por exemplo, print('kid' if age < 18 else 'adult') é uma forma compacta de escrever um bloco if-else completo.

Agora, vamos praticar o uso de um bloco condicional completo. Abra o arquivo if_example.py e adicione o seguinte código. Este script verificará o valor da variável name e imprimirá uma mensagem diferente de acordo.

## if_example.py
name = 'Antony'

if name == 'Debora':
   print('Hi Debora!')
elif name == 'George':
   print('Hi George!')
else:
   print('Who are you?')

Execute o script a partir do terminal:

python3 if_example.py

Como o name é 'Antony', nem a condição if nem a elif são satisfeitas, então o bloco else é executado.

Saída:

Who are you?

Instrução Switch Case

Nesta etapa, você explorará o Structural Pattern Matching (Correspondência Estrutural de Padrões), o poderoso equivalente ao switch-case do Python introduzido no Python 3.10. Você praticará a correspondência de valores, o uso de padrões OR e a implementação de casos padrão com as palavras-chave match e case.

Uma instrução match recebe uma expressão e compara seu valor com padrões sucessivos fornecidos como um ou mais blocos case.

Correspondência Básica

Você pode fazer correspondência com valores literais como números ou strings.

Padrões OR

Você pode combinar vários padrões literais em um único case usando o operador | (ou). Por exemplo, case 200 | 201:.

Caso Padrão (Default Case)

O símbolo de sublinhado (_) é um curinga (wildcard) e é usado para definir um caso padrão que corresponderá se nenhum outro caso tiver correspondido.

Vamos praticar isso. Abra o arquivo match_example.py e adicione o seguinte código. Este script usará uma instrução match para determinar uma ação com base em um código de resposta HTTP.

## match_example.py
response_code = 800

match response_code:
    case 200 | 201:
        print("OK")
    case 300 | 307:
        print("Redirect")
    case 400 | 401:
        print("Bad Request")
    case 500 | 502:
        print("Internal Server Error")
    case _:
        print("Invalid Code")

Execute o script a partir do seu terminal:

python3 match_example.py

Como response_code é 800, ele não corresponde a nenhum dos casos específicos, então o caso padrão (_) é executado.

Saída:

Invalid Code

Laços While e Controle de Laço

Nesta etapa, você dominará o laço while para execução repetida enquanto uma condição for verdadeira. Você também aprenderá a gerenciar o comportamento do laço usando a instrução break para sair do laço e a instrução continue para pular a iteração atual.

O Laço while

Um laço while executa repetidamente uma instrução alvo enquanto uma condição dada for True. É crucial garantir que a condição eventualmente se torne False para evitar um laço infinito.

A Instrução break

A instrução break termina o laço atual e retoma a execução na próxima instrução, assim como o break tradicional em C.

A Instrução continue

A instrução continue rejeita todas as instruções restantes na iteração atual do laço e move o controle de volta para o topo do laço.

Vamos criar um laço while simples. Abra o arquivo while_example.py e adicione o seguinte código. Este script imprimirá uma mensagem cinco vezes.

## while_example.py
spam = 0
while spam < 5:  ## Continue enquanto spam for menor que 5
    print('Hello, world.')
    spam = spam + 1  ## Incrementa o contador para evitar laço infinito

Agora, execute o script a partir do terminal:

python3 while_example.py

O laço será executado enquanto spam for menor que 5. Em cada iteração, spam é incrementado em 1.

Saída:

Hello, world.
Hello, world.
Hello, world.
Hello, world.
Hello, world.

Laços For e Iteração

Nesta etapa, você usará o laço for para iterar sobre itens em uma sequência como uma lista ou string. Esta etapa abrange o uso da função range() para executar um laço um número específico de vezes, o bloco else opcional em um laço for e como terminar um programa completamente com sys.exit().

O Laço for

Um laço for é usado para iterar sobre uma sequência (que pode ser uma lista, uma tupla, um dicionário, um conjunto ou uma string).

A Função range()

A função range() gera uma sequência de números, o que é útil para executar um laço um número específico de vezes.

• range(stop): Gera números de 0 até (mas não incluindo) stop.
• range(start, stop): Gera números de start até stop.
• range(start, stop, step): Gera números de start até stop, incrementando por step.

Encerrando um Programa com sys.exit()

A função sys.exit() pode ser chamada para terminar o programa imediatamente. Você deve primeiro usar import sys para utilizá-la.

Vamos praticar o uso de um laço for com range(). Abra o arquivo for_example.py e adicione o seguinte código. Este script imprimirá números pares de 0 a 8.

## for_example.py
## range(start, stop, step)
for i in range(0, 10, 2):
   print(i)

Execute o script a partir do terminal:

python3 for_example.py

A função range(0, 10, 2) gera números começando em 0, até (mas não incluindo) 10, com um passo (step) de 2.

Saída:

0
2
4
6
8

Resumo

Parabéns por completar o laboratório! Você agora dominou os conceitos fundamentais de controle de fluxo em Python.

Neste laboratório:

• Você aprendeu a usar operadores de comparação e booleanos para formar condições lógicas.
• Você praticou o controle da execução do programa com as instruções if, elif e else, bem como o conciso operador ternário.
• Você explorou a poderosa instrução match-case do Python 3.10 para correspondência estrutural de padrões (structural pattern matching).
• Você aprendeu a criar laços com while e for, e a controlar seu comportamento usando break e continue.

Com estas habilidades, você agora pode escrever programas Python mais complexos e inteligentes que podem tomar decisões e repetir tarefas.