We’ve now learned two powerful syntaxes for creating sequences: list comprehensions (Post #120), which build a full list in memory, and generator expressions (Post #127), which create a “lazy” generator object. We know that generators are the clear winner for memory usage, especially with large datasets. But what about speed? Is one always faster than … Read more
In Post #127, we learned about generator expressions, a concise, one-line syntax for creating generators. They are perfect for simple, lazy iteration. But what happens when the logic for generating your sequence is too complex for a single line? What if it requires if statements, helper variables, or other multi-line logic? For these situations, Python … Read more
In Post #126, we were introduced to generators as a memory-efficient solution for working with large sequences. We saw how the built-in range() function allows us to loop over millions of numbers without storing them all in memory. But how do we create our own custom generators? The simplest way is with a generator expression. … Read more
In Post #125, we discovered the major drawback of lists: when they get very large, they consume a huge amount of memory and can be slow to create. We called this “eager evaluation” because the entire list is built before we can use a single item from it. The solution to this problem is “lazy … Read more
In our recent posts on comprehensions (Posts #120 Post #121 Post #122 Post #123 Post #124), we celebrated them as a powerful way to create new lists. The pattern of building a full list of results in memory is simple and works wonderfully for most everyday tasks with a few hundred or even a few … Read more
In our last few posts, we’ve celebrated comprehensions as a concise, powerful, and “Pythonic” way to create lists, sets, and dictionaries. It can be tempting to see them as a superior replacement for every for loop. However, the most important principle of Pythonic code is readability. Sometimes, a comprehension can be too clever, becoming so … Read more
In the last few posts, we’ve seen how powerful list comprehensions are for creating new lists in a single, readable line (Post #120, Post #121, Post #122). This concise syntax is so useful and “Pythonic” that the language provides a similar structure for its other main collection types: sets and dictionaries. In this post, we’ll … Read more
In Post #121, we learned how to add an if clause to the end of a list comprehension to filter items. This is great for deciding whether to include an item in the new list. But what if we want to include every item from the original list, but transform each one differently based on … Read more
In Post #120, we were introduced to the power of list comprehensions for creating a new list by applying an expression to every item in an existing one, like [x**2 for x in numbers]. But what if we don’t want to include every item? What if we only want to apply the expression to items … Read more
A very frequent task in programming is to create a new list by performing an operation on every item in an existing list. For example, you might want to create a list of squared numbers from an original list of numbers, or a list of uppercased names from a list of lowercase names. While you … Read more