MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Python替代switch case语句的方法

2021-09-206.7k 阅读

使用字典替代 switch case 语句

在许多编程语言中，switch case 语句是一种非常有用的条件分支结构，它允许根据一个表达式的值来执行不同的代码块。然而，Python 并没有原生的 switch case 语句。不过，Python 提供了一些其他的方法来实现类似的功能，其中一种常用的方法就是使用字典。

字典的基本原理

字典是 Python 中一种无序的键值对集合。它的基本原理基于哈希表，通过键来快速查找对应的值。在实现类似于 switch case 功能时，我们可以将 switch 语句中表达式可能的值作为字典的键，而将对应要执行的代码块（通常是函数）作为字典的值。

简单示例

假设我们有一个根据数字返回星期几的需求，在有 switch case 的语言中可能这样写：

// Java 示例
int day = 3;
String dayName;
switch (day) {
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    default:
        dayName = "Unknown";
        break;
}
System.out.println(dayName);

在 Python 中，我们可以使用字典来实现：

day = 3
day_dict = {
    1: "Monday",
    2: "Tuesday",
    3: "Wednesday"
}
day_name = day_dict.get(day, "Unknown")
print(day_name)

在上述代码中，我们首先定义了一个字典 day_dict，键是数字，值是对应的星期几的字符串。然后使用字典的 get 方法，第一个参数是要查找的键（即 day 的值），第二个参数是如果键不存在时返回的默认值。这样就实现了类似 switch case 的功能。

处理复杂逻辑

当 case 后面的代码块不仅仅是简单的赋值操作，而是包含复杂逻辑时，我们可以将函数作为字典的值。例如，假设我们要根据不同的操作符对两个数进行运算：

def add(a, b):
    return a + b


def subtract(a, b):
    return a - b


def multiply(a, b):
    return a * b


operator = '*'
operation_dict = {
    '+': add,
    '-': subtract,
    '*': multiply
}
result = operation_dict.get(operator, lambda a, b: None)(2, 3)
if result is not None:
    print(result)
else:
    print("Unknown operator")

在这个例子中，我们定义了三个函数 add、subtract 和 multiply 分别用于加法、减法和乘法运算。然后创建了一个字典 operation_dict，键是操作符，值是对应的函数。通过 get 方法获取到对应的函数，并调用该函数传入参数 2 和 3 来得到运算结果。如果操作符不存在，get 方法返回一个返回 None 的匿名函数，最后根据结果进行相应的输出。

优势与不足

  • 优势：
    • 代码简洁明了，通过字典的形式可以很直观地看到不同条件对应的操作。
    • 易于扩展，当需要增加新的条件时，只需要在字典中添加新的键值对即可。
  • 不足：
    • 不像原生的 switch case 语句那样有明显的结构，对于不熟悉这种方式的开发者来说，理解起来可能有一定难度。
    • 如果字典中的值是函数，调用函数时可能会有一定的性能开销，尤其是在频繁调用的场景下。

使用 if - elif - else 链替代

除了使用字典，Python 中最直接的替代 switch case 的方式就是使用 if - elif - else 链。

if - elif - else 链的原理

if - elif - else 链是 Python 中用于条件判断的基本结构。它会按照顺序依次判断每个 if 或 elif 后面的条件表达式，如果某个条件为真，则执行对应的代码块，然后跳过整个 if - elif - else 结构。如果所有条件都为假，则执行 else 后面的代码块（如果存在 else）。

简单示例

还是以根据数字返回星期几为例，使用 if - elif - else 链实现如下：

day = 3
if day == 1:
    day_name = "Monday"
elif day == 2:
    day_name = "Tuesday"
elif day == 3:
    day_name = "Wednesday"
else:
    day_name = "Unknown"
print(day_name)

上述代码通过依次判断 day 的值，来确定 day_name 的值。如果 day 等于 1，则 day_name 为 "Monday"；如果 day 等于 2，则 day_name 为 "Tuesday"，以此类推。如果 day 不满足任何前面的条件，则 day_name 为 "Unknown"。

处理复杂逻辑

当处理复杂逻辑时，if - elif - else 链同样适用。例如，根据不同的成绩等级给出相应的评价：

grade = 'B'
if grade == 'A':
    print("Excellent")
elif grade == 'B':
    print("Good")
elif grade == 'C':
    print("Fair")
else:
    print("Poor")

在这个例子中，根据变量 grade 的值，输出不同的评价。如果 grade 是 'A'，输出 "Excellent"；如果是 'B'，输出 "Good"，依此类推。

优势与不足

  • 优势：
    • 这是 Python 中非常基础和常见的条件判断结构，几乎所有 Python 开发者都熟悉，代码的可读性和可维护性较好。
    • 对于简单的条件判断逻辑，代码简洁易懂。
  • 不足：
    • 当条件较多时，if - elif - else 链会变得很长，代码显得比较冗余。
    • 由于是顺序判断，对于有大量条件且分布不均匀的情况，性能可能不如其他方式（例如字典方式，字典查找通常是 O(1) 时间复杂度，而 if - elif - else 链是 O(n) 时间复杂度）。

使用 match - case 语句（Python 3.10+）

从 Python 3.10 开始，引入了 match - case 语句，这在一定程度上模拟了传统编程语言中 switch case 的功能。

match - case 语句的原理

match - case 语句基于模式匹配。match 后面跟一个表达式，然后 case 语句定义不同的模式和对应的代码块。当 match 的表达式值与某个 case 的模式匹配时，就执行该 case 对应的代码块。

简单示例

以根据数字返回星期几为例，使用 match - case 实现如下：

day = 3
match day:
    case 1:
        day_name = "Monday"
    case 2:
        day_name = "Tuesday"
    case 3:
        day_name = "Wednesday"
    case _:
        day_name = "Unknown"
print(day_name)

在上述代码中，match 表达式为 day。每个 case 语句定义了一个模式，当 day 的值与某个 case 的模式匹配时，就执行该 case 块中的代码。这里 case _ 表示默认情况，类似于传统 switch case 中的 default。

处理复杂模式匹配

match - case 不仅可以处理简单的值匹配，还支持更复杂的模式匹配。例如，匹配列表的结构：

my_list = [1, 2]
match my_list:
    case [1, x]:
        print(f"First element is 1, second element is {x}")
    case [x, 2]:
        print(f"Second element is 2, first element is {x}")
    case _:
        print("Unmatched list")

在这个例子中，match 表达式是 my_list。第一个 case 模式 [1, x] 表示列表的第一个元素是 1，第二个元素可以是任意值，将其绑定到变量 x。第二个 case 模式 [x, 2] 类似，只是对第二个元素是 2 进行匹配。如果列表不满足前面的模式，则执行 case _ 中的代码。

优势与不足

  • 优势：
    • 提供了一种更接近传统 switch case 的语法结构，对于习惯这种结构的开发者来说更易读。
    • 支持复杂的模式匹配，功能更强大。
  • 不足：
    • 只在 Python 3.10 及以上版本可用，如果项目需要兼容更低版本的 Python，则无法使用。
    • 对于简单的条件判断，可能会显得有些繁琐，不如字典或简单的 if - elif - else 简洁。

选择合适的替代方法

在实际开发中，选择使用哪种方法来替代 switch case 语句，需要根据具体的场景来决定。

考虑性能

如果条件判断非常频繁，并且需要快速定位到对应的操作，字典方式通常是较好的选择，因为字典的查找时间复杂度平均为 O(1)。而 if - elif - else 链的时间复杂度为 O(n)，随着条件数量的增加，性能会逐渐下降。match - case 语句在性能方面与 if - elif - else 类似，也是顺序匹配，但由于其模式匹配的特性，在某些复杂匹配场景下可能有不同的性能表现。

考虑代码可读性和维护性

对于简单的条件判断，if - elif - else 链是最直观和易于理解的，尤其是对于新手开发者。如果项目需要兼容较低版本的 Python 且条件判断逻辑不是特别复杂，if - elif - else 是一个可靠的选择。对于 Python 3.10 及以上版本，match - case 语句提供了一种更清晰的结构，特别是在处理复杂模式匹配时，能让代码更易读和维护。字典方式在处理简单值映射到函数或其他操作时，代码简洁，但对于不熟悉这种方式的人可能理解起来有一定门槛。

考虑功能需求

如果只是简单的基于值的条件分支，三种方式都可以满足需求。但如果需要进行复杂的模式匹配，如匹配列表、元组、对象结构等，match - case 语句则具有明显的优势。字典方式虽然也可以通过一定的技巧来模拟复杂匹配，但代码会变得复杂且难以维护。

例如，在一个游戏开发项目中，根据不同的游戏事件类型执行不同的处理逻辑。如果事件类型比较简单且数量不多，if - elif - else 链可以很好地实现。但如果事件类型有多种不同的结构（如不同参数的事件），使用 match - case 语句能更清晰地处理。而如果游戏中有频繁的根据某个固定值来选择操作的场景，字典方式可能会在性能上更优。

又如，在一个数据处理脚本中，根据不同的数据格式代码进行不同的解析操作。如果数据格式简单且固定，if - elif - else 或字典方式都可行。但如果数据格式有复杂的嵌套结构，match - case 语句可以更方便地进行模式匹配解析。

实际应用场景及示例代码扩展

菜单驱动程序

在一个简单的命令行菜单驱动程序中，用户可以输入不同的选项来执行不同的操作。我们可以使用字典来实现：

def option1():
    print("执行选项 1 的操作")


def option2():
    print("执行选项 2 的操作")


def option3():
    print("执行选项 3 的操作")


menu_dict = {
    '1': option1,
    '2': option2,
    '3': option3
}

choice = input("请输入选项 (1 - 3): ")
action = menu_dict.get(choice, lambda: print("无效选项"))
action()

在这个示例中，用户输入一个选项，程序通过字典查找对应的函数并执行。如果输入的选项无效，就执行默认的提示操作。

如果使用 if - elif - else 链来实现同样的功能：

choice = input("请输入选项 (1 - 3): ")
if choice == '1':
    print("执行选项 1 的操作")
elif choice == '2':
    print("执行选项 2 的操作")
elif choice == '3':
    print("执行选项 3 的操作")
else:
    print("无效选项")

对于 Python 3.10 及以上版本，使用 match - case 语句实现：

choice = input("请输入选项 (1 - 3): ")
match choice:
    case '1':
        print("执行选项 1 的操作")
    case '2':
        print("执行选项 2 的操作")
    case '3':
        print("执行选项 3 的操作")
    case _:
        print("无效选项")

状态机实现

在一个简单的状态机中，根据当前状态和输入执行不同的状态转换和操作。假设我们有一个简单的电梯状态机，电梯有 "idle"（空闲）、"moving"（运行）和 "stopped"（停止）三种状态，输入可以是 "up"（上升）、"down"（下降）和 "stop"（停止）。

使用字典实现：

def idle_to_moving_up():
    print("电梯从空闲状态上升")
    return "moving"


def idle_to_moving_down():
    print("电梯从空闲状态下降")
    return "moving"


def moving_to_stopped():
    print("电梯从运行状态停止")
    return "stopped"


state_dict = {
    ("idle", "up"): idle_to_moving_up,
    ("idle", "down"): idle_to_moving_down,
    ("moving", "stop"): moving_to_stopped
}

current_state = "idle"
input_command = "up"
new_state_func = state_dict.get((current_state, input_command), lambda: None)
if new_state_func:
    current_state = new_state_func()
else:
    print("无效的状态转换")

使用 if - elif - else 链实现：

current_state = "idle"
input_command = "up"
if current_state == "idle" and input_command == "up":
    print("电梯从空闲状态上升")
    current_state = "moving"
elif current_state == "idle" and input_command == "down":
    print("电梯从空闲状态下降")
    current_state = "moving"
elif current_state == "moving" and input_command == "stop":
    print("电梯从运行状态停止")
    current_state = "stopped"
else:
    print("无效的状态转换")

对于 Python 3.10 及以上版本，使用 match - case 语句实现：

current_state = "idle"
input_command = "up"
match (current_state, input_command):
    case ("idle", "up"):
        print("电梯从空闲状态上升")
        current_state = "moving"
    case ("idle", "down"):
        print("电梯从空闲状态下降")
        current_state = "moving"
    case ("moving", "stop"):
        print("电梯从运行状态停止")
        current_state = "stopped"
    case _:
        print("无效的状态转换")

数据库查询操作

在一个数据库操作程序中，根据不同的查询类型执行不同的 SQL 查询语句。假设我们有三种查询类型："select_all"（查询所有记录）、"select_by_id"（根据 ID 查询记录）和 "select_by_name"（根据名称查询记录）。

使用字典实现：

import sqlite3


def select_all():
    conn = sqlite3.connect('example.db')
    cursor = conn.cursor()
    cursor.execute('SELECT * FROM users')
    results = cursor.fetchall()
    conn.close()
    return results


def select_by_id(id):
    conn = sqlite3.connect('example.db')
    cursor = conn.cursor()
    cursor.execute('SELECT * FROM users WHERE id =?', (id,))
    result = cursor.fetchone()
    conn.close()
    return result


def select_by_name(name):
    conn = sqlite3.connect('example.db')
    cursor = conn.cursor()
    cursor.execute('SELECT * FROM users WHERE name =?', (name,))
    result = cursor.fetchone()
    conn.close()
    return result


query_type = "select_all"
query_dict = {
    "select_all": select_all,
    "select_by_id": select_by_id,
    "select_by_name": select_by_name
}
if query_type == "select_by_id":
    result = query_dict[query_type](1)
elif query_type == "select_by_name":
    result = query_dict[query_type]("John")
else:
    result = query_dict[query_type]()
print(result)

使用 if - elif - else 链实现：

import sqlite3

query_type = "select_all"
if query_type == "select_all":
    conn = sqlite3.connect('example.db')
    cursor = conn.cursor()
    cursor.execute('SELECT * FROM users')
    results = cursor.fetchall()
    conn.close()
    print(results)
elif query_type == "select_by_id":
    conn = sqlite3.connect('example.db')
    cursor = conn.cursor()
    cursor.execute('SELECT * FROM users WHERE id =?', (1,))
    result = cursor.fetchone()
    conn.close()
    print(result)
elif query_type == "select_by_name":
    conn = sqlite3.connect('example.db')
    cursor = conn.cursor()
    cursor.execute('SELECT * FROM users WHERE name =?', ("John",))
    result = cursor.fetchone()
    conn.close()
    print(result)

对于 Python 3.10 及以上版本，使用 match - case 语句实现：

import sqlite3

query_type = "select_all"
match query_type:
    case "select_all":
        conn = sqlite3.connect('example.db')
        cursor = conn.cursor()
        cursor.execute('SELECT * FROM users')
        results = cursor.fetchall()
        conn.close()
        print(results)
    case "select_by_id":
        conn = sqlite3.connect('example.db')
        cursor = conn.cursor()
        cursor.execute('SELECT * FROM users WHERE id =?', (1,))
        result = cursor.fetchone()
        conn.close()
        print(result)
    case "select_by_name":
        conn = sqlite3.connect('example.db')
        cursor = conn.cursor()
        cursor.execute('SELECT * FROM users WHERE name =?', ("John",))
        result = cursor.fetchone()
        conn.close()
        print(result)

通过以上多种实际应用场景和示例代码的扩展，我们可以更清楚地看到不同替代方法在不同场景下的应用方式和优缺点。开发者可以根据项目的具体需求、性能要求、代码可读性等多方面因素，选择最合适的替代 switch case 语句的方法。在实际开发中，灵活运用这些方法，能够使代码更加简洁、高效且易于维护。