Simulando Switch-Case em Python: 3 Métodos Simples e Eficientes

Deseja implementar uma estrutura switch-case em Python? Explore as diversas estratégias que você pode adotar para simular o comportamento de um switch-case.

Se você já programou em C ou JavaScript, certamente utilizou a instrução switch-case. Mas qual a necessidade de uma estrutura switch-case?

Imagine que você possui um conjunto de ações distintas (ou blocos de código). E a ação que você executa (o bloco de código que será executado) depende do valor de uma variável ou expressão.

Alguns exemplos práticos incluem:

• Atribuir notas aos alunos com base em seus desempenhos.
• Selecionar técnicas de manipulação de strings de acordo com a escolha do usuário.
• Efetuar operações aritméticas em dois números, dependendo da entrada fornecida pelo usuário.

Nesse contexto, a estrutura switch-case oferece um método conveniente para implementar tal lógica. Ela se torna útil quando você precisa executar — baseado no valor de uma variável ou expressão — uma entre várias ações possíveis.

Embora Python não possua uma estrutura switch-case nativa, existem várias abordagens que você pode usar para alcançar uma funcionalidade similar. Neste artigo, analisaremos essas abordagens.

Simulando o comportamento Switch-Case em Python

Vamos verificar como podemos simular o comportamento switch-case em Python usando um exemplo.

Desenvolveremos um programa simples que faz o seguinte:

• Selecionar uma palavra, uma string Python, aleatoriamente de uma lista de palavras.
• Contextualizar e informar o usuário. Definir as operações de string – manipulação de string – que devem ser executadas na palavra selecionada.
• Considerar operações de alteração de maiúsculas e minúsculas (minúsculas, maiúsculas, capitalização, entre outras), incluindo um comportamento padrão. Utilizar métodos de string integrados do Python quando necessário.
• Solicitar a entrada do usuário. Como a entrada é uma string por padrão, convertê-la para um inteiro por meio da conversão de tipo.

Strings Python são imutáveis. Portanto, métodos de string não alteram a string original. Em vez disso, eles retornam uma cópia da string com as modificações aplicadas. Vamos revisar os métodos de string do Python que usaremos:

Método de String	Descrição
lower()	Retorna uma cópia da string com todos os caracteres em minúsculas
upper()	Retorna uma cópia da string com todos os caracteres em maiúsculas
title()	Retorna uma cópia da string formatada em capitalização
swapcase()	Retorna uma cópia da string com caracteres maiúsculos e minúsculos trocados

O trecho de código a seguir seleciona aleatoriamente uma palavra de word_list e recebe a entrada do usuário:

import random

# Lista de palavras para seleção
word_list = ["Python", "programação", "Olá", "mundo", "contexto", "Switch"]

# Seleciona aleatoriamente uma palavra da lista
word = random.choice(word_list)

# Informa contexto e opções disponíveis ao usuário
print("Bem-vindo(a)! Você tem uma palavra selecionada aleatoriamente.")
print("Escolha uma opção para manipular a palavra:")
print("1. Minúsculas")
print("2. Maiúsculas")
print("3. Capitalização")
print("4. Trocar maiúsculas/minúsculas")
print("5. Comportamento padrão")

# Obtém a opção do usuário
option = int(input("Digite sua opção: "))

Aqui está um exemplo que mostra como a string ‘Python’ é modificada com base na escolha do usuário:

Ao executar o programa, você deverá ser solicitado a fornecer a entrada da seguinte forma:

Bem-vindo(a)! Você tem uma palavra selecionada aleatoriamente.

Escolha uma opção para manipular a palavra:
1. Minúsculas
2. Maiúsculas
3. Capitalização
4. Trocar maiúsculas/minúsculas
5. Comportamento padrão

Digite sua opção:

A seguir, vamos implementar as diferentes abordagens.

Utilizando a escada If-Elif-Else

Nesta abordagem, usamos uma sequência de instruções if-elif-else para comparar a escolha do usuário com as opções predefinidas. Em seguida, executamos o bloco de código correspondente com base na entrada do usuário.

# if-elif-else

if option == 1:
    result = word.lower()
elif option == 2:
    result = word.upper()
elif option == 3:
    result = word.title()
elif option == 4:
    result = word.swapcase()
else:
    result = word

print(f"Sua palavra aleatória é {word} e o resultado é {result}")

Aqui:

• Comparamos a entrada do usuário com cada opção usando as instruções if-elif.
• Quando uma correspondência é encontrada, executamos o bloco de código pertinente.
• Se nenhuma das condições if-elif for atendida, executamos o bloco else para o comportamento padrão.

Você pode executar o script agora, inserir a opção e analisar a saída:

Bem-vindo(a)! Você tem uma palavra selecionada aleatoriamente.

Escolha uma opção para manipular a palavra:
1. Minúsculas
2. Maiúsculas
3. Capitalização
4. Trocar maiúsculas/minúsculas
5. Comportamento padrão

Digite sua opção: 2

Sua palavra aleatória é Switch e o resultado é SWITCH.

A escada if-elif-else é fácil de implementar. No entanto, pode ser um desafio mantê-la. Neste exemplo, tínhamos cinco casos (incluindo o comportamento padrão). Na prática, entretanto, podemos ter um número muito maior de casos. Sequências longas de if-elif-else são um sinal de código que você deve evitar.

Portanto, vamos avançar para uma implementação que seja mais sustentável.

Utilizando mapeamento de dicionário e funções de primeira classe

Você pode aproveitar dicionários e funções Python para simular o comportamento de um switch-case.

📑 Funções Python são consideradas cidadãs de primeira classe.

Em Python, as funções são elementos de primeira classe. Isso permite que você faça muito mais do que apenas definir e chamar funções:

• Após definir uma função, você pode atribuí-la a outra variável, usar funções como itens de listas, valores em um dicionário, entre outras coisas.
• Além disso, você pode distribuí-las: funções podem ser passadas como argumentos para outras funções e funções podem retornar outras funções.

Nesta abordagem, empregaremos um dicionário para mapear as escolhas do usuário para as funções ou ações correspondentes. Esta é uma maneira mais eficiente de lidar com múltiplas escolhas, pois evita uma longa cadeia de instruções if-elif.

Primeiramente, vamos definir as seguintes funções para as diversas operações de string:

# Define funções para cada opção
def lower_case(word):
    return word.lower()

def upper_case(word):
    return word.upper()

def title_case(word):
    return word.title()

def swap_case(word):
    return word.swapcase()

Em seguida, faremos o seguinte:

• Criar um dicionário denominado options em que as chaves são as escolhas do usuário e os valores são as funções ou ações a serem executadas.
• Utilizar o método get() do dicionário para recuperar a ação selecionada com base na escolha do usuário. Se a escolha não for encontrada no dicionário, fornecemos uma ação padrão especificada por uma função lambda.
• Então, executamos a ação selecionada na palavra aleatória.

# Armazenar funções em um dicionário
options = {
    1: lower_case,
    2: upper_case,
    3: title_case,
    4: swap_case,
}

# Utilizar o dicionário para selecionar e chamar a função apropriada
result = options.get(option, lambda x: x)(word)

print(f"Sua palavra aleatória é {word} e o resultado é {result}")

Aqui está um exemplo de saída:

Bem-vindo(a)! Você tem uma palavra selecionada aleatoriamente.

Escolha uma opção para manipular a palavra:
1. Minúsculas
2. Maiúsculas
3. Capitalização
4. Trocar maiúsculas/minúsculas
5. Comportamento padrão

Digite sua opção: 4

Sua palavra aleatória é Olá e o resultado é oLÁ.

Utilizando Match-Case

📝 Nota: é necessário Python 3.10 ou uma versão posterior para usar instruções match-case.

A partir do Python 3.10, você pode usar a instrução match para implementar uma estrutura similar a switch-case. A instrução match, com sua sintaxe simples, fornece uma maneira mais intuitiva de lidar com vários casos. O símbolo _ (sublinhado) funciona como um caso padrão.

Veja como podemos reescrever nosso exemplo usando match-case:

• Usamos a instrução match para comparar a entrada do usuário com diversos casos.
• Cada case especifica uma escolha e o código a ser executado se essa escolha corresponder.
• O _ (sublinhado) funciona como o case padrão, executando o código quando nenhum dos outros casos corresponder.

match option:
    case 1:
        result =  word.lower()
    case 2:
        result = word.upper()
    case 3:
        result = word.title()
    case 4:
        result = word.swapcase()
    case _:
        result = word  # Comportamento padrão, retorna a string como está

print(f"Sua palavra aleatória é {word} e o resultado é {result}.")

Agora você pode executar o script e verificar a saída:

Bem-vindo(a)! Você tem uma palavra selecionada aleatoriamente.

Escolha uma opção para manipular a palavra:
1. Minúsculas
2. Maiúsculas
3. Capitalização
4. Trocar maiúsculas/minúsculas
5. Comportamento padrão

Digite sua opção: 2
Sua palavra aleatória é mundo e o resultado é MUNDO.

⚙ Embora a instrução match forneça uma forma prática de implementar uma estrutura switch-case, ela é mais adequada para tarefas de correspondência de padrões estruturais mais avançadas, além da simples emulação do comportamento de switch-case.

Resumindo

Vamos recapitular as diferentes abordagens para obter a funcionalidade switch-case em Python:

• A escada if-elif-else é fácil de implementar, mas difícil de manter. Portanto, utilize-a de forma limitada – apenas quando não houver muitas opções para verificar.
• Você pode aproveitar dicionários e funções Python para simular o comportamento switch-case. Inclua as diferentes opções e as funções correspondentes como chaves e valores do dicionário, respectivamente.
• A instrução match-case, introduzida no Python 3.10, auxilia na implementação dessa estrutura switch-case com uma sintaxe simples e intuitiva. No entanto, a instrução match-case é uma ótima alternativa para casos de uso mais interessantes de correspondência de padrões estruturais.

Você pode encontrar os exemplos de código para este tutorial em GitHub. Se você está se preparando para entrevistas de programação, confira esta compilação das principais perguntas de entrevista sobre Python.