# ❌ Imperative accumulation
result = []
for item in items:
    if item.active:
        result.append(item.name.upper())
# ✅
result = [item.name.upper() for item in items if item.active]

# ❌ Dict built in a loop
d = {}
for k, v in pairs:
    d[k] = v
# ✅
d = dict(pairs)
# or
d = {k: v for k, v in pairs}

# ❌ Generator converted to list unnecessarily
total = sum(list(x * 2 for x in nums))
# ✅ — generator expression works directly in sum()
total = sum(x * 2 for x in nums)

# ❌ Index access
first = items[0]
rest = items[1:]
# ✅
first, *rest = items

# ❌ Temporary variable for swap
tmp = a
a = b
b = tmp
# ✅
a, b = b, a

# ❌ items() with separate indexing
for i in range(len(items)):
    print(i, items[i])
# ✅
for i, item in enumerate(items):
    print(i, item)

# ❌ zip with separate index
for i in range(len(a)):
    process(a[i], b[i])
# ✅
for x, y in zip(a, b, strict=True): # Python 3.10+; fail if lengths differ
    process(x, y)

# ❌ Manual max search
max_val = items[0]
for item in items[1:]:
    if item > max_val:
        max_val = item
# ✅
max_val = max(items)

# ❌ Manual grouping
from collections import defaultdict
groups = defaultdict(list)
for item in items:
    groups[item.category].append(item)
# ✅ — same thing, just be explicit about defaultdict; it IS the right tool
# (this example is already correct — don't replace defaultdict with a loop)

# ❌ Manual sentinel for dict default
if key in d:
    val = d[key]
else:
    val = default
# ✅
val = d.get(key, default)

# ❌ Rolling your own counter
counts = {}
for item in items:
    counts[item] = counts.get(item, 0) + 1
# ✅
from collections import Counter
counts = Counter(items)

# ❌ Mutable default argument (bug, not just style)
def append_to(item, lst=[]):
    lst.append(item)
    return lst
# ✅
def append_to(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

# ❌ Positional args for everything when keyword clarity helps
create_user("Alice", True, False, 30)
# ✅ — use keyword args at call site for boolean/ambiguous params
create_user("Alice", is_admin=True, is_active=False, age=30)

# ❌ Long function doing multiple things
def process_and_save(data):
    # 40 lines of transform
    # 20 lines of DB write
    ...
# ✅ — split only if each part is reused OR independently testable
def _transform(data): ...
def _save(record): ...
def process_and_save(data): _save(_transform(data))

# ❌ Manual __init__ for data holders
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
# ✅
from dataclasses import dataclass
@dataclass
class Point:
    x: float
    y: float

# ❌ Class just to hold a namespace of functions
class MathUtils:
    @staticmethod
    def add(a, b): return a + b
# ✅ — module-level functions; classes for state + behavior
def add(a, b): return a + b

# ❌ __repr__ written manually when dataclass gives it free
# (see above — use @dataclass)

# ❌ Bare except
try:
    risky()
except:
    pass
# ✅ — catch the specific exception; don't swallow silently
try:
    risky()
except ValueError as e:
    logger.warning("Invalid value: %s", e)

# ❌ LBYL (look before you leap) when EAFP is cleaner
if os.path.exists(path):
    with open(path) as f:
        data = f.read()
# ✅ (EAFP)
try:
    with open(path) as f:
        data = f.read()
except FileNotFoundError:
    data = None

# ❌ Re-raising with raise e (adds a re-raise frame)
except Exception as e:
    raise e
# ✅
except Exception:
    raise  # bare raise preserves original traceback

# ❌ Overly verbose Union syntax (Python <3.10 style in new code)
from typing import Optional, Union
def f(x: Optional[int]) -> Union[str, None]: ...
# ✅ (Python 3.10+)
def f(x: int | None) -> str | None: ...

# ❌ Any where a TypeVar or Protocol would be informative
from typing import Any
def first(lst: list[Any]) -> Any: ...
# ✅
from typing import TypeVar
T = TypeVar("T")
def first(lst: list[T]) -> T: ...