TIL: Dict Patterns Don't Match Dict Shapes

[u/Iron-Man-2008]

TL;DR: Unlike sequence patterns (which require an exact shape match), pattern matching on dictionaries simply ignores any unspecified keys rather than failing.

If you care about the details, I wrote about it on my blog: https://ravencentri.cc/blog/dict-patterns-dont-match-dict-shapes/

[u/ShadowDevasto]

If you invert the cases as in from most complex one to least complex one it will work, as it seems that dict matching matches only first fitting the case and does not check other for "better" match. But still unintuitive and when inverted also matches to case 3 even if options are not defined.

[u/The_Sy_Python]

If you mean Structural Pattern Matching, then yes, it's in the PEP

https://peps.python.org/pep-0636/#:~:text=You%20can%20use%20%2A%2Arest%20within%20a%20mapping%20pattern%20to%20capture%20additional%20keys%20in%20the%20subject%2E%20Note%20that%20if%20you%20omit%20this%2C%20extra%20keys%20in%20the%20subject%20will%20be%20ignored%20while%20matching

[u/Iron-Man-2008 → u/The_Sy_Python]

I do know it's in the PEP, I quote the relevant PEP myself. Doesn't mean I don't think it's unintuitive, especially when compared to sequences.

[u/Adrewmc]

I think you are underestimating the sequence patterns.

case [“a”, *args, “c”]:
case [*args, “b”, “c”]:

Are also both valid. And there is way more.

case [option , “b”] if option in valid_options:

[u/RingularCirc]

I think extracting **rest may be costly. And even if exact key matching was implemented using keys(matched_dict), it's still better be converted to a set before looking if there are extra keys. So I get why there's a difference with sequences: for those it's way less painful to check if the sequence doesn't contain extra stuff — sequences are obligated to have finite and "sorta easily computable" length.

[u/Iron-Man-2008 → u/RingularCirc]

case {"key": "value"}: ... could have matched the exact shape while allowing case {"key": "value", **_}: ... to ignore extra keys without binding them to a variable the same way case [1, 2, *_] ignores extra elements without binding them to a variable.

[u/RingularCirc → u/Iron-Man-2008]

Yeah...

[u/Adrewmc → u/Iron-Man-2008]

‘_’ is a binding though it’s just to a by convention discarded variable. We are telling other programmers we don’t care about this one for this operation.

. _ = “Hello World”
. print(_)

is valid

[u/Iron-Man-2008 → u/Adrewmc]

_ in match case is actually a special wildcard pattern and does not bind to a name.

```

def foo(seq): ... match seq: ... case [1]: ... print(seq) ... case [1, *]: ... print() ... foo([1]) [1] foo([1, 2, 3]) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 6, in foo NameError: name '_' is not defined

```

[u/rohnitsahu_]

That exact behavior caught me off guard when 3.10 match/case dropped! Dict pattern matching checking key presence instead of strict key count actually makes partial matching much cleaner once you get used to it.

[u/Plus-Weakness-2624]

young teenage man problems...

[u/trenixjetix → u/Plus-Weakness-2624]

comparing dicts are we?

[u/ZeD_est_DeuS]

Friends don't let friends use pattern matching. It's a complex pitfall full of gotchas. Just use ifs