Pythonic Conventions

Pythonic Conventions

Essential Python idioms that make code more readable, concise, and efficient.

Quick Reference

Comprehensions Over Loops

Use comprehensions to build lists, dicts, and sets. They're more readable and often faster.

List Comprehensions

# INCORRECT - manual loop
squares = []
for x in range(10):
    squares.append(x ** 2)

# CORRECT - list comprehension
squares = [x ** 2 for x in range(10)]

# CORRECT - with condition
even_squares = [x ** 2 for x in range(10) if x % 2 == 0]

Dict Comprehensions

# INCORRECT - manual loop
name_to_length = {}
for name in names:
    name_to_length[name] = len(name)

# CORRECT - dict comprehension
name_to_length = {name: len(name) for name in names}

# CORRECT - transform keys/values
upper_mapping = {k.upper(): v * 2 for k, v in mapping.items()}

Set Comprehensions

# INCORRECT - manual loop
unique_lengths = set()
for word in words:
    unique_lengths.add(len(word))

# CORRECT - set comprehension
unique_lengths = {len(word) for word in words}

When NOT to Use Comprehensions

# INCORRECT - comprehension too complex (nested + multiple conditions)
result = [
    transform(x, y)
    for x in items
    if is_valid(x)
    for y in x.children
    if y.active and y.score > threshold
]

# CORRECT - use a loop for complex logic
result = []
for x in items:
    if not is_valid(x):
        continue
    for y in x.children:
        if y.active and y.score > threshold:
            result.append(transform(x, y))

Built-in Functions

enumerate() for Index + Value

# INCORRECT - manual index tracking
i = 0
for item in items:
    print(f"{i}: {item}")
    i += 1

# INCORRECT - range with index access
for i in range(len(items)):
    print(f"{i}: {items[i]}")

# CORRECT - enumerate
for i, item in enumerate(items):
    print(f"{i}: {item}")

# CORRECT - custom start index
for i, item in enumerate(items, start=1):
    print(f"{i}: {item}")

zip() for Parallel Iteration

# INCORRECT - manual parallel iteration
for i in range(len(names)):
    print(f"{names[i]}: {scores[i]}")

# CORRECT - zip
for name, score in zip(names, scores):
    print(f"{name}: {score}")

# CORRECT - strict mode (raises on length mismatch)
for name, score in zip(names, scores, strict=True):
    print(f"{name}: {score}")

any() and all() for Boolean Checks

# INCORRECT - loop with flag
has_negative = False
for x in numbers:
    if x < 0:
        has_negative = True
        break

# CORRECT - any()
has_negative = any(x < 0 for x in numbers)

# INCORRECT - loop with flag for all
all_positive = True
for x in numbers:
    if x <= 0:
        all_positive = False
        break

# CORRECT - all()
all_positive = all(x > 0 for x in numbers)

sum(), max(), min() with Generators

# INCORRECT - manual summation
total = 0
for item in items:
    total += item.value

# CORRECT - sum with generator
total = sum(item.value for item in items)

# CORRECT - max/min with key function
oldest = max(users, key=lambda u: u.age)
shortest = min(strings, key=len)

sorted() with Key Functions

# INCORRECT - manual sort key extraction
pairs = [(len(s), s) for s in strings]
pairs.sort()
sorted_strings = [s for _, s in pairs]

# CORRECT - sorted with key
sorted_strings = sorted(strings, key=len)

# CORRECT - sort by multiple criteria
sorted_users = sorted(users, key=lambda u: (u.department, -u.salary))

Context Managers

Always use with for resource management.

# INCORRECT - manual cleanup
f = open("file.txt")
try:
    data = f.read()
finally:
    f.close()

# CORRECT - context manager
with open("file.txt") as f:
    data = f.read()

# CORRECT - multiple resources
with open("input.txt") as infile, open("output.txt", "w") as outfile:
    outfile.write(infile.read())

Common Context Managers

# File I/O
with open(path) as f:
    ...

# Locks
with lock:
    ...

# Database connections
with connection.cursor() as cursor:
    ...

# Temporary directories
with tempfile.TemporaryDirectory() as tmpdir:
    ...

# Suppressing exceptions
with contextlib.suppress(FileNotFoundError):
    os.remove(path)

Unpacking

Tuple/List Unpacking

# INCORRECT - index access
point = (3, 4)
x = point[0]
y = point[1]

# CORRECT - unpacking
x, y = point

# CORRECT - swap without temp variable
a, b = b, a

# CORRECT - extended unpacking
first, *rest = items
first, *middle, last = items

Dict Unpacking

# CORRECT - merge dicts
merged = {**defaults, **overrides}

# CORRECT - function kwargs
config = {"timeout": 30, "retries": 3}
response = fetch_data(url, **config)

Unpacking in Loops

# INCORRECT - index access
for pair in pairs:
    print(f"{pair[0]}: {pair[1]}")

# CORRECT - unpacking
for key, value in pairs:
    print(f"{key}: {value}")

# CORRECT - with enumerate
for i, (key, value) in enumerate(mapping.items()):
    print(f"{i}: {key}={value}")

Membership Testing

# INCORRECT - loop for membership
found = False
for item in items:
    if item == target:
        found = True
        break

# CORRECT - in operator
found = target in items

# CORRECT - use sets for repeated membership tests
allowed = {"admin", "moderator", "user"}
if role in allowed:
    ...

Walrus Operator (:=)

Use assignment expressions to avoid redundant calls or lines.

# INCORRECT - call twice or use temp variable
match = pattern.search(text)
if match:
    process(match.group())

# CORRECT - walrus operator
if match := pattern.search(text):
    process(match.group())

# CORRECT - in while loops
while chunk := file.read(8192):
    process(chunk)

# CORRECT - in comprehensions with filtering
results = [y for x in data if (y := expensive_compute(x)) is not None]

Generators Over Lists

Use generator expressions when you only iterate once.

# INCORRECT - creates full list in memory
total = sum([x ** 2 for x in range(1_000_000)])

# CORRECT - generator expression (no brackets)
total = sum(x ** 2 for x in range(1_000_000))

# CORRECT - generator function for complex logic
def read_large_file(path: Path) -> Iterator[str]:
    with open(path) as f:
        for line in f:
            if line.strip():
                yield line.strip()

Collections Module

defaultdict

# INCORRECT - manual key initialization
groups = {}
for item in items:
    if item.category not in groups:
        groups[item.category] = []
    groups[item.category].append(item)

# CORRECT - defaultdict
from collections import defaultdict

groups = defaultdict(list)
for item in items:
    groups[item.category].append(item)

Counter

# INCORRECT - manual counting
counts = {}
for word in words:
    counts[word] = counts.get(word, 0) + 1

# CORRECT - Counter
from collections import Counter

counts = Counter(words)
most_common = counts.most_common(10)

String Operations

str.join() for Concatenation

# INCORRECT - concatenation in loop
result = ""
for word in words:
    result += word + " "

# CORRECT - join
result = " ".join(words)

F-strings Over Format/Concatenation

# INCORRECT - old-style formatting
msg = "Hello, %s! You have %d messages." % (name, count)
msg = "Hello, {}! You have {} messages.".format(name, count)

# CORRECT - f-string
msg = f"Hello, {name}! You have {count} messages."

# CORRECT - f-string with expressions
msg = f"Total: {price * quantity:.2f}"

Boolean Expressions

Truthy/Falsy Checks

# INCORRECT - explicit comparison
if len(items) > 0:
    ...
if len(items) == 0:
    ...
if value == None:
    ...
if value == True:
    ...

# CORRECT - truthy/falsy
if items:
    ...
if not items:
    ...
if value is None:
    ...
if value is True:  # Only when specifically checking True, not truthy
    ...
if value:  # Usually preferred for boolean check
    ...

Chained Comparisons

# INCORRECT - separate comparisons
if x > 0 and x < 10:
    ...

# CORRECT - chained comparison
if 0 < x < 10:
    ...

Conditional Expressions

# INCORRECT - if/else for simple assignment
if condition:
    value = x
else:
    value = y

# CORRECT - conditional expression
value = x if condition else y

# CORRECT - with function calls
status = "active" if user.is_active else "inactive"

Dictionary Operations

dict.get() with Default

# INCORRECT - explicit key check
if key in d:
    value = d[key]
else:
    value = default

# CORRECT - get with default
value = d.get(key, default)

defaultdict for Lazy Initialization

# INCORRECT - check then set
if key not in d:
    d[key] = []
d[key].append(item)

# INCORRECT - setdefault (prefer defaultdict for clarity)
d.setdefault(key, []).append(item)

# CORRECT - defaultdict
from collections import defaultdict

d = defaultdict(list)
d[key].append(item)

Exception Handling

EAFP Over LBYL

Easier to Ask Forgiveness than Permission.

# INCORRECT - LBYL (Look Before You Leap)
if key in mapping:
    value = mapping[key]
else:
    value = default

# CORRECT - EAFP
try:
    value = mapping[key]
except KeyError:
    value = default

# Even better for this case
value = mapping.get(key, default)

Specific Exception Types

# INCORRECT - bare except
try:
    result = risky_operation()
except:
    handle_error()

# INCORRECT - too broad
try:
    result = risky_operation()
except Exception:
    handle_error()

# CORRECT - specific exceptions
try:
    result = risky_operation()
except (ValueError, TypeError) as e:
    handle_error(e)