10 Python Secrets to Boost Productivity and Elegance in Your Code

1. Tuple Unpacking for Parallel Assignment

Python lets you assign multiple variables simultaneously from any iterable. This goes well beyond simple variable swaps:

# Swap without a temp variable
a, b = 10, 20
a, b = b, a
print(a, b)  # 20 10

# Unpack from a list or tuple
first, *middle, last = [1, 2, 3, 4, 5]
print(first, middle, last)  # 1 [2, 3, 4] 5

The starred expression (*middle) captures everything between the first and last element — enormously useful when parsing structured data or function return values where the exact length may vary.

2. List Comprehensions That Scale

The classic list comprehension replaces a multi-line loop with a single, readable expression. But you can nest conditions and even nest comprehensions:

# Basic
squares = [x**2 for x in range(10)]

# With filtering
even_squares = [x**2 for x in range(10) if x % 2 == 0]

# Flatten a 2D list
matrix = [[1,2,3],[4,5,6],[7,8,9]]
flat = [val for row in matrix for val in row]

Comprehensions also have a performance edge — because Python evaluates them as a single bytecode operation rather than a loop with repeated APPEND calls, they run measurably faster on large datasets.

3. Dictionary Comprehensions for Data Transformation

Transforming one dictionary into another is a common task in data processing. Dictionary comprehensions make this concise and readable:

prices = {"apple": 1.5, "banana": 0.75, "cherry": 3.0}

# Apply a 10% discount
discounted = {item: round(price * 0.9, 2) for item, price in prices.items()}

# Invert a dictionary (swap keys and values)
inverted = {v: k for k, v in prices.items()}

You can combine comprehensions with conditional logic to filter entries as you build the new dictionary — all without touching a temporary variable.

4. enumerate() — Loop with Index Included

Manually tracking an index counter inside a loop is error-prone. Python's enumerate() gives you both the index and value cleanly:

tasks = ["Deploy app", "Run tests", "Update docs"]

for i, task in enumerate(tasks, start=1):
    print(f"{i}. {task}")

# Output:
# 1. Deploy app
# 2. Run tests
# 3. Update docs

The optional start argument lets you begin counting from any number — handy when generating numbered lists for users or matching 1-indexed data sources.

5. zip() — Pair Up Parallel Sequences

When you have two related lists and need to work with matching pairs, zip() is the idiomatic solution. It stops at the shortest iterable:

names = ["Anjali", "Bharat", "Carol"]
scores = [91, 87, 95]
depts = ["Engineering", "Marketing", "Design"]

# Combine three lists at once
for name, score, dept in zip(names, scores, depts):
    print(f"{name} ({dept}): {score}")

# Build a dict from two lists
employee_scores = dict(zip(names, scores))

For cases where the lists might differ in length and you want to fill missing values, use itertools.zip_longest(fillvalue=None) instead.

6. *args and **kwargs for Flexible APIs

When designing functions that need to accept a variable number of inputs — think utility functions, decorators, or wrappers — *args and **kwargs are essential:

def log_event(event_type, *messages, **metadata):
    print(f"[{event_type}]")
    for msg in messages:
        print(f"  - {msg}")
    for key, val in metadata.items():
        print(f"  {key}: {val}")

log_event("ERROR", "File not found", "Retrying...",
          user="akash", request_id="abc123")

You can also use the unpacking operators to pass existing lists and dicts into functions: func(*my_list, **my_dict). This pattern is the backbone of many Python frameworks.

7. Safe Dictionary Access with .get() and setdefault()

Accessing a missing key in a Python dict raises a KeyError. Two methods save you from defensive if key in dict checks:

config = {"timeout": 30, "retries": 3}

# Returns None (or a default) if key is missing
host = config.get("host", "localhost")

# Sets and returns a default only if the key is absent
config.setdefault("debug", False)
print(config)  # {"timeout": 30, "retries": 3, "debug": False}

setdefault() is particularly useful when building lookup tables where you want to initialize keys lazily — like grouping items into lists by category.

8. f-Strings: The Modern Way to Format Strings

Introduced in Python 3.6, f-strings are faster and more readable than format() or %-style formatting. They support full Python expressions inline:

name = "Akash"
total = 4295.678

# Basic interpolation
print(f"Hello, {name}!")

# Inline expressions
print(f"Pi rounded: {3.14159:.2f}")

# Debugging (Python 3.8+)
value = 42
print(f"{value=}")  # value=42

# Formatted numbers
print(f"Total: ${total:,.2f}")  # Total: $4,295.68

The = specifier (Python 3.8+) prints the variable name alongside its value — invaluable for quick debug logging without any extra code.

9. any() and all() for Readable Condition Checks

These two built-ins let you replace complex boolean loops with a single expressive line:

permissions = ["read", "write", "execute"]

# Does the user have ANY write or admin permission?
can_modify = any(p in permissions for p in ["write", "admin"])

# Does a list of numbers satisfy ALL conditions?
numbers = [10, 20, 30, 40]
all_positive = all(n > 0 for n in numbers)
all_even = all(n % 2 == 0 for n in numbers)

print(can_modify, all_positive, all_even)  # True True True

Both functions short-circuit — any() stops at the first True, and all() stops at the first False. This means they're efficient even on large iterables.

10. Advanced Slicing Techniques

Python slicing goes far beyond simple list extraction. The full syntax is sequence[start:stop:step], and each part is optional:

data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(data[::2])    # Every second element: [0, 2, 4, 6, 8]
print(data[::-1])   # Reversed: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
print(data[2:7])    # Sublist: [2, 3, 4, 5, 6]
print(data[-3:])    # Last 3 elements: [7, 8, 9]

# Works identically on strings
text = "Dev Knowledge"
print(text[::-1])   # Reversed string
print(text[:10])    # First 10 characters

Slicing works on strings, tuples, NumPy arrays, and any custom class that implements __getitem__. Negative indices count from the end, making it easy to grab tails of sequences without knowing their length.

Bonus: Context Managers and Walrus Operator

Two more patterns worth knowing: the with statement guarantees resource cleanup (files, database connections, locks) even when exceptions occur. And the walrus operator (:=, Python 3.8+) lets you assign and test in a single expression:

# Context manager
with open("data.csv") as f:
    content = f.read()  # File closed automatically after this block

# Walrus operator - assign and use in one step
if (n := len(data)) > 5:
    print(f"Large dataset: {n} items")