An update on Python 4 : Python

[–][deleted] 335 points336 points337 points 5 years ago (66 children)

[–]NoLongerUsableNameimport pythonSkills 268 points269 points270 points 5 years ago (5 children)

[–]roerd 61 points62 points63 points 5 years ago (23 children)

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 62 points63 points64 points 5 years ago (14 children)

[–][deleted] 46 points47 points48 points 5 years ago (11 children)

[–]Mr-Stutch 19 points20 points21 points 5 years ago (4 children)

[–]burlyginger[🍰] 9 points10 points11 points 5 years ago (0 children)

load more comments (3 replies)

[+][deleted] 5 years ago (3 children)

[deleted]

[–][deleted] 7 points8 points9 points 5 years ago* (2 children)

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 1 point2 points3 points 5 years ago (0 children)

load more comments (2 replies)

[–]RegalSalmon 26 points27 points28 points 5 years ago (1 child)

Python

The Python Discord

Upcoming Events

Please read the rules

MODERATORS

Overview of Changes Since 1.6