Picture by Creator | Ideogram
Python’s commonplace library has a number of utilities that may remodel your code from clunky and verbose to elegant and environment friendly. Amongst these, the functools and itertools modules usually are available in tremendous useful for non-trivial duties.
Right now, we’ll have a look at seven important instruments — features and interior decorators — from these modules that’ll make your Python code higher.
Let’s get began.
🔗 Hyperlink to the code on GitHub
1. functools.lru_cache
You should utilize the @lru_cache decorator to cache operate outcomes, and to keep away from repeating costly operations.
Right here’s an instance:
from functools import lru_cache
@lru_cache(maxsize=128)
def fetch_user_data(user_id):
# Costly database name
return database.get_user(user_id)
# First name hits database, subsequent calls use cache
consumer = fetch_user_data(123) # Database name
consumer = fetch_user_data(123) # Returns cached end result
The way it works: The @lru_cache decorator shops ends in reminiscence. When fetch_user_data(123) is named once more, it returns the cached end result as a substitute of hitting the database. maxsize=128 retains the 128 most up-to-date outcomes.
2. itertools.chain
To course of a number of iterables as one steady stream, you should use chain.from_iterable() from the itertools module.
Let’s take an instance:
from itertools import chain
# Course of a number of log recordsdata as one stream
error_logs = ['app.log', 'db.log', 'api.log']
all_lines = chain.from_iterable(open(f) for f in error_logs)
error_count = sum(1 for line in all_lines if 'ERROR' in line)
The way it works: chain.from_iterable() takes a number of iterables and creates one steady stream. It reads one line at a time.
3. functools.partial
Partial features in Python are tremendous useful when it’s essential to create specialised variations of features. That means you’d wish to create variations of the operate with some arguments already set utilizing partial from the functools module.
This is an instance of a partial operate:
from functools import partial
import logging
def log_event(degree, part, message):
logging.log(degree, f"[{component}] {message}")
# Create specialised loggers
auth_error = partial(log_event, logging.ERROR, 'AUTH')
db_info = partial(log_event, logging.INFO, 'DATABASE')
# Clear utilization
auth_error("Login failed for consumer")
db_info("Connection established")
The way it works: partial creates a brand new operate with some arguments pre-filled. Within the instance, auth_error is basically log_event with degree and part already set, so that you solely want to supply the message.
4. itertools.combos
When it’s essential to generate all potential combos of things for testing or optimization, you should use combos from the itertools module.
Take into account the next instance:
from itertools import combos
options = ['cache', 'compression', 'cdn']
# Take a look at all pairs of options
for combo in combos(options, 2):
efficiency = test_feature_combo(combo)
print(f"{combo}: {efficiency}ms")
The way it works: combos(options, 2) generates all potential pairs from the record. It creates combos on-demand with out storing all of them in reminiscence, making it environment friendly for giant datasets.
5. functools.singledispatch
The @singledispatch decorator from the functools module will help you make features that act in another way primarily based on enter sort.
Have a look at the next code snippet:
from functools import singledispatch
from datetime import datetime
@singledispatch
def format_data(worth):
return str(worth) # Default
@format_data.register(datetime)
def _(worth):
return worth.strftime("%Y-%m-%d")
@format_data.register(record)
def _(worth):
return ", ".be a part of(str(merchandise) for merchandise in worth)
# Routinely picks the precise formatter
print(format_data(datetime.now())) # this outputs "2025-06-27"
print(format_data([1, 2, 3])) # this outputs "1, 2, 3"
The way it works: Python checks the kind of the primary argument and calls the suitable registered operate. Nevertheless, it makes use of the default @singledispatch operate if no particular handler exists.
6. itertools.groupby
You’ll be able to group consecutive parts that share the identical property utilizing the groupby operate from itertools.
Take into account this instance:
from itertools import groupby
transactions = [
{'type': 'credit', 'amount': 100},
{'type': 'credit', 'amount': 50},
{'type': 'debit', 'amount': 75},
{'type': 'debit', 'amount': 25}
]
# Group by transaction sort
for trans_type, group in groupby(transactions, key=lambda x: x['type']):
whole = sum(merchandise['amount'] for merchandise in group)
print(f"{trans_type}: ${whole}")
The way it works: groupby teams consecutive gadgets with the identical key. It returns pairs of (key, group_iterator). Necessary: it solely teams adjoining gadgets, so kind your knowledge first if wanted.
7. functools.cut back
You should utilize the cut back operate from the functools module to use a operate cumulatively to all parts in an iterable to get a single worth.
Take the next instance:
from functools import cut back
# Calculate compound curiosity
monthly_rates = [1.01, 1.02, 0.99, 1.015] # Month-to-month development charges
final_amount = cut back(lambda whole, price: whole * price, monthly_rates, 1000)
print(f"Ultimate quantity: ${final_amount:.2f}")
The way it works: cut back takes a operate and applies it step-by-step: first to the preliminary worth (1000) and the primary price, then to that end result and the second price, and so forth. It really works effectively for operations that construct up state.
Wrapping Up
To sum up, we’ve seen how you should use:
@lru_cachewhen you’ve features which can be referred to as usually with the identical argumentsitertools.chainwhen it’s essential to course of a number of knowledge sources as one steady streamfunctools.partialto create specialised variations of generic featuresitertools.combosfor systematic exploration of potentialities@singledispatchwhile you want type-based operate conductgroupbyfor environment friendly consecutive grouping operationscut backfor complicated aggregations that construct up state
The subsequent time you end up writing verbose loops or repetitive code, pause and take into account whether or not certainly one of these may present a extra elegant answer.
These are only a handful of instruments I discover useful. There are a lot of extra in the event you take a more in-depth have a look at the Python commonplace library. So yeah, glad exploring!
Bala Priya C is a developer and technical author from India. She likes working on the intersection of math, programming, knowledge science, and content material creation. Her areas of curiosity and experience embody DevOps, knowledge science, and pure language processing. She enjoys studying, writing, coding, and low! At present, she’s engaged on studying and sharing her data with the developer neighborhood by authoring tutorials, how-to guides, opinion items, and extra. Bala additionally creates participating useful resource overviews and coding tutorials.
