Image by Author | Ideogram
Â
As developers, we often get comfortable with our go-to built-in Python functions and even jump right into writing our own functions for non-trivial tasks. Python’s standard library, however, is packed with some super helpful functions that often fly under the radar.
In this article, we’ll look at a collection of underutilized Python functions that deserve way more spotlight. Let’s get started right away!
🔗 All the code snippets are on GitHub.
Â
1. bisect
Â
Python’s built-in bisect module is super useful when you need to work with sorted sequences. It provides functions for maintaining sorted lists efficiently and finding insertion points quickly.
In this example, we code a practical grade tracking system that shows three key uses of bisect:
- finding insertion points,
- maintaining sorted lists, and
- creating grade boundaries.
from bisect import bisect_left, bisect_right, insort
# Let's create a grade tracking system
grades = [60, 70, 75, 85, 90, 95]
# Find where to insert a new grade while keeping the list sorted
new_grade = 82
position = bisect_left(grades, new_grade)
print(f"Insert 82 at position: position")
# Insert while maintaining sort order
insort(grades, new_grade)
print(f"Grades after insertion: grades")
# Find grade ranges
def grade_to_letter(score):
breakpoints = [60, 70, 80, 90] # F, D, C, B, A
grades="FDCBA"
position = bisect_right(breakpoints, score)
return grades[position]
print(f"Score 82 gets grade: grade_to_letter(82)")
print(f"Score 75 gets grade: grade_to_letter(75)")Â
Output:
Insert 82 at position: 3
Grades after insertion: [60, 70, 75, 82, 85, 90, 95]
Score 82 gets grade: B
Score 75 gets grade: CÂ
This is particularly efficient for use cases where traditional methods would require multiple comparisons.
Â
2. itertools.pairwise
Â
The pairwise function from the itertools module is useful when you need to process consecutive pairs in a sequence. This is particularly useful for analyzing trends or calculating differences.
Let’s take a practical example of temperature analysis. With the pairwise function, we can calculate changes between readings:
from itertools import pairwise
# Let's analyze temperature changes
temperatures = [20, 23, 24, 25, 23, 22, 20]
# Calculate temperature changes between consecutive readings
changes = []
for prev, curr in pairwise(temperatures):
change = curr - prev
changes.append(change)
print("Temperature changes:", changes)Â
Output:
Temperature changes: [3, 1, 1, -2, -1, -2]Â
You can also compute moving averages:
# Calculate moving averages
moving_averages = []
for t1, t2 in pairwise(temperatures):
avg = (t1 + t2) / 2
moving_averages.append(avg)
print("Moving averages:", moving_averages)Â
Output:
Moving averages: [21.5, 23.5, 24.5, 24.0, 22.5, 21.0]Â
And tasks like finding the largest temperature jump:
# Finding the largest temperature jump
max_jump = max(abs(b - a) for a, b in pairwise(temperatures))
print(f"Largest temperature change: max_jump degrees")Â
Output:
Largest temperature change: 3 degreesÂ
This function eliminates the need for complex indexing or manual iteration that often leads to off-by-one errors.
Â
3. statistics.fmean
Â
The fmean function from the built-in statistics module is both faster and more precise than the usual mean(). It’s particularly useful when working with floating-point numbers or large datasets.
from statistics import mean, fmean
import time
# Let's compare fmean with regular mean
# Imagine we're analyzing daily temperature readings
temperatures = [
21.5, 22.1, 23.4, 22.8, 21.8,
23.2, 22.7, 23.1, 22.6, 21.9
] * 100000 # Create a large dataset
# Let's compare speed and precision
start_time = time.perf_counter()
regular_mean = mean(temperatures)
regular_time = time.perf_counter() - start_time
start_time = time.perf_counter()
fast_mean = fmean(temperatures)
fast_time = time.perf_counter() - start_time
print(f"Regular mean: regular_mean:.10f (took regular_time:.4f seconds)")
print(f"fmean: fast_mean:.10f (took fast_time:.4f seconds)")Â
Output:
Regular mean: 22.5100000000 (took 0.4748 seconds)
fmean: 22.5100000000 (took 0.0164 seconds)Â
You’ll notice fmean is significantly faster and maintains precision. The difference is especially beneficial with larger datasets.
Â
4. itertools.takewhile
Â
Itertools module’s takewhile function is useful for processing sequences until a condition is no longer met. It’s a cleaner version of breaking a loop when a condition fails.
Let’s take this example of processing log entries until an error occurs.
from itertools import takewhile
# Processing log entries until an error
log_entries = [
"INFO: System started",
"INFO: Loading data",
"INFO: Processing users",
"ERROR: Database connection failed",
"INFO: Retrying connection",
]
# Get all logs until first error
normal_operation = list(takewhile(
lambda x: not x.startswith("ERROR"),
log_entries
))
print("Logs before first error:")
for entry in normal_operation:
print(entry)Â
Output:
Logs before first error:
INFO: System started
INFO: Loading data
INFO: Processing usersÂ
5. operator.attrgetter
Â
It can often be difficult to efficiently access nested attributes of objects, especially when dealing with large datasets or complex object structures. The attrgetter function solves this by providing a memory-efficient way to retrieve nested attributes and creates reusable accessor functions.
Let’s code an example: a blog article system where we need to sort and access various nested properties:
from operator import attrgetter
from datetime import datetime
# Let's create a simple class to demonstrate
class Article:
def __init__(self, title, author, views, date):
self.title = title
self.author = author
self.stats = type('Stats', (), 'views': views) # Nested attribute
self.date = date
def __repr__(self):
return f"self.title by self.author"
# Create some sample articles
articles = [
Article("Python Tips", "Alice", 1500, datetime(2025, 1, 15)),
Article("Data Science", "Bob", 2500, datetime(2025, 1, 20)),
Article("Web Dev", "Alice", 1800, datetime(2025, 1, 10))
]Â
We can now sort the articles as needed.
# Sort articles by multiple criteria
get_author_views = attrgetter('author', 'stats.views')
# Sort by author and then by views
sorted_articles = sorted(articles, key=get_author_views)
for article in sorted_articles:
print(f"article.author: article.title (article.stats.views views)")
# You can also use it to extract specific attributes
dates = list(map(attrgetter('date'), articles))
print("\nArticle dates:", dates)Â
Output:
Alice: Python Tips (1500 views)
Alice: Web Dev (1800 views)
Bob: Data Science (2500 views)
Article dates: [datetime.datetime(2025, 1, 15, 0, 0), datetime.datetime(2025, 1, 20, 0, 0), datetime.datetime(2025, 1, 10, 0, 0)]Â
Â
6. itertools.chain.from_iterable
Â
When working with nested data structures (lists within lists, or any nested iterables), flattening them efficiently can be challenging.
While list comprehensions are common, they create intermediate lists that consume memory. chain.from_iterable solves this by providing a memory-efficient way to flatten nested structures by creating an iterator.
from itertools import chain
# Let's say we're processing data from multiple sources
sales_data = [
[('Jan', 100), ('Feb', 150)],
[('Mar', 200), ('Apr', 180)],
[('May', 210), ('Jun', 190)]
]
# Flatten the data efficiently
flat_sales = list(chain.from_iterable(sales_data))
print("Flattened sales data:", flat_sales)
# List comprehension approach (creates intermediate list):
flat_list = [item for sublist in sales_data for item in sublist]
# chain.from_iterable approach (generates items one at a time):
flat_iterator = chain.from_iterable(sales_data)Â
Output:
Flattened sales data: [('Jan', 100), ('Feb', 150), ('Mar', 200), ('Apr', 180), ('May', 210), ('Jun', 190)]Â
7. itertools.product
Â
You can use the itertools.product function for generating all possible combinations of input iterables.
Let’s see how the product function can help with generating combinations say you’re building a customization system for a product.
from itertools import product
# Available options for a custom laptop
processors = ['i5', 'i7', 'i9']
ram = ['8GB', '16GB', '32GB']
storage = ['256GB', '512GB', '1TB']
# Generate all possible combinations
configurations = list(product(processors, ram, storage))
print("Possible laptop configurations:")
for config in configurations:
print(f"Processor: config[0], RAM: config[1], Storage: config[2]")Â
Output:
Possible laptop configurations:
Processor: i5, RAM: 8GB, Storage: 256GB
Processor: i5, RAM: 8GB, Storage: 512GB
Processor: i5, RAM: 8GB, Storage: 1TB
Processor: i5, RAM: 16GB, Storage: 256GB
Processor: i5, RAM: 16GB, Storage: 512GB
Processor: i5, RAM: 16GB, Storage: 1TB
Processor: i5, RAM: 32GB, Storage: 256GB
Processor: i5, RAM: 32GB, Storage: 512GB
Processor: i5, RAM: 32GB, Storage: 1TB
.
.
.
Processor: i9, RAM: 32GB, Storage: 256GB
Processor: i9, RAM: 32GB, Storage: 512GB
Processor: i9, RAM: 32GB, Storage: 1TB
Â
This function eliminates the need for nested loops and makes the code more readable and maintainable.
Â
Wrapping Up
Â
Here’s a quick review of all the functions we went over:
- bisect – For maintaining sorted sequences efficiently
- itertools.pairwise – For processing sequential pairs of data
- statistics.fmean – More precise mean calculation
- itertools.takewhile – For processing sequences until a condition is met
- operator.attrgetter – For cleaner access to nested attributes
- itertools.chain.from_iterable – Flattening nested iterables rather cleanly
- itertools.product – Generating all possible combinations
Would you like to add any functions to this list? Let us know in the comments.
Â
Â
Bala Priya C is a developer and technical writer from India. She likes working at the intersection of math, programming, data science, and content creation. Her areas of interest and expertise include DevOps, data science, and natural language processing. She enjoys reading, writing, coding, and coffee! Currently, she’s working on learning and sharing her knowledge with the developer community by authoring tutorials, how-to guides, opinion pieces, and more. Bala also creates engaging resource overviews and coding tutorials.