Python中match...case的用法

最新推荐文章于 2024-07-30 07:00:00 发布
最新推荐文章于 2024-07-30 07:00:00 发布
阅读量2k 收藏 11
点赞数 2
文章标签： python match case switch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ctbinzi/article/details/133219015
版权

在C语言中有switch...case语句，Pthon3.10之前应该是没有类似语法，从Python3.10开始引入match...case与switch分支语句用法类似，但有细微差别，总结如下：

1.语法

肉眼可见的是关键词从switch变成了match，同时match...case语句遵循Python语法风格，如下：

switch(condition)
{
    case 1：
        do_something_1();
        break;
    case 2:
        do_something_2();
        break;
    case 3:
        do_something_3();
        break;
    default:
        do_default();
}

以上是C语言中switch...case的语法，需要注意：case后面需要有break，否则会继续执行下面的语句

match condition:
    case 1:
        do_something_1()
    case 2:
        do_something_2()
    case 3:
        do_something_3()
    case _:
        do_default()

以上是Python中match...case的语法，没有break，也没有default，取而代之的是捕捉模式（Capture），比如本例中的case _: ，与default功能类似，表示其他值，同时_相当于一个局部变量，其值等于condition，_也可以取其他变量名，当然，一个match语句中最多只能有一个捕捉模式的case，且必须位于最后一个case，就像只能有一个default一样

2.数据类型支持

C语言中的case后面只能是整形值，Python的case后面可以是大部分数据类型，对于不同数据类型的匹配规则，列举如下：

数值(int,float) & 字符串(string) & None：使用等号规则进行匹配

n = -1.2
match n:
  case 0: # 不匹配
    print("1")
  case 1: # 不匹配
    print("1")
  case 1.1: # 不匹配
    print("1.1")
  case 1.2: # 不匹配
    print("1.2")
  case "-1.2": # 不匹配
    print("str -1.2")
  case -1.2: # 匹配，且命中
    print("-1.2")
  case default: # 匹配，但未命中，因为前面case已经命中
    print("default = " + str(default))
s = '3'
print("s == num(3) ? " + str(s == 3))
match s:
  case 1: # 不匹配
    print("1")
  case 3: # 不匹配
    print("3")
  case "3": # 匹配，且命中
    print("str 3")
  case default: # 匹配，但未命中，因为前面case已经命中
    print("default" + default)
n = None
match n:
  case 0: # 不匹配
    print("0")
  case "": # 不匹配
    print('""')
  case False: # 不匹配
    print("False")
  case None: # 匹配，且命中
    print("None")
  case default: # 匹配，当未命中，因为前面case已经命中
    print("default" + str(default))

布尔值(Boolean)：比较特殊，True会匹配True和数字1，False会匹配False和数字0

b = True
match b:
  case "": # 不匹配
    print('""')
  case 0: # 不匹配
    print("0")
  case 11: # 不匹配
    print(11)
  case 1: # 匹配，且命中
    print(1)
  case True: # 匹配，但未命中，因为前面case已经命中
    print(True)
  case False: # 不匹配
    print(False)
  case default: # 匹配，但未命中，因为前面case已经命中
    print("default = " + str(default))
b = False
match b:
  case "": # 不匹配
    print('""')
  case 0: # 匹配，且命中
    print("0")
  case 11: # 不匹配
    print(11)
  case 1: # 不匹配
    print(1)
  case True: # 不匹配
    print(True)
  case False: # 匹配，但未命中，因为前面case已经命中
    print(False)
  case default: # 匹配，但未命中，因为前面case已经命中
    print("default = " + str(default))

字典(dictionary)：当condition是个字典时，case后面只要是字典，且case后面字典的键值对在condition中都能找到，则该case命中，键值对无顺序要求，有一个比较特殊情况，假如case后面跟的是空字典，那么不管condition字典内容是什么，该case必然命中

a = {"ab":3, "5":5}
match a:
  case 1: # 不匹配
    print("1")
  case {"ab":2}: # 不匹配
    print("ab2")
  case {"ab":1}: # 不匹配
    print("ab1")
  case {"c":3}: # 不匹配
    print("c3")
  case {"5":5, "ab":3}: # 匹配，且命中
    print("5:5 ab:3")
  case {"ab":3, "t":3}: # 不匹配
    print("ab3 t3")
  case {"ab":3, "5":4}: # 不匹配
    print("ab3 5:4")
  case {"ab":3, "5":5, "t":2}: # 不匹配
    print("ab3 5:5 t2")
  case {"ab":3, "5":5}: # 匹配，但未命中，因为前面case已经命中
    print("ab3 5:5")
  case {"ab":3}: # 匹配，但未命中，因为前面case已经命中
    print("ab3")
  case {}: # 匹配，但未命中，因为前面case已经命中
    print("{}")
  case _b: # 匹配，但未命中，因为前面case已经命中
    print("_______" + str(_b))

列表 (list)& 元组(tuple)：当condition是个列表或元组时，在做case比对时不分列表和元组，只要元素数量相同，且每个索引位置值相同，即可匹配成功

l = [2,3,4,5]
match l:
  case 2: # 未匹配
    print("2")
  case 2,3: # 未匹配
    print("2,3")
  case 2,3,4,5,6: # 未匹配
    print("2,3,4,5,6")
  case [2,4,3,5]: # 未匹配
    print("[2,4,3,5]")
  case (2,4,3,5): # 未匹配
    print("(2,4,3,5)")
  case (2,3,4,5): # 匹配，且命中
    print("(2,3,4,5)")
  case [2,3,4,5]: # 匹配，但未命中，因为已经命中了前面的case
    print("[2,3,4,5]")
  case default: # 匹配，但未命中，因为已经命中了前面的case
    print("default = " + str(type(default)) + str(default))

集合(set)：目前似乎还不支持集合数据类型的匹配（不确定，如有错误之处，望留言指正）

类(Class)：首先判断是否属于同一个class，然后判断calss各属性值是否相等

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
class Point2:
    def __init__(self, x, y):
        self.x = x
        self.y = y

obj = Point(1,2)
match obj:
    case Point(x=3, y=4): # 不匹配，属性值不相等
        print("Point,3,4")
    case Point2(x=1, y=2): # 不匹配，class类型不一致
        print("Point2,1,2")
    case {"x":1, "y":2}: # 不匹配，Class类型不一致
        print("{x,y}")
    case Point(x=1, y=2): # 匹配，且命中
        print("Point,1,2")
    case default:
        print("default=" + str(default))

3.组合case

在C语言中，可以多个case对应一个执行过程，如下所示

switch(condition)
{
    case 1：
        do_something_1();
        break;
    case 2:
    case 3:
        do_something_2_3();
        break;
    case 4:
    case 5:
        do_something_4_5();
        break;
    default:
        do_default();
}

当condition等于2或3时，执行do_sometion_2_3()函数，当condition等于4或5时，执行do_something_4_5()函数

在Python中也有类似写法，叫作组合(OR)模式，如下所示

c = 5
match c:
  case 1: # 不匹配
    print("1")
  case 1 | 2: # 不匹配
    print("1 | 2")
  case 3 | 4: # 不匹配
    print("3 | 4")
  case 5 | 6 | 7: # 匹配，且命中
    print("5 | 6 | 7")
  case 5: # 匹配，但未命中，因为前面case已经命中
    print("5")
  case _: # 匹配，但未命中，因为前面case已经命中
    print("default = " + str(_))

4.通配符，捕捉模式的扩展

当捕捉模式应用到列表和字典等复杂数据类型时，情况会比较复杂，我们通过几个例子来进行说明

d = [1,2,3,4]
match d:
  case a,b: # 不匹配，元素数量不等
    print("a,b")
    print([a,b])
  case a,b,c: # 不匹配，元素数量不等
    print("a,b,c")
    print([a,b,c,d])
  case 2,*b: # 不匹配，索引位值不相等，其中*b代表任意个元素
    print("2,*b")
    print(b)
  case 1,*b,3: # 不匹配，索引位值不相等
    print("1,*b,3")
    print(b)
  case *b,2: # 不匹配，索引位值不相等
    print("*b,2")
    print(b)
  case 1,2,3,*b,4: # 匹配，且命中
    print("1,2,3,*b,4")
    print(b) // b = []
  case 1,*b,4: # 匹配，但未命中，因为前面case已命中
    print("1,*b,4")
    print(b)
  case *b,4: # 匹配，但未命中，因为前面case已命中
    print("*b,4")
    print(b)
  case 1,*b: # 匹配，但未命中，因为前面case已命中
    print("1,*b")
    print(b)
  case *b,: # 匹配，但未命中，因为前面case已命中
    print("*b,")
    print(b)
  case [*b]: # 匹配，但未命中，因为前面case已命中
    print("[*b]")
    print(b)
  case 2,b,c,d: # 不匹配，索引位值不相等
    print("2,b,c,d")
    print([2,b,c,d])
  case 1,2,c,d: # 匹配，但未命中，因为前面case已命中
    print("1,2,c,d")
    print([1,2,c,d])
  case 1,b,c,d: # 匹配，但未命中，因为前面case已命中
    print("1,b,c,d")
    print([1,b,c,d])
  case a,b,c,d: # 匹配，但未命中，因为前面case已命中
    print("a,b,c,d")
    print([a,b,c,d])
  case _: # 匹配，但未命中，因为前面case已命中
    print("_")

本例中的a,b,c,d为捕捉模式在列表中的应用，而*b为通配符，表示匹配任意个元素，包括0个元素，且一个case中只能有一个通配符变量

类似地，捕捉模式和通配符还可以应用到字典数据类型，如下

d = {"a":1, "b":"bb", "c": [3,4], "d": {"dd":5}}
match d:
  case {"s": 1}: # 不匹配
    print("s:1")
  case {"a":a}: # 匹配，且命中
    print("a:a")
    print(a) # a=1
  case {"b":bbb}: # 匹配，但未命中，因为前面case已经命中
    print("b:bbb")
    print(bbb) # bbb = "bb"
  case {"a":1, **p}: # 匹配，但未命中，因为前面case已经命中
    print("a:1:**p")
    print(p) # p = {"b":"bb", "c": [3,4], "d": {"dd":5}}
  case {**p}: # 匹配，但未命中，因为前面case已经命中
    print("**p")
    print(p) # p = {"a":1, "b":"bb", "c": [3,4], "d": {"dd":5}}
  case {"d":d, **p}: # 匹配，但未命中，因为前面case已经命中
    print("d:d:**p")
    print(p) # p = {"a":1, "b":"bb", "c": [3,4]}
  case _: # 匹配，但未命中，因为前面case已经命中
    print("default=" + str(default)) # default = d = {"a":1, "b":"bb", "c": [3,4], "d": {"dd":5}}

倘若要将捕捉模式和通配符用于自定义类，需要给自定义类定义一个__match_args__数组，如下

class Point:
    __match_args__ = ('x', 'y')

    def __init__(self, x, y):
        self.x = x
        self.y = y

或者使用标准库的dataclasses.dataclass装饰器，它会提供__match_args__属性，如下

from dataclasses import dataclass

@dataclass
class Point2:
    x: int
    y: int

这样就可以使用捕捉模式，如下

class Point:
    __match_args__ = ('x', 'y')

    def __init__(self, x, y):
        self.x = x
        self.y = y


from dataclasses import dataclass

@dataclass
class Point2:
    x: int
    y: int


obj = Point2(1,2)
match obj:
    case Point(x, y): # 不匹配，Class类型不一致
        print(f'Point({x=},{y=})')
    case Point2(x, y): # 匹配，且命中
        print(f'Point2({x=},{y=})')
    case Point(x=3, y=4): # 不匹配，Class类型不一致
        print("Point,3,4")
    case Point2(x=1, y=2): # 匹配，但未命中，因为前面case已经命中
        print("Point2,1,2")
    case {"x":1, "y":2}: # 不匹配，Class类型不一致
        print("{x,y}")
    case Point(x=1, y=2): # 不匹配，Class类型不一致
        print("Point,1,2")
    case default:# 匹配，但未命中，因为前面case已经命中
        print("default=" + str(default))

5.数据类型匹配

简单来说就是只根据数据类型来判断是否匹配，如下

a = {1,2,3}
match a:
  # case object():
  #   print("object")
  case int(): # 不匹配
    print("int")
  case str(): # 不匹配
    print("str")
  case list(): # 不匹配
    print("list")
  case tuple(): # 不匹配
    print("tuple")
  case dict(): # 不匹配
    print("dict")
  case set(): # 匹配，命中
    print("set")
  case bool(): # 不匹配
    print("bool")
  case default:
    print("default=" + str(type(default)) + str(default))

需要注意的是True和False会匹配int()和bool()，所有值都会匹配object

6.AS语法

简单来说就是当匹配某个case时，将匹配到的值存入用as语句声明的新变量中，通常和数据类型匹配相结合使用，如下

a  = [1,2,3,"4"]
match a:
  case {"b": bb} as v: # 不匹配
    print("b:bb:v")
    print(bb)
    print(v)
  case [1, *b, int() as v]: # 不匹配
    print("[1, *b]:int,v")
    print(b)
    print(v)
  case [1, *b, str() as v]: # 匹配，命中
    print("[1, *b]:str,v")
    print(b) # b = [2,3]
    print(v) # v = "4"
  case _:
    print("default = " + str(type(default)) + str(default))

7.补充条件模式

可以在case后面使用if语句来添加匹配的判断条件，如下

a = [3, 4, 5, 6]
match a:
  case [a, *b, c] if a>10: # 不匹配，a不大于10
    print("a>10")
    print("c=" + str(c))
  case [a, *b, c] if a>5: # 不匹配
    print("10>a>5")
    print("c=" + str(c))
  case [a, *b, c] if a>0: # 匹配
    print("5>a>0")
    print("c=" + str(c)) # c = 6
  case [a, *b, c] if a<0: # 不匹配
    print("a<0")
    print("c=" + str(c))
  case _:
    print("a=0")

再比如

cmd = ["go", "away"]
match cmd:
  case ["go", dir] if dir in ["east", "west"]: # 不匹配
    print("go->" + dir)
  case ["go", dir] if dir == "north" or dir == "south": # 不匹配
    print("stop")
  case ["go", dir]: # 匹配，命中
    print("unknown dir:" + dir)
  case _:
    print("default")

ctbinzi
关注
python中case的用法_Python Switch Case三种实现方法代码实例
weixin_39820158的博客
12-03 1469
Python没有switch语句，只能通过模拟来对应实现：方法一：使用dictionary**values = {value1: do_some_stuff1,value2: do_some_stuff2,...valueN: do_some_stuffN,}values.get(var, do_default_stuff)()根据需求可以自行更改参数内容，灵活运用def add(x,y):pri...
第三章 Python流程控制 03-match case
shawn
02-02 183
跟我一起学习Python吧
Python match case这样用，从此告别if-elif-else！
xyh2004的博客
07-13 1565
在Python 3.10及更高版本中，match-case语句引入了一种新的模式匹配机制，它类似于其他语言中的switch-case结构，但更加强大和灵活。match-case允许开发者通过模式匹配来进行复杂的条件判断 ，而不仅仅是简单的值比较。这不仅提高了代码的可读性，还提供了更丰富的表达能力。
Python 教程（七）：match...case 模式匹配
最新发布
前端探索者
07-30 1526
在 Python 中，match和case是一种新的语法结构，首次出现在 Python 3.10 中。这种结构提供了一种类似于其他编程语言中switch或case的功能，允许基于不同条件执行不同的代码块。代码可读性：模式匹配使得代码更易于理解和维护。减少嵌套：可以减少语句的嵌套，使代码更简洁。类型安全：通过类型匹配，可以确保变量的类型正确，减少类型错误。match和case是 Python 3.10 中引入的新特性，它们提供了一种强大且灵活的方式来处理条件逻辑。
python：结构化模式匹配 match case
OceanStar的博客
01-09 2514
match 语句将 subject 表达式 与 case 语句中的每个模式（pattern）从上到下进行比较，直到找到匹配的模式。若找不到匹配的表达式，则匹配 _ 通配符（wildcard）（如有），实际上它就是其它语言中的 default 关键字。字面常数（literal）：如 int、float、string、bool 和 None，不支持 f-string 不是字面常数捕获模式：用匹配表达式赋值目标，一个名称最多只能绑定一次。
Python中match-case语法: 引领新的模式匹配时代
涛哥聊Python
11-23 4958
匹配自定义模式 EvenNumbercase _:# 其他情况的处理在match-case的世界中，模式的多样性能够更灵活地进行数据匹配，提高了代码的表达力和可读性。match-case引入的模式守卫和条件匹配使得模式匹配更加灵活和强大。这些特性使得在匹配模式时可以进一步添加条件，以适应更多复杂的情况。match-case还可以用于引入自定义的错误类型，通过模式匹配对这些错误进行处理。这有助于更好地组织和管理错误类型。try:# 处理数据的逻辑case 0:在这个例子中，定义了一个。
Python 结构化模式匹配 match case （switch case）
m0_73482095的博客
12-26 1501
match 语句将 subject 表达式 与 case 语句中的每个模式（pattern）从上到下进行比较，直到找到匹配的模式。若找不到匹配的表达式，则匹配 _ 通配符（wildcard）（如有），实际上它就是其它语言中的 default 关键字。字面常数（literal）：如 int、float、string、bool 和 None，不支持 f-string 不是字面常数捕获模式：用匹配表达式赋值目标，一个名称最多只能绑定一次不作为变量名，是一种特殊的模式，它始终匹配但从不绑定值。
Python 3.10里面的Match-Case语法详解
m0_59485658的博客
08-13 6835
很多 Python 核心开发者都认为 Python 不需要添加switch-case这种语法，因为可以通过if/elif/else实现一样的效果。事实上 Guido 本人也对这种语法不感冒，所以直到 Python 3.10 一个新的match-case才被加了进来。...
match-case的使用
08-13 638
对于无构建参数的自定义类，可以使用match-case直接进行匹配，但是，它们只是做了类型匹配，并没有比较二者的“值”是否相同match cp:case MyClass1(): #只是做了类型上的匹配case _:')'''10John20'''
linkedin.learning.python.3.10.rar
12-04
- **结构化赋值（Pattern Matching）**：Python 3.10引入了新的`match`语句和`case`表达式，类似于其他语言的模式匹配，增强了代码的可读性和灵活性。 - **赋值解包增强**：现在可以对字典和集合进行解包赋值，如`...
python中match/case & 析构
asunshineboy的博客
09-12 1166
match/case、序列模式匹配 、映射模式匹配、 析构
python case_使用 Python 实现简单的 switch/case 语句的方法
weixin_39609620的博客
12-03 2091
在Python中是没有Switch / Case语句的，很多人认为这种语句不够优雅灵活，在Python中用字典来处理多条件匹配问题字典会更简单高效，对于有一定经验的Python玩家不得不承认，的确如此。但今天我们还是来看看如果一定要用Python来Switch / Case，可以怎么玩。语法约束我们先定义一下Switch/Case应该怎么表达，为了简单我们可以让它长成这样。def cn():pri...
python case 语句
2401_85969209的博客
07-04 745
语句的等价物）为程序员提供了一种更简洁、更直观的条件判断方式。它使用模式匹配的方式进行条件判断，使得代码更加简洁明了、易于扩展和维护。语句，为Python程序员提供了一种更简洁、更直观的条件判断方式。语句是Python 3.10引入的一种新特性，它使用模式匹配来执行条件判断。语句的功能和特性也将不断完善和扩展，为Python程序员带来更多的便利和可能性。在Python编程语言的发展历程中，对于条件判断的需求一直存在。子句中的模式，直到找到匹配的模式并执行相应的代码块。语句的等价物）及其在实际编程中的应用。
python中case的用法_如何在Python中使用TestCase实现一个断言功能
weixin_36330387的博客
03-01 686
如何在Python中使用TestCase实现一个断言功能？相信很多没有经验的人对此束手无策，为此本文总结了问题出现的原因和解决方法，通过这篇文章希望你能解决这个问题。Python TestCase断言方法unittest.TestCase 类中提供了很多断言方法， 通过这些断言方法，我们就可以检查程序逻辑是否符合预期。方法说明assertEqual(x,y)验证 x = yassertNotEqu...
python中case的用法_python中Switch/Case实现的示例代码
weixin_39704727的博客
02-03 2302
python 的 python中Switch/Case实现的示例代码学习Python过程中，发现没有switch-case,过去写C习惯用Switch/Case语句，官方文档说通过if-elif实现。所以不妨自己来实现Switch/Case功能。使用if…elif…elif…else 实现switch/case可以使用if…elif…elif..else序列来代替switch/case语句，这是大...
Python match case结构化模式匹配
龚建波
01-30 4032
Python 在 3.10 之前没有提供类似 switch case 一样的分支语句，虽然也能用 if elif else 或者字典来实现同样的逻辑。到 3.10 版本终于提供了 match case 结构化模式匹配，该语法比 switch case 更加灵活和强大。 match 语句接受一个表达式并将其值与以一个或多个 case 语句块形式给出的一系列模式进行比较。和其他语言 switch case 语句很不同的一点是，match case 不用 break 进行退出，每个 case 是独立的逻辑。
Python学习之Python3.10中match-case的用法和示例
分享型博主
10-19 1341
在 Python 3.10 中引入了新的match-case语法，它是一种用于模式匹配的结构。它类似于语句，可以根据不同的模式匹配执行不同的代码块。match-case。
【Python】Python 3.10 新特性之 match case语句
AiFool的博客
03-01 7262
PEP 634：结构化模式匹配¶ 增加了采用模式加上相应动作的match 语句和case 语句的形式的结构化模式匹配。 模式由序列、映射、基本数据类型以及类实例构成。 模式匹配使得程序能够从复杂的数据类型中提取信息、根据数据结构实现分支，并基于不同的数据形式应用特定的动作。 语法与操作 模式匹配的通用语法如下: match subject: case <pattern_1>: <action_1> case <pattern_2...
python3的match case函数
04-14
好的，我会尽力回答您关于python3的match case函数的问题。Match case函数是Python 3.10中的一项新功能，它可以让开发者更容易地对数据进行模式匹配和比较。它可以用于处理复杂的数据类型，并能在代码中节省大量的if/else语句。需要注意的是，match case函数需要在Python 3.10及以上版本中才能正常使用。您可以参考Python官方文档来了解match case函数的具体用法以及示例代码。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ctbinzi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值