使用结构模式匹配反转测试

Question

我一直在将if-elif链转换为结构模式匹配，但在反向测试中遇到了困难。

很容易生成与任何支持的模式（文本、类、映射、序列等）匹配的案例。我如何证明一个否定的匹配？

例如，当对象的类型不匹配时，我需要强制它：

   if isinstance(x, (list, dict)):
      x = json.dump(x)  
   elif not isinstance(x, str):    # <-- Inverted test
      x = str(x)

Answer 1

从本质上讲，结构模式匹配的设计仅在存在正匹配的情况下触发。然而，有两种解决方法。

最简单的方法是添加一个保护表达式。但这是最后的手段，因为它并没有利用模式匹配和分解功能。

第二种方法是添加早期匹配测试，以便稍后的案例可以假定反向匹配为真。如果负面案例是最后一个案例，那么这种方法效果很好。如果没有，则会变得有点尴尬，因为需要嵌套。

进行反向测试并将其移动到if表达式中：

   match x:
       case list() | dict():
           x = json.dump(x)
       case _ if not isinstance(x, str):    # <-- Inverted test
           x = str(x)

这里的基本思想是进行积极匹配，以便后续案例可以假设消极匹配：

   match x:
       case list() | dict():
           x = json.dump(x)
       case str():                          # <-- Positive match
           pass
       case _:                              # <-- Inverted case
           x = str(x)

除非您有其他要匹配的情况，否则预测试技术是优雅的：

   if isinstance(x, (list, dict)):
      x = json.dump(x)  
   elif not isinstance(x, str):    # <-- Inverted test
      x = str(x)
   elif x == 'quit':               # <-- Additional test
      sys.exit(0)

这里最简单的解决方案是将附加测试移动到倒置测试之前：

   match x:
       case list() | dict():
           x = json.dump(x)
       case 'quit':                    # <-- Moved the test up
           sys.exit(0)
       case str():                     # <-- Positive match
           pass
       case _:                         # <-- Inverted case
           x = str(x)

并不总是可以重新安排测试顺序。如果是这样，则可以引入新级别的嵌套匹配：

   case list() | dict():
       x = json.dump(x)
   case str():                     # <-- Positive match
       match x:                    # <-- Nested match
           case 'quit':            # <-- Inner case
               sys.exit(0)               
   case _:                         # <-- Inverted case
       x = str(x)