Information to Python comprehensions | Marcin Kozak

PYTHON PROGRAMMING

Study the intricacies of listing comprehensions (listcomps), set comprehensions (setcomps), dictionary comprehensions (dictcomps) — and even generator expressions

Comprehensions represent most likely the most well-liked syntactic sugar in Python. They’re so highly effective that after I lastly understood them, they blew my thoughts, and I really like utilizing them ever since.

Sure, you bought that proper. The primary time I understood comprehensions, not noticed them. It is because, at first look, they don’t appear that readable. Many individuals making their first steps in Python discover them neither clear nor comprehensible. Some might desire for loops; some others might desire the map() perform; nonetheless others might desire no matter else will work — simply not comprehensions.

In case you’re amongst them, I hope this text will persuade you that comprehensions can turn out to be useful in numerous conditions, generally being rather more readable than another device that Python affords. In case you aren’t amongst them, I hope this text will allow you to study extra about how comprehensions work; this can assist you each perceive and create each easy and superior comprehensions. As well as, we are going to talk about a major side of comprehensions: when a comprehension cross the too-difficult line, through which case it is best to quit utilizing it. Generally, so as to try this, you will have to have the ability to persuade your self to forego a selected comprehension, so superior that utilizing it would present you as an skilled Python programmer.

It is because in some conditions, a distinct device can do higher. We’ll dig deep into the practicalities of comprehensions, and I hope you’ll not solely study from this text but in addition take pleasure in studying it. I’ll attempt to write every thing you could learn about them, which doesn’t imply I’ll write every thing about them. However when you’ve understood their necessities and need to study extra, you should have enough information to try this.

Thus, this text goals to elucidate what Python comprehensions are, and the way and when to make use of them. It additionally gives some important intricacies of comprehensions and of utilizing them.

I can even introduce a brand new time period, a Python incomprehension. Whereas the final Python codebase primarily based is filled with each comprehensions and incomprehensions, it is best to try for an affordable variety of the previous and not one of the latter.

The very first thing about comprehensions I’d such as you to know is the that means of the phrase comprehension. Whereas I had identified the that means of the phrase for years earlier than even studying Python comprehensions, I did not put this that means within the Python context. The Cambridge Dictionary gives the next definition of the phrase comprehension:

the power to know utterly and be aware of a scenario, info…

Now, that is one thing I’d such as you to recollect — that is precisely what Python comprehensions do: they assist perceive the motion the code is doing. So, you are able to do this motion in one other means, however this motion is completed by way of a comprehension, it helps perceive what’s occurring. It helps each their creator and reader.

Nonetheless, concentrate on the phrase incomprehension, the antonym of comprehension. Whereas Python doesn’t supply incomprehensions, once we overdo with comprehensions and make them unreadable, they are going to turn out to be incomprehensions . The picture under introduces the time period Python incomprehension, which is a Python comprehension become one thing incomprehensible; that’s, to one thing that goes in opposition to of what comprehensions exist for: to assist perceive the motion the code is doing. As a substitute, incomprehensions make it obscure what the code is to be doing.

We are going to talk about the right way to preserve our comprehensions understandable, as an alternative of creating them incomprehensible; the right way to not flip them into Python incomprehensions; and so, in flip, the right way to make your code Pythonic, simple and comprehensible.

I deal with comprehensions as syntactic sugar that allows me to make use of cleaner and shorter code as an alternative of a distinct coding device, comparable to a for loop, to create a listing, dictionary, set, or generator expression. As you see, you need to use comprehensions to create objects of 4 differing types. Earlier than going additional, let’s analyze a easy instance, just like these you’ve most likely seen in lots of different sources.

Within the first instance, I’ll present you the right way to use the only kind of comprehension to create a listing, a set, a generator expression, and a dictionary. Afterward, we are going to work primarily with lists or dictionaries, relying on what we can be discussing. Generator expressions, though created utilizing the identical syntactic-sugar syntax, supply fairly completely different habits, so I’ll save them for an additional article, devoted to them and their comparability with listing comprehensions.

Checklist comprehensions (aka listcomps)

Think about there aren’t any comprehensions in Python, and we need to do the next. We’ve got a listing of numerical values, say x, and we need to create a listing that comprises squared x values. Let’s do it:

>>> x = [1, 2, 3]
>>> x_squared = []
>>> for x_i in x:
...     x_squared.append(x_i**2)
>>> x_squared
[1, 4, 9]

Now let’s return to actuality: Python does supply listing comprehensions. We will obtain the identical with a lot shorter and, for that matter, rather more comprehensible code:

>>> x = [1, 2, 3]
>>> x_squared = [x_i**2 for x_i in x]
>>> x_squared
[1, 4, 9]

The listing comprehension right here is [x_i**2 for x_i in x]. You possibly can learn it as follows: calculate x_i**2 for every worth in x, and return the brand new values in a listing.

To check lengths of each approaches, let me outline the comprehension ratio:

n_for / n_comprehension

the place n_for stands for the variety of characters in a for loop whereas n_comprehension the variety of characters within the corresponding comprehension. To make this honest, I’ll use solely one-character names. The ratio could be supplied in percentages.

The comprehension ratio exhibits how shorter comprehension code is in comparison with that of the for loop. Warning: It represents just one side of the story: a comprehension’s brevity. Whereas for some examples this brevity is an efficient factor, in some others it’s not, because the code can turn out to be too obscure. We are going to use the ratio anyway, so that you’ve got the concept of how shorter the comprehension is in comparison with the for loop counterpart. Moreover, generally one other coding device can do higher than a for loop, e.g., the map() perform.

On this easy instance, the unique for loop required 26 characters (with out areas); the listing comprehension, 15 characters. Simply to make this clear, I counted characters within the following texts:

for loop:
y=[]foriinx:y.append(i**2)
listing comprehension:
y=[i**2foriinx]

On this very instance, the comprehension ratio was 173%. Not dangerous!

Set comprehensions (aka setcomps)

>>> x = [1, 2, 3]
>>> x_squared = set()
>>> for x_i in x:
...     x_squared.add(x_i**2)
>>> x_squared
{1, 4, 9}

Right here’s the corresponding set comprehension:

>>> x = [1, 2, 3]
>>> x_squared = {x_i**2 for x_i in i}
>>> x_squared
{1, 4, 9}

The comprehension ratio is 186%.

Dictionary comprehensions (aka dict comprehensions, dictcomps)

>>> x = [1, 2, 3]
>>> x_squared = {}
>>> for x_i in x:
...     x_squared[x_i] = x_i**2
>>> x_squared
{1: 1, 2: 4, 3: 9}

A dict comprehension turns into now:

>>> x = [1, 2, 3]
>>> x_squared = {x_i: x_i**2 for x_i in x}
>>> x_squared
{1: 1, 2: 4, 3: 9}

Its comprehension ratio is smaller than it was for listcomps and setcomps, because it’s 124%.

Generator expressions

It’s possible you’ll surprise, what does the time period generator expression has to do with comprehensions? Ought to it’s one thing like generator comprehension?

A legitimate level. I feel… I feel it might be. To me, it’d make a lot sense. However that’s how we name it: generator expressions. They’re right here as a result of generator expressions are created utilizing the identical syntactic sugar as the opposite comprehensions, although their habits may be very completely different. I can’t talk about this distinction in habits, as this subject is way too vital to cover it inside a common textual content on comprehensions. Therefore, I’ll solely present generator expressions right here, with a promise that I’ll write extra about them later.

To create a generator expression, it’s sufficient to take the code contained in the sq. brackets ([]) surrounding listcomp code, and encompass it with parentheses (()):

>>> x = [1, 2, 3]
>>> x_squared = (x_i**2 for x_i in x)

Right here, x_squared is a generator expression created primarily based on a listing. Simple to see {that a} comprehension ratio of a generator expression is identical as that of the corresponding listing comprehension.

The above comprehensions had been the only one, since they included an operation finished for every component of an iterable. By operation I imply this a part of the comprehension: x_i**2; and no matter else we’re doing with x_i — see the picture under, which explains what operation is. We will lengthen this half, however not solely that; there are various potentialities to increase Python comprehensions, and that is the place the ability of this device comes from.

The next listing exhibits how we are able to lengthen the only comprehensions. We will achieve this utilizing

• a number of capabilities within the operation
• a number of filters for the unique knowledge, utilizing the if assertion
• a number of filters for the output of the operation, utilizing the if assertion
• utilizing a conditional expression within the operation, to make use of a number of filters for the unique knowledge; or to make use of a number of filters for the output of the operation
• utilizing superior looping
• the combos of the above

That is the place issues can get difficult, and it’s our job to make sure that our comprehensions don’t flip into incomprehensions. Earlier than discussing why, let’s leap into examples of the above eventualities. Analyze every instance and, if attainable, run it in your Python interpreter, particularly while you’re new to Python comprehensions.

The classification above goals that will help you perceive how comprehensions work. It’s not formal, and to be sincere, you don’t even want to recollect it. I exploit it to indicate you the way completely different and the way highly effective comprehensions could be. So, analyze the examples, perceive them, and in the event you suppose they can assist you, attempt to keep in mind them.

Utilizing perform(s) within the operation

>>> def sq.(x):
...     return x**2
>>> x = [1, 2, 3]
>>> x_squared_list = [square(x_i) for x_i in x]
>>> x_square_list
[1, 4, 9]
>>> x_squared_dict = {x_i: sq.(x_i) for x_i in x}
{1: 1, 2: 4, 3: 9}

Learn the [square(x_i) for x_i in x] comprehension, as an example, as: calculate sq.(x_i) for every worth in x and return the outcomes as a listing.

Above, we used one perform. We will use extra:

>>> def multiply(x, m):
...     return x*m
>>> def sq.(x):
...     return x**2
>>> x = [1, 2, 3]
>>> x_squared_list = [multiply(square(x_i), 3) for x_i in x]
>>> x_squared_dict = {x_i: multiply(sq.(x_i), 3) for x_i in x}
>>> x_square_list
[3, 12, 27]
>>> x_squared_dict = {x_i: sq.(x_i) for x_i in x}
{1: 3, 2: 12, 3: 27}

Any more, I’ll current solely listing comprehensions. I hope at this level you understand how the various kinds of comprehensions work, so there is no such thing as a level in repeating them again and again and litter the code that means.

Filtering the unique knowledge

>>> x = [1, 2, "a", 3, 5]
>>> integers = [x_i for x_i in x if isinstance(x_i, int)]
>>> integers
[1, 2, 3, 5]

We create right here the listing from x, by taking solely integers (so, when x_i has the kind of int, that’s, if isinstance(x_i, int)).

Do you see how related this model is to the earlier one? It’s as a result of each of them use the if assertion to filter the unique knowledge; they only do it in a barely completely different means. Beforehand, we added it to the operation; right here, we added it after the loop.

This and the earlier variations filter the unique knowledge, in distinction to what we are going to do within the subsequent level, that’s, filter the outcomes of the operation. In different phrases, right here you possibly can obtain the identical by first filtering the information and making use of the listing comprehension for the filtered knowledge. Within the model under, you’d first use the listing comprehension after which filter its values.

Filtering the output of the operation

>>> x = [1, 2, 3, 4, 5, 6]
>>> x_squared = [x_i**2 for x_i in x if x_i**2 % 2 == 0]

Right here, we preserve solely these outcomes which are even, and reject odd ones.

Be aware that this code is just not excellent: we run the identical operation twice, first within the operation after which within the conditional expression (which begins with if). As of Python 3.8, we are able to enhance this code utilizing the walrus operator:

>>> x = [1, 2, 3, 4, 5, 6]
>>> x_squared = [y for x_i in x if (y := x_i**2) % 2 == 0]

As you see, the walrus operator allows us to avoid wasting half of the calculations on this listing comprehension. That’s why, if you wish to use extra superior comprehensions than the only one, it is best to turn out to be pals with the walrus operator.

For enjoyable and to study one thing, we are able to use timeit to benchmark these two comprehensions, to see whether or not the walrus operator helps us certainly to enhance the listcomp’s efficiency. For the benchmarks, I used code introduced within the Efficiency part under, with the next code snippets:

setup = """x = listing(vary(1000))"""
code_comprehension = """[x_i**2 for x_i in x if x_i**2 % 2 == 0]"""
code_alternative = """[y for x_i in x if (y := x_i**2) % 2 == 0]"""

That is what I acquired on my machine (32 GB RAM, Home windows 10, WSL 1):

Time for the comprehension : 26.3394
Time for the choice   : 31.1244
comprehension-to-alternative ratio: 0.846

Clearly, it’s undoubtedly price utilizing the walrus operator — although the efficiency achieve is just not shut 50%, as one may need anticipated and hoped. As soon as you understand how this operator and this model of comprehensions work, you may make the code not solely extra performant, but in addition simpler to know.

This comprehension is a bit more tough to learn than the earlier ones, although the that means is simply as easy: calculate x_i**2 for every worth in x and reject all even values of the output (x_i**2); return the outcomes as a listing.

As you see, you could perceive the intricacies of comprehensions to learn this one, however as soon as they don’t pose issues to you, such a comprehension turns into simple to learn. As you will notice later, nevertheless, some comprehensions are something however easy to learn…

filtering the information utilizing a conditional expression within the operation

>>> x = [1, 2, "a", 3, 5]
>>> res = [x_i**2 if isinstance(x_i, int) else x_i for x_i in x]
>>> res
[1, 4, 'a', 9, 25]

This listing comprehension ought to be understood as follows: For every worth in x, use the next algorithm: when it’s an integer, sq. it; go away it untouched in any other case; accumulate the leads to a listing.

This model is sort of just like knowledge filtering; in reality, it’s a selected kind of information filtering, one which’s carried out as a conditional expression (x if situation else y) contained in the operation (as an alternative of out of doors of it). To be sincere, you’ll be able to simply rewrite this listing comprehension utilizing knowledge filtering as introduced above. I can’t present it right here, so as to keep away from confusion. However you’ll be able to take into account this a very good train: rewrite this comprehension utilizing knowledge filtering utilizing the if situation outdoors of the operation, that’s, after the comprehension loop.

Be aware: See additionally a word block within the subsequent subsection, to study when it’s wonderful to make use of a conditional expression and when it’s higher to keep away from it.

Filtering the outcomes utilizing a conditional expression within the operation

The above listcomp filtered the information; we are able to additionally use the conditional expression to filter the outcomes of the operation, like right here:

>>> x = [1, 2, 70, 3, 5]
>>> res = [y if (y := x_i**2) < 10 else 10 for x_i in x]
>>> res
[1, 4, 10, 9, 10]

We used the walrus operator once more, so as to keep away from utilizing the identical calculation twice, as right here:

>>> res = [x_i**2 if x_i**2 < 10 else 10 for x_i in x]

Whereas this model is just not incorrect (notably for Python 3.7 and earlier), it’s not performant.

Since a conditional expression is added into the operation code, it may be helpful when the situation is brief. In any other case, it should litter the operation code. In such a case, it’s higher to make use of the common filtering, with the if situation introduced after the comprehension loop.

Utilizing superior looping

You wouldn’t have to make use of solely easy looping, as we did until now. For instance, we are able to use enumerate() in a comprehension’s loop, the identical means you’d do it in a for loop:

>>> texts = ["whateveR! ", "ntZulugula RULES!n", ]
>>> d = {i: txt for i, txt in enumerate(texts)}
>>> d
{1: "whateveR! ", 2: "ntZulugula RULES!n"}

Now, let’s loop over key-value pairs of the d dictionary:

>>> [(k, v.lower().strip()) for k, v in d.items()]
[(1, 'whatever!'), (2, 'zulugula rules!')]

Principally, you need to use any method to looping that will work in a for loop.

Combos of the above eventualities

The above eventualities had been fundamental, and often you needn’t suppose whether or not such comprehensions are or are usually not too tough; they aren’t. Nonetheless, a scenario can turn out to be far harder, particularly when it contains a couple of simply operation or filtering; in different phrases, when it combines the above eventualities (together with utilizing the identical situation twice or much more in a single comprehension).

In case you’ve heard that Python comprehensions can turn out to be too advanced, you’ve heard it proper. That’s why you’ll be able to usually learn that you shouldn’t overuse comprehensions; and that’s additionally greater than true. That is what I’ve proposed the time period incomprehensions for. You must undoubtedly keep away from utilizing incomprehensions in your Python code.

Let’s take into account a few examples so that you could see for your self that comprehensions can get tough. Not all of those examples can be too advanced, although — however some undoubtedly will.

Contemplate this listcomp, which mixes filtering the information with filtering the output:

>>> x = vary(50)
>>> [y for x_i in x if x_i % 4!= 0 if (y := x_i**2) % 2 == 0]
[4, 36, 100, 196, 324, 484, 676, 900, 1156, 1444, 1764, 2116]

Look what we’re doing right here: calculate x_i**2 for all values of x which are divisible by 4, and take solely these ensuing output values which are divisible by 2.

We’ve got two if circumstances right here. In that case, we are able to attempt to simplify the comprehension by becoming a member of the 2 circumstances utilizing and:

>>> [y for x_i in x if x_i % 4!= 0 and (y := x_i**2) % 2 == 0]
[4, 36, 100, 196, 324, 484, 676, 900, 1156, 1444, 1764, 2116]

To be sincere, for me two circumstances introduced in two if blocks appear simpler to know than one if block with two circumstances joined with the and operator. In case you disagree, so if in your opinion and helped enhance readability, please share this within the feedback. This is to some extent a subjective matter, so I don’t count on all of you to agree with me.

No matter what you concentrate on utilizing and, we are able to enhance the readability of this comprehension by splitting it up into a number of rows, every row representing a block that means one thing and/or does one thing:

>>> [y for x_i in x
...  if x_i % 4 != 0
...  and (y := x_i**2) % 2 == 0]
[4, 36, 100, 196, 324, 484, 676, 900, 1156, 1444, 1764, 2116]

Or

>>> [
...     y for x_i in x
...     if x_i % 4 != 0
...     and (y := x_i**2) % 2 == 0
... ]
[4, 36, 100, 196, 324, 484, 676, 900, 1156, 1444, 1764, 2116]

and even

>>> [
...     y
...     for x_i in x
...     if x_i % 4 != 0
...     and (y := x_i**2) % 2 == 0
... ]
[4, 36, 100, 196, 324, 484, 676, 900, 1156, 1444, 1764, 2116]

This final model is extra helpful once we apply a number of capabilities within the first row, so the row is longer than only one identify, like right here.

As I discussed, two if blocks are extra readable for me:

>>> [
...     y for x_i in x
...     if x_i % 4 != 0
...     if (y := x_i**2) % 2 == 0
... ]
[4, 36, 100, 196, 324, 484, 676, 900, 1156, 1444, 1764, 2116]

What I notably like this this very model is the visible symmetry of the if blocks on the left facet. Do you see it? If not, return to the earlier block of code, and word the distinction between this half:

...     if x_i % 4 != 0
...     if (y := x_i**2) % 2 == 0

and this half:

...     if x_i % 4 != 0
...     and (y := x_i**2) % 2 == 0

Whereas these points are usually not too vital, they assist, at the very least for me. I imply, after I work on an extended comprehension, I take them into consideration — and I’d wish to recommend you taking such points into consideration, too. First, consider me or not, this provides me enjoyable. Second, while you do listen even to such small points of your comprehensions, you’ll really feel you already know them very nicely; you’ll really feel they’re (or are usually not, when they don’t seem to be prepared) prepared, completed, full.

This comprehension was not that tough in spite of everything, was it? So, let’s make the scenario — and therefore the listing comprehension — slightly extra advanced:

>>> [
...     y for x_i in x
...     if x_i % 4 != 0 and x_i % 5 != 0
...     if (y := square(multiply(x_i, 3))) % 2 == 0
... ]
[36, 324, 1764, 2916, 4356, 6084, 10404, 12996, 15876, 19044]

This is extra advanced, however I feel that put that means, even this comprehension is sort of readable. Nonetheless, with an increasing number of circumstances being added, it’d be getting an increasing number of advanced — finally, in some unspecified time in the future, crossing the road of being too advanced.

As I already wrote, generally a for loop can be extra readable than a comprehension. There are, nevertheless, extra alternate options, such because the map() and filter() capabilities. You possibly can learn extra about map() in this text, through which I clarify why it’s good to understand how this perform works, and when it may be a greater answer than a comprehension.

These capabilities could be even faster than the corresponding comprehensions, so at any time when efficiency counts, chances are you’ll want to examine whether or not map()– and filter()-based code doesn’t work higher than the comprehension you’ve used.

In easy eventualities, comprehensions are often higher; in difficult ones, this doesn’t must be the case. It’s greatest to indicate this utilizing examples. Thus, under I present a few examples of a comprehension (together with generator expressions) and the corresponding different answer.

Instance 1. The map() perform as an alternative of a easy generator expression.

>>> x = vary(100)
>>> gen = (sq.(x_i) for x_i in x)
>>> different = map(sq., x)

On this scenario, each variations appear equally readable to me, however the comprehension seems considerably extra acquainted. The map() perform is an abstraction: you could know the way it works, which argument should goes first (the callable) and which should go then (the iterable)¹.

Not like map(), in my eyes easy comprehensions, just like the one above, don’t look summary. I can learn them straight, from left to put in writing: I’m making use of the perform sq.() to x_i, and x_i’s are the following components of x; I retailer the leads to a generator object.

Sounds simple, however I do know that to learn comprehensions like that (sure, I do learn them that means!), you could know this particular Python syntactic sugar. This is the reason for superior (even intermediate) Python programmers, this generator expression (and different such easy comprehensions) look easy, however they seldom look easy for starting Python builders. So, comprehensions could be summary, too. As we are going to see quickly, nevertheless, this syntax could be a lot clearer than its direct alternate options.

Using the map() perform turns into much less clear while you use a lambda perform inside map(). Examine:

>>> x = vary(100)
>>> gen = (x_i**2 for x_i in x)
>>> different = map(lambda x_i: x_**2, x)

Whereas lambdas do have their place in Python and could be extremely helpful, in some conditions they’ll lower readability — and that is such a scenario. Right here, I undoubtedly desire the generator expression over the map() model.

Instance 2: The filter() perform used as an alternative of a generator expression with an if block for knowledge filtering.

>>> x = vary(100)
>>> gen = (x_i for x_i in x if x_i % 5 == 0)
>>> different = filter(lambda x_i: x_i % 5 == 0, x)

All of the above feedback for map() apply to the filter() perform. Like map(), it may be used with (like right here) or with out lambda. Right here, once more, I desire the generator expression.

Instance 3: Combining map() and filter() as an alternative of a generator expression that makes use of a perform to course of the weather and an if block to filter knowledge.

>>> x = vary(100)
>>> gen = (sq.(x_i) for x_i in x if x_i % 5 == 0)
>>> different = map(sq., filter(lambda x_i: x_i % 5 == 0, x))

You are able to do the identical in two steps:

>>> x_filtered = filter(lambda x_i: x_i % 5 == 0, x)
>>> different = map(sq., x_filtered)

This is without doubt one of the conditions while you mix the map() and filter() capabilities so as to course of the information and filter them. However it is usually a type of conditions through which I want a while to know what this code is doing, on the identical time having the ability to perceive the corresponding comprehensions (right here, a generator expression) virtually instantly. Right here, I’d undoubtedly select the generator expression model.

Instance 4: Utilizing map() with a wrapper perform as an alternative of a dictionary comprehension.

Dictionary comprehensions make creating dictionaries fairly easy. Contemplate this instance:

>>> def sq.(x):
...     return x**2
>>> y = {x: sq.(x) for x in vary(5)}
>>> y
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

This seems easy, doesn’t it? Now attempt to obtain the identical utilizing map().

The issue is that you could create key-value pairs, so, if we need to use map(), it’s not sufficient for the perform to return the output; it must return the important thing as nicely. A pleasant answer is to make use of a wrapper perform round sq.():

>>> def wrapper_square(x):
...     return x, sq.(x)
>>> y = dict(map(wrapper_square, vary(5)))
>>> y
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Will you agree that the above dict comprehension was a lot extra readable, a lot simpler to put in writing, and a lot simpler to learn than this map()-based model? Right here, a for loop can be simpler to know than the map() model:

>>> y = {}
>>> for x in vary(5):
...     y[x] = sq.(x)
>>> y
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Instance 5: A for loop for filtering the information mixed with filtering the output.

Let’s return to the instance through which we carried out fairly a posh listcomp:

>>> [
...     y for x_i in x
...     if x_i % 4 != 0 and x_i % 5 != 0
...     if (y := square(multiply(x_i, 3))) % 2 == 0
... ]
[36, 324, 1764, 2916, 4356, 6084, 10404, 12996, 15876, 19044]

That is what the corresponding for loop seems right here like:

>>> output = []
>>> for x_i in x:
...     y = sq.(multiply(x_i, 3))
...     if y % 2 == 0 and x_i % 4 != 0 and x_i % 5 != 0:
...         output.append(y)
>>> output
[36, 324, 1764, 2916, 4356, 6084, 10404, 12996, 15876, 19044]

It’s not that dangerous, truly. That is I feel a borderline scenario, one through which some will nonetheless select the listcomp model whereas others will take into account it unreadable and select the for loop as an alternative. For me, the listcomp remains to be wonderful, however I’m fairly positive for some it has already crossed the road of too tough.

Instance 6: Splitting a listcomp.

Let’s use the exact same instance as above. Let’s attempt to do one thing I’m not an ideal fan of; particularly, let’s break up this advanced comprehension into a number of ones, with the hope that this can simplify the code:

>>> y_1 = [x_i for x_i in x]
>>> y_2 = [
...     y_1_i
...     for y_1_i in y_1
...     if y_1_i % 4 != 0 and y_1_i% 5 != 0
... ]
>>> y = [
...     y_final
...     for y_2_i in y_2
...     if (y_final := square(multiply(y_2_i, 3))) % 2 == 0
... ]
>>> y
[36, 324, 1764, 2916, 4356, 6084, 10404, 12996, 15876, 19044]

Regardless of the splitting, this model is in my view even much less readable than the earlier one. It’s not solely for much longer; it is usually much less readable to me. I’d by no means select this one, however I wished to indicate it to you, simply in case you will have been questioning whether or not an method like that will work. This time, it wouldn’t.

Instance 7: Simplifying operations and filters utilizing capabilities.

You possibly can generally simplify a comprehension by exporting among the work to be finished to exterior capabilities. In our case, we are able to achieve this with each the operations and the filters:

>>> def filter_data(x_i):
...     return x_i % 4 != 0 and x_i % 5 != 0
>>> def filter_output(y_i):
...     return y_i % 2 == 0
>>> def pipeline(x_i):
...     return sq.(multiply(x_i, 3))
>>> def get_generator(x):
...     return (
...         y for x_i in x
...         if filter_output(y := pipeline(x_i))
...         and filter_data(x_i)
..      )
>>> listing(get_generator(x))
[36, 324, 1764, 2916, 4356, 6084, 10404, 12996, 15876, 19044]

I feel this makes the comprehension a lot easier to learn. We will do the identical with the for loop, nevertheless:

>>> output = []
>>> for x_i in x:
...     y = pipeline(x_i)
...     if filter_output(y) and filter_data(x_i):
...         output.append(y)
>>> output
[36, 324, 1764, 2916, 4356, 6084, 10404, 12996, 15876, 19044]

However is that this for loop higher than the corresponding generator under (copied from the above snippet)?

>>> (
...     y for x_i in x
...     if filter_output(y := pipeline(x_i))
...     and filter_data(x_i)
... )

I’d select the listcomp. It’s extra concise and appears extra readable, at the very least to me.

It’s a very good second to say naming. Look as soon as extra on the perform names used within the above comprehension: filter_data, filter_output and pipeline. These are clear names, ones that inform what they’re accountable for; that means, they need to assist us perceive what’s occurring contained in the comprehension.

Maybe some would say that they’re poor decisions for the capabilities, as comprehensions ought to be brief, and shorter perform names would assist us write extra concise comprehensions. They’d be proper in just one factor: that the comprehensions can be extra concise. However writing brief comprehensions doesn’t imply writing good-because-readable comprehensions. Examine the above comprehension with the one under, through which I used shorter however on the identical time a lot much less significant names:

>>> def fd(x_i):
...     return x_i % 4 != 0 and x_i % 5 != 0
>>> def fo(y_i):
...     return y_i % 2 == 0
>>> def pi(x_i):
...     return sq.(multiply(x_i, 3))
>>> def g_g(x):
...     return (y for x_i in x if fo(y := pi(x_i)) and fd(x_i))
>>> listing(get_generator(x))
[36, 324, 1764, 2916, 4356, 6084, 10404, 12996, 15876, 19044]

Undoubtedly shorter — and undoubtedly worse.

Be aware that whereas the creator of such a comprehension will know that fd stands for filter_data whereas pi stands for pipeline, will anybody else understand it? Will the creator keep in mind it after a month? Or a 12 months? I don’t suppose so. That is thus poor naming, one which carries no actual connotation with what the capabilities are accountable for, and one whose secret code (fo stands for filter_output) will shortly be forgotten.

In case you resolve to go for utilizing exterior capabilities in comprehensions, do keep in mind to make use of good names — good that means brief and significant. The identical applies for all names utilized in a comprehension. Right here, nevertheless, we must always use names which are as brief as attainable, and never longer. There’s an unwritten rule that when a variable has a slim scope, it doesn’t want a protracted identify. Whereas not all the time is that this rule smart, it usually is smart in comprehensions. As an example, take into account these listing comps:

>>> y = [square(x_i) for x_i in x if x_i % 2 == 0]
>>> y = [square(xi) for xi in x if xi % 2 == 0]
>>> y = [square(p) for p in x if p% 2 == 0]
>>> y = [square(element_of_x) for element_of_x in x if element_of_x % 2 == 0]

The primary two work virtually equally nicely for me, although I’d select the primary one. It is because x_i seems like x with subscript i; xi doesn’t appear to be that. So, I’m prepared to make use of the extra _ character to affix x and i, to hold this extra that means. That means, x_i seems type of mathematically, as x_i, that means that x_i belongs to x. Whereas the xi model seems fairly related, it misses this good resemblance of mathematical equations. Therefore my selection of the previous.

I don’t just like the third model. Why use p as a looping variable’s identify? What does p imply? If it means one thing from a standpoint of the algorithm we implement, then wonderful. However in any other case, it’s not wonderful. Principally, it’s good to make use of names that imply one thing — however keep in mind that in comprehensions, it is best to use brief names that imply one thing.

In comprehensions, it is best to use brief names that imply one thing.

This is the reason I don’t just like the fourth model, both. Whereas the identify element_of_x does carry appropriate that means, the identify is unnecessarily lengthy. Don’t use a protracted identify when a brief one can be equally informative. That is the case right here: x_i is far shorter and at the very least as informative as element_of_x, if no more — due to how x_i resonates with mathematical equations.

There’s yet another factor. Once you do not use the looping variable, use _ as its identify. As an example:

>>> template = [(0, 0) for _ in range(10)]

No want to make use of i or no matter we would like right here.

With time and expertise, you’ll study that generally it’s tough to resolve whether or not a selected comprehension remains to be understandable or has reached, if not crossed, the too-difficult borderline. In case you’re at a loss, it’s safer to decide on the for loop, as a result of will probably be understood by virtually everybody — whereas not everybody will be capable to perceive a posh listcomp.

Bear in mind, nevertheless, to make the comprehension as simple as attainable. For instance, we did that by transferring some or all the calculations to well-named exterior capabilities (within the instance above, these had been pipeline(), filter_data() and filter_output()). Don’t overuse this method, nevertheless, because it’s extra wordy than a pure comprehension. Extra importantly, it’s seldom a good suggestion to outline capabilities which are used simply as soon as within the code.

The purpose is, anytime you’ve written a comprehension that appears advanced, it is best to analyze it and resolve whether or not it’s simple sufficient to know or not. If not, exchange it with a distinct method. Generally generator pipelines primarily based on perform composition could be a good answer, as proposed right here.

It’s not all the time simple to resolve which comprehension is too advanced. The variety of operations doesn’t must be a very good indicator, as generally a protracted comprehension could be a lot simpler to know than a shorter one, relying on what it goals to realize and the naming used.

Another factor to recollect is {that a} tough comprehension means tough for the typical developer, not tough for you. So, when you’ve got written an especially advanced comprehension that you just perceive with out issues, it doesn’t imply it is best to go for it. This can be the case that you just perceive it since you spent three hours on writing these couple of strains of code! So, keep in mind to make your comprehensions — and code, for that matter — comprehensible to others, too.

The way in which variable scope works in comprehensions makes them completely different from for loops — completely different in a great way: The looping variable utilized in a comprehension is just not seen within the comprehension’s outer scopes, nor does it overwrite variables from outer scopes.

It’ll be simpler to elucidate this utilizing an instance:

>>> x = [i**2 for i in range(10)]
>>> x
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> i
Traceback (most up-to-date name final):
File "<stdin>", line 1, in <module>
NameError: identify 'i' is just not outlined

Do you see what’s occurring? Though we used i as a looping variable contained in the listing comprehension, it’s alive solely inside the scope of this comprehension. It’s not seen outdoors of this scope — it was deleted as soon as the comprehension completed creating the listing.

The looping variable utilized in a comprehension is just not seen within the comprehension’s outer scopes, nor does it overwrite variables from outer scopes.

This isn’t all. Because the under snippet exhibits, you need to use a reputation inside a comprehension even when a variable with the identical identify is utilized in an outer scope. So, there can be two completely different objects with the identical identify on the identical time! However these names can be seen solely of their scopes².

>>> i = "that is i"
>>> x = [i**2 for i in range(10)]
>>> x
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> i
'that is i'

After all, you can not use the outer-scope variable inside a comprehension if the looping variable has the identical identify. In different phrases, you wouldn’t have entry to the outer-scope i from contained in the listing comprehension that makes use of an inner-scope i variable for looping (or for the rest).

Warning: Keep in mind that this rule doesn’t work with variables being assigned utilizing the walrus operator:

>>> i = "that is i"
>>> x = [i for j in range(10) if (i := j**2) < 10]
>>> x
[0, 1, 4, 9]
>>> i
81

As you see, utilizing the walrus operator places the assigned variable (right here, i) within the comprehension’s outer scope.

Another warning. Don’t overuse this characteristic, because the ensuing code can turn out to be tough to learn, like right here:

>>> x = vary(10)
>>> x = [x**2 for x in range(10)]
>>> x
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

This goes too far.

This method to variable scopes makes utilizing comprehensions secure, as you wouldn’t have to fret that the comprehension’s looping variable will overwrite an vital variable. As talked about above, that is not how for loops work:

>>> i = "that is i"
>>> for i in vary(3):
...     print(i)
...
0
1
2
>>> i
2

As you see, in the event you use the identical identify in a for loop, a variable that was named the identical means within the outer scope can be overwritten with the present worth of the looping variable; finally, with its final worth.

One of many points many builders take into account when deciding to make use of syntactic sugar is efficiency. Some say it’s not that vital; others says it’s.

My opinion is someplace in between. Please don’t snort at me, however I feel that efficiency issues when… when efficiency issues. And when it doesn’t, no must take it into consideration.

efficiency issues when… when efficiency issues.

Even when this may increasingly sound slightly humorous, if not silly, it makes excellent sense. If it doesn’t matter whether or not or not your utility is quick, then why must you fear about efficiency? In such a scenario, it’s higher to make use of different elements to decide on coding model, like brevity and readability. Nevertheless, when efficiency does matter, and particularly when it issues so much (as an example, in dashboards) — you’ll be able to optimize your code on the expense of readability.

One other factor that issues is growth time. If it issues, then maybe you shouldn’t spend two full days optimizing the code that will allow you to avoid wasting two seconds of the app execution time.

Okay, now that we all know when to think about efficiency, let’s talk about how performant comprehensions are. Usually, efficiency strongly will depend on the information and the comprehension itself, so if efficiency issues for a selected comprehension, it is best to benchmark this very comprehension (if that is attainable).

Right here, I’ll present you the right way to carry out such benchmarking utilizing the built-in timeit module. You possibly can learn extra about that from this introductory article. You should utilize the snippet under as a template, to conduct your personal benchmarks. Within the close to future, nevertheless, I’ll write one other article, devoted to such benchmarks. They are going to be designed in a means in order that we are able to draw deep conclusions in regards to the efficiency of comprehensions.

# benchmark_comprehension.py
import timeit
def benchmark(code_comprehension: str,
code_alternative: str,
setup: str,
n: int,
rep: int) -> None:
t_comprehension = timeit.repeat(
code_comprehension,
setup=setup,
quantity=n,
repeat=rep
)
t_alternative = timeit.repeat(
code_alternative,
setup=setup,
quantity=n,
repeat=rep
)
print(
"Time for the comprehension :"
f" {spherical(min(t_comprehension), 4)}"
"nTime for the  different : "
f"{spherical(min(t_alternative), 4)}"
"ncomprehension-to-alternative ratio: "
f"{spherical(min(t_comprehension)/min(t_alternative), 3)}"
)
# timeit settings
n = 100
rep = 7
# code
setup = """move"""
code_comprehension = """
for _ in [x**2 for x in range(1_000_000)]:
move
"""
code_alternative = """
for _ in map(lambda x: x**2, vary(1_000_000)):
move
"""
if __name__ == "__main__":
benchmark(code_comprehension, code_alternative, setup, n, rep)

As a way to run this code, use the next shell command (working each in Home windows and Linux):

$ python benchmark_comprehension.py

This may run the benchmarks and print the outcomes to the console. This one, for instance, supplied the next output on my machine:

Time for the comprehension : 20.3807
Time for the choice   : 19.9166
comprehension-to-alternative ratio: 1.023

You possibly can change the next elements of the snippet:

• The setup code → change setup; that is code that’s ran earlier than working the benchmarked code.
• The code → change code_comprehension and code_alternative; word that the code is written in triple quotes, so you’ll be able to break up it into extra strains; you’ll be able to, nevertheless, use one-liners, too.
• The variety of repeats, handed to timeit.repeat() → change rep.
• The variety of occasions to run the code, handed to timeit.repeat() → change n.

(In case you are undecided how quantity and repeat arguments work in timeit.repeat(), you can see this, and extra, in this text.)

I made the code so simple as attainable, which is why I didn’t use command-line arguments; only a naked utility for benchmarking. You possibly can, in fact, enhance it nevertheless you need.

Towards what ought to we benchmark comprehensions?

That is maybe a very powerful query we have to ask earlier than conducting such benchmarks. The plain however unsatisfactory reply is, in opposition to one of the best corresponding method; it’s unsatisfactory as a result of it does not likely reply the query. Let’s take into consideration that.

It’s simple to resolve in opposition to what we must always benchmark generator expressions: map() and filter() and/or their combos, or in opposition to another method returning a generator. The 2 capabilities return map and filter objects, respectively, and they’re mills, similar to generator expressions.

One apparent method to check with is a for loop. We have to keep in mind that in easy eventualities, listing comprehensions can be extra readable than the corresponding for loops; in advanced eventualities, nevertheless, the alternative will often be true.

One other method could be the usage of map() and/or filter(), with the following use of listing(). In that case, nevertheless, bear in mind that this isn’t a pure comparability, as while you want a listing, you employ a listing comprehension, not a generator comprehension.

• Dictionary comprehensions

Like above, we’ve got two most pure variations: the for loop and the map() and/or filter() capabilities. This time, nevertheless, utilizing these two capabilities is slightly tough, as we have to use key-value pairs, so the perform should return them, too. I’ve proven how to do that above, utilizing a wrapper perform. The reality is, nonetheless, that on this regard, dict comprehensions are a lot simpler to make use of right here.

With units, the scenario is nearly the identical as with lists, so use the above recommendations for them.

Some benchmarks

As talked about, we won’t even try to research the efficiency of comprehensions right here, as there’s not a straightforward reply to a query as as to if they’re extra performant than their alternate options. The reply will depend on the context. I need, nevertheless, to shed some gentle on this side of utilizing comprehensions — on the very least to indicate you the fundamentals.

Within the following examples, I’ll present

• the arguments n and rep to be handed to timeit.repeat() as quantity and repeat, respectively;
• setup, code_comprehension and code_alternative from the benchmark snippet supplied above; and
• the output, as formatted within the instance supplied earlier than.

Benchmark 1

n = 1_000_000
rep = 7
# code
size = 10
setup = """move"""
code_comprehension = f"""y = [x**2 for x in range({length})]"""
code_alternative = f"""
y = []
for x_i in vary({size}):
y.append(x_i**2)
"""

Time for the comprehension : 1.6318
Time for the  different : 1.7296
comprehension-to-alternative ratio: 0.943

The outcomes for size = 100 (so for the lists of 100 components) and n = 100_000:

Time for the comprehension : 1.4767
Time for the  different : 1.6281
comprehension-to-alternative ratio: 0.907

Now for size = 1000 (lists of 1000 components) and n = 10_000:

Time for the comprehension : 1.5612
Time for the  different : 1.907
comprehension-to-alternative ratio: 0.819

And finally, for size = 10_000 (lists of 10_000 components) and n = 1000:

Time for the comprehension : 1.5692
Time for the  different : 1.9641
comprehension-to-alternative ratio: 0.799

Within the output, a very powerful component to take a look at is the ratio, because it’s unit-free whereas the occasions within the first two rows are usually not, relying on quantity (n in our case). As you see, the size of the constructed listing makes a distinction: the longer it’s, the comparatively slower the for loop is.

Benchmark 2

We are going to outline a perform size(x: Any) -> int, which

• returns 0 when x is an empty iterable or None;
• returns size of an object when it may be decided; and
• returns 1 in any other case.

Therefore, for instance, a quantity could have the size of 1. We are going to use this perform to create a dictionary that has

• keys being values from the iterable; and
• values being a tuple of the size of an object, as outlined above; and of the rely of this component within the iterable x.

setup = """
def size(x):
if not x:
return 0
attempt:
return len(x)
besides:
return 1
x = [1, 1, (1, 2, 3), 2, "x", "x", 1, 2, 1.1,
"x", 66, "y", 34, 34, "44", 690.222, "bubugugu", "44"]
"""
code_comprehension = """
y = {el: (size(el), x.rely(el)) for el in set(x)}
"""
code_alternative = """
y = {}
for el in set(x):
y[el] = (size(el), x.rely(el))
"""

Time for the comprehension : 0.5727
Time for the  different : 0.5736
comprehension-to-alternative ratio: 0.998

After we made x consisting of 100 x lists, we acquired comprehension-to-alternative ratio: 1.009. As we see, the size of the listing doesn’t matter on this case: each strategies are equally performant — although the dict comprehension is far shorter and stylish, however I feel you could know Python comprehensions to have the ability to respect them.

You should know Python comprehensions to have the ability to respect them.

This may occasionally appear unusual, however it may be tempting to make use of comprehensions even when you don’t want the ensuing object. That is one instance of this:

>>> def get_int_and_float(x):
...     [print(i) for i in x]
...     return [i for i in x if isinstance(i, (int, float))]
>>> y = get_int_and_float([1, 4, "snake", 5.56, "water"])
1
4
snake
5.56
water
>>> y
[1, 4, 5.56]

Be aware what this perform does: it takes an iterable and filters the information, by eradicating these which aren’t of int and float varieties. This use of listing comprehension, which we see within the return line, is simply wonderful. Nonetheless, we are able to see additionally one other listing comprehension used within the perform: [print(i) for i in x]. This listing comprehension solely prints all of the gadgets, and the ensuing listing is neither saved nor used anyhow. So, what was it created for? Do we want it? After all not. We must always use a for loop as an alternative:

>>> def get_int_and_float(x):
...     for i in x:
...         print(i)
...     return [i for i in x if isinstance(i, (int, float))]
>>> y = get_int_and_float([1, 4, "snake", 5.56, "water"])
1
4
snake
5.56
water
>>> y
[1, 4, 5.56]

On this instance, the for loop is a pure method.

It’s a quite simple instance, and it might look slightly too easy. Let‘s take into account one other instance, then. Think about a perform that reads textual content from a file, processes the textual content one way or the other, and writes the output (the processed textual content) to a different file:

import pathlib
def process_text_from(input_path: pathlib.Path
output_path: pathlib.Path) -> None:
# textual content is learn from input_path, as string;
# it's then processed one way or the other;
# the ensuing processed_text object (additionally string)
# is written to an output file (output_path)
def make_output_path(path: pathlib.Path):
return path.mother or father / path.identify.exchange(".", "_out.")

Necessary: Be aware that the process_text_from() perform doesn’t return something.

Subsequent, we have to implement a perform that runs process_text_from() for every component of an iterable of paths, input_paths:

from typing import Checklist
def process_texts(input_paths: Checklist[pathlib.Path]) -> None:
[process_text_from(p, make_output_path(p)) for p in input_paths]

Once more, that is not a completely purposeful listing comprehension: we create a listing that’s neither saved nor used. In case you see one thing like this, it’s a touch that it is best to unlikely use the comprehension. Consider one other method.

Right here, once more, a for loop appears to be the only option:

def process_texts(input_paths: Checklist[pathlib.Path]) -> None:
for p in input_paths:
process_text_from(p, make_output_path(p))

Python is straightforward and readable, or at the very least that is what we’re informed — and that is what most Pythonistas consider it. Each simplicity and readability consequence, at the very least partially, from syntactic sugar the language affords. Maybe probably the most important component of this syntactic sugar is comprehensions.

I affiliate comprehensions with class. They permit us to put in writing concise and readable code — and stylish code. Generally the code is difficult, however often it’s easy — at the very least for many who know Python. That’s why Python novices have issues with understanding comprehensions, and thus appreciating them; and that’s why they begin studying them as quickly as they’ll.

I affiliate comprehensions with class. They permit us to put in writing concise and readable code — and stylish code.

It’s a good suggestion, as a result of comprehensions are in all places in Python code. I can’t think about an intermediate Python developer, to not point out a complicated Python developer, who doesn’t write comprehensions. They’re so pure for Python that there is no such thing as a Python with out comprehensions. No less than I can’t — and don’t need to — think about Python with out them.

This text aimed to introduce Python comprehensions: listing, dictionary and set comprehensions; and generator expressions. The final kind is sort of completely different from the others, so possibly for this reason its identify is so completely different. Generator expressions have related syntax to that of the opposite varieties, however they produce mills. Therefore they deserve their very own article, and I’m going to put in writing it quickly.

Here’s a abstract together with a number of further take-away ideas about comprehensions:

1. Use comprehensions to facilitate the person perceive what the code is accountable for.
2. When you could create a listing, use a listing comprehension, not a distinct kind of comprehension. The identical means, when you could create an object of a selected kind, use the corresponding listing comprehension: dictcomp for a dictionary, setcomp for a set, and generator expression for a generator.
3. Generally it might be tempting to make use of a very difficult comprehension. Some succumb to this temptation, hoping that on this means, they’ll present they’ll write advanced and superior Python code. Resist such temptation at any price. As a substitute of exhibiting off, write clear code; when a comprehension is just not clear, resist the temptation of protecting it within the code anyway. By no means flip your comprehensions into incomprehensions, similar to by no means flip your again on readability.
4. Once you see {that a} comprehension is getting extra difficult than readable, it’s time to consider simplifying the code — both by simplifying the comprehension code, or through the use of another answer. Possibly higher names will do the job? Or splitting the comprehension into a number of strains? Or, in the event you’ve already finished this, possibly you possibly can attempt to change this splitting? If nothing works, attempt a distinct answer. Generally a for loop will work greatest; generally one thing else.
5. In case you select to make use of a comprehension though you already know it’s far too tough, bear in mind that the majority superior programmers will suppose you wished to indicate off. I understand how tempting this may be! I’ve fallen into such temptation extra usually than I’m keen to confess. If solely you’re conscious of this drawback and attempt to combat it off, with time and expertise you’ll discover that it’s simpler to face up to the temptation.
6. In some circumstances, you’ll be able to exchange a very advanced comprehension with a generator pipeline; it’s on this scenario that you’ll present fairly deep understanding of Python programming, not like within the earlier one.
7. Bear in mind how comprehension scope works. Use it in your functions — however don’t overuse it.
8. When engaged on a comprehension, take note of each single element of it. This contains whether or not or not you break up it into extra strains; the variety of strains to separate it to, and the right way to do it; whether or not to make use of if or and; whether or not the comprehension seems visually wonderful; and the like. The consideration of each tiny element of your comprehensions can assist you perceive them much better.
9. Naming is important, for a number of causes: comprehensions are concise and thus delicate, one mistake having the ability to mess the entire comprehension; they usually carry quite a lot of accountability, like making use of a number of capabilities, filtering knowledge and/or output, and looping over an iterable; and they should use at the very least one variable of an area scope (i.e., one that’s restricted to the comprehension’s scope). Thus, it makes a distinction the way you identify your objects inside a comprehension and out of doors of it. Use the next suggestion for naming variables inside comprehensions: use brief and significant names.
10. Don’t use comprehensions when you don’t want the ensuing object.

By no means flip your comprehensions into incomprehensions, similar to by no means flip your again on readability.

¹ In R, the scenario is slightly worse. The built-in Map() perform (from base R) takes a perform as the primary argument and a vector because the second:

> Map(perform(x) x^2, 1:3)
[[1]]
[1] 1
[[2]]
[1] 4
[[3]]
[1] 9

Nevertheless, the purrr::map() perform, rather more standard, particularly amongst dplyr customers, takes the identical arguments however within the reverse order:

> purrr::map(1:3, perform(x) x^2)
[[1]]
[1] 1
[[2]]
[1] 4
[[3]]
[1] 9

It is because while you use the pip operator, %>%, you employ a vector for piping:

> library(dplyr)
> 1:3 %>% purrr::map(perform(x) x^2)

Theoretically, you are able to do this in a reversed order, utilizing Map():

> (perform(x) x^2) %>% Map(1:3)
[[1]]
[1] 1
[[2]]
[1] 4
[[3]]
[1] 9

however it seems unnatural to me.

² If you already know Go, you will have most likely seen the resemblance, as that is how scopes work in Go.