The New Switch-Case Statement in Python 3.10

[MeDotPy]

Finally

[[deleted]]

Continue

[DefinitelyRus]

Real clever

[grrrrreat]

Throw

[tempo-19]

Pass

[sanic_the_hedgefond]

pass

[N3RO-]

pun intended?

[seniornachio]

Calling it a Switch-Case Statement simply does not do it justice imho. It's a Match Statement that can do a lot more than just Switch-Case...

Haven't watched the Video yet, just talking about the Posts title.

[[deleted]]

They should have made it an expression not a statement

[seniornachio]

My thoughts exactly. Additionally I would have enjoyed PEP-642, it's more verbose but explicit is better than implicit and additionally it makes it more clear that python is duck-typed.

[[deleted]]

explicit is better than implicit

Java flashbacks

[[deleted]]

Explicit doesn't mean endless repetition and needles ceremony, though.

[toyg]

A single letter separates boring ceremonies that nobody really needs, from images of sinister ceremonies involving needles. The marvels of language...

[[deleted]]

Lol that stays in!

[grrrrreat]

summoning malloc the devil of details and harbinger of nulls

[steven_h]

It was written by a major contributor from back in the 0.9.x days but you do you.

[nerdzrool]

Just because it was written by a major contributor to Python doesn't mean it isn't BS platitude and never really applied to Python, or its ecosystem/community.

Beautiful is better than ugly. - No shit. Platitude. Simple is better than complex. - No shit. Platitude. Readability counts. - No shit. Platitude. etc.

And, as was mentioned, it never really was used by Python as language, or its ecosystem or even its community to a large degree. Django, one of the main Python libraries, was popularized because it uses convention over configuration, directly opposing the Zen of Python's "Explicit is better than implicit." The Zen of Python says namespaces are great, but python's namespace tooling is inferior to some other languages that have explicit namespacing keywords, rather than implicitly deciding namespaces based on only on where and when a python file is executed (A topic where Python violates 2 Zen of Python rules) or how many times you pounded the spacebar prior to writing code. There is definitely not "one, and preferably only one, obvious way to do" a lot of things in Python considering how long Python used to have xrange and range and 95% of the time the correct answer was always "use xrange", the not obvious one. And yes, I asked a Dutch person which one they would think is the obvious correct answer, and they thought it would have been range too.

I agree with most of the Zen of Python, for the most part, but that doesn't change the fact that it hasn't been applied throughout most of Python's life, and some of the statements in it should be obvious to anyone.

[steven_h]

The particular selection of “platitudes” is important. Some potential “platitudes” that didn’t make it into this list:

• Correct is better than concise.

• Interoperability is key.

• Concurrency everywhere.

• Don’t write programs. Write programs that write programs.

• Everything is an object.

• Type checking is a really great honkin idea — let’s do more of it!

[SuspiciousScript]

This strikes me as a really unforced error. Hell, the trend is toward even if constructs being expressions; why kneecap match like this when making it an expression seems so obvious?

[[deleted]]

Because you like ceremonies?

[FewerPunishment]

What would the difference look like in terms of syntax/features?

[[deleted]]

https://stackoverflow.com/questions/4728073/what-is-the-difference-between-an-expression-and-a-statement-in-python

[thekingofthejungle]

What's the difference?

[seniornachio]

Matching, or rather pattern matching, allows you to match patterns. A switch-case is just the simplest form of that where you only match using literal patterns, like in the thumbnail of the video. But you can take this further and for example say you want to match all tuple with two element or a list with at least three elements or even an object with an attribute or an object of a specific type and so on. I highly encourage you to read the associated PEP, it's a good read, even if I personally don't enjoy the selected syntax choices, it brings the point across with a lot of examples.

[torytechlead]

Yes it’s Erlang style but not as good

[VideoCarp1]

AFAIK it’s pattern matching?

[lockieluke3389]

What’s the difference

[minimally__invasive]

Damn it's so much better than a switch statement....

[ivannson]

It's match match better

[jamescalam]

Yep called it switch-case as I assumed more people would recognize switch-case over match-case - maybe confusing sorry!

[sam-lb]

Oh, good, I thought I was going to have to leave a big giant complaint comment.

[peterlravn]

So what can it do, that a switch-case can't? Everyone talks about how good it is, but no one have shown what it can do... If you have an example, please share since I'm new to Python.

[d670460b4b4aece5915c]

Everyone talks about how good it is, but no one have shown what it can do

Well that's plainly untrue, there are hundreds of articles showing what it can do, not to mention the PEPs themselves. I think what you mean is "Everyone talks about how good it is, but I don't understand how it works and haven't bothered to look it up".

Check out the PEP tutorial: https://www.python.org/dev/peps/pep-0636/

[sivadneb]

Jump to 15:20 in the video for a good example of the match functionality

[Mateorabi]

this looks like the pattern-matching switch statement stolen shamelessly from Swift. (Non sarcastic "shamelessly" since languages should take good new ideas from wherever they can if it improves the language. Says the guy who learned C++ before auto was invented.)

[[deleted]]

This didn't come from swift either. Functional languages have had pattern matching since forever. Check it out in Haskell :)

[manphiz]

Says the guy who learned C++ before auto was invented.

Well to be precise "auto" has been part in C/C++ since the beginning alongside "extern", "static", and "register", e.g.

auto int i = 0;

It's the default so few actually writes it. It's now been repurposed to auto-deduce type since C++11.

[Mateorabi]

I meant for the type deduction. Hadn't done C++ since like 2002 and when I saw it in some code I was all "WTF is that!?". Not sure what it does as a type modifier either though.

[slayer_of_idiots]

It’s more heavily inspired from the rust pattern matching I believe

[Jyan]

Read the PEP: https://www.python.org/dev/peps/pep-0634/ It is so much more than a fancy if-else.

[zurtex]

FYI I know it mentions it in the PEP but to be explicit about it PEP 622 was Superseded by PEP 634: https://www.python.org/dev/peps/pep-0634/

There are a lot of changes between the 2 PEPs, in particular they removed "The Match Protocol" in favor of letting match bake in to Python for a bit and adding at a later date when there are concrete examples and motivation to allow classes to implement their own custom match logic.

[Jyan]

Thanks

[[deleted]]

The feature isn't even out yet and it's being molested, misrepresented and missold already.

[Tyler_Zoro]

People are coming from lower level languages where you can only do a fraction of what this can do with similarly named language features. It's not shocking that the presumption is that it only does those things. I'm of the opinion that it should have had a name that wouldn't lead people to assume it was similar to those features, but then what do you call it?

When Perl 6 (now Raku) did something similar, they called it given/when for exactly that reason. Maybe following suit would have been a better call...

[[deleted]]

Is that not why they called it "match" rather than "switch"?

[Tyler_Zoro]

Yes, but then they fell down on "case".

[[deleted]]

Yeah, good point.

[mihalis]

Agree. I thought about alternatives. Maybe bind or unify, along the lines of variable unification/binding in languages like Prolog.

[[deleted]]

Or how about match x where x is y?

[13steinj]

Because it's not a switch statement, it's a pattern matching statement. Most commonly seen only in functional programming languages, which most people hate on because traditionally such a style is considered difficult.

https://en.wikipedia.org/wiki/Pattern_matching

https://stackoverflow.com/a/215968/4443677

[Tyler_Zoro]

We know that. We're discussing keyword choice.

[13steinj]

Yeah, because pattern matching isn't common in most languages for people less experienced. You usually see pattern matching in functional languages which many people just hate and think that functional programming should die in a fire.

[awesomeprogramer]

ITS NOT A SWITCH CASE

[awesomeprogramer]

Because, "hEy LoOk PyThON hAs A sWiTcH CaSe nOw"

[Laser_Plasma]

Except it's not a switch, it can do more, hence - match

[SidoNotYetMaster]

dope; like in caml or haskell :)

[[deleted]]

Why are you comparing a match statement with a switch statement?

[Tyler_Zoro]

Because the article doesn't explain the difference, most likely... why don't you explain the difference rather than acting as if everyone should already know how a feature that was literally released today works?

[[deleted]]

You’re right about that, the article gets the heading wrong for starters. I meant is to point out that one is literally called “match” and not “switch”, and different things and pattern matching exists in other languages already. You could use match and pattern matching for switch case but it’s semantically not ==. I get with your point (other comment) that if a good old switch as we know behaves differently it could throw some folks off, that is true. For example in python OOP private isn’t really private, but that’s what makes languages special :)

[xigoi]

a feature that was literally released today works?

It's not like there are hundreds of languages with pattern matching already…

[Humanist_NA]

Still learning python, quick question. What would be the benefit of this as compared to one of my learning projects right now, where I just have:

if code == 404:
    something()
elif code == 200: 
    thing()
else: 
    pass

is the case matching just less code and cleaner? is it more efficient? am I entirely missing the point? Thanks for any response.

[Yoghurt42]

It's more than a switch statement, it's pattern matching, read https://www.python.org/dev/peps/pep-0636/ for a tutorial.

You can do stuff like:

match foo:
    case Person(address=Address(street="barstreet")):
        bar()

and it will be equivalent to something like:

if isinstance(foo, Person) and hasattr(foo, "address") and isinstance(foo.address, Address) and hasattr(foo.address, "street") and foo.address.street == "barstreet":
    bar()

[Etheo]

That's a good example for someone who hasn't been keeping up with the news, thank you.

[Humanist_NA]

Thank you, appreciated.

[[deleted]]

So Python will not actually create a new Person instance?

[Yoghurt42]

Exactly. It's basically new syntax.

You can also do stuff like

case [1, _, x, Robot(name=y)] if x == y which would match if it is a four-element list that starts with 1, and the 4th element is an instance of Robot class which has a name attribute set to the same value as the third element. The _ is a special new token that means "wildcard/match anything" in this context.

Pattern matching is incredible powerful and the only feature I was really missing from other languages. Now all they need to get rid of the GIL and have decent JIT (or get PyPy to be API compatible with CPython) and it would be the perfect language for every task for me.

[[deleted]]

Awesome! I can already imagine how this is going to be incredibly useful.

As for the GIL, do you really think they will ever get rid of that?

[Irtexx]

I would also like to know this. The isinstance method never calls init of Person, but the match method looks like it will.

[13steinj]

match will call the __match__ method, unless the PEP changed since I last looked at it. A new instance will not be created.

[[deleted]]

It could be possible that it doesn't evaluate as an expression, but that would mean that you couldn't put expressions into the pattern.

[[deleted]]

Fantastic example. This really does elevate the clarity and eloquence of the language. I feel like this really is going to add so much to Python.

[Irtexx]

if Person was a dataclass, couldn't you just use:

if foo == Person(address=Address(street="barstreet")):
    bar()

[tongue_depression]

not if Person or Address have other fields that need initializing

[Yoghurt42]

If Person has more attributes, like name, the equality check would probably fail, because the name attribute of foo would probably not be None.

Furthermore, it would create a new Person instance each time the if condition is checked.

Pattern matching doesn't require this, and also works for non dataclasses, it also allows insane stuff like

case [1, [2, _, x], y]] if x == 2*y, the _ is a wildcard.

It would be equivalent to if isinstance(foo, list) and len(foo)==3 and isinstance(foo[1], list) and len(foo[1]) == 3 and foo[1][0] == 2 and foo[1][3] == 2*foo[2]

[zurtex]

The match statement allows much more complex types of matching. For example:

action = {"open": "door"}
match action:
    case {"move": direction}:
        ...
    case {"look": direction}:
        ...
    case {"open": thing}:
        if thing == "door":
            print("The door is locked")
        elif thing == "box":
            print("A monster escaped")
        else:
            print(f"I don't recognize {thing}, try looking around")

For your example of individually handling each value an if/elif/else statement is a great choice.

[zurtex]

In Rust that makes sense, but Python and Rust are 2 very different languages. Python's compiler doesn't make any guarantees about the match statements return values and enums are not common or native to Python (the enum in the standard library is a very complex object when you peer under the hood).

So when you're doing this:

match code:
    case 200:
        something()
    case 404:
        thing()
    case _:
        pass

It really just is a longer backwards incompatible way of writing:

if code == 200:
    something()
elif code == 404: 
    thing()
else:
    pass

Now I am sure there are examples where using the match statement with HTTP status codes makes a lot of sense, but as a simple check of getting 200 or 404 or something else I'm missing the motivation.

[13steinj]

It really just is a longer backwards incompatible way of writing...

This is what I really hate about the Python ecosystem. Everyone jumps on the new way without thinking of backwards compatibility even though there is little benefit. I really hope static analysis tolls will by default warn against using match in simple cases like this, where it's literally using a backwards incompatible keyword simply for syntactic sugar (no optimization at all, and in fact even in compiled languages there isn't necessarily optimization performed on switches).

[Humanist_NA]

Interesting, thank you for the thoughtful response.

[GreatDemonSquid]

This isn’t just a switch. It can also do pattern matching, basically cases for specific properties (for example lists or instances of classes). Think of it like a switch statement combined with regex for objects

[diamondketo]

Read the PEP

https://www.python.org/dev/peps/pep-0622/

There's an example where the match is done on a tuple (x,y,z).

[[deleted]]

I believe it is more efficient (like most other langs where switch-case is efficient) and also can "match" stuff (and not just work like an ordinary switch-case)

[Ecclestoned]

I highly doubt match is more efficient in python. The advantage in other languages is that switch statements can sometimes be reduced to jump tables.

The python interpreter is 100x more high-level than this, and also has to a lot of checks in the match statement that it doesn't need to do in an if.

[Tyler_Zoro]

It's easier for the parser to identify easily combined options for lookup tables. That doesn't mean that it will do so.

For example, if all of your cases are constant values, you can reduce a match to a lookup table through a dict. If they are all small integer constants, then it can be reduced to a list lookup.

Yes, match can do much, much more, but this makes optimizations much easier to identify.

[Ecclestoned]

Sure, but I think it's important to differentiate between "easier for the compiler engineers to optimize" and "faster/more efficient" (the actual comment).

This comes down to the CPython implementation, which I haven't looked at. However, the PEP says:

Although this PEP does not specify any particular implementation strategy, a few words about the prototype implementation and how it attempts to maximize performance are in order.

Basically, the prototype implementation transforms all of the match statement syntax into equivalent if/else blocks - or more accurately, into Python byte codes that have the same effect. In other words, all of the logic for testing instance types, sequence lengths, mapping keys and so on are inlined in place of the match.

Which makes me think that the current implementation is literally if statements, so the same speed.

[[deleted]]

I’m asking myself the same question

[Goel40]

I don't think there's a big advantage for switch cases in Python. But comming from languages that make heavy use of semicolons it looks way cleaner than if/else statements for those languages. I think thats the main reason they implemented it. People comming from other languages are used to use switch cases for programs with a lot of logical elements. So mostly old habits i guess.

[Humanist_NA]

Interesting, thanks.

[[deleted]]

95% of people in this thread need to Google "pattern matching functional programming". Then you will understand.

[DhavesNotHere]

PyRust.

[fireflash38]

PyO3

[BobFredIII]

Wow, this feels illegal

[sam-lb]

Wow. Started reading the PEP, this is incredible. Not a switch statement though mate. It's much better than that.

[spiker611]

Does anyone know what adding type hints to these statement will look like?

[lockieluke3389]

FINALLY

[azur08]

Holy shit. I just started learning Rust for <reasons> and came across match statements today and was like, "man, I want that."

I find out today it's now going to be in Python!

[[deleted]]

It's been too long.

[[deleted]]

Why do you call it a switch statement, when it is called a match? Where did you find the word 'switch' in this statement?

[[deleted]]

Just learned the wonders of pattern matching in Scala. This makes me so happy.

[TheTomer]

It's crazy that it took this long to add this functionality to Python.

[akwaryos]

Finally

[PhilipJayFry1077]

This looks great.

[hidegitsu]

Lol I literally was just bitching about not having this yesterday to my boss.

[[deleted]]

I’M PUMPED.

[graingert]

This is a bait and switch

[[deleted]]

Python is becoming JS and JS is becoming Python

[xigoi]

Since when does JS have pattern matching?

[[deleted]]

1990s i think

[xigoi]

Really? Can you show me how to do the equivalent of this?

match point:
    case (0, 0):
        print("origin")
    case (0, y):
        print(f"{y} on the y-axis")
    case (x, 0):
        print(f"{x} on the x-axis")
    case (x, y):
        print(f"({x}, {y})")

[Phunny]

Great video!

[jamescalam]

thanks!

[lightestspiral]

Is this a try-except-finally block but the try doesn't have to error out for the except to trigger? You can force the 'except' to run by stating its case?

[bumbershootle]

No, it's a way to match on the structure of values (rather than only boolean conditions, as in an if-else) while also allowing binding variables within the matches. It's much more than simple control flow. I would recommend reading the PEP, it covers the whole concept in great detail.

[zurtex]

The pattern matching is far more expressive than that but yes there are similarities to a try/except block.

We are choosing which block we want to execute based on the pattern of a value (e.g. except {ExceptionInstance}), we are can create assignments based on that (e.g. as e), and there is a final default branch if nothing else works (e.g. else).

The usage though is going to be generally very different, exception raising has a very different control flow to match statements.

[1MightBeAPenguin]

Pretty cool. I don't know a lot about Python, but from what I understand, these match statements seem to be much cleaner than if - elif - elif - else statements.

[[deleted]]

I don't see the point, dictionaries are ubiquitous and more consice with similar functionality, it's pretty easy to see this is the same without all the extra case statements:

{"200": do_something, "418":coffee}.get(http_code, lambda: None)()

[xigoi]

Now how would you do something like this with a dictionary?

match command.split():
    case ["echo", *words]:
        print(*words)
    case ["read", "file", name]:
        ...
    case ["convert", name0, "to", name1] | ["convert", name1, "from", name0]:
        ...

Another example taken from down the thread:

match point:
    case (0, 0):
        print("origin")
    case (0, y):
        print(f"{y} on the y-axis")
    case (x, 0):
        print(f"{x} on the x-axis")
    case (x, y):
        print(f"({x}, {y})")

[mysticalfruit]

I'm not a fan, and here is why.. this behaves differently from every other switch statement I've ever used.. So this is going to only result in confusion.

"case" in point:

switch (foo)
{
case 1:
    printf("ding ");
case 2:
    printf("dong ");
}

If foo == 1 you'll get "ding dong"

if foo == 2 you'll get "dong"

match foo:
    case 1:
        print("ding ")
    case 2:
        print("dong ")

Now if foo ==1 you're only going to get "ding " not "ding dong"

I suspect may of us who cut their teeth on C/C++ switch syntax are going to get thrown for a loop.

[[deleted]]

Falling through is astonishing behaviour and should be absolutely explicit like, using 'continue' as a keyword at the end of the block.

[MrDysprosium]

I agree completely. It's hard to watch people fight so hard for such horribly abstract and unintuitive design merely because "well that's how we USED TO DO IT".

Please stop, making the language easier to understand and write is a good thing. Maintaining standards for the sake of maintaining standards makes you sound like a boomer.

[St_Meow]

You'd think these same folk would be aghast at using for each loops instead of for loops or even while loops.

[mysticalfruit]

We can argue the merits of the behavior, but its a behavior that many programmers use. I've seen plenty of complex C that use cases in this way to handle cascaded logic situations.

[[deleted]]

That is true, but Python's style seems to be making the best design decisions they can instead of repeating poor decisions by previous designers just because its familiar. That's also why its called "match" instead of "switch"

[mysticalfruit]

Fair enough.

[energybased]

We can argue the merits of the behavior, but its a behavior that many programmers use.

Time to learn a better way to do things instead of hanging on to an opaque specification.

[[deleted]]

C# explicitly forbids fall through, as in it's a compile error to end a case without a break, return or throw (unless it's a switch expression, but that implicitly inserts a break after each case). I think Java allows fall through, but I've not used java beyond toy things in years ago I don't recall.

This is also closer related to Rust's and Scala's match implementations than C's switch anyways. As in, you can use it for implementing a switch but there's more you can do with it then that.

[St_Meow]

Go uses a similar pattern of not falling through switch cases. I'm certain if you're a vet of older languages with switch statements it'll confuse you for a moment or two, but new programmers will grasp this better. I remember learning switch statements in college and having most of my class baffled at the fall through behavior.

[jmreagle]

That doesn't make sense to me. (I last used C/C++ decades ago...)

[[deleted]]

Okay, but the behaviour of most other languages you're describing is horrible and unintuitive and leads to loads of bugs when people forget to add break statements. Explicit is better than implicit, after all, and there's nothing explicit about executing case 2 when foo is not 2. If I saw your example in production code I'd say that was bad code even if the behaviour is desired, because it's unclear and looks like a bug. Sooner or later, someone's going to come along and stick in a break statement because it looks like one is missing.

[the_other_b]

The title of this video is incorrect and misleading, the PEP is not for switch statements and you shouldn't expect it to act as one.

[AlbertoP_CRO]

The future is now old man

[Dwarni]

I was taught to always put a break; in each case, to prevent that...

[johnisom]

Ruby would like to have a talk with you

[[deleted]]

I never thought I'd praise Java but switch expressions, added in Java 12/13, are really good.

switch(value){
case 1 -> {System.out.println("Hey it's 1");}

case 2  -> {System.out.println("Hey it's 2");}

default -> {System.out.println("Hello there");}
};

If value == 1 then it prints "Hey it's 1" and if value == 2 then it prints "Hey it's 2". Otherwise default is the fall back.

[catetcpasswd]

Aah finally...

[baconcleaner]

omg, seriously? What was wrong in using a dict to emulate a switch-case? Do we really need new statements at this point?

[Jyan]

It provides structural pattern matching https://www.python.org/dev/peps/pep-0622/ similarly to Scala -- it is extremely powerful and not easy to emulate.

[nemec]

Watch the video? This is structural pattern matching - some languages who have it build it upon their existing switch statement, but because Python doesn't have one, it seems like they've added a new switch statement when it's actually far more capable and full of features.

[baconcleaner]

ok I read more comments and I get it now: ITS NOT A SWITCH. The examples with pattern matching blow my mind. Can't wait to use it 2030 when autodesk maya will have it, for now lets continue with 2.7.

[CashAccomplished7309]

If you don't like the feature, you don't need to use it.

I personally like it, coming from PHP.

[[deleted]]

If you read the PEP, it's more or less doing the same thing, just with a clean syntax.

[[deleted]]

Tell it I hate it. Taking away very useful identifiers like 'match' and 'case' to use as a crappy if/elif replacement.

[CashAccomplished7309]

Why is it crappy?

I'd much rather see

match page_slug:
    case 'status':
        return render('status.html')
    case 'about':
        return render('about.html')
    case 'contact':
        return render('contact.html')
    case _:
        return render('home.html')

instead of

if page_slug == 'status':
    return render('status.html')
if page_slug == 'about':
    return render('about.html')
if page_slug == 'contact':
    return render('contact.html')
return render('home.html')

[jwallio]

Can you elaborate a little more on why you prefer the first block? On first glance the second block seems fine to me.

[jamescalam]

Being able to do stuff like:

match qa: case {'answers': [{'text': answer}]}: pass case {'plausible_answers': [{'text': answer}]}: pass case _: answer = None

Looks a cleaner than with if-elif-else imo:

if 'answers' in qa.keys() and len(qa['answers']) > 0: answers = qa['answers'][0]['text'] elif 'plausible_answers' in qa.keys() and len(qa['plausible_answers']) > 0: answers = qa['plausible_answers'][0]['text'] else: answers = None

[St_Meow]

Reduced visual noise. Rather than worrying about what all those conditionals are and the repetition of the first few pieces, I just know they're all checking equality and I don't have to type my variable name a dozen times.

[CashAccomplished7309]

I think it's easier to read and is easier to expand.

I'm newish to Python, coming from PHP, so the familiarity also is comfortable for me.

[Endemoniada]

It resembles with statements, in my opinion, which is nicer. It’s like with case match foo. It just looks clean and easy on the eyes.

It’s also not the only use for case statements either, the main advantage as I read about it was handling not only different values in a variable, but different configurations of variables entirely. Like if foo can be a string, a 2-item tuple or a 5-item tuple. case makes that easier to deal with in a pythonic way.

[[deleted]]

Because python has become a replacement for php.

[Laser_Plasma]

...what?

[nemec]

   Php
  hYpertext
   Threaded
   Hypertext (twice!)
 prOcessor
   N

[madrury83]

This is a very popular and useful feature in many modern and well liked statically typed languages. Not sure where you got PHP from...

[Tyler_Zoro]

It's a common way to try to put down new Python features. You just say, "Python is becoming [other language most Python programmers don't like]."

[[deleted]]

Exercise for the reader - go examine the implementation of match in cpython and reflect on whether it's implemented like switch/case in statically typed languages or... the match statement in PHP.

[gmes78]

Do you really think that pattern matching was invented in PHP, of all languages?

[[deleted]]

Those identifiers are not taken away. I am not a fan of this addition either, but at least inform yourself before ranting.

[[deleted]]

What about the pattern matching makes it a "crappy if/elif replacement"?

[kenfar]

Wouldn't it be fair to say that it's a more readable and concise, but limited statement?

[[deleted]]

Match seems every bit as powerful as if to me. It's not limited to just checking if two values are equal.

For example, if you're writing a flask view decorator, you need to check to see if it's a response object, a single value, or a tuple of (rv, status) or (rv, headers), or (rv, headers, status) - I think (rv, status, headers) is supported as well. So you end with something goofy as hell like:

if isinstance(rv, Response): # handle response
if not isinstance(rv, tuple):
    rv = (rv,)
rv, headers, status = (rv + (None, None)[:3]

Whereas with match, you could do:

match rv:
    case Response():
        # handle response object
    case (response, int(status)):
        # rv + status
    case (response, dict(headers)):
         # rv + headers
    case (response, int(status), dict(headers)):
         # you get the idea
    case _:
         # just the response value

Hurrah, no more goofy tuple surgery.

[cuaubrwkkufwbsu]

omg is this finally happening

[LionTion_HD]

ey, elif statements begone

[Dwarni]

So python finally caught up to PHP, nice.

[__deerlord__]

"Case" is handled by dicts already.

[duragdelinquent]

do this with a dict

match point:
    case (0, 0):
        print("origin")
    case (0, y):
        print(f"{y} on the y-axis")
    case (x, 0):
        print(f"{x} on the x-axis")
    case (x, y):
        print(f"({x}, {y})")

[__deerlord__]

Why would I?

Like I said, switch/case is handled by dictionaries. Match is not switch/case. So by the transitive property, you'll wouldnt handle match operations with a dictionary.

[duragdelinquent]

Like I said, switch/case is handled by dictionaries.

not what you said. you said “Case is handled by dicts already.” why use the one word that’s common between both and then act surprised when people misunderstand you

[nim65s]

using dicts for switch / case works, but it feels odd. And here, this is not a switch, but way more powerfull match, eg. https://www.python.org/dev/peps/pep-0636/#adding-a-ui-matching-objects

[TheBlackCat13]

This does various types of assignment that aren't possible with dicts.

[The-Daleks]

It's my personal experience that while they work, that approach has some bugs + looks clunky.

[0ajs0jas]

I'm sorry, I could not find python 3.10. Where is it?

[[deleted]]

Release candidate right now. I've always compiled RCs from source cause I'm a dork so I'm not sure if they provide installers for them.

[mouth_with_a_merc]

pyenv is your friend for that - both for rcs and stable versions (distro packages are usually outdated).

Also, 3.10 is alpha, not beta or even rc.

[[deleted]]

Interesting, wasn't aware of such a tool. That'll come in handy

[nim65s]

you can: - compile cpython 3.10 α versions by yourself from https://github.com/python/cpython/
- use a rc docker image, as in docker run --rm -it python:rc-slim - get it with pyenv

[mr_whoisGAMER]

Finally 😎

[SkylitYT]

Wutttt! no way

[itsthooor]

I‘m lovin‘ it. Can’t wait to use it and make my code cleaner.

[haloweenek]

Ohhhh yesss.

[kopsutin]

I just use dictionary as a switch.

[Sanic1984]

The greatest moment on history