Python list comprehension expensive

by

You are never calling your squares function, so it is not doing anything.

List comprehensions are in fact faster:

>>> import timeit
>>> def squares(values):
...     lst = []
...     for x in range(values):
...         lst.append(x*x)
...     return lst
... 
>>> def squares_comp(values):
...     return [x*x for x in range(values)]
... 
>>> timeit.timeit('f(10)', 'from __main__ import squares as f')
3.9415171146392822
>>> timeit.timeit('f(10)', 'from __main__ import squares_comp as f')
2.3243820667266846

If you use the dis module to look at the bytecode for each function, you can see why:

>>> import dis
>>> dis.dis(squares)
  2           0 BUILD_LIST               0
              3 STORE_FAST               1 (lst)

  3           6 SETUP_LOOP              37 (to 46)
              9 LOAD_GLOBAL              0 (range)
             12 LOAD_FAST                0 (values)
             15 CALL_FUNCTION            1
             18 GET_ITER            
        >>   19 FOR_ITER                23 (to 45)
             22 STORE_FAST               2 (x)

  4          25 LOAD_FAST                1 (lst)
             28 LOAD_ATTR                1 (append)
             31 LOAD_FAST                2 (x)
             34 LOAD_FAST                2 (x)
             37 BINARY_MULTIPLY     
             38 CALL_FUNCTION            1
             41 POP_TOP             
             42 JUMP_ABSOLUTE           19
        >>   45 POP_BLOCK           

  5     >>   46 LOAD_FAST                1 (lst)
             49 RETURN_VALUE        
>>> dis.dis(squares_comp)
  2           0 BUILD_LIST               0
              3 LOAD_GLOBAL              0 (range)
              6 LOAD_FAST                0 (values)
              9 CALL_FUNCTION            1
             12 GET_ITER            
        >>   13 FOR_ITER                16 (to 32)
             16 STORE_FAST               1 (x)
             19 LOAD_FAST                1 (x)
             22 LOAD_FAST                1 (x)
             25 BINARY_MULTIPLY     
             26 LIST_APPEND              2
             29 JUMP_ABSOLUTE           13
        >>   32 RETURN_VALUE

The squares function looks up the .append() method of the list in each iteration, and calls it. The .append() function has to grow the list by one element each time it is called.

The list comprehension on the other hand doesn’t have to do that work. Instead, python uses the LIST_APPEND bytecode, which uses the C API to append a new element to the list, without having to do the lookup and a python call to the function.

More Related Contents:

  1. List Comprehension with if statement and append – Phyton [closed]
  2. List comprehensions
  3. Accessing class variables from a list comprehension in the class definition
  4. How to find all occurrences of an element in a list
  5. Create a dictionary with comprehension
  6. Python Dictionary Comprehension
  7. Are for-loops in pandas really bad? When should I care?
  8. Pythonic way to print list items
  9. Understanding nested list comprehension
  10. List comprehension with if statement
  11. recursive iteration through nested json for specific key in python
  12. How to unzip a list of tuples into individual lists? [duplicate]
  13. What is the advantage of a list comprehension over a for loop?
  14. How to recursively find specific key in nested JSON?
  15. List comprehension and lambdas in Python [duplicate]
  16. How to handle exceptions in a list comprehensions?
  17. Single Line Nested For Loops [duplicate]
  18. Add an element in each dictionary of a list (list comprehension)
  19. Why is one class variable not defined in list comprehension but another is?
  20. Is it possible to access current object while doing list/dict comprehension in Python?
  21. Nested list comprehensions
  22. Nested dictionary comprehension python
  23. Change values in dict of nested dicts using items in a list?
  24. List with duplicated values and suffix
  25. Python list comprehension – want to avoid repeated evaluation
  26. Name is not defined in a list comprehension with multiple loops
  27. Why do list comprehensions write to the loop variable, but generators don’t? [duplicate]
  28. How do I convert a tuple of tuples to a one-dimensional list using list comprehension? [duplicate]
  29. Line continuation for list comprehensions or generator expressions in python
  30. Optimal method to find the max of sublist items within list

Leave a Comment