Python’s simplicity can be deceiving. While defining a variable (x = 10) is one of the first concepts developers learn, modern Python introduces elegant assignment patterns, memory optimizations, and built-in shortcuts that dramatically improve code readability and performance.
Whether you are writing clean backend microservices or building data pipelines, mastering these professional variable techniques will make your Python code idiomatic, robust, and maintainable.
1. Extended Iterable Unpacking (* Operator)
Most developers know basic tuple unpacking (x, y = 1, 2), but modern Python allows flexible unpacking with the starred * expression to slice iterables cleanly without manual indexing.
The Code
Python
# Extracting head, middle, and tail from a dataset
numbers = [10, 20, 30, 40, 50, 60]
first, *middle, last = numbers
print(first) # Output: 10
print(middle) # Output: [20, 30, 40, 50]
print(last) # Output: 60
# Ignoring unwanted intermediate values
start, *_, end = range(100)
print(start, end) # Output: 0 99
Why It Matters
Using numbers[0], numbers[1:-1], and numbers[-1] adds boilerplate and increases the risk of IndexError on empty or dynamic sequences. Extended unpacking handles variable length iterables gracefully while keeping intent clear.
2. Inline Assignment with the Walrus Operator (:=)
Introduced in Python 3.8 (PEP 572), the assignment expression operator—affectionately known as the Walrus Operator—allows you to assign a variable and return its value within a single expression.
The Code
Python
import re
sample_text = "Contact support at admin@example.com for assistance."
email_pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
# Traditional Approach (Requires pre-assignment and separate check)
# match = re.search(email_pattern, sample_text)
# if match:
# print(f"Found email: {match.group()}")
# Modern Python Approach using Walrus Operator
if match := re.search(email_pattern, sample_text):
print(f"Found email: {match.group()}")
Practical Application in List Comprehensions
Python
def expensive_calculation(x):
return x ** 2 + 3 * x + 5
data = [1, 5, 8, 12, 15]
# Calculates expensive_calculation(x) twice per iteration in traditional code
# [expensive_calculation(x) for x in data if expensive_calculation(x) > 50]
# Efficient: Calculates only once and binds result to `result`
filtered = [result for x in data if (result := expensive_calculation(x)) > 50]
print(filtered) # Output: [93, 185, 275]
3. Self-Documenting F-Strings for Debugging (=)
Forget writing print("variable_name:", variable_name). Python 3.8 introduced the = specifier inside f-strings, which prints both the expression and its evaluated result.
The Code
Python
user_id = 4092
status = "PENDING_VERIFICATION"
metrics = {"latency_ms": 42.8, "throughput": 1200}
# Self-documenting variable output
print(f"{user_id=}, {status=}")
# Output: user_id=4092, status='PENDING_VERIFICATION'
# Works with inline expressions and dictionary key access
print(f"{user_id * 2=}")
# Output: user_id * 2=8184
print(f"{metrics['latency_ms']=}")
# Output: metrics['latency_ms']=42.8
4. Pattern Matching Variable Binding (Python 3.10+)
Structural Pattern Matching (match-case) goes far beyond simple switch statements. It decomposes complex data structures and binds values directly to variables in one step.
The Code
Python
def process_event(event: dict):
match event:
case {"type": "user_signup", "payload": {"user_id": uid, "email": email}}:
print(f"Signing up User #{uid} with email: {email}")
case {"type": "payment", "amount": float(amt), "status": "SUCCESS"}:
print(f"Payment processed successfully for ${amt:.2f}")
case {"type": "payment", "amount": amt}:
print(f"Payment pending or failed for ${amt}")
case _:
print("Unknown event format")
# Test event payload
process_event({
"type": "user_signup",
"payload": {"user_id": 8801, "email": "dev@company.io"}
})
Why It Matters
This eliminates multiple nested if-else checks and dict.get() calls, structural pattern matching validates data shape and assigns variables simultaneously.
5. Dictionary Merging and Unpacking Operators (| and **)
Python 3.9 introduced the union operator (|) and update operator (|=) for dictionaries, replacing older, clunkier merging methods.
The Code
Python
default_config = {"theme": "light", "notifications": True, "timeout": 30}
user_config = {"theme": "dark", "timeout": 60}
# Python 3.9+ Union Operator (Creates a new dictionary)
merged_config = default_config | user_config
print(merged_config)
# Output: {'theme': 'dark', 'notifications': True, 'timeout': 60}
# In-place Update Operator
default_config |= user_config
print(default_config)
# Output: {'theme': 'dark', 'notifications': True, 'timeout': 60}
6. Memory Optimization using __slots__ for Instance Variables
By default, Python stores class instance attributes in a dynamic dictionary (__dict__). When instantiating millions of small objects, this creates substantial memory overhead. Defining __slots__ disables __dict__ and allocates a fixed amount of space for specified attributes.
The Code
Python
import sys
class StandardPoint:
def __init__(self, x, y):
self.x = x
self.y = y
class OptimizedPoint:
__slots__ = ('x', 'y') # Restricts instance variables to 'x' and 'y'
def __init__(self, x, y):
self.x = x
self.y = y
p1 = StandardPoint(10, 20)
p2 = OptimizedPoint(10, 20)
print(f"Standard instance size: {sys.getsizeof(p1) + sys.getsizeof(p1.__dict__)} bytes")
print(f"Optimized instance size: {sys.getsizeof(p2)} bytes")
Performance Impact
For high-throughput applications handling millions of objects (such as data analysis or game loops), using __slots__ can reduce memory footprint by up to 40–50% and improve access speed.
7. Closure Variable State Modification with nonlocal
When working with nested functions (closures), assigning a variable inside an inner function creates a local variable by default rather than updating the variable in the outer scope. Use nonlocal to explicitly manipulate enclosing variables without resorting to global scope.
The Code
Python
def make_rate_limiter(max_requests: int):
request_count = 0 # Enclosing variable
def allow_request() -> bool:
nonlocal request_count # Enables modification of outer variable
if request_count < max_requests:
request_count += 1
print(f"Request allowed ({request_count}/{max_requests})")
return True
print("Rate limit exceeded")
return False
return allow_request
limiter = make_rate_limiter(max_requests=2)
limiter() # Request allowed (1/2)
limiter() # Request allowed (2/2)
limiter() # Rate limit exceeded
Cheat Sheet: Python Variable Shortcuts
| Shortcut / Technique | Minimum Python Version | Primary Use Case |
a, *b, c = seq | Python 3.0+ | Extracting variable-length elements cleanly |
f"{var=}" | Python 3.8+ | Fast self-documenting print statements |
(x := expr) | Python 3.8+ | Assigning values inside conditions/comprehensions |
dict_a | dict_b | Python 3.9+ | Clean dictionary merging without mutation |
case {"key": val} | Python 3.10+ | Structural destructuring and pattern matching |
__slots__ | Python 3.0+ | Reducing class instance memory usage |
Applying these modern techniques will instantly improve your code quality. By leveraging built-in language features like extended unpacking, the walrus operator, and pattern matching, your Python code becomes cleaner, faster, and more professional.
