← Python

Pythonic Idioms & Philosophy

← Pythonic Idioms & Philosophy

Select a question from the sidebar

12 questions in this topic

Question 1 / 12

What is the Zen of Python and what are its most important principles?

The Zen of Python (PEP 20) is a collection of 19 guiding principles for writing Python. Access it with import this. The most impactful principles for daily coding:

Beautiful is better than ugly - Write clean, readable code.
Explicit is better than implicit - Do not hide behavior; make intent clear.
Simple is better than complex - Choose the simplest solution that works.
Readability counts - Code is read far more often than written.
There should be one-- and preferably only one --obvious way to do it - Python prefers one clear approach.
Errors should never pass silently - Handle exceptions explicitly.
In the face of ambiguity, refuse the temptation to guess - Be explicit.
Flat is better than nested - Avoid deep nesting; use early returns.
If the implementation is hard to explain, it's a bad idea - Simplicity wins.

Pseudo Code

import this  # Prints the Zen of Python

Key takeaways:
- Readability > cleverness
- Explicit > implicit
- Simple > complex
- Flat > nested
- One obvious way to do it

Code

# import this  # Prints the Zen of Python

# Principle: Beautiful is better than ugly
# Ugly
result = dict([(k,v) for k,v in zip(keys,vals)])
# Beautiful
result = dict(zip(keys, vals))

# Principle: Explicit is better than implicit
# Implicit (what does * do here?)
from math import *
# Explicit
from math import sqrt, pi

# Principle: Simple is better than complex
# Complex
def is_even(n):
    return True if n % 2 == 0 else False
# Simple
def is_even(n):
    return n % 2 == 0

# Principle: Flat is better than nested
# Nested
def process(data):
    if data:
        if data.get('valid'):
            if data.get('type') == 'user':
                return handle_user(data)
    return None

# Flat (early returns)
def process(data):
    if not data:
        return None
    if not data.get('valid'):
        return None
    if data.get('type') != 'user':
        return None
    return handle_user(data)

# Principle: Errors should never pass silently
# Bad: silently ignoring errors
try:
    value = int(user_input)
except:
    pass

# Good: handle explicitly
try:
    value = int(user_input)
except ValueError:
    print(f"Invalid number: {user_input}")
    value = 0

# Principle: Readability counts
# Clever but unreadable
result = [x for x in (y.strip() for y in open('f.txt')) if x and not x.startswith('#')]

# Readable
with open('f.txt') as f:
    result = []
    for line in f:
        line = line.strip()
        if line and not line.startswith('#'):
            result.append(line)

Key Points

•Readability and simplicity are core Python values
•Prefer explicit imports, explicit error handling, and clear variable names
•Use early returns to flatten nested conditionals
•Never use bare except:; always catch specific exceptions
•If it is hard to explain, simplify it

Gotchas

•The Zen of Python has intentional contradictions (e.g., 'practicality beats purity')
•'One obvious way' does not mean there is literally one way; it means prefer the conventional way
•Clever one-liners are not Pythonic if they sacrifice readability

The Zen of Python (import this) guides Python style: readability counts, explicit beats implicit, simple beats complex, flat beats nested, errors should not pass silently. Write code for humans to read, not just computers to execute.

•Readability, simplicity, and explicitness are core values
•Early returns to flatten nested code

# import this

# Explicit > implicit
from math import sqrt  # not: from math import *

# Simple > complex
def is_even(n): return n % 2 == 0  # not: True if n%2==0 else False

# Flat > nested (early returns)
if not data: return None
if not valid: return None
return process(data)

Clever one-liners are not Pythonic if they sacrifice readability

Question 2 / 12

What is duck typing and how does Python use it?

Duck typing: 'If it walks like a duck and quacks like a duck, it is a duck.' In Python, the type of an object is less important than the methods/attributes it has. You do not check the type; you check the behavior.

This means you can pass any object to a function as long as it has the required methods, regardless of its class hierarchy. There is no need for inheritance or interfaces.

Python's entire ecosystem relies on duck typing: for loops work with any iterable, with works with any context manager, len() works with anything that has __len__.

Pseudo Code

Don't check: isinstance(x, Duck)
Do check: does x have quack() and walk()?

Python built-in duck typing:
- for loop: anything with __iter__()
- len(): anything with __len__()
- with: anything with __enter__/__exit__
- + operator: anything with __add__

Code

# Duck typing: no type checking needed
class Duck:
    def quack(self):
        return "Quack!"
    def walk(self):
        return "Walking"

class Person:
    def quack(self):
        return "I'm quacking like a duck!"
    def walk(self):
        return "Walking like a duck"

class RobotDuck:
    def quack(self):
        return "ELECTRONIC QUACK"
    def walk(self):
        return "Mechanical walking"

def duck_test(thing):
    """Works with anything that has quack() and walk()."""
    print(thing.quack())
    print(thing.walk())

# All work -- no inheritance needed!
duck_test(Duck())
duck_test(Person())
duck_test(RobotDuck())

# Python built-in duck typing examples

# 1. Any iterable works in a for loop
class Fibonacci:
    def __init__(self, n):
        self.n = n
    def __iter__(self):
        a, b, count = 0, 1, 0
        while count < self.n:
            yield a
            a, b = b, a + b
            count += 1

for num in Fibonacci(5):  # Works because it has __iter__
    print(num)

# 2. Any object with __len__ works with len()
class Playlist:
    def __init__(self, songs):
        self.songs = songs
    def __len__(self):
        return len(self.songs)

print(len(Playlist(['a', 'b', 'c'])))  # 3

# 3. Any object with __enter__/__exit__ works with 'with'
class Timer:
    def __enter__(self):
        import time
        self.start = time.time()
        return self
    def __exit__(self, *args):
        import time
        print(f"Elapsed: {time.time() - self.start:.3f}s")

with Timer():
    sum(range(1000000))

# EAFP: Easier to Ask Forgiveness than Permission
# (Pythonic approach to duck typing)
def process(data):
    try:
        result = data.process()  # Just try it
    except AttributeError:
        raise TypeError("data must have a process() method")

# Expected Output: (timing values are approximate)
# Quack!
# Walking
# I'm quacking like a duck!
# Walking like a duck
# ELECTRONIC QUACK
# Mechanical walking
# 0
# 1
# 1
# 2
# 3
# 3
# Elapsed: 0.007s

Key Points

•Duck typing: type is irrelevant; only behavior (methods) matter
•No inheritance or interface implementation needed
•Python's for, with, len, operators all use duck typing internally
•EAFP: try the operation, catch the exception if it fails
•typing.Protocol (3.8+) formalizes duck typing for static checkers

Gotchas

•Duck typing can cause confusing errors when the wrong object is passed
•EAFP catches AttributeError/TypeError, which may mask real bugs
•Use Protocol for static type checking of duck-typed interfaces

Duck typing: 'if it has the right methods, it works.' Python does not check types; it checks behavior. for works with any iterable, len() with any __len__, with with any context manager. No inheritance needed.

•Check behavior (methods), not type (class)
•Python built-ins (for, with, len) all use duck typing

# Any object with quack() works
def make_it_quack(thing):
    print(thing.quack())  # No type check!

class Duck:
    def quack(self): return "Quack"
class Robot:
    def quack(self): return "BEEP"

make_it_quack(Duck())   # Works
make_it_quack(Robot())  # Also works

Quack
BEEP

Confusing errors when wrong object is passed; use Protocol for static checking

Question 3 / 12

What is EAFP vs LBYL and which does Python prefer?

LBYL (Look Before You Leap): Check if an operation is possible before doing it. Common in C, Java.

EAFP (Easier to Ask Forgiveness than Permission): Just try the operation and handle the exception if it fails. Python prefers EAFP.

Why EAFP is Pythonic:

Simpler code: No pre-checks needed; just try and catch.
Race condition safe: Between checking and acting, the state could change (TOCTOU bug).
Duck typing friendly: Works with any object that has the right behavior.
More efficient in the common case: If the operation usually succeeds, exceptions are rare and cheap to set up (try is nearly free; except is expensive only when triggered).

Pseudo Code

LBYL: if key in dict: value = dict[key]
EAFP: try: value = dict[key] except KeyError: ...

Python prefers EAFP because:
- try block has near-zero cost when no exception occurs
- Avoids TOCTOU race conditions
- Works naturally with duck typing

Code

# LBYL (Look Before You Leap) - less Pythonic
def lbyl_get_value(data, key):
    if isinstance(data, dict):       # Check type
        if key in data:               # Check key exists
            return data[key]
    return None

# EAFP (Easier to Ask Forgiveness) - Pythonic
def eafp_get_value(data, key):
    try:
        return data[key]
    except (KeyError, TypeError):
        return None

# File operations
# LBYL: race condition! File could be deleted between check and open
import os
if os.path.exists('data.txt'):       # File exists now...
    with open('data.txt') as f:      # ...but might not exist here!
        data = f.read()

# EAFP: safe from race conditions
try:
    with open('data.txt') as f:
        data = f.read()
except FileNotFoundError:
    data = ''

# Division
# LBYL
def safe_divide_lbyl(a, b):
    if b == 0:
        return 0
    return a / b

# EAFP
def safe_divide_eafp(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return 0

# Dictionary access
# LBYL
if 'name' in user_dict:
    name = user_dict['name']
else:
    name = 'Unknown'

# EAFP (even better: use dict.get())
name = user_dict.get('name', 'Unknown')

# Attribute access
# LBYL
if hasattr(obj, 'process'):
    obj.process()

# EAFP
try:
    obj.process()
except AttributeError:
    pass  # Object does not have process()

# Type conversion
# LBYL
if isinstance(value, str) and value.isdigit():
    number = int(value)
else:
    number = 0

# EAFP
try:
    number = int(value)
except (ValueError, TypeError):
    number = 0

# When LBYL is actually better:
# 1. When the check is cheap and failure is common
# 2. When try/except would mask real bugs
# 3. When the operation has side effects that are hard to undo

# Example: LBYL is better here (side effect: sending email)
if user.email_verified:  # Check first
    send_email(user.email)  # Side effect

Key Points

•EAFP (try/except) is Pythonic; LBYL (check first) is less Pythonic
•try block has near-zero overhead when no exception occurs
•EAFP avoids TOCTOU race conditions (check then act)
•Use dict.get() instead of key-in-dict check for dictionary access
•LBYL is better when failure is common or operation has side effects

Gotchas

•Bare except: catches everything including KeyboardInterrupt; always catch specific exceptions
•EAFP can mask real bugs if you catch too broad an exception
•except blocks are expensive when triggered; LBYL is better if exceptions are frequent

EAFP (try/except) is Pythonic: just try the operation, handle failure. LBYL (check first) has race conditions and extra checks. try is nearly free; except is only costly when triggered. Use LBYL only when failure is common or has side effects.

•EAFP is Pythonic; try is nearly free when no exception
•LBYL for common failures or side effects

# LBYL (less Pythonic)
if key in d:
    val = d[key]

# EAFP (Pythonic)
try:
    val = d[key]
except KeyError:
    val = default

# Best: use built-in
val = d.get(key, default)

Catch specific exceptions; bare except masks real bugs

Question 4 / 12

What are the key PEP 8 style guidelines every Python developer should know?

PEP 8 is Python's official style guide. Key rules:

Indentation & Whitespace:

4 spaces per indent (no tabs)
79 characters max line length (72 for docstrings)
2 blank lines between top-level definitions
1 blank line between methods

Naming:

snake_case for functions, variables, methods
PascalCase for classes
UPPER_SNAKE_CASE for constants
_single_leading_underscore for private (convention)
__double_leading for name mangling

Imports:

One import per line
Order: stdlib, third-party, local (separated by blank lines)
Avoid from x import *

Whitespace:

No spaces inside brackets: func(a, b) not func( a, b )
Spaces around operators: x = 1 + 2 not x=1+2
No space before colon in slices: list[1:3] not list[1 : 3]

Pseudo Code

Naming: snake_case functions, PascalCase classes, UPPER constants
Indent: 4 spaces, 79 char line length
Imports: stdlib -> third-party -> local, one per line
Whitespace: spaces around =, no spaces in brackets

Code

# PEP 8 Compliant Code Example

# Imports: stdlib -> third-party -> local
import os
import sys
from datetime import datetime

import requests
from flask import Flask

from myapp.models import User
from myapp.utils import validate_email

# Constants: UPPER_SNAKE_CASE
MAX_RETRY_COUNT = 3
DEFAULT_TIMEOUT = 30
API_BASE_URL = "https://api.example.com"


# Classes: PascalCase, 2 blank lines before
class UserService:
    """Service for user operations."""

    def __init__(self, api_url: str = API_BASE_URL) -> None:
        self._api_url = api_url  # Private: leading underscore
        self._session = requests.Session()

    def get_user(self, user_id: int) -> dict | None:
        """Fetch a user by ID."""
        response = self._session.get(
            f"{self._api_url}/users/{user_id}",
            timeout=DEFAULT_TIMEOUT,
        )
        if response.status_code == 200:
            return response.json()
        return None

    def create_user(self, name: str, email: str) -> dict:
        """Create a new user.

        Args:
            name: The user's display name.
            email: The user's email address.

        Returns:
            The created user dictionary.

        Raises:
            ValueError: If email is invalid.
        """
        if not validate_email(email):
            raise ValueError(f"Invalid email: {email}")

        return self._session.post(
            f"{self._api_url}/users",
            json={"name": name, "email": email},
        ).json()


# Functions: snake_case
def calculate_total_price(
    items: list[dict],
    tax_rate: float = 0.1,
) -> float:
    """Calculate total price with tax."""
    subtotal = sum(item["price"] * item["quantity"] for item in items)
    return subtotal * (1 + tax_rate)


# Comparisons
# Good
if x is None:
    pass
if not items:
    pass
if isinstance(x, int):
    pass

# Bad
if x == None:       # Use 'is' for None
    pass
if len(items) == 0: # Use truthiness
    pass
if type(x) is int:  # Use isinstance
    pass

Key Points

•snake_case for functions/variables; PascalCase for classes; UPPER for constants
•4 spaces indent; 79 char line length; 2 blank lines between top-level definitions
•Import order: stdlib -> third-party -> local, separated by blank lines
•Use 'is None' not '== None'; use truthiness for empty checks
•Trailing commas in multi-line structures (easier diffs)

Gotchas

•PEP 8 says 'consistency within a project is more important than following PEP 8'
•Use a formatter (black, ruff) to auto-enforce style instead of manual checks
•79 chars is the guideline; many teams use 88 (black default) or 120

PEP 8: snake_case for functions, PascalCase for classes, UPPER_CASE for constants. 4-space indent, 79-char lines. Import order: stdlib, third-party, local. Use is None, truthiness for empty checks, isinstance() for type checks.

•snake_case, PascalCase, UPPER_CASE naming conventions
•Use is None, truthiness, isinstance()

# Naming
def calculate_price(): ...      # snake_case
class UserService: ...          # PascalCase
MAX_RETRIES = 3                 # UPPER_SNAKE_CASE

# Imports (in order)
import os
import requests
from myapp import utils

# Comparisons
if x is None: ...       # not == None
if not items: ...       # not len(items) == 0

Use a formatter (black, ruff) to auto-enforce; consistency > PEP 8 compliance

Question 5 / 12

How do you use unpacking (*, **) idiomatically in Python?

Python's unpacking operators (* and **) are versatile:

Iterable unpacking (*): Spread elements from lists/tuples.
Dict unpacking (**): Spread key-value pairs from dicts.
Extended unpacking (*rest): Capture remaining elements.
Function parameters: *args (positional), **kwargs (keyword).
Keyword-only arguments: Parameters after * must be passed by name.

Pseudo Code

* unpacks iterables: [*list1, *list2] merges lists
** unpacks dicts: {**dict1, **dict2} merges dicts
*rest captures remaining: first, *rest = [1,2,3,4]
*args: variable positional args
**kwargs: variable keyword args

Code

# Extended unpacking
first, *rest = [1, 2, 3, 4, 5]
print(first)  # 1
print(rest)   # [2, 3, 4, 5]

first, *middle, last = [1, 2, 3, 4, 5]
print(first)   # 1
print(middle)  # [2, 3, 4]
print(last)    # 5

# Swap values (no temp variable needed)
a, b = 1, 2
a, b = b, a
print(a, b)  # 2, 1

# Merge lists
list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged = [*list1, *list2]
print(merged)  # [1, 2, 3, 4, 5, 6]

# Merge dicts (Python 3.5+)
defaults = {'host': 'localhost', 'port': 5432, 'debug': False}
overrides = {'port': 8080, 'debug': True}
config = {**defaults, **overrides}
print(config)  # {'host': 'localhost', 'port': 8080, 'debug': True}

# Python 3.9+ dict merge operator
config = defaults | overrides  # Same result

# Function arguments
def greet(name, greeting='Hello'):
    return f'{greeting}, {name}!'

args = ['Alice']
kwargs = {'greeting': 'Hi'}
print(greet(*args, **kwargs))  # Hi, Alice!

# *args and **kwargs
def flexible(*args, **kwargs):
    print(f'args: {args}')      # Tuple of positional args
    print(f'kwargs: {kwargs}')  # Dict of keyword args

flexible(1, 2, 3, name='Alice', age=30)
# args: (1, 2, 3)
# kwargs: {'name': 'Alice', 'age': 30}

# Keyword-only arguments (after *)
def create_user(name, *, email, admin=False):
    """email and admin MUST be passed as keyword arguments."""
    return {'name': name, 'email': email, 'admin': admin}

create_user('Alice', email='a@b.com')        # OK
# create_user('Alice', 'a@b.com')             # TypeError!
create_user('Alice', email='a@b.com', admin=True)  # OK

# Unpacking in loops
pairs = [('a', 1), ('b', 2), ('c', 3)]
for key, value in pairs:
    print(f'{key}: {value}')

# Nested unpacking
points = [(1, 2), (3, 4), (5, 6)]
for x, y in points:
    print(f'x={x}, y={y}')

# Ignore values with _
name, _, email = ('Alice', 30, 'a@b.com')
first, *_, last = [1, 2, 3, 4, 5]

1
[2, 3, 4, 5]
1
[2, 3, 4]
5
2 1
[1, 2, 3, 4, 5, 6]
{'host': 'localhost', 'port': 8080, 'debug': True}
Hi, Alice!
args: (1, 2, 3)
kwargs: {'name': 'Alice', 'age': 30}
a: 1
b: 2
c: 3
x=1, y=2
x=3, y=4
x=5, y=6

Key Points

•*rest captures remaining elements in unpacking
•[*list1, *list2] merges lists; {**dict1, **dict2} merges dicts
•a, b = b, a swaps without a temp variable
•Parameters after * are keyword-only (must be passed by name)
•Use _ for values you want to ignore in unpacking

Gotchas

•*rest in unpacking always produces a list, even if unpacking a tuple
•Dict merge with ** gives priority to the last dict (rightmost wins)
•You can only have one *rest in an unpacking expression

* unpacks iterables, ** unpacks dicts. first, *rest = list for extended unpacking. {**d1, **d2} or d1 | d2 (3.9+) for dict merge. Parameters after * are keyword-only.

•* for iterables, ** for dicts; *rest captures remaining
•Swap: a, b = b, a; keyword-only after *

first, *rest = [1, 2, 3, 4]  # first=1, rest=[2,3,4]
a, b = b, a                    # Swap
merged = [*list1, *list2]      # Merge lists
config = {**defaults, **overrides}  # Merge dicts

def func(*, keyword_only): ...  # Must be passed by name

In dict merge, rightmost wins for duplicate keys

Question 6 / 12

How does truthiness work in Python and what values are falsy?

Every Python object has a boolean value (truthiness). The following are falsy (evaluate to False in boolean context):

None
False
Zero: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
Empty sequences: '', (), [], {}
Empty sets: set(), frozenset()
Objects with __bool__ returning False or __len__ returning 0

Everything else is truthy.

Python checks __bool__() first; if not defined, checks __len__(); if neither, defaults to True.

Pseudo Code

Falsy: None, False, 0, 0.0, '', [], {}, (), set()
Truthy: everything else

Check order: __bool__() -> __len__() == 0 -> True

Use truthiness: if items: (not if len(items) > 0:)

Code

# Falsy values
print(bool(None))       # False
print(bool(False))      # False
print(bool(0))          # False
print(bool(0.0))        # False
print(bool(''))         # False
print(bool([]))         # False
print(bool({}))         # False
print(bool(()))         # False
print(bool(set()))      # False

# Truthy values
print(bool(1))          # True
print(bool(-1))         # True (non-zero)
print(bool('hello'))    # True (non-empty)
print(bool([0]))        # True (non-empty, even with falsy element)
print(bool(' '))        # True (space is not empty!)

# Pythonic truthiness checks
items = [1, 2, 3]

# Good: use truthiness
if items:
    print("Has items")
if not items:
    print("Empty")

# Bad: verbose
if len(items) > 0:
    print("Has items")
if items != []:
    print("Has items")

# None check: use 'is'
result = None
if result is None:       # Correct
    print("No result")
if result is not None:   # Correct
    print(f"Got: {result}")

# Careful: 0 and '' are falsy but valid!
def process(value):
    # Bug: treats 0 and '' as missing
    if not value:
        return 'default'
    return value

print(process(0))      # 'default' -- wrong! 0 is a valid value
print(process(''))     # 'default' -- wrong! '' might be valid

# Fix: check for None explicitly
def process_fixed(value):
    if value is None:
        return 'default'
    return value

print(process_fixed(0))   # 0 (correct)
print(process_fixed(''))  # '' (correct)

# Custom truthiness
class Playlist:
    def __init__(self, songs):
        self.songs = songs

    def __bool__(self):
        return len(self.songs) > 0

    def __len__(self):
        return len(self.songs)

playlist = Playlist([])
if not playlist:
    print("Empty playlist")  # Triggered

# Short-circuit evaluation
name = user.get('name') or 'Anonymous'  # '' would give 'Anonymous' too!
name = user.get('name', 'Anonymous')    # Better: dict.get default

False
False
False
False
False
False
False
False
False
True
True
True
True
True
Has items
No result
default
default
0

Empty playlist

Key Points

•Falsy: None, False, 0, 0.0, '', [], {}, (), set()
•Use 'if items:' not 'if len(items) > 0:' for empty checks
•Use 'is None' not 'not value' when 0 or '' are valid values
•__bool__() is checked first, then __len__(), then defaults to True
•Short-circuit 'or' treats falsy values as missing (dangerous with 0 and '')

Gotchas

•0, '', and empty collections are falsy; check 'is None' when they are valid
•'x or default' fails for falsy x values; use 'x if x is not None else default'
•' ' (space) is truthy; only '' (empty) is falsy

Falsy: None, False, 0, '', [], {}, (), set(). Everything else is truthy. Use if items: for empty checks. Use is None when 0 or '' are valid values.

•Use truthiness for empty checks; is None for None checks
•0 and '' are falsy but may be valid values

# Pythonic checks
if items:        # Non-empty
if not items:    # Empty
if x is None:    # Specifically None (not falsy)

# Danger: 0 and '' are falsy
if not value:    # Catches None AND 0 AND ''
if value is None:  # Only catches None

'x or default' fails for falsy x values like 0 and ''

Question 7 / 12

How do you use any() and all() idiomatically?

any() and all() are built-in functions that test truthiness across an iterable:

any(iterable): Returns True if ANY element is truthy. Short-circuits on first True.
all(iterable): Returns True if ALL elements are truthy. Short-circuits on first False.

Both accept generator expressions, making them powerful and memory-efficient for checking conditions across collections.

Pseudo Code

any([False, False, True, False]) -> True (at least one)
all([True, True, True, True]) -> True (every one)
any([]) -> False (empty = no truthy elements)
all([]) -> True (empty = no falsy elements, vacuously true)

Code

# Basic usage
print(any([False, False, True]))  # True
print(all([True, True, False]))   # False

# Empty iterables
print(any([]))  # False (no truthy elements)
print(all([]))  # True (vacuously true: no falsy elements)

# With generator expressions (memory efficient + short-circuit)
numbers = [2, 4, 6, 8, 10]

# Check if any number is odd
has_odd = any(n % 2 != 0 for n in numbers)
print(has_odd)  # False

# Check if all numbers are positive
all_positive = all(n > 0 for n in numbers)
print(all_positive)  # True

# Real-world examples
users = [
    {'name': 'Alice', 'active': True, 'admin': False},
    {'name': 'Bob', 'active': True, 'admin': True},
    {'name': 'Charlie', 'active': False, 'admin': False},
]

# Is there at least one admin?
has_admin = any(u['admin'] for u in users)
print(has_admin)  # True

# Are all users active?
all_active = all(u['active'] for u in users)
print(all_active)  # False (Charlie is inactive)

# Validation: all required fields present
required_fields = ['name', 'email', 'age']
data = {'name': 'Alice', 'email': 'a@b.com', 'age': 30}

all_present = all(field in data for field in required_fields)
print(all_present)  # True

missing = [f for f in required_fields if f not in data]
print(missing)  # []

# File checking: does any file exist?
import os
files = ['config.json', 'config.yaml', 'config.toml']
exists = any(os.path.exists(f) for f in files)

# Short-circuit: stops at first match
def expensive_check(x):
    print(f"Checking {x}")
    return x > 5

result = any(expensive_check(x) for x in [1, 2, 10, 3, 4])
# Prints: Checking 1, Checking 2, Checking 10
# Stops! Does not check 3 and 4

# Replacing loops with any/all
# Instead of:
def has_negative_loop(numbers):
    for n in numbers:
        if n < 0:
            return True
    return False

# Use:
def has_negative(numbers):
    return any(n < 0 for n in numbers)

# Negation patterns
# "none of" = not any
none_negative = not any(n < 0 for n in [1, 2, 3])
print(none_negative)  # True

# "not all" = at least one fails
not_all_positive = not all(n > 0 for n in [1, -2, 3])
print(not_all_positive)  # True

True
False
False
True
False
True
True
False
True
[]
Checking 1
Checking 2
Checking 10
True
True

Key Points

•any() returns True if at least one element is truthy; all() if every element is truthy
•Both short-circuit: any stops on first True, all stops on first False
•Use generator expressions for memory efficiency and lazy evaluation
•any([]) is False; all([]) is True (vacuous truth)
•Replace 'for + if + return' patterns with any()/all() for cleaner code

Gotchas

•all([]) is True (vacuous truth); this surprises many developers
•Generator expressions are consumed after use; cannot reuse them
•any/all with generator expressions evaluate lazily; list comprehensions evaluate eagerly

any() returns True if any element is truthy; all() if all are. Both short-circuit and work with generator expressions. Replace for + if + return True patterns with any(condition for x in items).

•any = at least one; all = every one; both short-circuit
•Use generators for lazy evaluation

# Any admin?
has_admin = any(u['admin'] for u in users)

# All required fields present?
all_present = all(f in data for f in required_fields)

# Short-circuits (stops at first match)
any(x > 100 for x in huge_list)  # Stops at first True

all([]) is True (vacuous truth)

Question 8 / 12

Why should you use enumerate() instead of range(len())?

enumerate() provides both the index and value during iteration, replacing the anti-pattern for i in range(len(items)) with cleaner, more Pythonic code.

enumerate(iterable, start=0) yields (index, value) tuples. The optional start parameter sets the starting index.

Pseudo Code

Bad:  for i in range(len(items)): item = items[i]
Good: for i, item in enumerate(items):

enumerate yields (index, value) pairs
start= parameter sets starting index

Code

fruits = ['apple', 'banana', 'cherry']

# Anti-pattern: range(len())
for i in range(len(fruits)):
    print(f"{i}: {fruits[i]}")

# Pythonic: enumerate()
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

# Start from 1 (useful for display)
for num, fruit in enumerate(fruits, start=1):
    print(f"{num}. {fruit}")
# 1. apple
# 2. banana
# 3. cherry

# Find index of first match
def find_first(items, predicate):
    for i, item in enumerate(items):
        if predicate(item):
            return i
    return -1

index = find_first(['a', 'bb', 'ccc'], lambda x: len(x) > 1)
print(index)  # 1

# Build indexed dict
index_map = {item: i for i, item in enumerate(fruits)}
print(index_map)  # {'apple': 0, 'banana': 1, 'cherry': 2}

# Enumerate with zip
names = ['Alice', 'Bob', 'Charlie']
scores = [85, 92, 78]

for i, (name, score) in enumerate(zip(names, scores), start=1):
    print(f"#{i} {name}: {score}")
# #1 Alice: 85
# #2 Bob: 92
# #3 Charlie: 78

# enumerate works with any iterable
for i, line in enumerate(open('file.txt'), start=1):
    print(f"Line {i}: {line.strip()}")

# enumerate returns an iterator (lazy)
result = enumerate(fruits)
print(next(result))  # (0, 'apple')
print(next(result))  # (1, 'banana')

0: apple
1: banana
2: cherry
0: apple
1: banana
2: cherry
1. apple
2. banana
3. cherry
1
{'apple': 0, 'banana': 1, 'cherry': 2}
1 Alice: 85
2 Bob: 92
3 Charlie: 78
Line 1: Hello
Line 2: More
(0, 'apple')
(1, 'banana')

Key Points

•enumerate() replaces range(len()) with cleaner (index, value) iteration
•start= parameter sets the starting index (default 0)
•Works with any iterable, not just lists
•Returns an iterator (lazy); combine with zip for parallel iteration
•Unpacks naturally: for i, item in enumerate(items)

Gotchas

•enumerate returns an iterator; convert to list() if you need to iterate multiple times
•range(len()) is needed when you want to iterate indices without values (rare)
•Do not use enumerate just for the index if you never use the value

enumerate(items) gives (index, value) pairs. Replaces for i in range(len(items)). Use start=1 for 1-based numbering. Works with any iterable.

•enumerate gives (index, value); start= for custom start
•Always prefer over range(len())

# Bad
for i in range(len(items)):
    print(i, items[i])

# Good
for i, item in enumerate(items):
    print(i, item)

# 1-based
for num, item in enumerate(items, start=1):
    print(f"{num}. {item}")

enumerate returns an iterator, not a list

Question 9 / 12

How do you merge dictionaries in Python (including the | operator)?

Python offers several ways to merge dictionaries, with newer versions providing cleaner syntax:

| operator (Python 3.9+): merged = d1 | d2 (creates new dict).
|= operator (Python 3.9+): d1 |= d2 (updates d1 in-place).
**{**d1, **d2}** (Python 3.5+): Unpacking into a new dict.
d1.update(d2): Updates d1 in-place (no new dict).
ChainMap: View over multiple dicts (no copying).

In all cases, later values override earlier ones for duplicate keys.

Pseudo Code

d1 | d2       -> new dict (3.9+), d2 wins on conflicts
d1 |= d2      -> update d1 in-place (3.9+)
{**d1, **d2}  -> new dict (3.5+), d2 wins
d1.update(d2) -> update d1 in-place
ChainMap(d1, d2) -> view over both (no copy)

Code

d1 = {'a': 1, 'b': 2}
d2 = {'b': 3, 'c': 4}

# Python 3.9+: | operator (new dict)
merged = d1 | d2
print(merged)  # {'a': 1, 'b': 3, 'c': 4}
print(d1)      # {'a': 1, 'b': 2} (unchanged)

# Python 3.9+: |= in-place update
d1_copy = d1.copy()
d1_copy |= d2
print(d1_copy)  # {'a': 1, 'b': 3, 'c': 4}

# Python 3.5+: ** unpacking (new dict)
merged = {**d1, **d2}
print(merged)  # {'a': 1, 'b': 3, 'c': 4}

# Merge 3+ dicts
d3 = {'d': 5}
merged = d1 | d2 | d3          # 3.9+
merged = {**d1, **d2, **d3}     # 3.5+

# .update() (in-place, returns None)
d1_copy = d1.copy()
d1_copy.update(d2)
print(d1_copy)  # {'a': 1, 'b': 3, 'c': 4}

# ChainMap (no copying, first dict wins)
from collections import ChainMap

defaults = {'color': 'red', 'size': 'medium', 'debug': False}
user_prefs = {'color': 'blue', 'debug': True}

# ChainMap searches dicts in order; first match wins
config = ChainMap(user_prefs, defaults)
print(config['color'])  # 'blue' (from user_prefs)
print(config['size'])   # 'medium' (from defaults)
print(dict(config))     # {'color': 'blue', 'size': 'medium', 'debug': True}

# Merge with custom conflict resolution
def merge_with(d1, d2, resolver):
    """Merge dicts using a resolver function for conflicts."""
    result = d1.copy()
    for key, value in d2.items():
        if key in result:
            result[key] = resolver(result[key], value)
        else:
            result[key] = value
    return result

# Sum values for duplicate keys
scores1 = {'alice': 10, 'bob': 20}
scores2 = {'bob': 15, 'charlie': 25}
merged = merge_with(scores1, scores2, lambda a, b: a + b)
print(merged)  # {'alice': 10, 'bob': 35, 'charlie': 25}

{'a': 1, 'b': 3, 'c': 4}
{'a': 1, 'b': 2}
{'a': 1, 'b': 3, 'c': 4}
{'a': 1, 'b': 3, 'c': 4}
{'a': 1, 'b': 3, 'c': 4}
blue
medium
{'color': 'blue', 'size': 'medium', 'debug': True}
{'alice': 10, 'bob': 35, 'charlie': 25}

Key Points

•| operator (3.9+) is the cleanest way to merge dicts
•Later dicts override earlier ones for duplicate keys
•{**d1, **d2} works in Python 3.5+
•ChainMap provides a view without copying (first dict has priority)
•Use .update() or |= for in-place modification

Gotchas

•| creates a new dict; update() and |= modify in-place
•ChainMap priority is opposite to |: first dict wins in ChainMap, last wins in |
•** unpacking requires all keys to be strings (for function calls); dicts can have non-string keys

Python 3.9+: d1 | d2 (new dict, d2 wins). 3.5+: {**d1, **d2}. In-place: d1.update(d2) or d1 |= d2. ChainMap for read-only view. Later dicts override earlier for duplicate keys.

•| creates new dict (3.9+); later values win
•ChainMap for lazy, copy-free merging

# Python 3.9+
merged = defaults | overrides  # New dict
defaults |= overrides          # In-place

# Python 3.5+
merged = {**defaults, **overrides}

# No copy
from collections import ChainMap
config = ChainMap(overrides, defaults)  # overrides checked first

ChainMap priority is reversed: first dict wins

Question 10 / 12

What is the walrus operator (:=) and when should you use it?

The walrus operator (:=, PEP 572, Python 3.8+) is an assignment expression that assigns a value to a variable as part of an expression. It lets you assign and use a value in the same line.

The name comes from the visual similarity of := to a walrus face turned sideways.

Use cases:

Avoid computing a value twice (compute + check in one expression).
Simplify while loops that need a read-check pattern.
Reduce nesting in comprehensions and conditionals.

Pseudo Code

Without walrus: compute, assign, check separately
With walrus: (result := compute()) used in the same expression

Best for:
- while (line := f.readline()): ...
- if (match := pattern.search(text)): ...
- [y for x in data if (y := transform(x)) > threshold]

Code

# Without walrus: compute value twice or use extra line
data = input("Enter data: ")
while data != 'quit':
    print(f"Processing: {data}")
    data = input("Enter data: ")  # Repeated!

# With walrus: assign and check in one expression
while (data := input("Enter data: ")) != 'quit':
    print(f"Processing: {data}")

# Pattern: avoid double computation
import re

text = "The price is $42.99"

# Without walrus
match = re.search(r'\$(\d+\.\d+)', text)
if match:
    print(f"Found price: {match.group(1)}")

# With walrus
if match := re.search(r'\$(\d+\.\d+)', text):
    print(f"Found price: {match.group(1)}")

# Reading files
with open('data.txt') as f:
    while line := f.readline():
        print(line.strip())

# List comprehension with walrus (filter + transform)
import math

numbers = [1, 4, 9, 16, 25, 36]
# Without walrus: compute sqrt twice
result = [math.sqrt(n) for n in numbers if math.sqrt(n) > 3]

# With walrus: compute once
result = [root for n in numbers if (root := math.sqrt(n)) > 3]
print(result)  # [4.0, 5.0, 6.0]

# Validation: check and use
def process_user(data: dict) -> str:
    if (name := data.get('name')) is None:
        return "Name required"
    if (email := data.get('email')) is None:
        return "Email required"
    return f"User: {name} <{email}>"

# API pagination
import requests

def fetch_all_pages(url):
    results = []
    page = 1
    while (response := requests.get(url, params={'page': page})).json():
        data = response.json()
        if not data:
            break
        results.extend(data)
        page += 1
    return results

# When NOT to use walrus (over-complication)
# Bad: too clever
if (n := len(items)) > 10 and (first := items[0]) == 'special':
    print(f"{n} items, first is {first}")

# Better: explicit
n = len(items)
if n > 10 and items[0] == 'special':
    print(f"{n} items, first is {items[0]}")

Key Points

•:= assigns AND returns the value in one expression
•Best for while loops with read-check pattern and if statements with compute-check
•In comprehensions, avoids computing a value twice (filter + use)
•Named 'walrus operator' because := looks like a walrus face sideways
•Do not overuse: readability is more important than brevity

Gotchas

•Cannot be used for augmented assignment (no +=, -=, etc.)
•:= has lower precedence than most operators; use parentheses when needed
•Overuse makes code harder to read; use only when it clearly simplifies

:= (walrus operator, 3.8+) assigns and returns a value in one expression. Best for while (line := readline()): and if (match := search()): patterns. Avoids computing values twice. Do not overuse.

•:= assigns and returns; best for while/if patterns
•Avoids double computation; do not overuse

# Assign + check in one line
if (match := re.search(pattern, text)):
    print(match.group())

# While loop with read-check
while (line := f.readline()):
    process(line)

# Comprehension: compute once
result = [y for x in data if (y := transform(x)) > threshold]

Use parentheses around := in conditions; lower precedence

Question 11 / 12

What are the most useful f-string tips and tricks?

F-strings (PEP 498, Python 3.6+) are the preferred way to format strings in Python. They are faster than .format() and % formatting, and more readable.

Beyond basic f"{variable}", f-strings support:

Expressions and method calls inside {}
Format specifiers (: after the expression)
Self-documenting = (Python 3.8+)
Multi-line f-strings
Nested quotes and braces

Pseudo Code

f"{value}"          - basic interpolation
f"{value:.2f}"      - 2 decimal places
f"{value:>10}"      - right-align, width 10
f"{value=}"         - self-documenting (3.8+)
f"{value!r}"        - repr() of value
f"{value:,}"        - thousands separator

Code

name = 'Alice'
age = 30
price = 42.5678

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

# Expressions
print(f"Next year: {age + 1}")          # Next year: 31
print(f"Upper: {name.upper()}")         # Upper: ALICE
print(f"Length: {len(name)}")           # Length: 5

# Format specifiers
print(f"Price: {price:.2f}")            # Price: 42.57
print(f"Price: ${price:,.2f}")          # Price: $42.57
print(f"Percent: {0.456:.1%}")          # Percent: 45.6%
print(f"Binary: {42:b}")               # Binary: 101010
print(f"Hex: {255:#x}")                # Hex: 0xff
print(f"Oct: {8:o}")                   # Oct: 10

# Alignment and padding
print(f"{'left':<20}")                  # left                (left-align)
print(f"{'right':>20}")                 # right               (right-align)
print(f"{'center':^20}")                # center              (center)
print(f"{'padded':*^20}")               # *******padded*******
print(f"{42:05d}")                      # 00042 (zero-padded)

# Self-documenting = (Python 3.8+)
x = 10
y = 20
print(f"{x=}, {y=}")                    # x=10, y=20
print(f"{x + y=}")                      # x + y=30
print(f"{name=!r}")                     # name='Alice'
print(f"{price=:.2f}")                  # price=42.57

# repr vs str
print(f"{name!r}")   # 'Alice' (repr, with quotes)
print(f"{name!s}")   # Alice (str, default)

# Date formatting
from datetime import datetime
now = datetime.now()
print(f"{now:%Y-%m-%d %H:%M}")          # 2024-01-15 14:30
print(f"{now:%B %d, %Y}")               # January 15, 2024

# Thousands separator
big_number = 1234567890
print(f"{big_number:,}")                # 1,234,567,890
print(f"{big_number:_}")                # 1_234_567_890

# Dynamic format specification
width = 20
align = '^'
fill = '-'
print(f"{'hello':{fill}{align}{width}}")  # -------hello--------

# Nested f-strings (Python 3.12+)
# print(f"result: {f'{x} + {y}'}")  # 3.12+ allows nested f-strings

# Multi-line
message = (
    f"User: {name}\n"
    f"Age: {age}\n"
    f"Price: ${price:.2f}"
)
print(message)

# Dictionary access (use different quotes)
user = {'name': 'Alice', 'age': 30}
print(f"Name: {user['name']}")  # Use single quotes inside double

Hello, Alice!
Next year: 31
Upper: ALICE
Length: 5
Price: 42.57
Price: $42.57
Percent: 45.6%
Binary: 101010
Hex: 0xff
Oct: 10
left
right
center
*******padded*******
00042
x=10, y=20
x + y=30
name='Alice'
price=42.57
'Alice'
Alice
2026-03-18 11:31
March 18, 2026
1,234,567,890
1_234_567_890
-------hello--------
User: Alice
Age: 30
Price: $42.57
Name: Alice

Key Points

•f-strings are faster and more readable than .format() and % formatting
•= suffix (3.8+) self-documents: f'{x=}' prints 'x=10'
•:.2f for decimals, :, for thousands, :>10 for alignment, !r for repr
•Support any expression: method calls, math, ternary, etc.
•Use different quote styles for nested quotes: f"{d['key']}"

Gotchas

•Backslashes are not allowed inside f-string expressions; use a variable instead
•Curly braces in f-strings must be escaped: f'{{literal braces}}'
•f-strings evaluate expressions at runtime; be careful with side effects

F-strings: f"{value:.2f}" for formatting, f"{x=}" (3.8+) for self-documenting output, !r for repr, :, for thousands, :<20 for alignment. Faster and more readable than .format() and %.

•= for self-documenting; :.2f for decimals; :, for thousands
•Faster than .format() and % formatting

x = 42
print(f"{x=}")          # x=42 (self-documenting)
print(f"{x:.2f}")       # 42.00 (decimal places)
print(f"{x:,}")         # 42 (thousands separator for big numbers)
print(f"{x:>10}")       # "        42" (right-align)
print(f"{'hi':*^10}")   # "****hi****" (center with fill)

x=42
42.00
42
42
****hi****

No backslashes inside f-string expressions; escape {{ for literal braces

Question 12 / 12

What are the most common Python anti-patterns to avoid?

Python anti-patterns are common coding mistakes that lead to bugs, poor performance, or unreadable code. Here are the most important ones to avoid:

Pseudo Code

1. Mutable default arguments
2. Bare except clauses
3. Using type() instead of isinstance()
4. range(len()) instead of enumerate()
5. Manual string concatenation in loops
6. Not using context managers for resources
7. Catch-all exception handling
8. Global mutable state

Code

# Anti-pattern 1: Mutable default argument
# BAD: default list is shared across all calls!
def append_to(value, items=[]):
    items.append(value)
    return items

print(append_to(1))  # [1]
print(append_to(2))  # [1, 2] -- BUG! Shared list!

# GOOD: use None sentinel
def append_to(value, items=None):
    if items is None:
        items = []
    items.append(value)
    return items

# Anti-pattern 2: Bare except
# BAD: catches EVERYTHING including KeyboardInterrupt and SystemExit
try:
    result = risky_operation()
except:
    pass  # Silently swallows ALL errors

# GOOD: catch specific exceptions
try:
    result = risky_operation()
except ValueError as e:
    print(f"Invalid value: {e}")
except (IOError, OSError) as e:
    print(f"I/O error: {e}")

# Anti-pattern 3: type() instead of isinstance()
# BAD: does not account for inheritance
if type(x) == int:
    pass

# GOOD: works with subclasses
if isinstance(x, int):
    pass
if isinstance(x, (int, float)):  # Multiple types
    pass

# Anti-pattern 4: range(len()) instead of enumerate()
# BAD
for i in range(len(items)):
    print(i, items[i])

# GOOD
for i, item in enumerate(items):
    print(i, item)

# Anti-pattern 5: String concatenation in loops
# BAD: O(n^2) due to string immutability
result = ''
for item in items:
    result += str(item) + ', '

# GOOD: O(n)
result = ', '.join(str(item) for item in items)

# Anti-pattern 6: Not using context managers
# BAD: file may not be closed on exception
f = open('data.txt')
data = f.read()
f.close()  # May never run if read() raises!

# GOOD: guaranteed cleanup
with open('data.txt') as f:
    data = f.read()

# Anti-pattern 7: Using == for None/bool comparison
# BAD
if x == None:
    pass
if x == True:
    pass

# GOOD
if x is None:
    pass
if x:  # or: if x is True: (if you need exact True)
    pass

# Anti-pattern 8: Wildcard imports
# BAD: pollutes namespace, hides where names come from
from os.path import *

# GOOD: explicit imports
from os.path import join, exists, dirname

# Anti-pattern 9: Using list as a set for membership
# BAD: O(n) lookup
if item in large_list:
    pass

# GOOD: O(1) lookup
large_set = set(large_list)
if item in large_set:
    pass

Key Points

•Use None for mutable defaults, not [] or {}
•Catch specific exceptions, never bare except:
•isinstance() for type checks, not type() ==
•enumerate() instead of range(len())
•''.join() instead of += in loops

Gotchas

•Mutable default argument bug is the most common Python gotcha
•Bare except catches KeyboardInterrupt and SystemExit (use except Exception at minimum)
•These anti-patterns are tested in interviews; know them well

Top anti-patterns: mutable defaults (def f(x=[]):), bare except:, type() instead of isinstance(), range(len()) instead of enumerate(), += strings in loops, not using with for files. Know these for interviews.

•None for mutable defaults; specific exceptions; isinstance()
•enumerate(); join(); with for resources

# Mutable default: use None
def f(items=None):
    items = items or []

# Specific exceptions
except ValueError as e:

# isinstance, not type()
if isinstance(x, int):

# enumerate, not range(len())
for i, item in enumerate(items):

# join, not +=
result = ', '.join(items)

Mutable default arguments are the #1 Python interview gotcha

Built by onllm.dev

Home GitHub Support awesomePrep