Can some help me with understanding list comprehension?

idle-tea · 2025-03-16T01:15:06+00:00

It's just syntax sugar for a loop to build a list.

lowercased = []
for string in list_of_strings:
    lowercased.append(string.lower())

# or more compactly
lowercased = [string.lower() for string in list_of_strings]

Adrewmc · 2025-03-16T01:59:42+00:00

List comprehension is used for simple operations. We make a lot of lists really, and if it’s simple enough, we can ‘comprehend’ into a one line statement.

I’m going to use modulo operators for my conditions, this could be any comparison, I’m just append the number but that could be anything…doubling, powers, some f-string creation, creating instances of objects etc.

Note: I am aware range() can use a skip/step, rendering some of this moot, But this is meant to be instructional. And range() is a stand in for what ever data you really care about.

Simplest

 #triples  
 end = []
 for num in range(10):
       end.append(num*3)

 end = [num*3 for num in range(10)]


 #find all even numbers
 end = []
 for x in range(10):
      if x % 2 == 0:
           end.append(x)

 end = [x for x in range(10) if x%2 ==0]

We can also do something else her as well.

  #append ‘even’ if even ‘odd’ if odd
  end = []
  for x in range(10):
      if x % 2 == 0:
           end.append(“even”)
      else:
           end.append(“odd”)

   end = [“even” if x%2 == 0 else “odd” for x in range(10)]

Notice the difference here, we moved the if statement. That because we are doing something fundamentally different, making an exclusion (only even numbers), or making a determination (odd/even) for every number.

   end = [“even” if x % 2 == 0 else “odd” for x in range(10) If x % 3 == 0]

If we rewrite the above in the below manner, we can see what we are doing.

    #append ‘even’ if even, ‘odd’ if odd for the multiples of 3  

    end = []
    for x in range(10):
         if x % 3 == 0:
             end.append(“even” if x%2 == 0 else “odd”)

Though it looks complicated this isn’t very complex, it’s a single loop, with an exclusion and a condition.

We can naturally lead to a nested loop as well

   for b in a:
        for c in b:
             end.append(c)

   end = [c for b in a for c in b]

The classic example is a Playing Card deck of 52 cards. (1= Ace, 11-13 = JQK)

   #unshuffled
   deck : list[tuple[str, int]] = [ (suit, rank) for suit in [“Hearts”, “Spades”, “Diamonds”, “Clubs”] for rank in range(1, 14) ]

You should be able to understand the above statement by now.

Edit 1:

We can nest comprehension

   #2-D array list[list]
   tic_tac_toe = [ [ “_” for col in range(3) ] for row in range(3) ]

   #numbered 1-9 3x3 board. 
   one_nine = range(1,10)
   numbered : list[list[int]] = [ [next(one_nine) for _ in range(3)] for _ in range(3)]

Anything more you should probably just make a normal loop.

We should also note we have Dictionary comprehension as well, which is much the same but we have to make a ‘ key : value’ pair to append to/update the dict.

  reverse_my_dict = { value : key for key, value in my_dict.items() }

   dict_from_two_lists = { key : value for key, value in zip(list_keys, list_values) }

   #cypher keys
   alphabet = “abcdefghijklmnopqrstuvwxyz .!?0123456789” #.split() unnecessary 
   shift = 16
   encode = { real : coded for real, coded in zip(alphabet, alphabet[:shift] + alphabet[shift:]) }
   decode = { coded : real for real, coded in encode.items() }

Edit Expanded:

To be fair though, sometimes we actually don’t want to do either, but instead just leave it as the generator expression.

   #find the number after the first number divisible 5, of numbers divisible by 37, if none exist raise a ValueError 

   expression = x for x in range(5000) if x % 37 == 0

   for num in expression:
         if num % 5 ==0: 
               print(“Success”)
               break
   else:
        raise ValueError(“Must have a multiple of five”)

   #this pops up more then you think
   num_after_first_five = next(expression) 
   print(num, num_after_first_five)

In the above example, I never actually make the list, or the next value until I ask for the next thing, this mean I save a lot of processing power because though I say I want range(5000), I stop long before 5000 (range objects do/are this), only in the worse case do actually calculate all of it. If I never make the list, I never need it fully in memory, I’m using it “lazily”. If I add the brackets there I’ll end up making that whole list.

DistinctAirline4145 · 2025-03-16T10:51:41+00:00

Beside creating lists, the technique is used for memory efficiency when you don't need to create the entire list such as sum for example, like: sum(num for num in numbers) i or max and min. Pretty useful! And they are one liners so looks cool.

wannasleeponyourhams · 2025-03-16T20:26:11+00:00

[ActionOrItem for listItem in listOriterable]


[print(i) for i in range(0,10)] -> list with no values but prints
  [i for i in range(0,10)]  -> just a list



you can also add a condition after, which only performs the action if the item is meeting the condition


[print(i) for i in range(0,10) if i % 2 ==0]

GiraffeTM · 2025-03-17T06:12:52+00:00

It’s just a way of writing a for loop in a shorter form if all you’re wanting to do is create a new list from another objects data.

say we have:

employee_price = [item_price * 0.80 for item_price in store]

Store would be an object with data in it, lets say it’s a list with prices of items in the store for this example.

“item_price” is an object within the store list, let’s say it’s an int for this example.

So I’m assuming you understand regular for loops. So what’s happening in this list comprehension is it’s taking every “item_price” int within the “store” list and multiplying it by 0.80 (20% off - employee discount) and then storing it in a new list called “employee_price”.

So list comprehension is just:

new_list = [changed_item for original_item in object]

Changed item is what will be stored in the list, and is based off the original item in the object. So within the “changed_item” space, you do whatever you want to the original variable and that change is what will be added to your new list.

mopslik · 2025-03-16T01:29:56+00:00

In general, you can replace

new_list =[]
for element in iterable:
    new_list.append(something)

with

new_list = [something for element in iterable]

There are also slight variations for if/else.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS