Programmer's Python Data - Comprehensions
Written by Mike James   
Monday, 30 May 2022
Article Index
Programmer's Python Data - Comprehensions
Using Comprehensions

Comprehend comprehensions in this extract from my new book Programmer's Python: Everything is Data.

Programmer's Python
Everything is Data

Is now available as a print book: Amazon


  1. Python – A Lightning Tour
  2. The Basic Data Type – Numbers
       Extract: Bignum
  3. Truthy & Falsey
  4. Dates & Times
  5. Sequences, Lists & Tuples
  6. Strings
  7. Regular Expressions
  8. The Dictionary
  9. Iterables, Sets & Generators
  10. Comprehensions
       Extract  Comprehensions ***NEW!!!
  11. Data Structures & Collections
  12. Bits & Bit Manipulation
  13. Bytes
  14. Binary Files
  15. Text Files
  16. Creating Custom Data Classes
  17. Python and Native Code
    Appendix I Python in Visual Studio Code
    Appendix II C Programming Using Visual Studio Code
Advanced Attributes


Comprehensions are a simple but powerful idea and are perhaps the most Pythonic idioms. They are a way of writing a for loop as a simpler, shorter expression. They start off from a simple way of initializing iterables, but they provide an alternative approach to some aspects of functional programming and prove useful in many unexpected ways.

Simple Comprehensions

A problem common to all computer languages is how to initialize data structures without having to write everything out explicitly. For example, suppose you want a list that contains the integers one to ten. One way to do the job is:

myList = [1,2,3,4,5,6,7,8,9,10]

which works for one to ten but what about one to ten hundred or one to ten million?

A better way is to use a for loop:

myList = []
for i in range(1,11):

This sort of initialization is so common that Python has a shorthand way of writing the for loop:

myList=[i for i in range(1,11)]

This is a comprehension and you can see that it is equivalent to the for loop given above.

In general, a Python comprehension takes the form:

expression for variable in iterable if condition

The final part, starting at the if, is optional and most comprehensions don’t use it. The comprehension is a shorthand for:

for variable in iterable:
	if condition:

Our earlier example fits this pattern:

expression      variable        iterable 
     i      for    i      in  range(1,11)

What happens is that the expression is evaluated for each value of the variable in the iterable. If there is a conditional part then the output only includes that value of the expression if the condition evaluates to true.

A comprehension generates elements that can be assigned to an object. At the moment Python supports four types of object assignments:


  • List comprehension

The values of the expression are used to create a list:

myList = [i for i in range(1,11)]

This creates a list [1,2,3,4,5,6,7,8,9,10]


  • Set comprehension

The values of the expression are used to create a set:

mySet = {i for i in range(1,11)} 

This creates the set {1,2,3,4,5,6,7,8,9,10}


  • Dictionary comprehension

The values of the expression are used to form key value pairs in a dictionary:

myDict = {i:2*i for i in range(1,11)}

This creates the dictionary:

{1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6:
12, 7: 14, 8: 16, 9: 18, 10: 20}


  • Generator comprehension

The comprehension is used to create a generator that produces the values of the expression:

myGen = (i for i in range(1,11))

This creates a generator object that returns the elements 1,2,3,4,5,6,7,8,9,10 each time it is called using next or when its __next__ method is called. Notice that the range function is called so that it returns an iterator which is used in the comprehension to create a generator object.

The list and set comprehensions are unsurprising. The dictionary comprehension is slightly different in that the expression takes the form key:value and key and value can be expressions in their own right. Finally the generator comprehension is different because it doesn’t create a data object such as a list, set or dictionary but a generator object, which creates each element of the iteration on the fly. That is, a generator comprehension effectively creates a function that generates the iteration rather than storing the elements concerned – this means it is lazy-evaluated. Notice that as this is a generator object, it is not callable. It is an iterator and you can use next, __next__ or __iter__ on it.

Also notice that what type of object you create depends on the type of brackets you put around the comprehension. That is [comprehension] is a list, {comprehension} is a set or a dictionary depending whether or not the expression includes a key, and (comprehension) is a generator object.

Last Updated ( Monday, 30 May 2022 )