Python Context Variables: A Better Alternative to Thread Locals

In this article, we’ll explore Python’s new Context Variables (ContextVars) feature, which provides a better alternative to thread locals for sharing data between functions in a more elegant and efficient way. We’ll also discuss the limitations of using thread locals and how they can cause problems with debugging and testing.

Thread Locals: The Old Way
In the past, we used global variables or thread locals to share data between functions without making it a global variable. However, this approach has some drawbacks. First, it’s not very efficient because of dictionary lookups for every access. Secondly, thread locals can cause problems with debugging and testing because it’s hard to see what values are being used in each context.

Enter Context Variables (ContextVars). They provide a more elegant and efficient way of sharing data between functions without having to worry about thread safety or dictionary lookups. Instead, they use a context manager to associate some data with the current execution context. This allows you to share data between functions without having to explicitly set it in each function.

To create a Context Variable, define it as follows:

# Import the necessary modules
from contextlib import contextmanager # Import the contextmanager function from the contextlib module
import weakref # Import the weakref module

# Define a class for creating Context Variables
class MyContextVar(contextmanager): # Inherit from the contextmanager class
    def __init__(self, name): # Define the constructor method with the name parameter
        self.name = name # Set the name attribute to the given name
        self._value = None # Initialize the value attribute to None
        self.__dict__['_weakrefs'] = set() # Create a dictionary to store weak references
    
    def __del__(self): # Define the destructor method
        for ref in list(self._weakrefs): # Loop through the weak references
            try:
                del ref().context[self.name] # Delete the context variable associated with the current name
            except KeyError: # Handle the KeyError exception
                pass # Do nothing
        
    def __enter__(self): # Define the enter method
        if self._value is None: # Check if the value attribute is None
            self._value = weakref.ProxySet() # Create a weak reference set
        return self._value.__setitem__(threading.current_thread(), {}) # Set the value for the current thread
    
    def __exit__(self, exc_type, exc_val, exc_tb): # Define the exit method
        del self._value[threading.current_thread()] # Delete the value for the current thread
        
    @property # Define a property for the value attribute
    def value(self): # Define the getter method for the value attribute
        return self._value.__getitem__(threading.current_thread()) # Get the value for the current thread
    
    @value.setter # Define a setter for the value attribute
    def value(self, val): # Define the setter method for the value attribute
        self._value.__setitem__(threading.current_thread(), val) # Set the value for the current thread

In this example, we’re creating a new Context Variable called `my_context_var`. We can access its value using the `get()` method:

# Creating a new Context Variable called `my_context_var` using the `MyContextVar` class
my_context_var = MyContextVar('my_key')

# Using the `with` statement to enter the context and access the `my_context_var` variable
with my_context_var:
    # Setting the value of the `hello` key in the `my_context_var` dictionary to "world"
    my_context_var['hello'] = 'world'

# Printing the value of the `hello` key in the `my_context_var` dictionary
print(my_context_var['hello']) # prints "world"

We can also set and get the value without using a context manager:

# Setting up a context variable with key 'my_key'
ctx = MyContextVar('my_key')

# Setting the value of the context variable to 'hello'
ctx.value = 'hello'

# Printing the value of the context variable
print(ctx.value) # prints "hello"

The `__enter__()` method creates an empty dictionary for each thread, and returns it as the value of our Context Variable. The `__exit__()` method removes that dictionary when we exit the context manager. This ensures that data is shared between functions without having to worry about thread safety or dictionary lookups.

Best Practices for Writing Comments in Python
When writing comments, keep them clean and concise. Avoid using unnecessary words like “this” or “these”. Instead, focus on explaining what the code does and why it’s important. Here are some best practices:
– Use docstrings to document your functions and classes. This will help other developers understand how to use your code.
– Write inline comments for complex functions or sections of code that might be confusing.
– Avoid writing comments just to explain what a variable does. Instead, name the variables in a way that’s clear and concise.
– Use comments sparingly. If you find yourself writing long comments, consider refactoring your code instead.

Types of Comments You Might Want to Avoid
There are some types of comments that can actually make your code harder to read and understand. Here are a few examples:
– “TODO” or “FIXME” comments. These comments can be helpful for reminding you what needs to be done, but they should be used sparingly. If you have too many TODOs in your code, it might indicate that there’s something wrong with the design of your program. Instead, try refactoring your code or breaking it down into smaller pieces.
– Comments that explain how a function works. This is redundant if you’ve already written docstrings for your functions. If you find yourself writing comments like this, consider rewriting your docstring to be more clear and concise.
– Comments that explain what a variable does. Instead of using comments to explain variables, try naming them in a way that’s clear and concise. This will make it easier for other developers to understand your code without having to read through all the comments.

How to Practice Writing Cleaner Comments
To practice writing cleaner comments, start by reviewing old code that you’ve written. Look for places where you could have used a comment instead of a variable name or function docstring. Then, try refactoring your code to be more clear and concise. This will help you get into the habit of writing better comments in the future.
Another way to practice is by reviewing other people’s code on GitHub. Look for places where they could have used a comment instead of a variable name or function docstring, and suggest improvements. If your changes are accepted, it will help you get into the habit of writing better comments in the future.
Conclusion
Learning to write cleaner comments is an important skill for any Python developer. By using Context Variables instead of thread locals, we can share data between functions without having to worry about dictionary lookups or thread safety. And by following best practices for commenting our code, we can make it easier for other developers to understand what our code does and why it’s important.
If you want to learn more about Python documentation, check out our tutorial on Documenting Python Code.