Python Tips

An instance-level method requires instantiating a class object to operate, while a class method doesn’t.

Class methods can provide alternate ways to construct objects. In the code below, the from_csv class method instantiates the class by reading data from a CSV file.

Having multiple function parameters can make code hard to maintain and prone to errors. In this article, we will explore how to simplify function parameters using dataclasses.

What are Dataclasses?

Dataclasses are a simple way to create classes that primarily hold data. They provide a simple syntax for creating classes, making them ideal for grouping related data into simple data structures.

The Problem: Multiple Function Parameters

We will start by creating two different datasets.

import numpy as np
import matplotlib.pyplot as plt

# Generate sample time series data
np.random.seed(42)

# Dataset 1: Stock-like price movements
n_points = 100
trend1 = np.linspace(100, 150, n_points)
noise1 = np.cumsum(np.random.normal(0, 1, n_points))
stock_prices = trend1 + noise1

# Dataset 2: Seasonal pattern with noise
t = np.linspace(0, 4*np.pi, n_points)
seasonal_data = 10 * np.sin(t) + np.random.normal(0, 1, n_points)

Now, let’s define the plot_time_series function using many arguments.

def plot_time_series(
data,
x_label: str,
y_label: str,
title: str,
line_color: str = "blue",
line_width: float = 1.5,
marker: str = "o",
marker_size: int = 6,
grid: bool = True,
):
plt.style.use("dark_background")
plt.plot(
data,
color=line_color,
linewidth=line_width,
marker=marker,
markersize=marker_size,
)
plt.xlabel(x_label)
plt.ylabel(y_label)
plt.title(title)
if grid:
plt.grid(True)
plt.show()

Reusing this function for different datasets requires passing the same arguments for the line color, line width, marker, marker size, and grid for both datasets, which can be error-prone and difficult to maintain.

plot_time_series(
data=stock_prices,
x_label="Trading Days",
y_label="Stock Price ($)",
title="Simulated Stock Price Movement",
line_color="#72BEFA",
line_width=1.5,
marker=".",
marker_size=8,
grid=True,
)

plot_time_series(
data=seasonal_data,
x_label="Time",
y_label="Amplitude",
title="Seasonal Pattern with Noise",
line_color="#72BEFA",
line_width=1.5,
marker=".",
marker_size=8,
grid=True,
)

The Solution: Dataclasses

With Dataclasses, we can group styling parameters into a PlotStyle dataclass.

from dataclasses import dataclass

@dataclass
class PlotStyle:
line_color: str = "#72BEFA"
line_width: float = 1.5
marker: str = "."
marker_size: int = 8
grid: bool = True

Then modify the plot_time_series function to accept a PlotStyle object.

def plot_time_series(
data, x_label: str, y_label: str, title: str, style: PlotStyle = PlotStyle()
):
plt.plot(
data,
color=style.line_color,
linewidth=style.line_width,
marker=style.marker,
markersize=style.marker_size,
)
plt.xlabel(x_label)
plt.ylabel(y_label)
plt.title(title)
if style.grid:
plt.grid(True)
plt.show()

Now we can create a custom style once and reuse it for multiple plots.

custom_style = PlotStyle(line_color="#E583B6", marker=".", marker_size=8)

plot_time_series(stock_prices, "Time", "Value 1", "Plot 1", custom_style)

plot_time_series(seasonal_data, "Time", "Value 2", "Plot 2", custom_style)

By using dataclasses, we can avoid passing multiple arguments to the function and make the code more maintainable.
Favorite

If you want to apply a common piece of functionality to multiple functions while keeping the code clean, use decorator. Decorator modifies the behavior of your Python functions without altering the code directly.

In the code above, time_func is a decorator that can be used to track the execution time of any function.

Before Python 3.9, merging two dictionaries without modifying the originals required using asterisks, which, although effective, can diminish code readability.

In Python 3.9, the | operator enables a more readable approach to merging dictionaries.

The Problem with Multiple If-Else Statements

When working with Python dictionaries, you often need to access values that may not exist. The traditional approach of using multiple nested if-else statements can result in repetitive code that’s harder to maintain and more prone to errors.

Let’s consider an example where we have a dictionary user_data with keys “name”, “age”, and possibly “email”. We want to assign default values to these keys if they don’t exist.

# Checking dictionary values with multiple if-else
user_data = {"name": "Alice", "age": 30}

# Repetitive code with multiple default values
if "name" in user_data:
name = user_data["name"]
else:
name = "Unknown"

if "age" in user_data:
age = user_data["age"]
else:
age = 0

if "email" in user_data:
email = user_data["email"]
else:
email = "no-email@example.com"

print(f"{name=}")
print(f"{age=}")
print(f"{email=}")

Output:

name='Alice'
age=30
email='no-email@example.com'

As you can see, this approach is tedious and prone to errors.

A Cleaner Approach with the .get() Method

With the .get() method, we can access dictionary values with default values in a single line of code. This approach is not only more concise but also more readable and maintainable.

# Using .get() method for cleaner code
user_data = {"name": "Alice", "age": 30}

# Concise way to handle missing values
name = user_data.get("name", "Unknown")
age = user_data.get("age", 0)
email = user_data.get("email", "no-email@example.com")

print(f"{name=}")
print(f"{age=}")
print(f"{email=}")

Output:

name='Alice'
age=30
email='no-email@example.com'

Conclusion

In conclusion, the .get() method is a powerful tool for simplifying dictionary value access with default values. By using this method, you can write more concise, readable, and maintainable code.
Favorite

Debugging code can be a tedious and time-consuming task, but having a clear traceback can greatly speed up the process. Python 3.11 introduces fine-grained error locations in tracebacks, allowing developers to quickly identify the exact location of errors.

In this post, we’ll explore the difference in traceback between Python 3.9 and Python 3.11 using an example.

Example Code

Let’s consider the following Python code with a typo in the variable name:

def greet(name):
greeting = "Hello, " + name + "!"
print(greetng) # Error: Typo in variable name

greet("Khuyen")

Traceback in Python 3.9

When we run this code in Python 3.9, we get the following traceback:

Traceback (most recent call last):
File "/Users/khuyentran/book/Efficient_Python_tricks_and_tools_for_data_scientists/Chapter1/trackback_test.py", line 5, in <module>
greet("Khuyen")
File "/Users/khuyentran/book/Efficient_Python_tricks_and_tools_for_data_scientists/Chapter1/trackback_test.py", line 3, in greet
print(greetng) # Error: Typo in variable name
NameError: name 'greetng' is not defined

Traceback in Python 3.11

Now, let’s run the same code in Python 3.11:

Traceback (most recent call last):
File "/Users/khuyentran/book/Efficient_Python_tricks_and_tools_for_data_scientists/Chapter1/trackback_test.py", line 5, in <module>
greet("Khuyen")
File "/Users/khuyentran/book/Efficient_Python_tricks_and_tools_for_data_scientists/Chapter1/trackback_test.py", line 3, in greet
print(greetng) # Error: Typo in variable name
^^^^^^^
NameError: name 'greetng' is not defined. Did you mean: 'greeting'?

As you can see, Python 3.11 provides a more detailed traceback with fine-grained error locations. The ^^^^^^^ symbol points to the exact location of the error, making it easier to identify and fix the issue. Additionally, Python 3.11 suggests a possible correction, which can be helpful in cases where the error is due to a typo.
Favorite