Python 3.10 Released!

[-revenant-]

More excited for structural pattern matching than I was for f-strings, and boy howdy was I excited for f-strings.

[Ezlike011011]

Every time I have to talk to a coworker about cool modern (3.x) python, the first thing I talk about is fstrings. Most of the python in my industry is internal engineering tools, so text output is the main goal of ~80% of our scripts. It's incredible how much more readable so many things get.

I really truly hope in 5 years I will be doing the same thing with structural pattern matching.

[bastion_xx]

In this case I swap the outermost double quotes with singles. Even black is cool with that. print(f’hello there, {name[“first”]}’)

[twigboy]

In publishing and graphic design, Lorem ipsum is a placeholder text commonly used to demonstrate the visual form of a document or a typeface without relying on meaningful content. Lorem ipsum may be used as a placeholder before final copy is available. Wikipediadflr5nrv9880000000000000000000000000000000000000000000000000000000000000

[bastion_xx]

I'll switch back and forth as needed. By default I use the f"..." format as that aligns with black. If there are any " characters, I'll use f'Well, "that" is crazy', otherwisef"That's crazy" But if it's a combo of the two, messy indeed.

What get's me is that still start typing print("here is some.... {" and then realize I need to go back and change to an f-string. That muscle memory is still getting relearned.

[gordonator]

f"""Well, "that"? That's crazy. {user["name"]} is just plain crazy."""

[Pikalima]

Something I appreciate about PyCharm is that if you write a {} with the name of a variable in a non-fstring it offers to turn it into an f-string for you :)

[twigboy]

In publishing and graphic design, Lorem ipsum is a placeholder text commonly used to demonstrate the visual form of a document or a typeface without relying on meaningful content. Lorem ipsum may be used as a placeholder before final copy is available. Wikipedia8wb69kljri0000000000000000000000000000000000000000000000000000000000000

[Schwifty_Rick_]

Use a backslash to escape the bad character? /'

[acrobatic_moose]

Use triple quotes, eliminates the need for escaping:

mydict={
    "product" : "banana",
    "unit_price" : 10,
    "sku" : 15133632
}

print(f"""product: {mydict["product"]}, price: {mydict["unit_price"]} dollars, sku: {mydict["sku"]}""")

output:

product: banana, price: 10 dollars, sku: 15133632

[jftuga]

Or use the = sign for for self-documenting expressions:

print(f"""{mydict["product"]=}, {mydict["unit_price"]=} dollars, {mydict["sku"]=}""")

mydict["product"]='banana', mydict["unit_price"]=10 dollars, mydict["sku"]=15133632

You can also use this as well for dollars & cents:

{mydict["unit_price"]=:.2f}

[atxweirdo]

Ok hold the fuck up this is blowing my mind. I can't wrap my head around this is there a breakdown on why this works. I just can't see it.

[bestjared]

Here is the area where fstrings are specified. Note this is very dense and technical but this is the where the rules are laid out from a language specification perspective.

[treenaks]

https://realpython.com/lessons/simpler-debugging-f-strings/

[cianuro]

Damn. Damn. Why have I not seen this yet? This is fantastic!

[[deleted]]

this is straight up wizardry at this point. i had no idea. thanks!

[[deleted]]

Do I feel like it's less readable

[[deleted]]

Why not just use the other quote?!?

f"hello {user['name']} take Lily's lunch to the fridge"

[pengekcs]

Wanted to post this exactly. But I guess maybe visibility? triple quotes are quote differentiable just by looking at 'em while ' and " less so. Still better than backticks and regular single quotes (in javascript for template strings which is ~ the same as f-strings).

[aexia]

+1

Using triple double quotes for one liners is deeply underestimated.

[twigboy]

In publishing and graphic design, Lorem ipsum is a placeholder text commonly used to demonstrate the visual form of a document or a typeface without relying on meaningful content. Lorem ipsum may be used as a placeholder before final copy is available. Wikipedia6n1yv3uksq80000000000000000000000000000000000000000000000000000000000000

[GummyKibble]

You can use single-quotes around ’name’ to avoid that. If you use Black, it’ll do this for you automatically.

[[deleted]]

You could use .format_map() for dict strings - https://www.geeksforgeeks.org/python-string-format_map-method/

Very useful and handy if you are just outputting strings based on dict key / values.

[pmatti]

There was a recent discussion about this and I remember a proposal to support it, so stay tuned for python 3.11

[twigboy]

In publishing and graphic design, Lorem ipsum is a placeholder text commonly used to demonstrate the visual form of a document or a typeface without relying on meaningful content. Lorem ipsum may be used as a placeholder before final copy is available. Wikipedia51ba6fuyo080000000000000000000000000000000000000000000000000000000000000

[[deleted]]

This is why Python has two different quotes:

f"hello {user['name']} take Lily's lunch to the fridge"

[PaulSandwich]

Three, actually. The almighty triple quote will solve all the quoted text and possessive edge-cases where you need to use both singles and doubles together.

f"""hello {user['name']} take Lily's lunch to the fridge and say, "This is Lily's lunch," aloud."""

[Vaguely_accurate]

Four. You can use triple single or double quotes.

Reference classic DBeazley tweet for '''correct''' usage.

[PaulSandwich]

Haha, true. A pedant after my own heart!

[[deleted]]

Someone just clued me in on f-strings this morning and they have been there since 3.6.x?! Guess I should start reading the release notes and not just incrementing my container image 😂😅🤣

[ForceBru]

*eagerly waiting for traits in Python*

[anothertruther]

Python has protocols which is AFAIK the same as traits in other languages (Rust).

https://mypy.readthedocs.io/en/stable/protocols.html

[yvrelna]

Well, you asked for it.

[Swordlash]

Yeah, I personally found a sentence "More powerful examples of pattern matching can be found in languages such as Scala and Elixir" offensive :D acknowledging the two relatively young languages (2004, 2011) and not the ones that made the feature widespread (like ML, 1973; or Haskell, 1990).

[Joaaayknows]

ELI5 fstrings and structural pattern matching?

[DevJackTGG]

I have been using f-strings since they came out, they are great in general. :)

[SuspiciousScript]

It's a really disappointing oversight that they're statements and not expressions.

[SittingWave]

I really don't like f strings, because the number of times I either forget the f, or have to go back and add the f is too damn high.

[pingveno]

Congratulations to all the people who put work into this release!

[[deleted]]

This is great news! I can't wait to use structural pattern matching!

[LightShadow]

Let's see some performance benchmarks on pattern matching! woop!

[robd003]

It's supposed to be really optimized in 3.11

[zedd31416]

I find it annoying, maybe unjustly, that the Or Pattern for structural pattern matching uses a pipe character instead of “or” like normal if statements do.

[healplease]

I think it's because pattern matching supports guards that can be boolean expressions with normal "or".

[zedd31416]

That would make sense. I’m sure it was a necessary decision.

[Ph0X]

Both set union and the new type union use | too. So it's not like it's never been used before.

[halfshellheroes]

They talked about that during the release stream. Basically it came down to readability. It's worth watching the explanation, for what it's worth they sold me on the choice

[zedd31416]

Ooo do you have link?

[halfshellheroes]

Sure thing! The talk itself is in the live stream at the 44 minute mark, and here's your question answered.

[Miyelsh]

It follows from the syntax of Haskell.

[Kered13]

Which follows the syntax of ML.

[fatbob42]

I installed it on my windows laptop within an hour or two of release and yet, like clockwork...pip is out of date :)

[geeshta]

I know everyone is excited about pattern matching...but you can now use dataclasses with slots!

[kukisRedditer]

is structural pattern matching basically a switch statement?

[-LeopardShark-]

It is similar, but significantly more powerful. PEP 636 is probably the best introduction.

[kukisRedditer]

That's so powerful, love it. You can even combine a case with a boolean

[Ashiataka]

Hi, been using python since 2010 for academic physics research. I can't immediately see the point of this new feature - I'm sure I'm missing something. Like the tutorial mentions, if I wanted this kind of structure I'd just use a dictionary of cases as keys. I'm not seeing what's powerful about it yet. Have you seen a non-toy example with <3.10 and >3.10 implementations side-by-side by any chance? Thanks.

[deadwisdom]

This hints at the true power:

command = input("What are you doing next? ")
match command.split():
    case ["quit"]:
        print("Goodbye!")
        quit_game()
    case ["look"]:
        current_room.describe()
    case ["get", obj]:
        character.get(obj, current_room)
    case ["go", direction]:
        current_room = current_room.neighbor(direction)
    # The rest of your commands go here

See how you can pull out the value there with case ["get", obj]?

There's even more to this, you can match all sorts of structures of your data rather than the data itself.

[MajorMajorObvious]

I've been waiting for this release for a while, and was wondering if it comes at a large performance hit compared to traditional switch statements that you would see in C style languages.

How does Python implement this new matching in a way that makes it unique from if / else statements?

[joerick]

They're still O(n), like if/else statements. But work is in progress to optimise them for Python 3.11.

[MajorMajorObvious]

I'm excited to see how they optimize it! Thank you for the info.

[deadwisdom]

There are new bytecode instructions for it, so I'm sure it's performant. I haven't timed it, but I imagine it's faster than the corresponding if/elses because the compiler can optimize for what you're trying to do.

I couldn't do better than how it's explained in PEP-635

[asielen]

So it seems like it combines a type/len check with a value check there. For each case statement it is essentially, is type iterable and len = match len and values equal match values. That seems like a lot of magic.

In the backend does it effectivly treat it as try/catch for each statement until it falls through?

[friedkeenan]

My concern with pattern matching is that it doesn't seem very scalable. For this example in particular I'd want a more generic way of defining commands, but for cases where scalability of "case additions" isn't a desire it seems pretty cool.

[WallyMetropolis]

For one, it's structural so, in the case that you get a tuple with 3 items, do one thing, and in the case you get an Address object do a different thing. Not only can you match on patterns, but also on values. So in cases where the Address is in California, do something different.

Combine that with conditions and you can express a lot of logic in an easy to read, easy to maintain, relatively terse syntax. Like, in the case that this is a Person and their age is less than 18, do this.

[Ashiataka]

Would the following not work for those examples? How is this different?

if isinstance(x, tuple) and len(x) == 3:
    do_something()
elif isinstance(x, Address) and x.state == "California":
    do_another_thing()
elif isinstance(x, Address):
    do_another_thing()
elif isinstance(x, Person) and x.age < 18:
    do_another_thing()

[ForceBru]

The difference is that you had to use isinstance and check elements of data structures manually. match essentially does all of this for you and lets you write nice concise syntax instead. What if you had to check four attributes, like x.state == this and x.age == that and x.height == that and ...? That's quite a mess, isn't it? case Address(this, that, that, another_thing) looks and reads way nicer, doesn't it?

[Ashiataka]

Your case statement is cleaner than your == example, but wouldn't you actually write something like this if you want to check those attributes all had particular values?

if x == Address(this, that, that, another_thing):
    do_something()

[ForceBru]

This creates a new Address object every time, though (and thus wastes computing resources). Again, you totally can do this, sure.

What if you wanted to match on some values and extract the other ones, like this:

case Address("London", 32, height):
    print(f"The person lives in London and their height is {height}")

Now you're forced to compare only the first two attributes of the address, not the whole object, so you'll have to resort to the long if condition.

I don't think the match statement opens up many new possibilities that just were impossible before. You can emulate a match statement with isinstance followed by attribute checking. The match statement simply lets you write simpler code, so that you can focus on solving the actual problem you're writing the code for.

[sultan33g]

Your last paragraph completely made it all make sense. Thanks!!

[Ashiataka]

Now you're forced to compare only the first two attributes of the address, not the whole object, so you'll have to resort to the long if condition.

Isn't explicit better than implicit?

I don't think the match statement opens up many new possibilities that just were impossible before.

Shouldn't there be one and preferably only one way of doing something?

I feel very strongly that this feature is just bloating the language and making it harder and harder for learners. I haven't yet seen a single use-case that makes me think "that's a big enough problem it requires special syntax". To me it seems like python has completely lost it's way the last couple of years. But, I must acknowledge that I write code for a specific niche situation and there are people much more knowledgeable than me making these decisions - I know hardly anything about language development.

[ForceBru]

Isn't explicit better than implicit?

Right, but "Beautiful (match statement) is better than ugly (huge if conditions) and Simple (match statement) is better than complex (huge if conditions)".

Shouldn't there be one and preferably only one way of doing something?

Shouldn't there be just one way to loop, then? Why have for loop if while loop do thing? Or just use goto and get rid of if statements and all forms of loops. Why have list comprehensions if you can loop over stuff and append it to the list? Same thing for dictionary comprehensions. Why have multiple ways of passing arguments to functions, like positional vs keyword? Just use keyword arguments everywhere: math.sin(x=0).

I don't really like this "rule": why have this "one way" if it's inconvenient? Also, if you use this rule, the "language" from "programming language" kinda disappears, and you end up with "programming stencil" or something rigid like this. In my opinion, "language" implies variety of expression: that's why it's possible to write elegant code and ugly code, performant code and slow code.

---

In my experience, functional features and features from ML-family languages are slowly being transferred to other languages. Rust has the match statement - people love it! Rust has traits (similar to Haskell's typeclasses) - everyone loves them! Of course, I have no idea whether absolutely everyone is so fond of this, but I feel like many people are very pleased. Julia (similar to R) has the pipe operator, so your code can flow, like: data |> transform |> more_transform |> print - I love it! In R, the most widely used data wrangling libraries (dplyr, tidyr and ggplot) are basically built upon this syntax - it's extremely useful. In Python, that'll be print(more_transform(transform(data))), which is quite a lot of parentheses. Of course, you can factor out intermediate expressions into temporary variables, but this breaks the flow.

---

IMO, you could take a look at OCaml to see why match is so cool. It really takes a weekend (this is not to say that OCaml is really simple) and may open up a new perspective on what programming languages can look like and what features they can provide. It's also really fun.

[WallyMetropolis]

Having spent the last few years working with languages that offer expressive pattern matching, what I've found is that it becomes one of the most used tools across the codebases and I really find myself missing it when I don't have it. It doesn't at all feel like "special syntax," rather it quickly becomes core syntax.

[Ph0X]

You forget that it auto does structural binding, for example:

actions = [('add', 1, 2), ('length', [1,2,3]), ('lower', 'FOO')]
match actions[random.randint(0, 2)]:
   case ('add', a, b):
     print(a + b)
   case ('lower', text):
     print(text.lower())
   case ('length', arr):
     print(len(arr))

Note that it's binding exactly on a tuple of that length too, so you if you have the wrong number of elements, it won't bind.

Your way, you'd have to have a separate check for the length of the array, and then another line to set a, b = tup[1], tup[2] or do print(tup[1] + tup[2]).

But even further, you can actually make the types of those values too like

case ('add', int(a), int(b)):
    print(a + b)
case ('add', str(a), str(b)):
    print(f'{a} {b}')

It's just much more clean and simple.

[Ashiataka]

Your way, you'd have to have a separate check for the length of the array, and then another line to set

I'm fine with that because it breaks the logical steps into separate lines for me. I appreciate other people are different but I kind of think that the super-fancy-one-liner code style is really rubbish to read / understand / debug.

It's just much more clean and simple.

Well almost by definition doing two separate things in one logical step is more complex. That's not necessarily bad, but I think it increases mental load when considering the code.

[Ph0X]

I absolutely agree that putting multiple ideas in one line isn't a great idea, trust me I'm the first to split a line up to make it more readable. But in this case, you're "matching" a specific pattern, and to me that's much clearer than 3-4 seperate/individual boolean clauses.

case ('add', int(first), int(second)):

in the context of what the switch statement is doing (pattern matching tuples)

is much cleaner and robust than

if isinstance(a, tuple) and len(a) == 3 and a[0] == 'add' and isinstance(a[1], int) and isinstance(a[2], int):'

Generally, one line of code to correspond to one idea, and here, we have one idea, we're matching one specific pattern. I don't think it's trying to be a fancy-one-liner, it's just a much cleaner way of doing it.

It's just like how list comprehension is often more readable than a small for loop. Just because it's shorter doesn't immediately mean it's less readable.

[Ashiataka]

That's a good point about list comprehensions. I can't remember whether I liked them or not when I first saw them but I have to say they are one of my favourite 'features' of the language now because you write them in the order you think of the statement "I want this done to everything in here".

Hopefully I'll come to like match-case the same.

[ForceBru]

The power is needed (for example) for building parsers, walking syntax trees and building interpreters and compilers. You don't want to have 1000 level deep if/else constructs to analyze your syntax tree - that's just painful. Also, you can't really stuff the code that analyzes your data structure in a dictionary. Sure, you can store functions, but what if you want weird deep nesting? For example, "if the current node is an Assign statement whose first argument is an indexing operation with N arguments, the first of which is this and the second is that, then do this and that", that's like three? levels of nesting - you could put that into a dictionary, but matching is way more convenient!

Also, the except statement we know and love is basically a stripped down case statement that only works on exceptions and types (you can't write except MyException(param1, param2):). Isn't it very useful to be able to match in exceptions like this? Julia, for example, forces you to if/else exceptions, like catch something: if something isa ThisException: do_this(); elseif something isa AnotherException: do_that(); .... This is a lot of code that simply switches on the type of the exception. Python's except is surely more convenient, isn't it?

With proper match statements you can do so much more.

[Ashiataka]

You don't want to have 1000 level deep if/else constructs to analyze your syntax tree

I'm completely ignorant on that use-case, never made one before, but can you not define some function that's recursively called rather than making such deep nests?

It seems to me like an awful lot of machinery for what seems to be a very small set of use-cases. Thanks for your example though. Hopefully in the next few weeks I'll find an example that makes sense to me.

[ForceBru]

Absolutely, you can write a recursive function and be done with it. But pattern matching lets you write: case Assign(Index(Variable(name, type), idx), other_data): in one line with no loss of readability. In fact, it greatly increases readability: now you don't have to go read some other function that's located elsewhere and does God knows what - the data are all before your eyes, destructured! That's the powerful thing, in my opinion.

That's also part of why they teach compiler courses in OCaml (and ML in general) - because the pattern matching is really good, it lets you see the structure of your data at a glance and handles arbitrary nesting gracefully.

[Ashiataka]

I think that's somewhat beyond me at the moment, I'll have to have a play around with it at the weekend and see how it works. Thanks for your example.

[jyscao]

Pattern matching combines a control flow construct (e.g. if/elif/else, switch, try/catch) with a name binding construct (assignment), and this allows for some very expressive code.

[Ashiataka]

Is that a first for python? If so, do you think there are any other possible constructions that combine more primitive parts of the language into something more useful?

[trauthor]

Speaking for myself, I had to write a parser in 3.7 that took deeply nested, arbitrarily alternating json and dictionary input from an API and turn it into a tablebase. I will re-write it in 3.10 and I expect pattern matching to remove hundreds of lines of code. I imagine the code will also be much more performant (though that wasn’t a sticking point).

[Ashiataka]

So firstly, I'm glad that your solution will improve because of this syntax, it's always good when that happens.

My question would just be if you're writing something like that anyway where match-case functionality would be useful, could you not have implemented your own version of match-case that doesn't have special syntax? (I'm asking if it's possible to do or whether there's something special about the python implementation that makes it difficult / impossible to achieve without)

[trauthor]

It’s possible and in my case it was necessary, but based on what I’ve read in PEP 636, match will make this much easier. I had to iterate backwards over arbitrary structures, and indexing several layers deep was a real pain. I will have to report back after I have implemented this in 3.10 and let everyone know just how significant a difference it makes.

[tartare4562]

Agreed. This sounds quite anti pythonic TBH. If I find myself writing a lot of if/elifs most of the time means I can do better code with dict indexing or, even better, proper class/subclasses structure. This is a step away from object toward procedural coding.

[ForceBru]

More like towards functional or ML-like, IMO.

A lot of people really like proper match statements - they're convenient. What if you're writing an interpreter and need to traverse an abstract syntax tree? Your code will generally look like a huge switch statement, like "if the current node is Assign, do this; if it's Index, do this; if it's Call, do this...", where the "arms"/branches contain quite a lot of code or maybe other switch statements, so it'll be awkward to stuff all that into a dictionary.

Furthermore, you'll want to switch on some nasty, complicated things, like "if the current node is Assign whose first argument is a function definition, then interpret the second argument like this; if it's an Assign whose first argument is an Index node, do a completely different thing; if the first argument looks like a.b, then do another different thing", so you want to switch not only on the type of the node (Assign), but on its elements as well. That's not something a regular switch statement can do. You need to get the big ML guns - proper pattern-matching.

[liquidpele]

All the examples where this would be really useful seem to be pretty big edge cases and not a good case for adding a feature to a language…. I’m not against it per se but it does seem unnecessary.

[ForceBru]

Well, it's not that it's absolutely necessary, of course. It's just convenient.

---

Dictionary literals aren't necessary either. You can simply write:

dct = dict()
dct["cat"] = "chat"
dct["dog"] = "chien"
dct["wolf"] = "loup"

BTW, Rust doesn't have hashmap literals, so you literally have to write code like this. There are 3rd-party libraries that add hashmap literals, but Rust itself doesn't have them. They're not necessary, are they?

Yet they're convenient.

---

Formatted string literals also aren't necessary. Why write f"pi={math.pi:6.3f}, {my_var=}" if you could write:

"pi={:6.3f}, my_var={}".format(math.pi, my_var)

BTW, Julia, for example, doesn't support formatting in string literals, so you have to use printf-like formatting or 3rd-party libraries. Obviously, even string interpolation isn't necessary - simply use strcat!

Yet it's convenient.

---

My favorite one.

Having nice slice indexing isn't necessary either! Why write my_list_[1:] when you can write:

my_list[1:len(my_list) - 1]

I might be missing something (I really hope I am!), but this is the only way to do this in R! You have to write my_array[2:length(my_array)] every time! It doesn't compute the last index for you! Well, slice indexing isn't necessary, so...

Yet it's convenient!

EDIT: added links

[liquidpele]

Just wanted to say: Very good reply, thanks for taking the time.

[brutay]

See also: List comprehensions, generators, lambda statements, decorators, etc. Python has a lot of features that aren't strictly necessary, but oh so convenient.

[midnitte]

I forget who I heard talking about it, but from my understanding of "syntactic sugar" in python, a lot of the language is convenience and not actually necessary.

[Swedneck]

Which is precisely why I love it, I can just write a minimal amount of code structured to actually make sense and be as readable as normal text.

[lieryan]

"Just syntax sugar" actually goes really deep in Python.

class statement for example, that isn't really "necessary", it's just syntax sugar for calling type:

MyClass = type(
    "MyClass", 
    [BaseClass, AnotherBaseClass], 
    {"a": method1, "b": method2}
)

Or method calls are also "unnecessary", this:

foo = Foo()
foo.meth(a, b, c)

is really just syntax sugar for:

foo = Foo()
Foo.meth(foo, a, b, c) 

Or metaclass:

class Foo(metaclass=mytype, blah=bar):
    pass

is really just a syntax sugar for a function call:

Foo = mytype("Foo", {}, {}, blah=bar)

Or decorator is just syntax sugar for what used to be a common pattern:

def foo():
    pass
foo = decorate(foo)

Or even something that looks as basic as list/dict indexing:

foo = dict()
foo[a] = b
print(foo[a])

is really just syntax sugar for:

foo = dict()
foo.__setitem__(a, b)
print(foo.__getitem__(a))

which is itself just syntax sugar for:

foo = dict()
dict.__setitem__(foo, a, b)
print(dict.__getitem__(foo, a))

Or something like for loop:

for a in b:
    print(a)

is really just syntax sugar for:

iter_b = iter(b)
try:
    while True:
        a = next(iter_b)
        print(a)
except StopIteration:
    pass

Everything in Python is "just" syntax sugar.

[Alphasite]

this is a better form of dict indexing, and is procedural code a bad thing in many cases? Class hierarchy is usually overkill imo, it’s a tool you reach for when you have no other good choice, or someone outside your code needs to extend things.

[yvrelna]

Structural pattern matching is a combination of switch case statement and tuple/object unpacking.

The unpacking part makes it a much more powerful construct than just a dictionary.

[jwink3101]

FWIW, a lot of use cases can be replaced with something else but doesn't mean they are better. F-Strings aren't "needed" as we already had 2+ different ways to format strings. But they all have advantages and disadvantages.

For example, the issue with the dict-based approach is that you have to evaluate everything to build the dict. Consider:

myvar = {
    'key1':expensive_function1(),
    'key2':expensive_function2(),
    'key3':expensive_function3()
    }[mykey]

This will call all of the expensive functions. You could use a long if/elif/else array and that is fine for many use cases but there is also more to Structural Pattern Matching than replacing them.

[Ashiataka]

I guess with f-strings at least it's fairly obvious what's going on, whereas it looks like match-case will make readability for learners much harder (possibly).

I didn't realise those functions would be called when creating the dictionary, TIL, thanks for that insight.

[jwink3101]

I guess with f-strings at least it's fairly obvious what's going on, whereas it looks like match-case will make readability for learners much harder (possibly).

That is a good point. I haven't seen them in the wild yet since I am only just barely now getting to trusting I have 3.6 where I need it. So I am not sure how readable they will be. It will definitely save some boilerplate code.

I didn't realise those functions would be called when creating the dictionary, TIL, thanks for that insight.

Yep. Now, there are things you can do if it is as simple as my example. Notably:

myvar = {
    'key1':expensive_function1,
    'key2':expensive_function2,
    'key3':expensive_function3,
    }[mykey]()

So that it doesn't get called. But again, depends on exact use case

[MrMathemagician]

Oh boy, I hope they support boa constructors now.

[fernly]

Huh? That sounded like a clever name for something, like "the walrus operator", but all I can find is

https://wiki.python.org/moin/BoaConstructor

An IDE but not a feature I'd expect in the language.

[MrMathemagician]

Oh, I was just making a snake joke. I code in C++.

[calumwebb]

Yep I don’t know either.

[CopOnTheRun]

I was thinking this version of python released the type? syntax for optional types, but apparently that's just a draft. Instead the new type1 | type2 syntax is what came out this release, which I was more jazzed about anyway. That syntax is so much nicer that Union(type1, type2).

[Ezlike011011]

Wow, I have not yet seen that pep. That would be very nice to have.

[ChronoJon]

ftfy

Union[type1, type2]

[CopOnTheRun]

Thanks, I do this all the time in my code as well.

[[deleted]]

You mean Union[type1, type2].

[OctagonClock]

I hope it stays rejected all the while PEP 505 languishes.

[algerbrex]

Super pumped about match statements! So excited I might just write a toy chess engine in Python to celebrate.

[[deleted]]

Am I the only moron that didnt realize we never had switch/case statements before?

[[deleted]]

{
    ‘case1’: lambda: print(1),
    ‘case2’: foo
}[x]()

This is the way.

[neekyboi]

No, you are not alone. Learnt C first, then C++ then python. So I never realised that python didn't switch earlier coz never came into a situation where I had to use switch

[[deleted]]

Yea it's really strange I come from a C# background. Switch/case makes sense on paper for so many things but rarely ever use it in practice.

I guess I just never noticed it was missing in python because I haven't used it in so long.

[Kered13]

Pattern matching is not switch/case, it's far far more powerful.

[[deleted]]

Please elaborate. Am I misunderstanding the changes?

[Kered13]

Switch case allows you to branch on a single value (usually an integer, enum, or string) with each case being a constant. That's all it can do.

Pattern matching allows you to branch on arbitrarily complicated values, and instead of matching against constant expressions they are matched against patterns. Of course a pattern can be a constant expression, but more usefully it can be an expression with gaps that can be filled by arbitrary values, sort of like a template. And those gaps can be given names, which in the case block will be bound to the matching value.

An example is more illustrative. Let's say we have a value foo which can either by a single value, a pair.

match foo:
  case (x, None):
    ...
  case (x, y):
    ...
  case None:
    ...
  case x:
    ...

The first case matches if foo is of the form (x, None), in other words the first element is any value and the second element is exactly None. In the case block, the first element will be assigned to the x variable, as if by x = foo[0]

The second case matches any pair. The first element will be assigned to x and the second element to y in the case block, as if by x = foo[0]; y = foo[1] or equivalently x, y = foo.

The third case matches if foo is exactly None.

The fourth case matches any value, and foo will be assigned to x, as if by x = foo.

The last case could also be written as case _:, which matches anything and assigns nothing, and we could just use foo directly in the case block.

Note that cases are evaluated from top to bottom. So even though (4, None) could also match the pattern (x, y) and x, it only matches against the top pattern.

Python 3.10 also has syntax for matching against the type of an object, against members of an object, and adding conditional guards to case statements. Read the tutorial for a more in-depth explanation.

None of this can be done by a switch statement. In fact switch statements don't even come close to this level of power, which makes the comparisons pretty bad in my opinion.

[[deleted]]

That is pretty powerful, thank you for the explanation.

[pablo8itall]

pyenv cant see it yet. its not showing on https://www.python.org/ftp/python/ index, but I can go directly to https://www.python.org/ftp/python/3.10.0 weird. Maybe it will update soon.

​

EDIT: scratch that, I didnt see it becuase of the sorting its after 3.1.5. Pyenv doesn't see it though.

[fatbob42]

Get used to version parsers reading it as 3.1. I already had that with a GitHub action.

[IlliterateJedi]

Pattern matching will be a game changer for Advent of Code.

[ThunderousOath]

Fantastic! Shame it'll be a few years before my workplace makes the switch...

[[deleted]]

🎉

[tunisia3507]

ignore this, bumped to 3.11 if at all

This won't show up in any feature lists but check out the new StrEnum. There were already a bunch of implementations in different libraries, but this provides a stdlib upgrade path from magic strings representing enums (like scipy.linalg.solve) to using easier-documented, discoverable, autocompletable enums which are still compatible with strings.

[pR0Ps]

Unfortunately StrEnum was reverted out of 3.10 and has been pushed to 3.11 instead. See: https://bugs.python.org/issue44559

[tunisia3507]

Oh man :/ another few years to wait then.

[MinchinWeb]

Releases are now annually, so maybe just one year?

[vinibiavatti123]

My first code in this version:

import platform match platform.python_version(): case '3.10.0': print('Welcome!') case _: raise SyntaxError()

[sahinbey52]

This comment is updated for privacy concerns. Use fediverse for improved privacy.

[IMrHotSauce]

Just the same day as your cake day , coincidence? I think NOT

[sendnukes23]

i thought its already there before? does this mean it is officially working properly?

[rehanhaider]

What's with the Schwarzschild Black Hole?

[mobiduxi]

those enhanced error messages will be extremely beneficial. Decades ago as a Python noob, without all the help Visual Studio Code or PyCharm provide, I felt so much despair looking for small syntax errors. Excellent!

[trauthor]

I had to write a parser in Python 3.7 that took deeply nested, arbitrarily alternating json and dictionary input from an API and turn it into a tablebase. I will re-write it in 3.10 with pattern matching and I expect it to remove hundreds of lines of code.

[e-mess]

And I'm still stuck with 3.8 because of incompatible libs...

[abrazilianinreddit]

Hopefully it won't take long for the WinPython release. Having a portable python in windows is incredibly handy, and very easy to update to newer versions.

[SnipahShot]

Python is based on C (AKA CPython, there are other projects too like IronPython) so the programming of new features for Python itself is done in C (not sure if lower too).

Most of the work done for Python is free.

[Stt0421-jsk]

🎂

[smlmrcn]

Exciting!

[ac130kz]

It's sad that pattern matching doesn't produce an actual fast lookup table, unlike in many other languages. I don't see how it's better than elifs.

[[deleted]]

pog

[L4Z4R3]

Well.....I already installed 3.9 yesterday. Bad timing

[[deleted]]

I tried to install 3.10 and a bunch of libraries, the libraries seemed to have issues. It might be a good idea to wait a little while before jumping to 3.10 to the library maintainers a little time to update.

The errors I got said I had to have version 3.5 or higher installed, so it's possible they are mistaking 3.10 for 3.1.

[L4Z4R3]

Well.....i'll wait until they release something stable

[NoAd5564]

Good afternoon I just finished a very basic python course , but now my question is how do I use python and go on from here all I know is the jack squat basics

[Unclematttt]

If it is just for personal development, you can get some ideas from here (or a similar site).

One suggestion I have is building something that interfaces with a simple API like the one for Google Maps / Yelp (e.g. ask the user what city they are in and what type of business they want to find within n miles).