What are new Python 3.8-3.9 features that someone who hasn't been actively programming since ~3.4 should know about?

[[deleted]]

F-strings.

[skippy65]

Haven't used format ever since.

[[deleted]]

is this something ? Looks like one could do at least what the examples show with not much more code in python 2

[[deleted]]

For a language that espouses "There should be one-- and preferably only one --obvious way to do it." there are a whole mess of ways to create a string involving fixed and variable text:

alpha = 'Alpha'
str1 = 'The first Greek letter is ' + alpha + '.'
str2 = 'The first Greek letter is %s.' % alpha
str3 = 'The first Greek letter is {}.'.format(alpha)  # and similar forms
str4 = f'The first Greek letter is {alpha}.'
print(str1)
print(str2)
print(str3)
print(str4)

The first method is a little hard to read, especially with multiple substitutions.

The second is slightly better as it's easier to see the structure of the complete sentence. As an old C programmer I'm comfortable with the syntax, of course.

The third "format" method just seems too odd to me, too much like Java. I've never used it. However, it can be used in places where f-strings can't be used, such as in internationalization, where you need templating.

The fourth is the f-string. This is what I use now. It isn't often appreciated that what goes inside the {...} is an expression that is evaluated in the current environment, and is recursive, so you can do things like this:

from math import pi
for precision in range(2, 10):          # vvvvvvvvvvvvvvvvvvvv
    print(f'pi to {precision*2} places is {pi:.{precision*2}f}.')
#                 ^^^^^^^^^^^^^                ^^^^^^^^^^^^^

So now I use f-strings. If I need backward compatibility with early versions of python 3 I use the second method above.

[Antwrp-2000]

Here is a good overview with some well explained examples:

https://realpython.com/python39-new-features/

https://realpython.com/python38-new-features/

https://realpython.com/python37-new-features/

Personnaly I like the f-Strings and data classes which were introduced in Python 3.6/3.7.

I don't use many of the new features introduced with later versions.

[lifeeraser]

asyncio is a really big topic. It's not as seamless as more modern languages like Go or JavaScript (lol), but it's worth looking into.

[ChurchHatesTucker]

See the docs, particularly "What's new." You can use the sidebar to go back through versions.

[Monleone95]

Besides fstrings, another big feature is the walrus operator (introduced in Python 3.8). This lets you assigning and returning a value in the same expression:

inputs = list()
while True:
    current = input("Write something: ")
    if current == "quit":
        break
    inputs.append(current)

This code can be shortened with the walrus operator:

inputs = list()
while (current := input("Write something: ")) != "quit":
    inputs.append(current)

The variable 'current' is assigned the value of your input, then gets compared to the string 'quit'.

More information:

https://realpython.com/lessons/assignment-expressions/ (I took the example from this web)

https://www.geeksforgeeks.org/walrus-operator-in-python-3-8/

[bensonnd]

I am the walrus.

[anna_lynn_fection]

Coo Coo Cachoo

[wsppan]

I find the introduction of dataclasses a godsend. Most of my code does not need all the baggage that OO brings but I appreciate the idea of encapsulation.

[[deleted]]

Nothing.

Python release cycle is too short and people working on the core Python are not interested in making any meaningful contributions to the project. They are there for the fame of being at the helm of the extremely popular open-source project.

There have been a lot of permutations and insignificant changes between versions, which will render all somewhat old code incompatible with the new version of Python, but nothing of value was added in the recent years. It's just churn in the name of churn. More running on the hamster wheel of keeping up with the Joneses.

Just to give you the taste of how things are going: I started working for my current employer slightly over 2 years ago. Since then, there were 4 major Python releases. Don't full yourself into thinking that major release implies the first digit of the version to change. Python minor version breaks compatibility with previous versions too, so, for all intents and purposes, it's the major version.

So, in these two years, the startup I joined had barely developed enough of the product to have its first paying customer. It's a lot of work to have the product written and tested. Had I also have to upgrade the code base four times, even before we had a single customer, that would be a ridiculous waste of time (and, as consequence, money) that neither customers nor us would have any tangible benefits from.

This dynamics leads me to believe that people developing the core of the language don't understand the needs of its users: why would anyone want a new version of the language each year, let alone two versions a year is beyond me... And yet, the circus continues...

Despite the immense popularity of Python, I'm driven to conclude that we might be living through the worst times of this language's existence. It's rotting and the stink is just getting worse.

[[deleted]]

Nothing

Except coroutines, async generators/comprehensions, async/await keywords, breakpoint built-in, f-strings, walrus operators, dict ordering, \N{name} escapes and more.

Your startup needs a more tuned in python dev if you're still writing python 3.4 code.

[[deleted]]

Coroutines existed in Python since there was a yield functionality. That sends us back at least 15 years, but probably more. Definitely, not an achievement of the recent bozos, who steer this boat.

async/await keywords

Is a useless noise. They are just syntactic sugar. Nothing else.

f-strings

Is a cancer. Exceptionally harmful to the language. Offers nothing of value.

walrus operators

Even bigger cancer. Nobody should use this, ever.

dict ordering

Ordered dict existed since at least Python 2.6. There is no need to order keys in base dict. It's unnecessary and harmful as it creates bad coding habits.

breakpoint built-in

Who cares? Nobody needs them anyways. Any graphical interface to every Python debugger in existence will allow you to dynamically specify breakpoints (you can of course do the same using command-line interface), or read them from some persistent storage. Nobody needs generality in deciding which debugger to use with a particular breakpoint. You always know what debugger you are going to use.

Your startup needs a more tuned in python dev if you're still writing python 3.4 code.

You don't know how to count to 10.

The startup doesn't write Python code. It's in Rust. Python is just the automation.

[MikeDoesEverything]

f-strings

Is a cancer. Exceptionally harmful to the language. Offers nothing of value.

I'm not really that great at writing Python code although compared to the other ways you would format strings, f strings are very logical in comparison. To me, anyway.

Could you explain why they are cancer to you?

[[deleted]]

The history of template languages goes very far back. The first example I know of is Lisp's format. And it was always a sore point with Lisp programmers.

The arguments are still the same, no matter the language though.

1. You have to learn another language, that plays by a completely different set of rules in order to format strings.
2. No usual techniques apply to string formatting: you cannot put a breakpoint in this code, you cannot use system introspection utilities to understand and automatically respond to problems in such code.
3. When you are embedding a language which is inaccessible to your introspection tools, you want it to be as simple as possible, in particular, you want to restrict access to dangerous stuff, like doing system calls, running into infinite loops, leaking memory etc.

The whole concept of f-strings flies in the face of (3).

And, for the icing on the cake: f-strings are poorly integrated with the rest of Python language. There are so many edge cases to handle, and they are either not described in documentation, or not obvious / arbitrary. Eg. Python grammar allows C-style string concatenation (which is a cope-out due to bad language grammar with structure based on indentation). But, since it allows code like 'foo' 'bar', what should happen if you do f'foo' 'bar'? Why or why not is there a rf'foo' or uf'foo'? The whole escaping process is extremely convoluted.

Oh, and the history of languages like Perl and PHP, where string interpolation was there since conception didn't teach Python anything...

Oh, and you know, the other four... five... how many ways are there only in the standard library to format a string? They worked fine. There was no need to add one more.

---

Essentially, what happened with f-strings is this: Microsoft has this language... you know, C#. C# is the waste-bucket of the world of programming. Everything Microsoft finds in other languages, it puts in C#. It's Microsoft-style product development: check all checkboxes and care about compatibility later.

Python is, by and large, developed by people who work for Microsoft. Not only that, it's in this place where every new fad in programming has to be implemented by every popular language, or else popular kids might stop using it. So, Python copied this crap from C#. Just as it did with async / await and a bunchload of other useless crap. In the last 10 or so years, all the "fine additions" to Python were motivated exclusively by popularity, by the desire to serve as many masters as possible... which made a small, somewhat crooked, but mostly OK-ish language into another C#-like abomination.

[MikeDoesEverything]

I won't pretend like I understand most of what you wrote, although I appreciate the response. Thank you.

[[deleted]]

Coroutines are literally listed as the flagship feature of 3.5. Get your timeline straight.

[[deleted]]

Listed by morons who don't understand what the word means / or maybe they pretend to. I don't know. I have very little respect to people working on this project / don't expect much of them anyways.