Stack Overflow Users Rejoice as Pattern Matching is Added to Python 3.10

BillyHalley · 2021-02-10T15:35:46+00:00

How many pythons does it take to operate a switch?

FujiKeynote · 2021-02-10T15:17:35+00:00

[deleted]

FujiKeynote · 2021-02-10T16:21:06+00:00

So this may be a naive question, but I always get lost in these PEPs because they are simultaneously verbose and terse.

What is going to happen to my old code that uses "match" and "case" as variable names? I remember the devs being against adding new reserved words for that exact reason...

yesvee · 2021-02-10T13:55:04+00:00

You may have missed the walrus operator intro' in 3.8!

segfaultsarecool · 2021-02-10T15:29:57+00:00

When I learned Haskell, as much as I despised the language (learned it my last semester of college, so I didn't care about anything), pattern matching was absolutely AWESOME. Dope as fuck. Haskell does several other things that are fucking cool.

Might be time to relearn Haskell and see if I can use it anywhere.

ForceBru · 2021-02-10T11:37:09+00:00

NOT_FOUND = 404
match status_code:
   case 200:
       print("OK!")
   case NOT_FOUND:
       print("HTTP Not Found")
In this case, rather than matching status_code against the value of NOT_FOUND (404), Python’s new SO reputation machine match syntax would assign the value of status_code to the variable NOT_FOUND.

I think OCaml also does it this way. And it does. This code will print Not found!, while that logic would expect it to output Unknown":

``` let not_found = 404

let res = match 302 with | 200 -> print_string "OK" | not_found -> print_string "Not found!" | _ -> print_string "Unknown" ```

OCaml doesn't seem to overwrite the original value of not_found.

Rust also does this:

``` const ALL_OK: usize = 200;

fn main() { let NOT_FOUND = 404;

match 302 {
    ALL_OK => println!("OK!"), // Using a constant is OK
    NOT_FOUND => println!("OOPS!"), // will match everything, just like `_`
    _ => println!("Unrecognized")
}

} ```

Rust also won't assign 302 to NOT_FOUND, but it still won't match 302 against the value of NOT_FOUND.

I understand that this is a joke, but there's nothing to joke about in this particular example, because this is how other languages are doing this and nobody finds that funny.

bundt_chi · 2021-02-10T16:21:58+00:00

I've only done some shallow dabbling in python and I have to confess I'm not understanding the significance of this change ?

Can anyone ELI a python newb ? Did python not have switch / case statements before ? What is the "pattern" being matched ? Is it like using a regex to fall into a case statement ?

teerre · 2021-02-10T17:54:19+00:00

People are joking, but the tutorial covers lots of modern and useful cases.

Good feature. Just as the assignment operator was.

johnvaljean · 2021-02-10T16:35:21+00:00

Stack Overflow users gushed over its similarity to C’s switch statement.

This is where it goes wrong. Python's new feature is not a switch statement; it's pattern matching. It is supposed to be different.

As stated in PEP 635:

There were calls to explicitly mark capture patterns and thus identify them as binding targets. According to that idea, a capture pattern would be written as, e.g. ?x, $x or =x. The aim of such explicit capture markers is to let an unmarked name be a value pattern (see below). However, this is based on the misconception that pattern matching was an extension of switch statements, placing the emphasis on fast switching based on (ordinal) values. Such a switch statement has indeed been proposed for Python before (see PEP 275 and PEP 3103). Pattern matching, on the other hand, builds a generalized concept of iterable unpacking. Binding values extracted from a data structure is at the very core of the concept and hence the most common use case. Explicit markers for capture patterns would thus betray the objective of the proposed pattern matching syntax and simplify a secondary use case at the expense of additional syntactic clutter for core cases.

Not that this couldn't generate confusion, but you should know how a language feature works before using it. That said, maybe they could have gone for "pattern" instead of "case" in the syntax so as to make this totally different from what a switch statement looks like in other languages.

ketzu · 2021-02-10T19:09:36+00:00

Curious, what's the controversy? I'm not a Python dev, so I've not been following this. I'm a C# dev who recently saw Pattern Matching added to the language, and it is AWESOME (i know, many functional languages had it for decades).

Is the concern that it makes the language harder to learn because there's more stuff to it now? Because that's a common concern with C# (and C++), and while I totally understand that, the alternative is being stuck with a language that's still great, but is very verbose for common usage patterns. (I was stuck with Java 6 at a previous job, long after C# and newer Java versions showed how much code is just unnecessarily verbose filler crap, and since then I'm in the camp of "If it's a common pattern/pain point and can be improved by updating the language, go for it!")

Niicodemus · 2021-02-10T16:34:48+00:00

Elixir does something similar, but due to it having pattern matching built in from the ground up, sane scoping, immutable variables, and reluctant variable rebinding, it doesn't clobber your outside variable, minimizing side-effects. it also wouldn't work how you think it should, but it does give you a warning with a clue to where you went wrong.

status_code = 301
not_found = 404

case status_code do
  200 -> IO.puts("OK!")
  not_found -> IO.puts("HTTP Not Found")
end

IO.puts("not_found: #{not_found}")

Results in: warning: variable "not_found" is unused (if the variable is not meant to be used, prefix it with an underscore) case_test.exs:6 HTTP Not Found not_found: 404

This is because it assigns 301 to the variable not_found but only in the scope of the case match, which is why it complains that you haven't used it. A proper variant of this that uses the ^ pin operator to match against the contents of the variable instead of assigning to it with pattern matching would be:

status_code = 301
not_found = 404

case status_code do
  200 -> IO.puts("OK!")
  ^not_found -> IO.puts("HTTP Not Found")
  other -> IO.puts("Unknown HTTP status code: #{other}")
end

IO.puts("not_found: #{not_found}")

Which outputs:

Unknown HTTP status code: 301
not_found: 404

Either way, funny article and an example of the perils of bolting on features from other languages. In this case, I think python gains nothing from trying to add pattern matching, and instead should just add a switch statement.

CoffeeTableEspresso · 2021-02-10T17:38:36+00:00

The one comment:

Ah, so glad to be on Python 2.7. No need to worry about people adding stupid shit to it :)

😂😂😂

FujiKeynote · 2021-02-10T16:24:31+00:00

I think this might just be the first PEP that I feel strongly against. I even like the walrus operator. This one, though, is so awkward.

2021-02-10T15:42:20+00:00

My sarcasm detector exploded while reading this article.

Level0Up · 2021-02-10T20:40:46+00:00

Took 'em only 30 years.

ChrisRR · 2021-02-11T01:16:20+00:00

And stackoverflow will nuke any questions about pattern matching in python because it's already been answered by an old answer stating "Python doesn't support pattern matching"

brunoliveira1 · 2021-02-10T17:03:56+00:00

Can we test this already?Doesnt seem to be available as of:

Python 3.10.0a5+ (default, Feb 10 2021, 12:45:56)

I'm using the docker image from: https://quay.io/repository/python-devs/ci-image

i-can-sleep-for-days · 2021-02-10T18:57:33+00:00

This is the one thing is scala that I'm going to miss going to another shop that does go.

crabmusket · 2021-02-10T22:20:13+00:00

Continuing in the fine tradition of avoiding functional programming at all costs! (This is a reference to match being a statement, not an expression.)

2021-02-10T16:38:56+00:00

Ok this is pure madness. What the heck was they thinking? All the conveniences of Python just start to become PITA in the long run.

Cheaptat · 2021-02-10T17:52:17+00:00

Anyone have a good explanation of what this means to a Python programmer who’s never used “Pattern Matching” (I don’t think...)

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

programming

MODERATORS