Intermediate Python and Scalable Software Design
Idiomatic Pythonic Patterns
Beyond the Basics
You know how to write Python code that works. Now, let's write Python code that feels like Python. This is often called writing “Pythonic” code. It’s about using the language's features to create solutions that are not just functional, but also readable, efficient, and elegant.
At its heart, Pythonic code follows a philosophy. A long-time Python developer named Tim Peters wrote a set of 19 guiding principles for Python's design. They're known as and can be revealed by running import this in a Python interpreter. We'll explore how to put these ideas into practice.
Elegant Loops with Comprehensions
A common task is creating a new list based on an existing one. You're likely familiar with initializing an empty list and using a for loop to append new elements.
# The traditional way
squares = []
for i in range(10):
squares.append(i * i)
# squares is now [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
This works perfectly fine, but it takes up four lines of code to express a simple idea. Python offers a more concise and readable way to do this: a list comprehension.
# The Pythonic way
squares = [i * i for i in range(10)]
Notice how it reads almost like plain English: "make a list of i * i for each i in the range of 10." This pattern is powerful and can even include conditional logic.
This same concept applies to creating sets and dictionaries.
# A set comprehension (notice the curly braces)
# This creates a set of unique squared values for numbers from -5 to 5
unique_squares = {x**2 for x in range(-5, 6)}
# {0, 1, 4, 9, 16, 25}
# A dictionary comprehension
# This creates a dictionary mapping each number to its square
num_to_square = {x: x**2 for x in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
Generators for Memory Efficiency
Comprehensions are great, but they build the entire collection in memory at once. What if you're working with millions of items? Storing them all could consume a lot of RAM.
This is where generator expressions shine. They look almost identical to list comprehensions, but they use parentheses instead of square brackets. The key difference is they use —they generate values one at a time, on demand, rather than all at once.
# A generator expression
squares_generator = (i * i for i in range(1000000))
# The generator object itself uses very little memory
# print(squares_generator)
# <generator object <genexpr> at 0x...>
# Values are computed only when you iterate over it
for num in squares_generator:
if num > 100:
print(f"First square over 100 is {num}")
break # We stop, and the rest are never computed
By yielding items one by one, generators allow you to process data streams that wouldn't even fit in memory. It's a powerful tool for writing efficient data processing pipelines.
Context and Truthiness
Pythonic code often leverages built-in behaviors to simplify logic. One such behavior is the concept of "truthiness."
In a boolean context, like an if statement, many objects have an inherent true or false value. For example, any empty collection (list, dictionary, set, string) is considered False. Any non-zero number is True.
my_list = []
# Un-Pythonic check
if len(my_list) == 0:
print("List is empty.")
# Pythonic check
if not my_list:
print("List is empty.")
Relying on truthiness makes your code cleaner and more direct.
Another key Pythonic pattern is the use of with the with statement. This is most commonly seen when working with files. A context manager automates the setup and teardown of resources, ensuring they are properly handled even if errors occur.
# Old way, requires explicit cleanup
try:
f = open('my_file.txt', 'w')
f.write('Hello, world!')
finally:
f.close()
# Pythonic way, with automatic cleanup
with open('my_file.txt', 'w') as f:
f.write('Hello, world!')
# The file is automatically closed here
The with statement is clearer, less error-prone, and encapsulates the resource management logic neatly.
Time to check your understanding of these concepts.
What is the primary advantage of using a generator expression like (i for i in big_list) over a list comprehension [i for i in big_list] when big_list contains millions of items?
Which of the following is the most "Pythonic" way to create a new list containing the squares of even numbers from an existing list called numbers?
Adopting these patterns will make your code more efficient, readable, and maintainable—in short, more Pythonic.