Python Switch Case: aprenda tudo sobre condições Switch Case

Em python switch case é uma estrutura de controle poderosa e útil na linguagem de programação Python que permite processar várias condições ou casos em um único bloco de código. Embora seja preciso sabermos o que é Python e que python é conhecido por ser uma linguagem de programação de alto nível e estilo de codificação, o switch case adiciona uma camada adicional de estrutura e abordagem de problemas que pode ser útil em casos específicos.

Neste artigo, vamos explorar como utilizar o switch case no Python, suas principais características e exemplos práticos de como aplicá-lo em suas soluções de programação. Também discutiremos comparações com o tradicional ‘if-else’ e situações em que o uso do switch case pode ser benéfico.

Portando, se estamos à procura de uma maneira mais eficiente e organizada de processar diferentes condições e casos de código python, este artigo contém um ótimo conteúdo sobre switch case e seus usos.

Sintaxe do switch case

A sintaxe do switch case em Python é semelhante à sintaxe do caso if-elif-else, mas em vez de ter vários blocos if e elif separados, temos apenas um bloco case. O bloco case é um bloco condicional que verifica se a condição especificada é verdadeira. Assim, se a condição for verdadeira, o código dentro do bloco case é executado. Entretanto, se a condição não for verdadeira, a execução do bloco caso é interrompida e a execução flui para o próximo bloco (se houver) ou para o caso default, que é o bloco que fica depois do último bloco caso.

A sintaxe geral para o switch case em Python é como nesse exemplo, o dicionário “switch_case” é usado para mapear as condições para os códigos correspondentes. Assim, se a variável “variavel” não estiver presente no dicionário, a função “funcionamento” executará o código para o caso “default”. Caso contrário, chamará a função correspondente no dicionário, veja:

def funcionamento(variavel):
    switch_case = {
        condição1: código_para_caso1,
        condição2: código_para_caso2,
        condição3: código_para_caso3,
        # ...
        default: código_para_default,
    }
    if variavel not in switch_case:
        código_para_default
    else:
        switch_case[variavel]()

A vantagem do switch case em Python é que é mais legível e organizado do que o uso de vários blocos se e elif separados. Portanto, é importante considerar cuidadosamente qual abordagem utilizamos para um projeto específico, levando em conta a legibilidade, manutenção e desempenho.

Exemplos de uso do switch case em python

Em python switch case é uma estrutura de controle que permite lidar com várias alternativas em um programa. Algumas situações em que o switch case pode ser usado incluem:

Lidando com respostas de usuário

Neste exemplo, estamos usando o switch case para perguntar ao usuário seu nome e saudação, e então imprimindo a resposta correta com base na saudação fornecida.

question = input("Qual é seu nome? ")

switch_case = {
    "mais": "Olá, {0}!".format(question),
    "fim": "Obrigado, {0}".format(question),
}

answer = input("Qual é a sua saudação? ")

print(switch_case[answer])

Processando números de telefone

Neste exemplo, estamos usando o switch case para processar números de telefone e imprimir a resposta correta com base no número de telefone fornecido.

phone_number = input("Insira seu número de telefone: ")

switch_case = {
    1: "Olá, {0}!".format(phone_number),
    2: "Tudo bem, {0}".format(phone_number),
    3: "Obrigado, {0}".format(phone_number),
    4: "Adeus, {0}".format(phone_number),
}

print(switch_case[int(phone_number)])

Controlando o fluxo de um programa

Neste exemplo, em python while é usado para criar um loop que perguntará ao usuário se deseja sair do programa. Assim, o sistema exibe a mensagem “Deseja sair do programa (s/n)?” no console. Se a resposta for “s”, o programa sai do loop e aguarda a vontade do usuário. Caso contrário, se a resposta for “n”, o programa exibe uma mensagem de despedida. Se a resposta for uma opção inválida, o sistema exibe um aviso para o usuário.

while True:
    mensagem = "Deseja sair do programa (s/n)? "
    resposta = input(mensagem)
    if resposta.lower() == "s":
        print("Aguardo a tua vontade...")
        break
    elif resposta.lower() == "n":
        print("É uma pena que você queira sair, mas farei o possível para te fazer feliz!")
    else:
        print("Opção inválida, por favor escolha uma resposta válida.")

Comparação de switch case com outras estruturas de controle

O switch-case em Python é uma estrutura de controle de fluxo que permite executar diferentes blocos de código em função do valor de uma variável. Diferentemente de outras linguagens, em Python não é necessário utilizar a palavra-chave “break” para sair de um case, pois a execução de um case será automaticamente interrompida quando houver uma coincidência.

Aqui estão alguns pontos importantes para considerar ao escolher entre switch-case e if/elif/else:

Número de casos:

Se tivermos um grande número de casos, o switch-case pode ser mais difícil de ler e manter do que um if/elif/else. Além disso com apenas um par de casos, o switch-case pode ser mais conciso e fácil de entender. Por exemplo, imagine um programa que precisamos processar diferentes tipos de erros e mostrar mensagens de erro específicas para cada um deles. Com um if/elif/else, então poderiamos escrever um código como este:

if error_type == "type 1":
    print("Erro tipo 1 detectado.")
elif error_type == "type 2":
    print("Erro tipo 2 detectado.")
elif error_type == "type 3":
    print("Erro tipo 3 detectado.")
else:
    print("Erro desconhecido detectado.")

Já com um switch-case, poderíamos escrever o mesmo código da seguinte forma:

switch error_type:
    case "type 1":
        print("Erro tipo 1 detectado.")
    case "type 2":
        print("Erro tipo 2 detectado.")
    case "type 3":
        print("Erro tipo 3 detectado.")
    default:
        print("Erro desconhecido detectado.")

Complexidade do código:

Se o código dentro dos cases for complexo ou ter muitas ramificações, o if/elif/else pode ser mais fácil de ler e manter do que o switch-case. Além disso, se o código for simples e não tiver muitas ramificações, o switch-case pode ser mais adequado. Por exemplo, imagine um programa que precisa processar uma lista de objetos e realizar diferentes ações em função do tipo de objeto. Com um if/elif/else, podemos escrever um código como este:

if obj.type == "type 1":
    # realizar ação 1
elif obj.type == "type 2":
    # realizar ação 2
elif obj.type == "type 3":
    # realizar ação 3
else:
    # realizar ação default

Já com um switch-case, assim podemos escrever o mesmo código da seguinte forma:

switch obj.type:
    case "type 1":
        # realizar ação 1
    case "type 2":
        # realizar ação 2
    case "type 3":
        # realizar ação 3
    default:
        # realizar ação default

Necessidade de controle de fluxo condicional:

Caso precisarmos controlar o fluxo de execução baseado no valor de uma variável, o if/elif/else é mais adequado. Já se precisarmos executar um bloco de código específico em função do valor de uma variável, o switch-case é mais adequado.

Vamos considerar um exemplo em que estamos desenvolvendo um sistema de compras que suporta diferentes métodos de pagamento. A variável payment_method que indica qual método de pagamento o cliente escolheu (por exemplo, Cartão de Crédito, débito, boleto ou mensalidade).

Neste exemplo, o switch é usado para controlar o fluxo de execução baseado no valor da variável payment_method. Dessa forma, se o método de pagamento tiver um valor específico, o process_payment será chamado com esse valor e a execução seguirá o caminho correspondente (case) até o pass, veja:

payment_method = 'Cartão de Crédito'  # ou qualquer outro valor

def process_payment(payment_method):
    if payment_method == 'Cartão de Crédito':
        # Realizar o processo de pagamento para cartão de crédito
        pass
    elif payment_method == 'Débito':
        # Realizar o processo de pagamento para débito
        pass
    elif payment_method == 'Boleto':
        # Realizar o processo de pagamento para boleto
        pass
    elif payment_method == 'Mensalidade':
        # Realizar o processo de pagamento para mensalidade
        pass
    else:
        # Tratar outros métodos de pagamento ou erros
        pass

process_payment(payment_method)

Por outro lado, se a necessidade for apenas executar um bloco de código específico em função do valor de uma variável, o if/elif/else seria mais adequado. Vejamos um exemplo em que o if/elif/else é usado para definir o conteúdo da mensagem a ser impressa em função do valor da variável color. Assim, não há a necessidade de controlar o fluxo de execução, apenas a escolha do conteúdo da mensagem. Portanto, o if/elif/else é mais adequado neste caso:

color = 'verde'

def print_color_message(color):
    if color == 'verde':
        message = 'A cor verde é fresca e revigorante.'
    elif color == 'azul':
        message = 'A cor azul é calma e serena.'
    elif color == 'laranja':
        message = 'A cor laranja é alegre e energetica.'
    else:
        message = 'A cor roxo é romântica e misteriosa.'
    print(message)

print_color_message(color)

Assim podemos ver, o switch-case é mais conciso e fácil de ler do que o if/elif/else, especialmente se tivermos muitos casos.

Dicas de uso dentro da estrutura switch case no python

Para tornar seu código mais legível e eficiente, Aqui estão algumas dicas, como o uso de constantes para códigos de caso, a utilização de strings para códigos de caso e a organização do código dentro da estrutura switch case:

Utilize constantes para códigos de caso:

Em vez de utilizamos valores literais para os códigos de caso, utilizamos constantes para garantir que os valores sejam consistentemente definidos e fáceis de entender. Por exemplo, em vez de usarmos 1 para um código de caso, use a constante CASE_1.

Utilize strings para códigos de caso:

Se precisarmos lidar com textos ou mensagens de erro, utilize string no python para armazenar esses valores. Isso pode ajudar a manter o código mais legível e evitar erros de typo. Por exemplo, em vez de utilizamos 1 para um código de caso, use a string "CASE_1".

Organize o código dentro da estrutura switch-case:

Certifique-se de que o código dentro da estrutura switch-case esteja organizado de forma lógica e fácil de entender. Por exemplo, grupo os códigos de caso por tipo de erro ou por área de responsabilidade.

Use comentários para explicar o código:

Adicione comentários para explicar o porquê de cada código de caso e qual é o propósito de cada uma das branches da estrutura switch-case. Isso ajudará a manter o código legível e fácil de entender para outros desenvolvedores que possam trabalhar com o código.

Use nomes de variáveis descritivos:

Use nomes de variáveis descritivos para as variáveis que estão sendo usadas na estrutura switch-case. Isso ajudará a manter o código legível e fácil de entender. Por exemplo, em vez de utilizamos x, use userInput para uma variável que armazena o input do usuário.

Teste seu código:

Contudo, é importante testarmos o código rigorosamente para garantir que ele funcione corretamente e handle todas as possíveis situações.

Use nomes de variáveis descritivos:

Assim, use nomes de variáveis descritivos para tornar o código mais legível e fácil de entender. Em vez de utilizamos var1, var2 e var3, use inputDoUsuario, erroMessage e tipoErro, respectivamente.

Use matrizes para armazenar dados:

Use matrizes para armazenar dados quando precisar lidar com vários valores em um único conjunto de dados. Assim, isso pode ajudar a manter o código organizado e fácil de compreender.

Utilize funções para reutilizar código:

Utilize funções para reutilizar código em diferentes partes do seu programa. Portanto, isso pode ajudar a evitar redundância e manter o código mais organizado.

Use structs para armazenar dados estruturados:

Use structs para armazenar dados estruturados, como objetos ou registros. Dessa maneira, isso pode ajudar a manter o código organizado e fácil de entender.

Erros comuns em switch case

Além de mostrar como utilizamos o switch case de maneira correta, é importante mencionar alguns erros comuns que cometemos ao escrever código switch case em Python e como evitá-los:

1. Erro: Escrever switch em vez de dict.
   * Solução: Contudo certifique-se de utilizar a palavra-chave dict no lugar de switch para criar um dicionário que contém os casos e seus respectivos blocos de código.
2. Erro: Definir valores de caso como string em vez de variáveis ou constantes.
   * Solução: Use variáveis ou constantes para definir os valores de caso, em vez de strings. Dessa forma, podemos manter um controle mais eficiente sobre os valores de caso e evitar erros tipográficos.
3. Erro: Escrever default em vez de default: sem o ponto.
   * Solução: Certifique-se de incluir o ponto em default, para assim definir a sequência de ações a serem executadas quando o valor não for matchado por nenhum caso.
4. Erro: Escrever break em vez de break.
   * Solução: Certifique-se de utilizar a palavra-chave break sem o pronome it (que é usado em outras construções de loop em Python) para romper a iteração atual do for ou while.
5. Erro: Definir múltiplos casos com o mesmo valor.
   * Solução: Garantir que cada caso tenha um valor único e exclusivo, ou utilize uma estrutura de seleção (if-else) para lidar com valores que podem matching a mais de um caso.

Ao evitar esses erros comuns e seguir as práticas de codificação adequadas, podemos escrever código switch case mais eficiente e manutenção em Python.

Conclusão

Portanto, o switch case é uma ferramenta poderosa em Python que permite criar decisões condicionais de forma mais simples e legível, em comparação com a lógica de múltiplas condições if-else. Assim, ao utilizar dicionários para armazenar os casos e seus respectivos blocos de código, é possível otimizar a execução do programa e reduzir a complexidade do código.

A aplicação correta do switch case pode evitar erros comuns e garantir um melhor controle sobre os valores de caso, além de facilitar a legibilidade e manutenção do código. Ao empregar esta estrutura de decisão condicional, estaremos se aproximando de uma abordagem mais eficiente e eficaz para gerenciar casos e condições em seu código Python. Contudo, ainda é possível deixar os códigos mais robustos quando adicionamos Len, range e Scan em python.