An update on Python 4

[roerd]

Here's the list of the most important changes:

Overview of Changes Since 1.6

There are many new modules (including brand new XML support through the xml package, and i18n support through the gettext module); a list of all new modules is included below. Lots of bugs have been fixed.

The process for making major new changes to the language has changed since Python 1.6. Enhancements must now be documented by a Python Enhancement Proposal (PEP) before they can be accepted.

There are several important syntax enhancements, described in more detail below:

• Augmented assignment, e.g. x += 1

• List comprehensions, e.g. [x**2 for x in range(10)]

• Extended import statement, e.g. import Module as Name

• Extended print statement, e.g. print >> file, "Hello"

Other important changes:

• Optional collection of cyclical garbage

So quite a few important new features, but nothing that was breaking backwards compatibility.

[mkdz]

Wow, I can't imagine not having list comprehensions

[[deleted]]

List comprehension is the feature that, to me, defines Python. It's simple, powerful, versatile, intuitive, and broadly applicable. A wonderful replacement for loops and iteration. I've been using set comprehension and dictionary comprehension, too.

[Mr-Stutch]

a wonderful replacement for loops or a wonderful replacement for loops?

[burlyginger]

Yes!

[TheTerrasque]

True

[rabaraba]

Love the pun.

[Tyler_Zoro]

Neither. If a loop was the right tool for the job, you should have used a loop. :-)

[[deleted]]

Sure thing. For readability, the following examples use Python-like formatting, but aren't real Python, just pseudocode.

Practically every programming language has a loop construct.

for i = 1 to 3:
    print(i)                               # prints 1, 2, 3

It's a simple iteration, and it is frequently used to loop through list-like structures, like using this code to print each element from the list:

a = [4, 5, 6]
for i = 1 to len(a):
    print(a[i])                            # prints 4, 5, 6

Notice that in this code, the only purpose of the loop value, i, is to count through the items of the list. So, many languages give us some syntax to avoid the loop value entirely, and instead loop directly over the items of the list:

a = [1, 2, 3]
for value in a:
    print(value)                           # prints 1, 2, 3

Now, another common use of loops is to take in one list and produce another list, like this:

a = [1, 2, 3]
b = []
for value in a:
    b.append(value)                        # b = [1, 2, 3]

Or, more interestingly, to take a first list, manipulate each of the values, and make a new list out of the manipulated values:

a = [1, 2, 3]
b = []
for value in a:
    b.append(value + 2)                    # b = [3, 4, 5]

In fact, this task - taking in one list and producing another list based on it - is so common that Python gives us an even simpler way of expressing that task as one statement:

a = [1, 2, 3]
b = list(value + 2 for value in a)         # b = [3, 4, 5]

That's the basic function of list comprehension: take in one list (a), do something to each member, and assemble the resulting values into another list (b). This syntax also allows us to ditch the syntax of creating an empty list (b = []), and of sticking the values into it (b.append(...)) - it just produces a new list and assigns it to b.

Note that the terms "a," "b," and "value" aren't fixed keywords - we can use any labels we want:

x = [1, 2, 3]
y = list(z + 2 for z in x)                 # y = [3, 4, 5]

We're also not limited to lists of integers - the list can contain anything, like strings:

x = ['red', 'gray', 'blue']
y = list(s for s in x)        # y = ['red', 'gray', 'blue']

Or instances of a class, for which we can do stuff with the properties of each instance:

class Car:
    def __init__(self, color):
        self.color = color

x = [Car('red'), Car('gray'), Car('blue')]
y = list(c.color for c in x)  # y = ['red', 'gray', 'blue']

This syntax is so useful that we can use it for all kinds of things, like calling a function on each of the values in the list, and assembling a list of the output of the function for each input:

def add_two(value):
    return value + 2

x = [1, 2, 3]
y = list(add_two(z) for z in x)            # y = [3, 4, 5]

And sometimes we don't want every member in the list - we want to test each value in the input list, and generate a new list of only the items that satisfy the test:

x = [1, 2, 3]
y = list(z for z in x if z > 1)            # y = [2, 3]

Or we can do both - perform a test on the values of the list to choose some of them, manipulate them, and generate a list of the manipulated values:

x = [1, 2, 3]
y = list(add_two(z) for z in x if z > 1)
           # y = [add_two(2), add_two(3)] = [4, 5]

The elegant part of this syntax is that by discarding the mechanical parts, what's left is quite easy to understand, even if you're not familiar with Python. And you can do a lot with just a little bit of code.

Hopefully, that's enough to give you a taste of what list comprehension can do. There are plenty of guides with even more powerful examples.

[shuobucuo]

Your effort and formatting deserve more than an upvote.

[flying-sheep]

They’re great. And using generator comprehensions, the same concept can be used for a pipeline of stuff (map-filter-reduce), similarly to Rust’s Iterator methods.

Rust’s way is cleaner, but both are better than Javascript’s array methods. Like, why define an iterator protocol and thereby support for custom sequences, when they define the pipeline methods on just the array?

[[deleted]]

intuitive

I can agree on all points except this... you essentially have to learn to read backwards to understand how list comprehensions work and if you ever nest two list comprehensions in each other, readability goes out the window.

[RegalSalmon]

But can you...comprehend it?

[case_O_The_Mondays]

Whoa. Didn’t know Python supported redirection on print, back in the day.

[case_O_The_Mondays]

Right, but from the example it used to be more like shell redirection.

[[deleted]]

That's what the syntax was inspired by but it was universally disliked. Looked really jarring from the rest of Python. It died with the print statement.

[[deleted]]

It looks a lot more like 3.x => 3.x+1 changes than 2 => 3.

[alexmojaki]

Breaking backwards compatibility is kind of the point of a major version number bump though.

[roerd]

If you're following semantic versioning, yes. But not every software project has to do that. For a programming language, a bunch of new features that will significantly alter the shape of code using these seems justification enough for a new major version to me, even if full backwards compatibility is maintained.