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

python 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

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 var1var2 e var3, use inputDoUsuarioerroMessage 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.

Este artigo foi útil?

Obrigado pela resposta!
Picture of Schênia T

Schênia T

Cientista de dados, apaixonada por ferramentas de tecnologia e games. Graduanda em Estatística pela UFPB. Seu hobby é maratonar séries, curtir uma boa música trabalhando ou cozinhando, ir ao cinema e aprender coisas novas!

Contato: schenia.blog@homehost.com.br

Ganhe 30% OFF

Indique seu nome e e-mail,e ganhe um cupom de desconto de 30% para sempre na Homehost!