COMMON PYTHON FIXES
Search a symptom, inspect broken code, and follow a full guide or a quick answer. Each guide explains the failure, its cause, the fix, and how to verify it.
Paste the last line of a Python error, or type what went wrong. This tool checks it in your browser and suggests relevant guides. Compare the cause in the guide with your own code before changing anything.
Your text stays in this browser. For a traceback, the final error line is usually enough; leave out file paths or private data.
Search specific wording or filter by topic. Full guides include a reproducible failure, explanation, correction, and practice.
Showing fixes from . Show all problems
402 results
No matches yet. Try another term or topic.
Deleting keys while looping over a dictionary invalidates its live iterator. Use a snapshot of keys for in-place deletion or build a new filtered dictionary, then verify the original-state rule.
Your output contains {name} instead of the value of name. Diagnose the missing f prefix, then learn when doubled braces are actually needed.
Use a list comprehension when you need a list immediately. filter() applies a predicate lazily, so convert its iterator to a list only when you need the whole result.
A function assigns to a name, so Python treats it as local throughout that function; reading it before a value is assigned raises UnboundLocalError. Pass the current value in and return the update, or initialize a branch-dependent local before reading it.
Use isinstance(value, Base) when instances of Base and its subclasses are valid. Use an exact type check only when the contract intentionally excludes subclasses.
The item was added, yet the variable assigned from append() contains None. See exactly which object changed and choose the right pattern for your program.
A default list is created when the function is defined, so later calls can reuse it. Trace that shared object, then create a fresh list when the caller omits the argument.
A datetime without timezone information cannot be ordered against one with an offset. Identify what the naive value means, make that interpretation explicit, and verify comparisons across offsets.
Square brackets fail when the value before them is None. Trace the lookup that produced None, handle the missing record explicitly, and test the edge cases.
The right-hand side produces more values than the assignment has targets. Count the fields, then choose the targets or a starred remainder that fits the data contract.
A list cannot be a set member or dictionary key because it is mutable and unhashable. Convert fixed coordinate values to tuples, then test duplicates and nested values.
int() can parse a valid whole-number string, but text such as '12.5' is not an integer literal. Inspect the actual input, validate the intended format, and test the edge cases.
Dividing by zero stops a calculation. Trace where the divisor came from, decide what zero means for your program, and test that rule instead of hiding the error.
The characters a person types look like a number, but input() returns a string. Find the mismatched types, convert deliberately, and handle text that cannot be converted.
An install can succeed in one Python environment while your program runs in another. Prove which interpreter each command uses, then make installation and execution use the same one.
If each loop iteration assigns a new value to one variable, the earlier values disappear. Trace the variable, create a collection before the loop, and add each result to it.
A relative filename is resolved from the process working directory, which may differ from the script's folder. Print both paths, then choose an explicit location for the data file.
A list has fewer positions than your code expects. Reproduce the failure, inspect the list length, and choose a safe lookup or iteration pattern that matches the task.
A message on the screen is not a value returned to the caller. Trace the function's result, add an explicit return, and test how another line can use that value.
A dictionary lookup with square brackets requires the exact key to exist. Inspect the available keys, then decide whether a missing key should be handled or treated as an error.
sorted(products) cannot compare whole dictionaries. Reproduce the TypeError, select a numeric price key, and test ties without changing the original list.
The code runs, but the historical claim is false.
print("Python was named after a snake.")print("Python was named after Monty Python.")A program can run successfully and still print incorrect information. Check the fact as well as the syntax.
The code runs, but it confuses two milestones.
print("Python 3.0 was first shared in 1991.")print("Python was public in 1991; Python 3.0 arrived in 2008.")Python's first public sharing and the Python 3.0 release happened at different times.
NameError: Python looks for a variable named Hello.
print(Hello)print("Hello")Put literal text inside quotes so Python treats it as a string.
SyntaxError in Python 3.
print "Hello"print("Hello")print is a function, so its argument goes inside parentheses.
NameError because Name and name are different names.
name = "Maya"
print(Name)name = "Maya"
print(name)Use exactly the same spelling and capitalization each time.
TypeError when joining a string and an integer.
age = 12
print("Age: " + age)age = 12
print("Age: " + str(age))Convert the number to a string before concatenating it with text.
IndexError because the only valid positive indexes are 0 and 1.
items = ["a", "b"]
print(items[2])items = ["a", "b"]
print(items[1])The final positive index is len(items) - 1.
The variable becomes None.
items = [1, 2]
items = items.append(3)
print(items)items = [1, 2]
items.append(3)
print(items)Call append without assigning its return value.
It prints 1 because ^ is bitwise XOR.
print(2 ^ 3)print(2 ** 3)Python's exponentiation operator is **.
ZeroDivisionError.
print(10 / 0)print(10 / 2)The divisor must be nonzero.
The literal text Hi, {name} is displayed.
name = "Maya"
print("Hi, {name}")name = "Maya"
print(f"Hi, {name}")Add f before the opening quote to evaluate placeholders.
NameError because username has not been defined.
name = "Maya"
print(f"Hi, {username}")name = "Maya"
print(f"Hi, {name}")A placeholder must refer to a defined name or valid expression.
IndexError because valid positive indexes are 0, 1, and 2.
word = "cat"
print(word[3])word = "cat"
print(word[2])The last positive index is one less than the string length.
TypeError because strings cannot be changed in place.
word = "cat"
word[0] = "b"word = "cat"
word = "b" + word[1:]
print(word)Construct a new string and assign it to the variable.
SyntaxError on the if line.
score = 75
if score >= 60
print("Passed")score = 75
if score >= 60:
print("Passed")End the if header with a colon.
IndentationError after the if header.
score = 75
if score >= 60:
print("Passed")score = 75
if score >= 60:
print("Passed")Indent statements that belong to the branch.
The condition stays true, so the loop keeps printing 0.
count = 0
while count < 3:
print(count)count = 0
while count < 3:
print(count)
count += 1Update the value tested by the condition.
Only 1, 2, and 3 appear.
for n in range(1, 4):
print(n)
# Expecting 1, 2, 3, 4for n in range(1, 5):
print(n)range excludes its stop argument.
The function prints 8, but result is None.
def double(value):
print(value * 2)
result = double(4)
print(result)def double(value):
return value * 2
result = double(4)
print(result)Use return when callers need to store or reuse the calculated value.
TypeError because name was not supplied.
def greet(name):
print(f"Hi, {name}")
greet()def greet(name):
print(f"Hi, {name}")
greet("Maya")Provide one argument for each required parameter.
TypeError because Python passes the instance automatically.
class Book:
def summary():
return "A book"
book = Book()
print(book.summary())class Book:
def summary(self):
return "A book"
book = Book()
print(book.summary())Instance methods need self as their first parameter.
AttributeError because no title attribute was stored on the object.
class Book:
def __init__(self, title):
title = title
book = Book("Python Notes")
print(book.title)class Book:
def __init__(self, title):
self.title = title
book = Book("Python Notes")
print(book.title)Assign to self.title to save the value on the instance.
KeyError for score.
learner = {"name": "Maya"}
print(learner["score"])learner = {"name": "Maya"}
print(learner.get("score", 0))Use get with a fallback if the key may be absent.
KeyError because 0 is not a key.
learner = {"name": "Maya"}
print(learner[0])learner = {"name": "Maya"}
print(learner["name"])Dictionary lookup uses keys, not numeric positions.
NameError if math has not been imported in this run.
print(math.sqrt(9))import math
print(math.sqrt(9))Import the module before using its name.
AttributeError because math now refers to the integer 4.
import math
math = 4
print(math.sqrt(9))import math
number = 4
print(math.sqrt(9))Avoid reusing an imported module's name for another value.
TypeError because entered_age is text.
entered_age = "17"
print(entered_age + 1)entered_age = "17"
print(int(entered_age) + 1)Convert numeric text before arithmetic.
ValueError because the text is not a valid integer.
entered_age = "seventeen"
print(int(entered_age))entered_age = "17"
print(int(entered_age))int accepts text that represents a valid whole number.
A 20% tip on 40 becomes 800 instead of 8.
tip = bill * 20tip = bill * 20 / 100Convert a percent to a fraction before multiplying.
The whole tip is charged to every person.
each = bill / people + tipeach = (bill + tip) / peopleAdd the tip once to the whole bill, then split the total.
SyntaxError because = is assignment, not comparison.
if guess = secret:
print('Correct')if guess == secret:
print('Correct')Use == when asking whether two values are equal.
The player receives a misleading hint.
if guess < secret:
return 'Too high'if guess < secret:
return 'Too low'Compare the guessed number to the secret from the player's perspective.
'red blue' reports eight characters instead of two words.
word_count = len(text)word_count = len(text.split())Split the text first when you want a word count.
'Code' and 'code' become separate dictionary keys.
words = text.split()words = text.lower().split()Normalize case before counting for a case-insensitive report.
It prints False because a set has only two distinct values.
print(len(set([1, 1, 2])) == 3)print(len(set([1, 1, 2])) == 2)A set keeps one copy of each equal value.
AttributeError: a dictionary has no add method.
items = {}
items.add('python')items = set()
items.add('python')Construct an empty set with set().
ZeroDivisionError still stops the program.
try:
print(4 / 0)
except ValueError:
print('Bad number')try:
print(4 / 0)
except ZeroDivisionError:
print('Cannot divide by zero')The except type must match the error that may be raised.
Unrelated bugs are hidden behind a vague message.
try:
risky_code()
except:
print('Something failed')try:
number = float('bad')
except ValueError:
print('Invalid number')Catch an expected error by name so other failures remain visible.
FileNotFoundError if the virtual file has not been created in this run.
with open('new_note.txt', 'r', encoding='utf-8') as file:
print(file.read())with open('new_note.txt', 'w', encoding='utf-8') as file:
file.write('Ready')
with open('new_note.txt', 'r', encoding='utf-8') as file:
print(file.read())Create the file before trying to read it in a fresh exercise run.
The old file contents disappear.
with open('note.txt', 'w', encoding='utf-8') as file:
file.write('second')with open('note.txt', 'a', encoding='utf-8') as file:
file.write('second')Choose a only when the new text should be added at the end.
SyntaxError in the browser editor: this is a shell command.
python -m venv .venvimport sys
print(sys.version_info.major)Use the browser editor for Python statements and a local terminal for setup commands.
The claim may be false because the browser runtime is separate.
print('My laptop uses Python 3.13')import sys
print(sys.version_info.major, sys.version_info.minor)Inspect each interpreter in its own environment rather than assuming they match.
The result contains doubled odd values, such as [2, 6] for [1, 2, 3, 4].
[n * 2 for n in numbers if n % 2][n * 2 for n in numbers if n % 2 == 0]The remainder is 1 for odd numbers, which is truthy. Compare explicitly with zero for even values.
SyntaxError: expected else after the conditional expression.
[n * 2 if n % 2 == 0 for n in numbers][n * 2 for n in numbers if n % 2 == 0]A trailing if filters items. An if before for is a different expression form and needs an else branch.
Odd inputs become zero, so the output still has one element per input instead of only even values.
[n if n % 2 == 0 else 0 for n in numbers][n for n in numbers if n % 2 == 0]Use a trailing if when items should disappear. Use an if/else expression when every item must produce an output.
NameError: name 'total' is not defined.
def total_with_tax(price):
total = price * 1.2
total_with_tax(20)
print(total)def total_with_tax(price):
total = price * 1.2
return total
print(total_with_tax(20))Return the local value. The call expression then provides it to the caller.
The output contains 8 and then None.
def double(n):
print(n * 2)
result = double(4)
print(result)def double(n):
return n * 2
result = double(4)
print(result)Printing is a side effect. A return statement makes the value available for assignment and further calculation.
JSONDecodeError because JSON keys and strings need double quotes.
json.loads("{'name': 'Ada'}")json.loads('{"name": "Ada"}')Use json.dumps to produce JSON from Python values instead of assembling a repr-like string yourself.
TypeError: can only concatenate str (not int) to str.
row = next(csv.DictReader(StringIO('score\n7\n')))
print(row['score'] + 1)row = next(csv.DictReader(StringIO('score\n7\n')))
print(int(row['score']) + 1)Every CSV cell starts as text. Convert with int only when the data should contain a whole number.
AttributeError because topic is the integer index.
for topic, number in enumerate(['loops'], start=1):
print(topic.upper())for number, topic in enumerate(['loops'], start=1):
print(topic.upper())enumerate gives index first, item second. Name the unpacked values in that order.
The second score is lost and no exception explains the mismatch.
list(zip(['Ada'], [8, 5]))list(zip(['Ada'], [8, 5], strict=True))Use strict=True when both sequences must have matching lengths; consume the iterator to trigger the check.
The result is a set of words with no lengths.
lengths = {word for word in ['cat', 'go']}lengths = {word: len(word) for word in ['cat', 'go']}Include key: value before for when the result should be a dictionary.
AttributeError: 'dict' object has no attribute 'add'.
seen = {}
seen.add('Ada')seen = set()
seen.add('Ada')Python reserves empty braces for a dictionary. Use set() for an empty set.
The terminal shows a value, but a wrong value does not fail a repeatable test.
print(double(4))assert double(4) == 8State the expected value explicitly so a regression fails when the test runs.
An implementation that always returns value passes even though it fails outside the range.
assert clamp(5, 0, 10) == 5assert clamp(5, 0, 10) == 5
assert clamp(-1, 0, 10) == 0
assert clamp(11, 0, 10) == 10Choose inputs that exercise each branch, including boundaries and errors.
Running Python with -O can remove the check and allow a negative age through.
def save_age(age):
assert age >= 0
return agedef save_age(age):
if age < 0:
raise ValueError('age must be non-negative')
return ageExplicit validation runs regardless of optimization; reserve assertions for checks whose removal does not change required behavior.
It prints an invalid February 30 instead of crossing into March.
start = '2024-02-28'
print(start[:-2] + str(int(start[-2:]) + 2))start = date.fromisoformat('2024-02-28')
print((start + timedelta(days=2)).isoformat())Calendar arithmetic handles the length of each month and leap years.
TypeError because a date cannot be added to a bare integer.
date.fromisoformat('2024-02-28') + 1date.fromisoformat('2024-02-28') + timedelta(days=1)Wrap the offset in a timedelta to state its unit and meaning.
The result is the text 12.503.00, not a money total.
total = "12.50" + "3.00"total = Decimal("12.50") + Decimal("3.00")Convert each string to Decimal before adding it. Build Decimal from the source text to keep decimal values exact.
A quoted category such as Food, snacks is split into too many pieces.
category, amount = line.split(",")for row in csv.DictReader(StringIO(csv_text)):
category = row["category"]The csv module understands quoted fields and uses the header names.
A second Food row hides the first Food expense.
totals[category] = amounttotals[category] = totals.get(category, Decimal("0")) + amountUse the previous total as the starting point when a category appears again.
Searching for ADA LOVELACE misses an existing contact.
book[name.strip().casefold()] = record
found = book.get(search_name)book[name.strip().casefold()] = record
found = book.get(search_name.strip().casefold())Apply the same rule to both the saved and searched name.
The program raises KeyError instead of reporting a missing contact.
record = book["missing person"]record = book.get("missing person")get returns None for an absent key, allowing the caller to show a friendly result.
Adding a second person with the same name overwrites the first.
book[person_name] = email # two people can share this name# For real data, use a separate stable contact ID as the key.Normalized names are convenient for this exercise but cannot serve as reliable unique identifiers in a real address book.
TypeError: '<' is not supported between instances of 'dict' and 'dict'.
sorted([{'price': 12}, {'price': 3}])sorted([{'price': 12}, {'price': 3}], key=lambda item: item['price'])Choose the numeric field that defines the order; dictionaries themselves have no default less-than ordering.
The call prints None, and products was changed in place.
products = [{'price': 12}, {'price': 3}]
ordered = products.sort(key=lambda item: item['price'])
print(ordered)ordered = sorted(products, key=lambda item: item['price'])Use sorted() when you need a new list and must preserve the input.
The text '10' comes before '2' lexicographically.
sorted(['10', '2'])sorted(['10', '2'], key=int)Convert numeric text in the key function when numeric order is intended.
FileNotFoundError if notes has not been created.
Path('notes/day-1.txt').write_text('hello', encoding='utf-8')path = Path('notes/day-1.txt')
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text('hello', encoding='utf-8')Create the containing folder first; parents=True also creates missing levels above it.
The file contains only second.
path.write_text('first', encoding='utf-8')
path.write_text('second', encoding='utf-8')path.write_text('first', encoding='utf-8')
with path.open('a', encoding='utf-8') as file:
file.write('second')Use append mode explicitly when existing text must be kept.
The result is reportssummary.txt rather than a child file.
'reports' + 'summary.txt'Path('reports') / 'summary.txt'The / operator on Path joins components using the current system's path rules.
The Python string contains backspace characters rather than regex word-boundary escapes, so the expected code is missed.
re.findall("\bORD-[0-9]{4}\b", "ORD-1234")re.findall(r"\bORD-[0-9]{4}\b", "ORD-1234")Prefix a regex pattern with r so backslashes reach the regular-expression parser as intended.
The expression is True even though a fifth digit remains.
re.match(r'ORD-[0-9]{4}', 'ORD-12345') is not Nonere.fullmatch(r'ORD-[0-9]{4}', 'ORD-12345') is not NoneUse fullmatch to validate a whole string; use word boundaries when extracting a whole code from a sentence.
AttributeError because search returns a Match object, not a string.
re.search(r'cat', 'A cat naps.').upper()match = re.search(r'cat', 'A cat naps.')
print(match.group().upper() if match else 'none')Check for None, then call group() to get matched text.
The values are correct, but the function returns a list rather than a generator.
def even_numbers(limit):
return [n for n in range(limit) if n % 2 == 0]def even_numbers(limit):
for n in range(limit):
if n % 2 == 0:
yield nUse yield when the task requires items to be produced on demand.
The second print displays [] because the first pass consumed values.
values = (n * n for n in range(3))
print(list(values))
print(list(values))def squares():
return (n * n for n in range(3))
print(list(squares()))
print(list(squares()))Call the generator-producing function again to make a fresh iterator.
The second request raises StopIteration.
items = iter([1])
next(items)
next(items)items = iter([1])
next(items)
print(next(items, None))Use a default or a for loop if exhaustion is expected.
Modern Python raises ValueError at class creation because a mutable list is an unsafe default.
@dataclass
class StudyTask:
title: str
tags: list[str] = []@dataclass
class StudyTask:
title: str
tags: list[str] = field(default_factory=list)A factory supplies an independent list each time an instance is created.
TypeError: non-default argument 'title' follows default argument.
@dataclass
class StudyTask:
done: bool = False
title: str@dataclass
class StudyTask:
title: str
done: bool = FalseKeep required fields before optional fields with defaults.
The instance can still be created with an integer title.
task = StudyTask(123)
# Assume title must be a str at runtime.if not isinstance(title, str):
raise TypeError('title must be text')
task = StudyTask(title)Use explicit validation when a runtime guarantee matters; an annotation alone is descriptive.
TypeError: first argument must be callable or None.
groups = defaultdict(list())groups = defaultdict(list)Pass the constructor itself so defaultdict can call it for each missing key.
Bug and bug are counted as two different labels.
Counter(['Bug', 'bug'])Counter(label.strip().lower() for label in ['Bug', 'bug'])Normalize the data before counting when case and surrounding whitespace should not matter.
The lookup silently adds unknown as an empty group.
groups = defaultdict(list)
print(groups['unknown'])print(groups.get('unknown', []))Use get for a read that should leave the mapping unchanged.
The function can return None although its annotation promises str.
def lookup(names: list[str], wanted: str) -> str:
return next((name for name in names if name == wanted), None)def lookup(names: list[str], wanted: str) -> str | None:
return next((name for name in names if name == wanted), None)Include None in the return hint whenever a normal branch can return it.
A runtime TypeError occurs inside the function; the hint did not convert '20'.
def age_next_year(age: int) -> int:
return age + 1
age_next_year('20')age = int('20')
print(age_next_year(age))Convert or validate user input explicitly before calling a function that expects an integer.
Readers cannot tell what the list contains or what maps to each count.
def count_words(words: list) -> dict:def count_words(words: list[str]) -> dict[str, int]:Element, key, and value hints make the contract more useful.
The decorated name becomes None, so calling it raises TypeError.
def announce(func):
def wrapper():
return func()
# no return wrapperdef announce(func):
def wrapper():
return func()
return wrapperThe decorator itself must return the callable that replaces the original name.
A function that returned a value now appears to return None.
def wrapper(*args, **kwargs):
func(*args, **kwargs)def wrapper(*args, **kwargs):
return func(*args, **kwargs)Return the original result unless changing it is the deliberate purpose of the decorator.
The decorated function reports __name__ as wrapper.
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper@wraps(func)
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapperfunctools.wraps keeps useful metadata and exposes __wrapped__.
The handle may remain open if later code raises before close().
note = open('note.txt', 'w', encoding='utf-8')
note.write('draft')with open('note.txt', 'w', encoding='utf-8') as note:
note.write('draft')with asks the file's context manager to close the handle on either exit path.
If the with body raises, the line after yield is skipped and cleanup is lost.
@contextmanager
def managed(log):
log.append('open')
yield
log.append('close')@contextmanager
def managed(log):
log.append('open')
try:
yield
finally:
log.append('close')Put cleanup in finally so it runs during exception propagation.
A real write error can disappear without the caller noticing.
with suppress(Exception):
write_important_note()with note_writer('note.txt') as note:
note.write('important')Resource cleanup and error handling are separate decisions; allow unexpected errors to propagate.
The entire readings iterator is consumed, even when only three totals are needed.
first = list(accumulate(readings))[:3]first = list(islice(accumulate(readings), 3))Place islice before list so upstream work stops at the requested count.
There are two separate ok groups, not one combined group.
from itertools import groupby
print([(key, list(group)) for key, group in groupby(['ok', 'fail', 'ok'])])from itertools import groupby
statuses = ['ok', 'fail', 'ok']
ordered = sorted(statuses)
print([(key, list(group)) for key, group in groupby(ordered)])Sort first when you need one group per key, and consider whether sorting is acceptable for your data.
The second list is empty because the iterator has already been consumed.
stream = chain([1], [2])
print(list(stream))
print(list(stream))stream = chain([1], [2])
values = list(stream)
print(values)
print(values)Recreate an iterator for another pass or store the results if repeated access is required.
The input never shrinks, so calls end in RecursionError.
def length(items):
if not items: return 0
return 1 + length(items)def length(items):
if not items: return 0
return 1 + length(items[1:])Each recursive call must move closer to the empty-list base case.
Numbers inside nested lists never contribute to the parent total.
if isinstance(item, list):
sum_nested(item)if isinstance(item, list):
total += sum_nested(item)The parent must use the value returned by its child call.
A second call starts from the first call's answer and nested lists are not handled.
total = 0
def sum_nested(items):
global total
for item in items: total += item
return totaldef sum_nested(items):
total = 0
for item in items:
total += sum_nested(item) if isinstance(item, list) else item
return totalA local total belongs to each call and is combined by returned values.
message captures any value, so this branch matches everything.
match event_type:
case message:
return 'message'match event_type:
case 'message':
return 'message'Quoted text is a literal pattern; an unqualified bare name captures.
The origin is handled by the first two-item pattern and never reaches its specific branch.
match point:
case (x, y): return 'point'
case (0, 0): return 'origin'match point:
case (0, 0): return 'origin'
case (x, y): return 'point'Order specific shapes before general ones.
Whitespace-only messages are treated as meaningful content.
case {'type': 'message', 'text': str(text)}:
return 'Message: ' + textcase {'type': 'message', 'text': str(text)} if text.strip():
return 'Message: ' + text.strip()A guard expresses conditions that a shape alone does not capture.
The INFO record is filtered out before it reaches a handler.
logger.setLevel(logging.WARNING)
logger.info('started')logger.setLevel(logging.INFO)
logger.info('started')Choose a threshold at or below the messages you need.
Repeated setup can make the same event appear multiple times.
logger = logging.getLogger('app')
logger.addHandler(logging.StreamHandler(stream))logger = logging.Logger('one-call')
logger.addHandler(logging.StreamHandler(stream))Use a fresh logger for a self-contained task or manage and remove shared handlers explicitly.
The token may be written to logs and retained outside the program.
logger.info('token=%s', api_token)logger.info('Authentication request started')Log the event and context needed for diagnosis without credentials or personal details.
The result is a coroutine object rather than '1: ADA', and it may be reported as never awaited.
result = fetch_label(1, 'ada')
print(result)result = asyncio.run(fetch_label(1, 'ada'))
print(result)At a top-level script, asyncio.run executes the coroutine. Inside async code, use await instead.
Independent waits are serialized, so their delays add up.
results = []
for item in jobs:
results.append(await fetch(item))results = await asyncio.gather(*(fetch(item) for item in jobs))gather schedules independent awaitables together; result order remains aligned with jobs.
asyncio.run raises RuntimeError when an event loop is already running.
async def main():
return asyncio.run(fetch_label(1, 'ada'))async def main():
return await fetch_label(1, 'ada')Use await inside a coroutine and reserve asyncio.run for a synchronous top-level script.
The profile job cannot receive a token that has not been returned yet.
await asyncio.gather(fetch_token(), fetch_profile(token))token = await fetch_token()
profile = await fetch_profile(token)Start independent waits together; keep a real producer-consumer dependency in sequence.
A message containing a pipe creates four parts and unpacking raises ValueError.
parts = line.split("|")
timestamp, level, message = partsparts = [part.strip() for part in line.split("|", 2)]
if len(parts) != 3 or not all(parts):
raise ValueError("Malformed log row")
timestamp, level, message = partsLimit the split to two separators and validate the three fields before unpacking.
The report says ERROR: 1 even after several ERROR records.
counts[level] = 1counts[level] = counts.get(level, 0) + 1Add one to the previous subtotal rather than assigning the initial value every time.
A row without a separator raises IndexError; an empty level can create a misleading category.
level = raw_line.split("|")[1].strip()parts = [part.strip() for part in raw_line.split("|", 2)]
if len(parts) != 3 or not all(parts):
skipped += 1
continueValidate the record shape and required fields before using their positions.
With three cards and two responses, the third card is never graded.
for card, response in zip(cards, responses):
grade(card, response)if len(cards) != len(responses):
raise ValueError("One response is required for each card")
for card, response in zip(cards, responses):
...Check the one-to-one contract before pairing the lists.
An expected answer stored as DEF still rejects a normalized def response.
if response.strip().casefold() == card["answer"]:if response.strip().casefold() == card["answer"].strip().casefold():Apply the same normalization to both strings before comparing them.
An empty deck raises ZeroDivisionError.
percent = correct / len(cards) * 100percent = correct / len(cards) * 100 if cards else 0The core grader returns counts, and any optional percentage display needs an explicit zero-card policy.
The genuine score zero is labeled as missing.
if not score:
return 'Not graded'if score is None:
return 'Not graded'Test the sentinel specified by the data contract, not every false value.
A supplied zero becomes 100.
score = supplied or 100score = 100 if supplied is None else suppliedThe explicit condition preserves all supplied values other than None.
The third requested index is missing.
items[1:3] # expect indexes 1, 2, 3items[1:4] # indexes 1, 2, 3Choose a stop one past the final positive index.
For count zero, the entire list is returned.
return items[-count:]if count == 0:
return []
return items[-count:]Zero needs its own branch because -0 equals 0.
The input's nested score changes too.
updated = report.copy()
updated['scores'][0]['points'] = 10from copy import deepcopy
updated = deepcopy(report)
updated['scores'][0]['points'] = 10A shallow copy retains the original scores list and row dictionaries.
Equal contents do not show whether nested objects are shared.
assert copied == original # therefore no shared objectsassert copied == original
assert copied is not original
assert copied['scores'][0] is not original['scores'][0]Inspect identity at the mutable level whose independence matters.
scores contains one list; sum(scores) tries to add a list to zero.
build_report('Ada', [2, 3])build_report('Ada', *[2, 3])Use * at the call site when each element should become a separate positional argument.
All three numbers enter scores; scale remains its default.
describe('Ada', 2, 3, 2) # last 2 is scaledescribe('Ada', 2, 3, scale=2)An option after *scores must be named explicitly.
Nonnumeric text raises ValueError, while zero and negatives pass through.
return int(text)try:
units = int(text)
except ValueError as exc:
raise QuantityError(f'Invalid units: {text!r}') from exc
if units <= 0:
raise QuantityError(f'Invalid units: {text!r}')
return unitsConversion and the positive-quantity rule both belong to the function's contract.
A bug inside calculate is silently converted into a valid-looking zero.
try:
return calculate(text)
except:
return 0except ValueError as exc:
raise QuantityError(f'Invalid units: {text!r}') from excCatch the expected failure and keep a diagnosable exception path.
Passing a dictionary to int is hidden and an invalid port looks successful.
try:
return int(config)
except TypeError:
return 0text = config['port']
number = int(text)Use the traceback to repair the wrong expression before handling expected input failures.
A missing port becomes a misleading out-of-range value instead of identifying the absent key.
text = config.get('port', 0)text = config['port']Required fields should fail clearly when absent; KeyError identifies the missing key.
The object retains the binary float's approximation instead of an exact tenth.
price = Decimal(0.1)price = Decimal('0.1')Parse the original decimal text before binary floating-point changes it.
Results may have more than two fractional digits, such as 1.005.
return str(price * (1 - rate))return str(amount.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))State a cent precision and explicit rounding rule at the output boundary.
Linus is served before Ada.
waiting = ['Ada', 'Grace', 'Linus']
next_name = waiting.pop()from collections import deque
waiting = deque(['Ada', 'Grace', 'Linus'])
next_name = waiting.popleft()A FIFO queue removes from the opposite end from append.
Each front removal shifts the remaining list items.
while waiting:
served.append(waiting.pop(0))waiting = deque(waiting)
while waiting:
served.append(waiting.popleft())deque provides efficient operations at both ends.
The second push raises TypeError when dictionaries are compared.
heapq.heappush(heap, (1, {'id': 'A'}))
heapq.heappush(heap, (1, {'id': 'B'}))heapq.heappush(heap, (1, 0, {'id': 'A'}))
heapq.heappush(heap, (1, 1, {'id': 'B'}))A unique counter is a comparable tie breaker.
Items after the root may appear out of priority order.
print([task for _, task in heap])while heap:
print(heapq.heappop(heap))Repeated pops yield ordered priorities.
ValueError is raised because 25 is not present.
position = scores.index(25)position = bisect_left(scores, 25)bisect_left finds an insertion position whether or not the value exists.
The returned position cannot guarantee a sorted result.
scores = [20, 10, 40]
position = bisect_left(scores, 15)scores = sorted(scores)
position = bisect_left(scores, 15)Establish sorted order before binary search; decide separately whether sorting a copy fits your contract.
Later calls may reuse an old price.
@lru_cache(maxsize=None)
def current_price(item):
return read_live_price(item)def current_price(item):
return read_live_price(item)A changing data source needs an explicit refresh or cache invalidation policy.
TypeError: unhashable type: 'list'.
@lru_cache(maxsize=None)
def total(values):
return sum(values)
print(total([1, 2]))@lru_cache(maxsize=None)
def total(values):
return sum(values)
print(total((1, 2)))A tuple of integers is hashable and can be used as a cache key.
The output becomes café.
data = 'café'.encode('utf-8')
print(data.decode('latin-1'))print(data.decode('utf-8'))The decoder must match the data's actual encoding.
The comparison is False because the emoji is four UTF-8 bytes but one code point.
print(len('🐍'.encode('utf-8')) == len('🐍'))text = '🐍'
print(len(text), len(text.encode('utf-8')))Name the measurement: code points and encoded bytes are different quantities.
A July New York time is one hour wrong.
local = utc_time - timedelta(hours=5)local = utc_time.astimezone(ZoneInfo('America/New_York'))Named-zone conversion chooses the offset for the date.
Python interprets the naive time using the host's local timezone.
value = datetime.fromisoformat('2026-01-15T12:00:00')
print(value.astimezone(ZoneInfo('America/New_York')))value = datetime.fromisoformat('2026-01-15T12:00:00+00:00')
print(value.astimezone(ZoneInfo('America/New_York')))Provide an explicit offset before converting a moment.
Changing to another sender requires changing the class hierarchy.
class NotificationService(EmailSender):
def notify(self, message):
return self.send(message)class NotificationService:
def __init__(self, sender): self.sender = sender
def notify(self, message): return self.sender.send(message)The service uses a sender rather than being one.
notify returns None even if send produces a receipt.
def notify(self, message):
self.sender.send(message)def notify(self, message):
return self.sender.send(message)Return the dependency's result when it is part of the service contract.
Assigning the property inside its own setter repeatedly calls that setter.
@celsius.setter
def celsius(self, value):
self.celsius = value@celsius.setter
def celsius(self, value):
self._celsius = valueStore into a distinct backing attribute after validation.
An invalid object can be created even if later writes are checked.
def __init__(self, celsius):
self._celsius = celsiusdef __init__(self, celsius):
self.celsius = celsiusRoute initial assignment through the public property.
The object holds a bad value after the exception.
self._celsius = value
if value < -273.15: raise ValueError('too cold')if value < -273.15: raise ValueError('too cold')
self._celsius = valueComplete validation before committing state.
The nonempty string 'false' evaluates to True.
debug = bool(env.get('APP_DEBUG', 'false'))text = env.get('APP_DEBUG', 'false').strip().lower()
if text in ('true', '1'):
debug = True
elif text in ('false', '0'):
debug = False
else:
raise ValueError('APP_DEBUG must be true or false')Recognize both true and false spellings, and reject every other supplied value.
A typo silently changes where the program listens.
try: port = int(env['APP_PORT'])
except ValueError: port = 8000try: port = int(env.get('APP_PORT','8000'))
except ValueError as error: raise ValueError('invalid APP_PORT') from errorDefaults are for absence, not malformed input.
The token may be copied into terminal logs or support records.
print('API_TOKEN', env.get('API_TOKEN'))print('API_TOKEN configured:', bool(env.get('API_TOKEN')))Report presence or a safe status instead of a credential value.
The operation can wait indefinitely or return an unexpected shape.
with urlopen(url) as response: data = json.load(response)with urlopen(request, timeout=5) as response:
data = json.load(response)
if not isinstance(data, list):
raise ValueError('expected list')The timeout bounds waiting; the shape check rejects a non-list response. Validate individual items before using them, as in the next fix.
A dictionary, numeric item, or missing title can cause an unrelated error or misleading result.
return [item['title'] for item in data]if not isinstance(data, list):
raise ValueError('expected list')
titles = []
for item in data:
if not isinstance(item, dict):
raise ValueError('expected object')
title = item.get('title')
if not isinstance(title, str) or not title.strip():
raise ValueError('expected nonblank title')
titles.append(title.strip())
return titlesValidate the list and each object before extracting a stripped, nonblank title.
URLs may be retained in logs and browser histories.
url = 'https://api.example.test/items?token=' + tokenrequest = Request(url, headers={'Authorization': 'Bearer ' + token})Follow the service's documented authentication method and avoid logging secrets.
The other operand cannot try its reflected equality behavior.
if not isinstance(other, Book): return Falseif not isinstance(other, Book): return NotImplementedNotImplemented is a dispatch signal, not an exception.
len(book) raises ValueError rather than yielding a useful length.
def __len__(self): return -1def __len__(self): return self.pagesValidate pages at construction so the method can return a nonnegative integer.
A formatting change can silently change equality semantics.
return repr(self) == repr(other)return (self.title, self.pages) == (other.title, other.pages)Compare the fields that define the value, not its display text.
The dependency is called twice and could return different data or incur two requests.
if fetch_user(user_id):
return fetch_user(user_id)['name']user = fetch_user(user_id)
return user['name']Store the single response before inspecting it.
A function could call the fake with a different ID and still receive its fixed return value.
assert load_user_label(7, fake) == '7: Ada'assert load_user_label(7, fake) == '7: Ada'
fake.assert_called_once_with(7)Verify a contractual interaction when a fixed mock response would hide a wrong call.
A missing name becomes the literal text None.
return f"{user_id}: {user.get('name')}"name = user.get('name')
if not isinstance(name, str) or not name.strip(): raise ValueError('name required')Reject invalid boundary data explicitly.
The result depends on the process running the example, not the supplied exercise input.
options = parser.parse_args()options = parser.parse_args(argv)Inject tokens for deterministic practice and testing.
Zero and negative integers parse successfully.
parser.add_argument('--limit', type=int)
# assume 0 is rejectedif options.limit < 1: raise ValueError('limit must be positive')Validate business rules after syntax conversion.
A misspelled flag can disappear without warning.
options, extra = parser.parse_known_args(argv)
# silently discard extraoptions = parser.parse_args(argv)For this command, unknown arguments should be errors.
0.1 + 0.2 compares unequal to 0.3.
return left == rightreturn math.isclose(left, right, rel_tol=1e-9)Use a documented tolerance when the inputs are approximate calculations.
The result is False even if this sensor reading is negligible.
math.isclose(0.005, 0.0, rel_tol=0.01)math.isclose(0.005, 0.0, abs_tol=0.01)A near-zero threshold is an absolute difference in the measured units.
A quoted product such as "Pens, blue" becomes multiple fields.
name, qty = line.split(',')reader = csv.DictReader(io.StringIO(csv_text))Use the parser to respect quoting and header order.
Missing or shifted cells fail late or are silently ignored.
quantity = int(row['qty'])if row.get('qty') is None or None in row:
raise ValueError('malformed row')
quantity = int(row['qty'])Check row shape before type conversion and domain rules.
Multiple top-level objects produce Extra data.
records = json.loads(text)for line in io.StringIO(text):
record = json.loads(line)Decode one nonblank line at a time under the chosen JSON Lines convention.
Lists, numbers, and records with missing or empty event values fail unpredictably.
counts[record['event']] += 1if not isinstance(record, dict) or not isinstance(record.get('event'), str) or not record['event']:
raise ValueError('invalid event')Validate the application schema after decoding syntax.
The label suggests an ordinary observation around 22.8, but none is nearby.
print(mean([2,3,4,5,100])) # typical valueprint('mean', mean(data), 'median', median(data))Show both summaries and interpret their disagreement.
A one-shot iterator may be empty on its second use.
average = mean(values)
middle = median(values)items = list(values)
average = mean(items)
middle = median(items)Materialize once when multiple passes are required.
Straße and STRASSE yield different comparison keys.
return text.strip().lower()return unicodedata.normalize('NFC', text.strip().casefold())casefold handles broader Unicode caseless mappings and NFC resolves canonical forms.
Different written names or words can collapse into the same key.
return ''.join(c for c in text if not unicodedata.combining(c))return unicodedata.normalize('NFC', text)Canonical equivalence preserves meaningful accent distinctions.
The branch never runs for a correctly spelled running state.
if state == 'runnning':
finish()if state is JobState.RUNNING:
finish()Normalize external text to an enum, then compare members.
A misspelling may accidentally start a new job.
return states.get(text, JobState.QUEUED)return JobState(text.strip().lower())Let unknown values raise ValueError so the caller can correct the input.
UnboundLocalError appears on the first call.
def advance():
count += 1def advance():
nonlocal count
count += 1The declaration targets the enclosing function's binding.
All counters affect the same module-level value.
global count
count += 1nonlocal count
count += 1Keep each counter's state inside its own factory call.
SubReading.from_text returns a Reading instead of a SubReading.
return Reading(name, value)return cls(name, value)The classmethod's cls parameter preserves the calling class.
True passes validation as the integer one.
isinstance(value, int)type(value) is int and value >= 0An exact-type check rejects bool for this domain contract.
The new error does not explicitly declare its original cause.
except ValueError:
raise ConfigError('invalid port')except ValueError as error:
raise ConfigError('invalid port') from errorExplicit chaining sets __cause__ and clarifies the diagnostic link.
A bad supplied setting is quietly ignored.
except ValueError:
return 8000except ValueError as error:
raise ConfigError('port must be an integer') from errorFail near the configuration boundary with a useful message.
The suite reports success even for a broken subtotal.
def test_cases(self):
passwith self.subTest(prices=prices):
self.assertEqual(subtotal(prices), expected)Assertions make the test sensitive to wrong results.
One test can leave state that changes another test.
cases = [] # module-level list reused by testsdef setUp(self):
self.cases = [([], 0), ([2], 2)]Construct fresh test data before each method.
The new text is added inside an existing query and the space is not encoded.
url = 'https://example.test/x?page=1'
print(url + '?q=red fox')from urllib.parse import urlsplit, urlunsplit, parse_qsl, urlencode
url = 'https://example.test/x?page=1'
p = urlsplit(url)
q = parse_qsl(p.query, keep_blank_values=True) + [('q', 'red fox')]
print(urlunsplit((p.scheme, p.netloc, p.path, urlencode(q), p.fragment)))Build one query from pairs, then reassemble the components once.
Only the final tag value remains in the dictionary.
params = dict([('tag', 'a'), ('tag', 'b')])from urllib.parse import urlencode
params = [('tag', 'a'), ('tag', 'b')]
print(urlencode(params))Keep the ordered pair list when multiple values for a key are allowed.
The label can be interpreted as markup instead of displayed literally.
label = '<b>Hi</b>'
print(f'<span>{label}</span>')from html import escape
label = '<b>Hi</b>'
print(f'<span>{escape(label, quote=True)}</span>')Escape the variable text at the HTML output boundary.
Character references become angle brackets again before insertion.
from html import unescape
print(unescape('<b>Hi</b>'))from html import escape
label = '<b>Hi</b>'
print(escape(label, quote=True))Keep the text escaped for HTML output; unescape is for decoding input when that is actually required.
TypeError: Strings must be encoded before hashing.
import hashlib
print(hashlib.sha256('abc').hexdigest())import hashlib
print(hashlib.sha256('abc'.encode('utf-8')).hexdigest())Make the text-to-bytes conversion explicit and stable.
The built-in hash value can differ across Python processes and is not a cryptographic content digest.
print(hash('abc'))import hashlib
print(hashlib.sha256(b'abc').hexdigest())Use a defined digest algorithm for reproducible content checks.
A string and integer cannot be added; the operation raises TypeError.
from configparser import ConfigParser
p=ConfigParser(); p.read_string('[job]\nretries=3\n')
print(p.get('job','retries') + 1)from configparser import ConfigParser
p=ConfigParser(); p.read_string('[job]\nretries=3\n')
print(p.getint('job','retries') + 1)Use getint and validate the resulting number.
A lone percent sign raises InterpolationSyntaxError with default interpolation.
from configparser import ConfigParser
p=ConfigParser(); p.read_string('[job]\nstatus=100% ready\n'); print(p.get('job','status'))from configparser import ConfigParser
p=ConfigParser(interpolation=None); p.read_string('[job]\nstatus=100% ready\n'); print(p.get('job','status'))Turn off interpolation when configuration values should be literal.
TypeError because bytes.split expects a bytes separator, not str.
from io import BytesIO
from zipfile import ZipFile
b=BytesIO()
with ZipFile(b,'w') as z: z.writestr('x.txt', b'one two')
with ZipFile(BytesIO(b.getvalue())) as z: print(z.read('x.txt').split(' '))from io import BytesIO
from zipfile import ZipFile
b=BytesIO()
with ZipFile(b,'w') as z: z.writestr('x.txt', b'one two')
with ZipFile(BytesIO(b.getvalue())) as z: print(z.read('x.txt').decode('utf-8').split(' '))Decode when converting stored bytes back to text.
The entry name describes a relative parent path that is inappropriate for this basename-only exercise.
archive.writestr('../notes.txt', b'hello')name='notes.txt'
assert '/' not in name and '\\' not in name
archive.writestr(name, b'hello')Validate names before archive creation; extraction also needs a separate policy.
An item with stock exactly equal to minimum appears unexpectedly.
if stock <= minimum:if stock < minimum:Follow the stated strict boundary.
The order leaves inventory at the trigger threshold instead of the desired target.
quantity = minimum - stockquantity = target - stockThe target determines the replenishment amount.
Back-to-back bookings are reported as a conflict.
a_start <= b_end and b_start <= a_enda_start < b_end and b_start < a_endStrict comparisons match half-open occupancy intervals.
The case where B fully contains A can be missed.
a_start <= b_start < a_enda_start < b_end and b_start < a_endThe symmetric condition covers containment and partial overlap.
A user cannot tell which source rows were rejected or why.
if invalid: continueerrors.append((reader.line_num, reason))
continueEvery rejected row needs a traceable report entry.
Later valid rows are never inspected.
qty = int(row['qty']) # uncaughttry: qty = int(raw_qty)
except ValueError:
errors.append((reader.line_num, 'invalid qty'))
continueCatch ordinary row-level validation errors under the chosen partial-success contract.
A changed b.txt is reported as healthy.
changed = [] # names match, so files matchchanged = [name for name in common if hashlib.sha256(archive.read(name)).hexdigest() != manifest[name]]Hash member bytes for every expected present file.
Inspection writes every member to disk and may expose path or resource risks.
archive.extractall(output_dir)data = archive.read(name)
digest = hashlib.sha256(data).hexdigest()This small fixture verifier only needs bytes, not extraction.
A home/about cycle can revisit pages until the limit is exhausted.
queue.extend(all_links)if target in pages and target not in queued:
queued.add(target)
queue.append(target)Mark a fixture URL when it is scheduled, not after another path finds it.
Arbitrary network requests are outside this deterministic browser-console exercise.
html = urllib.request.urlopen(url).read()html = pages[url]Keep the algorithm offline; teach real network crawling separately with operational safeguards.
Quotes break the query and SQL-looking values can alter its meaning.
query = f"SELECT name FROM items WHERE category = '{category}'"connection.execute('SELECT name FROM items WHERE category = ?', (category,))Bind values; do not manufacture SQL syntax from external text.
A later query plan can return a different order.
SELECT name FROM items WHERE category = ?SELECT name FROM items WHERE category = ? ORDER BY nameSpecify the order required by the interface.
Anyone with the seed can reproduce the token.
random.seed(7)
token = str(random.random())token = secrets.token_urlsafe(16)Use security-oriented randomness and enough random bytes.
A copied log now contains a usable secret.
print('issued token', token)print('token issued; characters:', len(token))Show harmless metadata when debugging, not the credential.
Other code's results depend on this function's call order.
random.seed(seed)
value = random.random()rng = random.Random(seed)
value = rng.random()Keep simulation state local.
Every trial repeats the first value.
for _ in range(count):
value = random.Random(seed).random()rng = random.Random(seed)
for _ in range(count):
value = rng.random()Create once, then advance that instance.
A default hides an explicit override.
ChainMap(defaults, environment, cli)ChainMap(cli, environment, defaults)Place the highest-priority source first.
The top db mapping lacks port and raises KeyError.
ChainMap({'db': {'host':'new'}}, {'db': {'port':5432}})['db']['port']Define a nested merge policy, or use flat keysChainMap combines top-level lookups, not nested values.
The old content is lost if writing fails partway.
Path(target).write_text(text, encoding='utf-8')write a temporary file, close it, then os.replace(temp_name, target)Stage complete content before changing the target name.
An exception can leave an orphaned name and an open file.
temp = NamedTemporaryFile(delete=False); temp.write(data); os.replace(temp.name, target)close the temporary file; use finally to unlink its name if it still existsFailure cleanup is part of the replacement pattern.
A title containing & produces invalid XML.
xml = '<title>' + title + '</title>'ET.SubElement(book, 'title').text = titleAssign text and let ElementTree escape it.
A missing year fails with a confusing conversion error.
year = int(book.get('year'))if book.get('year') is None: raise ValueError('missing year')Validate the catalog schema before conversion.
Concatenated diff output can put markers on the same line.
before.splitlines()before.splitlines(keepends=True)Preserve newline characters on input lines.
The +++ after file header is counted as an added line.
added = [line for line in diff if line.startswith('+')]skip the first two file headers before counting content linesUnified diff has metadata as well as content markers.
The denominator reflects the binary float, not exactly one tenth.
Fraction(0.1)Fraction('0.1')Pass decimal text when the decimal value is the source of truth.
Zero total weight divides by zero; negative weights make confusing shares.
left = total * left_weight / (left_weight + right_weight)if type(left_weight) is not int or left_weight <= 0: raise ValueError('positive weight required')Validate both ratio weights before calculation.
192.168.10.5 is incorrectly accepted.
address.startswith('192.168.1')ipaddress.ip_address(address) in ipaddress.ip_network('192.168.1.0/24')Use CIDR arithmetic for membership.
A host address can turn into a larger access range without notice.
ipaddress.ip_network(text, strict=False)ipaddress.ip_network(text)Strict parsing makes the configuration error visible.
The source path disappears after the operation.
shutil.move(source, destination)shutil.copy2(source, destination)Match the operation to the intended source outcome.
An existing target can be overwritten.
shutil.copy2(source, destination)if Path(destination).exists():
raise FileExistsError(destination)
shutil.copy2(source, destination)State and enforce a collision policy before the transfer.
callback is a string and cannot be invoked later.
callback = format_event('ERROR', 'ready')callback = partial(format_event, 'ERROR')Pass a configured callable, then supply the message later.
Later calls unexpectedly share and mutate one list.
callback = partial(add_item, items=[])callback = partial(add_item, items=tuple())Prefer immutable bound configuration or create fresh state per call.
Unrelated useful implementations are needlessly coupled.
class Html(Renderable): ... # required for all implementationsclass Html:
def render(self) -> str: ...Structural typing accepts matching members without inheritance.
A noncallable render attribute may still pass the presence check.
if isinstance(item, Renderable): return item.render()method = getattr(item, 'render', None)
if not callable(method): raise TypeError('render required')Validate the runtime behavior this function relies on.
A notification is sent before the proposed call is approved.
callback(**kwargs) # validation onlyinspect.signature(callback).bind(**kwargs)Bind the argument shape without executing side effects.
A wrongly typed or invalid address can still pass.
signature.bind(**kwargs) # all values are now safebound = signature.bind(**kwargs)
# Validate domain values separately.Signature binding does not check value semantics or type hints.
The input can execute code instead of supplying data.
values = eval(user_text)values = ast.literal_eval(user_text)Parse literal syntax with a limited parser, then validate it.
Tuples, booleans, huge values, or nested data slip through.
return ast.literal_eval(text)if type(values) is not list or any(type(x) is not int for x in values):
raise ValueError('integer list required')Apply the application's exact shape and range contract.
deploy can appear before test.
return sorted(dependencies)ready = [name for name, needs in dependencies.items() if not needs]
# Release dependents only after their prerequisites.Use graph relationships, not labels, to establish order.
The plan omits work without explaining why.
return order # even if some tasks remainif len(order) != len(dependencies):
raise ValueError('dependency cycle')A cycle means no complete valid ordering exists.
No transport or mailbox interaction occurred.
message = EmailMessage(); print('delivered')message = EmailMessage(); print('message built locally')Keep message construction separate from delivery.
A supplied newline violates this function's header contract.
message['Subject'] = user_subjectif '\n' in user_subject or '\r' in user_subject:
raise ValueError('single-line subject required')Validate header shape before assignment.
TypeError: a bytes-like object is required
base64.b64encode('Python')base64.b64encode('Python'.encode('utf-8'))The source text must be converted to bytes before a binary-to-text representation is applied.
The result contains a b prefix and quotation marks.
str(base64.b64encode(b'Python'))base64.b64encode(b'Python').decode('ascii')Decode the ASCII encoded bytes into an actual text token instead of formatting the bytes object for debugging.
A different sender can recalculate the same kind of tag.
hashlib.sha256(message).hexdigest()hmac.new(key, message, hashlib.sha256).hexdigest()The key must participate in the tag computation; printing more hash characters does not add authentication.
The comparison may leak timing information about matching prefixes.
provided_tag == expected_taghmac.compare_digest(provided_tag, expected_tag)Use the dedicated comparison for secret tags, then separately design replay protection and key handling.
ValueError: badly formed hexadecimal UUID string
uuid.UUID('guest')uuid.uuid5(uuid.NAMESPACE_URL, 'guest')The UUID constructor parses an existing identifier; uuid5 derives one from a namespace and name.
Repeated calls do not reproduce the same mapping.
return str(uuid.uuid4())return str(uuid.uuid5(uuid.NAMESPACE_URL, normalized_name))Choose uuid5 for a stable namespace/name mapping and normalize the name consistently.
Passing str directly to gzip.compress raises TypeError because the compressor expects bytes.
gzip.compress('hello')gzip.compress('hello'.encode('utf-8'), mtime=0)Use gzip.compress(text.encode('utf-8'), mtime=0) to make a reproducible sample payload, and gzip.decompress(payload).decode('utf-8') to recover the text. The mtime setting affects gzip header metadata; it is not a security feature and does not promise equal compression across every Python or zlib version.
A byte string that is not a gzip member raises an error during decompression, so blindly decoding arbitrary input is unsafe.
gzip.decompress(b'not gzip').decode('utf-8')validate and limit the compressed input before consuming itCompression can drastically expand during decompression for specially prepared input. The tiny classroom example does not enforce a production memory budget. Handle invalid data and size limits where the bytes enter a real service, and never treat gzip as encryption.
Unpacking a one-byte buffer with a three-byte format raises struct.error.
struct.unpack('>HB', b'\x03')if len(packet) == struct.calcsize('>HB'): struct.unpack('>HB', packet)Use struct.pack('>HB', identifier, status) to build the packet and struct.unpack('>HB', packet) to recover a tuple. Range-check integers against the format before packing if user input is involved. An unsigned short supports 0 through 65535 and an unsigned byte supports 0 through 255.
The verifier attempts to decode a truncated record and deliberately catches struct.error.
struct.pack('HB', identifier, status)struct.pack('>HB', identifier, status)A binary protocol must define length, byte order, version and validation explicitly. Native struct formats may add platform-dependent padding, so avoid an implicit native format for data exchanged between systems. The example is a local three-byte protocol, not a network framing implementation.
Reading a StringIO stream advances its cursor.
stream.read(); stream.read()stream.read(); stream.seek(0); stream.read()Implement count_lines(stream) as a single pass over the provided text stream. StringIO makes it easy to test that behavior without filesystem setup. To repeat the call on the same object, explicitly rewind with seek(0), then compare the count again.
An empty in-memory stream has zero lines.
len(stream.read().split('\n'))sum(1 for _ in stream)StringIO is a text stream, not a byte stream; use BytesIO when code expects bytes. It is also a test aid, not evidence that a function handles disk permissions or very large files. Those are separate integration concerns.
Indexing a missing nested key raises KeyError, while blindly using get with a default can hide a typo in a required setting.
config['service']['retry']validate config['service']['retries'] after parsingUse tomllib.loads for a text string and tomllib.load for a binary file object. After parsing, validate required tables and values explicitly; raise ValueError with a useful message when the contract is not met. tomllib does not write TOML, so do not assume a dumps method exists.
An invalid TOML document raises TOMLDecodeError before any application validation runs.
return config.get('service', {}).get('retries', 3)raise ValueError when required retries is missing or invalidConfiguration may contain secrets; avoid printing complete parsed dictionaries in production logs. The classroom string contains public sample settings only. Keep the distinction between syntax errors, missing settings and invalid values clear to a caller who must fix a configuration file.
fnmatch may normalize case according to the host operating system.
fnmatch.fnmatch(name, '*.py')fnmatch.fnmatchcase(name, '*.py')Use fnmatch.fnmatchcase(name, '*.py') for a case-sensitive in-memory filter, and sorted(...) for deterministic results. When searching actual directories, use pathlib.Path.glob or glob.glob but validate the search root and do not assume a pattern by itself enforces access controls.
The final run includes a nested name like src/main.py.
return [name for name in names if name.endswith('.py')]return sorted(name for name in names if '/' not in name and fnmatch.fnmatchcase(name, '*.py'))Shell-style glob patterns are not regular expressions. Asterisks and question marks have different syntax from re, and a pattern is not a security boundary. Define whether matching is case-sensitive and whether paths or base names are allowed before using results to delete or publish files.
Calling time.perf_counter once before and once after a single tiny operation gives a number, but its precision does not make it trustworthy.
time.perf_counter() around one tiny calltimeit.repeat(callable, number=many_calls, repeat=several_runs)Write per_call(total_seconds, number) to divide a measured duration by a positive integer call count. The function is simple by design: it keeps the unit conversion honest, while the demonstration shows how timeit supplies each total. A benchmark needs a stated interpreter, machine and input size before drawing conclusions.
Zero calls cannot yield a meaningful per-call number and would divide by zero.
return total_secondsreturn total_seconds / number after validating number > 0Benchmark results are observations, not language guarantees. The local demo does not prove which implementation is faster on the user's machine or production workload. Start by confirming both functions return the same value; then measure realistic inputs and report enough context to interpret the numbers.
Using list.pop() treats the frontier as a LIFO stack, producing depth-first traversal.
frontier.pop()frontier.popleft() using collections.dequeInitialize deque with the path containing start. Pop paths from the left, append neighbor paths on the right, and mark a node visited when enqueuing it. Return the first path ending at goal. For this small teaching graph, storing whole paths is readable; larger graphs can store predecessor pointers instead.
If start equals goal, the shortest path is the one-node list.
return [] when no route existsreturn None for unreachable goalBFS minimizes the number of edges only when edges have equal cost. It does not know that one route is geographically faster or cheaper than another. For large graphs, a queue of complete path copies consumes extra memory; reconstruct a path from parent pointers when scalability matters.
A single visited set is insufficient for directed cycle detection.
if neighbor in visited: return Trueif neighbor in active: return True; if neighbor in done: continueMaintain active and done sets. Entering a node adds it to active; after all descendants return without a cycle, move it to done. On a neighbor already active return True; on a done neighbor continue. Start DFS from every graph key to cover disconnected components; recursive visits also reach referenced neighbors.
A self-loop such as X to X is a cycle; an empty graph is not.
search only graph.keys() without referenced nodesinclude nodes appearing in adjacency values tooThis detector is for directed edges. For an undirected graph, the immediate edge back to a parent needs special treatment. Document graph representation and depth limits before using this recursive version on untrusted large graphs.
Greedy is correct for some coin systems but not for arbitrary denominations.
take the largest affordable coin repeatedlycompute dp[amount] from every reachable dp[amount - coin]Initialize dp[0] to zero and all other entries to an unreachable marker. For each amount, consider only positive coins not larger than that amount; if dp[amount - coin] is reachable, update dp[amount]. Return None when the target stays unreachable. Reject negative targets and nonpositive denominations before building the table.
Target zero requires zero coins.
return infinity for unreachable amountreturn None for unreachable amountThis algorithm minimizes coin count, not monetary value or weight; denominations define the available moves. Production financial calculations have other constraints and should not infer optimality from a greedy shortcut without proving it for the specific coin system.
A range ending at len(values) - size omits the final valid starting position.
range(len(values) - size)initialize first window, then update through index len(values)-1Initialize a sum for the first size values, append its average, then for each later index add values[index] and subtract values[index - size]. Append one average after each update. Reject nonpositive window sizes, and return an empty list when size exceeds the data length.
A window size equal to the data length yields one average.
average a partial final windowreturn [] if size > len(values)Floating-point averages can have tiny representation differences; tests should use appropriate tolerance for nonexact decimals. The lesson uses small integer inputs whose output is exactly representable. For streaming data too large to store, the same running-sum idea can be paired with a bounded deque.
Starting with one component per node and subtracting the number of edges gives the wrong answer for a cycle.
len(nodes) - len(edges)decrement only when union joins two different rootsInitialize parent[node] = node for every declared node, including isolated ones. A find function follows parent links and compresses paths. Union roots for each undirected edge, decrementing the component count only when the roots differ. In this compact demo an unknown edge endpoint raises KeyError from the parent lookup; validate endpoints explicitly if the caller needs a friendlier error.
An empty graph has zero components, and four isolated nodes have four.
initialize parents from edge endpoints onlyinitialize parents for every declared nodeThis small implementation uses path compression and is adequate for the exercise. For very large dynamic graphs, union by rank or size can further control tree height. Union-find answers connectivity under added edges; removing edges requires another strategy.
If the prefix array starts at the first input value instead of a leading zero, empty ranges and ranges beginning at zero become awkward and off-by-one errors appear.
prefix = [values[0]]prefix = [0]; append(prefix[-1] + value) for each valueBuild prefix by starting with [0] and appending the last total plus each next value. A query validates 0 <= start <= end <= len(values), then subtracts two stored totals. This precomputation costs one pass; each later query uses constant-time indexing and subtraction.
An empty range where start equals end returns zero, and the full range uses the final prefix entry.
prefix[end+1] - prefix[start]prefix[end] - prefix[start] for [start,end)Prefix sums are appropriate when source values stay unchanged between queries. After a value changes, later prefix totals become stale and must be rebuilt or maintained with another data structure. Keep the half-open interval convention visible in function names and tests.
AttributeError occurs when search returns None.
re.search(r'ORD-[0-9]+', text).group()match = re.search(r'ORD-[0-9]+', text)
if match is not None:
print(match.group())Check the optional match object before reading a group.
The first four digits are changed and the fifth remains.
re.sub(r'ORD-[0-9]{4}', 'order', 'ORD-12345')re.sub(r'\bORD-[0-9]{4}\b', 'order', 'ORD-12345')Both boundaries make the pattern match a complete code.
Range(8, 2) constructs even though the bounds are reversed.
@dataclass
class Range:
low: int
high: intdef __post_init__(self):
if self.low > self.high:
raise ValueError('low must not exceed high')Annotations document intended types; explicit logic enforces the relationship.
The caller may pass a span inconsistent with the bounds.
span: int = 0span: int = field(init=False)
# Set it in __post_init__.Derive the value from low and high in one place.
InvalidStateError may occur because the child has not completed.
task = group.create_task(job())
print(task.result())async with asyncio.TaskGroup() as group:
task = group.create_task(job())
print(task.result())Wait for context exit before reading the result.
The group may observe misleading child state and cleanup semantics.
try:
await work()
except asyncio.CancelledError:
return Nonetry:
await work()
finally:
release_resource()Clean up in finally; generally let cancellation propagate.
A duplicate right-hand value silently replaces the left value.
combined = left | rightif left.keys() & right.keys():
raise ValueError('duplicate key')
combined = left | rightCheck the policy before applying union.
combined is None and left has changed.
combined = left.update(right)combined = left | rightUse union for a fresh result, or call update when in-place mutation is intended.
A repeated left-side name appears twice in common.
[name for name in left if name in right]sorted(set(left) & set(right))The comparison is about unique membership, not event counts.
The function returns people only on the right.
right_set - left_set # left-onlyleft_set - right_set # left-onlyDifference keeps values from the first operand that are absent from the second.
Missing keys or null values raise unrelated KeyError or TypeError exceptions.
record['user']['address']['city']address = user.get('address')
if address is None:
return NoneHandle optional absence before deeper traversal.
A present list or null can still raise AttributeError or mask a malformed shape.
record.get('user', {}).get('address', {}).get('city')if not isinstance(address, dict):
raise ValueError('address must be an object')Verify each present container's type explicitly.
A quoted address containing a comma becomes two fields.
line.split(',')csv.reader(io.StringIO(line))Use the parser that understands quoted separators.
Commas or quotes inside values corrupt the output.
','.join(row)csv.writer(stream).writerow(row)The writer applies the dialect's escaping rules.
TypeError reports an unsupported datetime object.
json.dumps({'at': datetime.now()})json.dumps(data, default=encode_special)Define a representation for values JSON lacks.
An accidental set becomes a string instead of failing validation.
json.dumps(data, default=str)if isinstance(value, Decimal): return str(value)
raise TypeError('unsupported type')A narrow callback preserves the contract.
A type error occurs or strings concatenate instead of adding scores.
totals[name] += row['score']score = int(row['score']); totals[name] += scoreParse and validate the numeric field before arithmetic.
Tie order depends on input order rather than a documented rule.
sorted(rows, key=lambda row: -row['average'])sorted(rows, key=lambda row: (-row['average'], row['student']))The second key gives deterministic ranking.
A shell script treats invalid input as successful output.
print('usage: greet --name NAME')
return 0print('usage: greet --name NAME', file=sys.stderr)
return 2Keep diagnostics on stderr and return a failure status.
A unit test or browser exercise exits instead of inspecting a return code.
def main(argv):
sys.exit(2)def main(argv):
return 2
# at the local entry point: raise SystemExit(main(sys.argv[1:]))Separate testable command logic from process termination.
Blue notebook becomes two arguments.
line.split()shlex.split(line)shlex applies shell-style quoting rules to create the intended token boundaries.
User text can become shell syntax.
subprocess.run(line, shell=True)Dispatch known commands in PythonValidate token[0] against an allowlist and never concatenate it into a shell command.
Bad later input can leave state partly changed.
state[name] = int(count_text)Validate, then copy and updateThe original mapping remains usable after a rejected command.
The menu grants unintended system operations.
subprocess.run(line, shell=True)Dispatch only add, remove, show branchesTreat tokens as application data and keep the grammar explicit.
True is formatted as an integer.
if isinstance(value, int): ...Register bool separatelyThe most specific registered type handles booleans.
The second argument's type does not select an implementation.
@singledispatch def combine(left, right): ...Dispatch on one explicit first argumentUse other design patterns if both argument types determine behavior.
The old cached total remains visible.
self.values.append(value)self.values.append(value); self.__dict__.pop('total', None)Clearing the cached attribute causes recomputation on the next read.
A rejected update can still alter cache state.
self.__dict__.pop('total', None); self.values.append(value)Validate first, then mutate and invalidateKeep state transitions together and predictable.
Separate counters affect one another.
global count; count += stepself.value += stepInstance attributes keep state with the specific object.
An invalid step can corrupt state.
self.value += step; validate(step)Validate, then update self.valueRejected calls should leave the current value unchanged.
Truncated data looks like a complete record.
return stream.read(size)Check len(payload) == sizeA declared length is part of the format contract.
A valid binary payload may trigger UnicodeDecodeError.
stream.read(size).decode()Return bytes to the callerA separate layer can decode only when it knows the expected encoding.
Windows-style lines retain '\r'.
text.split('\n')text.splitlines()splitlines recognizes LF, CRLF, and CR boundaries.
Results depend on environment defaults.
open(path).read()open(path, encoding='utf-8', newline=None)An explicit encoding makes the data contract portable.
The result cannot say which files match.
len(set(files.values()))Group paths by contentKeep the human-readable identifiers alongside candidate digests.
A collision could create a false duplicate.
if hash_a == hash_b: duplicateConfirm the original bytes matchHashes narrow candidate sets; an exact byte comparison confirms a group.
Leap-year reports omit February 29.
date(year, 2, 28)calendar.monthrange(year, month)[1]Ask the calendar for the actual number of days.
True can masquerade as month one.
isinstance(month, int)type(month) is intThis input contract excludes boolean values.
A non-padded month may be accepted.
datetime.strptime('2026-1-02 09:05', pattern)Validate shape with re.fullmatch firstKeep a strict input contract separate from semantic date validation.
The instant becomes misrepresented.
local.replace(tzinfo=timezone.utc)Attach the true source zone, then astimezone(timezone.utc)This lesson's replace is valid only because the input was defined as UTC.
An imported old entry breaks a real streak.
for old, new in zip(days, days[1:])days = sorted(set(days))Normalize chronology and collapse repeated check-ins before comparing neighbors.
Month and leap-year boundaries fail.
new.day == old.day + 1new - old == timedelta(days=1)Calendar date subtraction handles transitions between months and years.
Q1 is 15.0 rather than the expected inclusive 20.0.
quantiles(values, n=4)quantiles(values, n=4, method='inclusive')State the interpolation convention explicitly when an exact result matters.
A summary suggests more evidence than the sample contains.
report one observation's quartiles as stablereject fewer than two observations and report sample sizeAn arithmetic output is not a substitute for context about how much data was observed.
A zero-weight item can still be selected.
rng.choice(items)rng.choices(items, weights=weights, k=1)[0]choices accepts relative weights; choice selects uniformly.
There is no positive probability mass to sample.
rng.choices(items, weights=[0,0], k=1)validate all weights and require sum(weights) > 0Input validation makes the statistical contract explicit and error messages useful.
A skipped answer raises KeyError.
row['choice']row.get('choice')Missing survey answers are expected input, not exceptional corruption.
Unrated responses lower the average or an empty export divides by zero.
sum(ratings) / len(rows)mean(ratings) if ratings else NoneThe denominator should count valid observed ratings only.
The model hides a scan over many list elements.
return (1, 1) because each search is one expressionincrement a counter for every inspected elementSeparate a source-code statement from the operations it performs.
The target may be discarded despite being present.
discard half of an arbitrary liststate and preserve sorted-input preconditionThe direction of each bound change depends on ordering.
The sum decreases and a valid pair is skipped.
if total < target: right -= 1if total < target: left += 1On sorted input the left pointer raises the smallest remaining addend.
A single 4 appears to satisfy target 8.
while left <= rightwhile left < rightA pair requires two distinct list positions.
Saved combinations turn into empty lists after backtracking.
results.append(path)results.append(tuple(path))A tuple snapshots the chosen values at that moment.
A smaller later candidate may be skipped.
break on any candidate above remaining in unsorted inputsort distinct positive candidates before pruningOnly ordered positive candidates support this branch elimination.
An HTML error page raises JSONDecodeError or a JSON error is treated as data.
payload = json.loads(body) before checking statusif status != 200: raise ValueError('unexpected status')Transport status and payload syntax are separate checks.
A list or missing field crashes later or produces misleading data.
return payload['name']validate dict, id type, and nonempty nameJSON parsing does not enforce the application's record schema.
Invalid input and programming bugs are hidden and repeated.
except Exception: continueexcept (TimeoutError, ConnectionError)State which failures might improve on a later attempt.
The caller waits even though no next call will occur.
wait(delay) before checking attempt limitif final_attempt: raise; else: wait(delay)A delay is useful only before another attempt.
A temporary 503 becomes a permanent cached error.
self.cache[path] = self.transport(path) before status validationcache only a validated 200 user recordCache insertion belongs after transport and schema checks.
A caller changes the cached name for every later lookup.
return self.cache[path]return dict(self.cache[path])A shallow copy is enough for this flat id/name record.
A checker still expects the key to be present.
nickname: str | Nonenickname: NotRequired[str]A nullable value and an absent key are different contracts.
This constructs a dict despite the incorrect value type.
profile = Profile(id='seven')Validate untrusted input, then annotate the result as ProfileTypedDict supports static analysis but does not reject bad runtime values.
A 1200×800 image becomes a distorted square.
image.resize((600, 600))image.resize((600, 400), resample=Image.Resampling.LANCZOS)Calculate a matching size from one scale factor.
The original object is changed in place.
image.thumbnail((600, 600))copy = image.copy(); copy.thumbnail((600, 600))Use a copy when the full-resolution source must remain available.
Pen and Pad sales in the same region merge into one subtotal.
sales.groupby('region').amount.sum()sales.groupby(['region', 'product']).amount.sum()Use the complete set of dimensions that defines a bucket.
Rows with a missing region or product are absent from the report.
sales.groupby(['region', 'product']).amount.sum()sales.groupby(['region', 'product'], dropna=False).amount.sum()Choose whether missing-key rows belong in reconciliation totals.
An East order receives both East and West price rows.
orders.merge(pricebook, on='sku')orders.merge(pricebook, on=['sku','region'])Use the entire composite key.
Duplicate lookup pairs can multiply orders and unmatched rows have NaN prices.
orders.merge(pricebook, how='left', on=['sku','region'])orders.merge(pricebook, how='left', on=['sku','region'], validate='many_to_one', indicator=True)State cardinality and inspect left_only rows.
Two rows with one email remain when their timestamps differ.
frame.drop_duplicates()frame.drop_duplicates(subset=['email'])Specify the column that defines duplicate identity.
A newer row appearing earlier can be discarded.
frame.drop_duplicates(subset=['email'], keep='last')frame.sort_values('_parsed_time', kind='stable').drop_duplicates(subset=['email'], keep='last')Define chronological order before choosing the last row.
The result is an empty string.
temp.write(text)
return temp.read()temp.write(text)
temp.seek(0)
return temp.read()Read from the beginning of the same open handle.
The caller receives a path that disappears after the context exits.
return temp.namereturn temp.read()Return the data you need before closing, or use a documented persistent destination.
The log grows without creating backups.
RotatingFileHandler(path, maxBytes=0, backupCount=2)RotatingFileHandler(path, maxBytes=24, backupCount=2)Both values must enable rollover.
Repeated runs can write the same record several times.
logging.getLogger('app').addHandler(handler)Use one owned logger and close/remove the handlerMake the lifetime of each handler explicit.
list accepts an irrelevant name and add does not require it.
parser.add_argument('--name')add_parser.add_argument('--name', required=True)Command-specific arguments belong on that child parser.
Running notes with no verb can yield command=None.
parser.add_subparsers(dest='command')parser.add_subparsers(dest='command', required=True)Reject incomplete invocations at the grammar boundary.
A slow first job delays handling completed later jobs.
for future in futures: print(future.result())for future in as_completed(futures): print(future.result())Process each job when it becomes available.
One failed job aborts the whole collection unexpectedly.
value = future.result()try: value = future.result()
except ValueError: value = '<error>'Choose and document an error policy per job.
The operating system may look for a program with that entire name.
subprocess.run('python -c code Ada')subprocess.run([sys.executable, '-c', code, 'Ada'])Use a sequence to identify executable and arguments precisely.
User-controlled text can change what the shell executes.
subprocess.run(f'python child.py {name}', shell=True)subprocess.run([sys.executable, 'child.py', name])Keep untrusted text in an argv element and avoid an unnecessary shell.
Unexpected members are written beside the intended text files.
archive.extractall(destination)Inspect infolist(), enforce a policy, then write accepted members.The application decides which files belong in its destination.
A failed operation leaves partial output.
write the first file, then reject a later pathValidate every member before creating destination files.A validation pass makes rejection predictable.
The API does not document the expected fields and limits as clearly.
def create_item(item: dict): ...Declare a BaseModel with required typed fields and constraints.FastAPI can then validate the body and publish its schema in OpenAPI docs.
A boolean can be treated as quantity one in handwritten checks.
isinstance(True, int)State the chosen coercion policy; use strict constraints when needed.Type coercion and business rules deserve an explicit decision.
Rows from a second table mix into the result.
soup.find_all('tr')Select the intended table first, then its rows.Scope a query to the table that carries the data you need.
A missing cell disappears from the record without warning.
dict(zip(headers, cells))Compare header and cell counts before zipping.A predictable extraction contract makes later analysis reliable.
A wrapper function is blamed for work in its subcalls.
cumtime == time spent only in this function's own linesCompare cumtime with tottime and inspect callees.A profiler report separates inclusive and exclusive time.
An algorithm that scales poorly appears harmless.
profile a list of three items and extrapolateProfile representative inputs and compare under the same conditions.Input size and shape affect where time is spent.
A renamed column silently changes every record key.
dict(zip(rows[0], row))Validate the expected header tuple before mapping rows.Data contracts should fail visibly when the sheet layout changes.
Formula cells may be None or stale.
load_workbook(path, data_only=True) # computes formulasUse cached values only after a spreadsheet application has recalculated and saved the workbook.openpyxl reads a workbook; it is not a formula engine.
The number supplied becomes the row count instead of the requested column count.
array.reshape(columns, -1)array.reshape(-1, columns)The last dimension is the number of entries per row.
ValueError because the requested shape requires eight elements.
np.arange(6).reshape(4, 2)np.arange(6).reshape(2, 3)Reshape preserves the total element count.
ValueError: duplicate entries cannot be reshaped.
sales.pivot(index='region', columns='product', values='amount')pd.pivot_table(..., aggfunc=['sum', 'mean'])A transaction table needs an aggregation policy for repeated pairs.
A missing observation can look like a real mean of zero.
pd.pivot_table(..., aggfunc=['sum','mean'], fill_value=0)Keep NaN until the reporting policy for missing cells is decided.Missing data and observed zero answer different questions.
The city column gets a numeric zero instead of a meaningful label.
frame.fillna(0)frame.fillna({'city': 'Unknown', 'score': 0})Choose replacements that match each field's meaning and type.
A city value of '' remains blank.
frame.fillna({'city':'Unknown'})Normalize blank strings deliberately before fillna if the data contract calls for it.fillna operates on recognized null markers.
Independent waits run one after another.
[await job(x) for x in inputs]await asyncio.gather(*(job(x) for x in inputs))Submit the independent awaitables before waiting for their collection.
With return_exceptions=True, a result can be an exception object.
result.upper()Check isinstance(result, ValueError) before formatting it.Keep expected failure handling explicit and leave unexpected exceptions visible.
Each new input requires another duplicated function.
test_zero(), test_twelve(), test_spaces() with repeated bodies@pytest.mark.parametrize('text, expected', rows)Keep one assertion body and enumerate varied inputs as rows.
Negative and malformed input behavior stays untested.
rows = [('1', 1), ('2', 2)]Add separate parametrized invalid cases using pytest.raises(ValueError).The error contract is part of the function's behavior.
Lexical order can differ from chronological order.
sort_values('date_text') on mixed formatspd.to_datetime(source, format='%Y-%m-%d')Parse according to a documented source format before date operations.
Invalid source records vanish without an error report.
pd.to_datetime(values, errors='coerce').dropna()parsed = pd.to_datetime(values, errors='coerce'); bad = parsed.isna()Preserve source row identity before filtering.
An empty or different chart is exported.
plt.savefig('chart.png') after creating another figurefig.savefig('chart.png')Keep and save the intended Figure object.
The resulting dimensions differ from the assumed canvas.
fig.savefig(path, dpi=200, bbox_inches='tight') # always 1200x600Inspect the saved dimensions if exact pixels matter.Bounding-box cropping changes the output canvas.
The list contains ERR and WARN rather than full codes.
re.findall(r'(ERR|WARN)-[0-9]{3}', text)re.findall(r'(?:ERR|WARN)-[0-9]{3}', text)Noncapturing parentheses retain alternation without changing the return shape.
ERR-101 appears even though the whole code has four digits.
re.findall(r'ERR-[0-9]{3}', 'ERR-1012')re.findall(r'\bERR-[0-9]{3}\b', text)A boundary after the digits rejects a longer word token.
A number or None raises AttributeError inside the validator.
value.strip()Check isinstance(value, str) before strip.A before validator sees raw input.
Validation receives None rather than a normalized handle.
value.strip().casefold() # no returnreturn value.strip().casefold()Validator output becomes the field value for later validation.
Every page begins at the first item.
return items[:limit]return items[skip:skip + limit]Slice start and stop must both reflect the offset.
A caller can request an excessive response size.
def list_items(limit: int = 10): ...limit: int = Query(default=10, ge=1, le=50)A bounded HTTP parameter makes the contract explicit and documented.
Tests depend on the working directory and can overwrite a real file.
Path('report.txt').write_text(data)Pass tmp_path to the writer and build tmp_path / 'report.txt'.A destination parameter makes the file side effect testable and isolated.
The test may pass without confirming the saved content.
assert save_report(tmp_path, lines).name == 'report.txt'Read the returned path with encoding='utf-8' and compare the text.The disk content is the behavior this test promises.
Nested Customer is still a Customer object and slotted dataclasses may lack __dict__.
order.__dict__Use asdict(order) for recursive dataclass conversion.asdict follows declared fields and converts nested dataclasses.
JSON encoding raises TypeError for unsupported values.
json.dumps(asdict(record_with_datetime))Convert special values explicitly before json.dumps, or supply a deliberate serializer.A Python dict is not automatically valid JSON data.
An object without age may still validate.
{'properties': {'age': {'type': 'integer'}}}Add 'required': ['age'] when age must be present.properties and required have separate roles in JSON Schema.
The string fails the integer rule.
validator.validate({'age': '20'}) # expects 20Parse or reject the string before validation according to your input contract.jsonschema checks the instance; it does not transform a value into another type.
The text uses Python quotes and is not guaranteed valid JSON.
return str(list(csv.DictReader(stream)))Pass the list of row dictionaries to json.dumps.JSON has its own serialization rules and escaping.
Extra cells may appear under a None key; missing cells may become null.
rows = list(csv.DictReader(stream)); json.dumps(rows)Check headers and each row before serializing.A predictable output schema depends on validating the CSV structure.
The original values array remains unchanged.
selected = values[mask]; selected[0] = 0Assign through values[mask] = 0 when the source should change.Boolean selection returns a separate array.
NumPy cannot interpret the truth value of a multi-element array.
values > 5 and values < 20Use (values > 5) & (values < 20).The ampersand combines the Boolean arrays element by element.
Follow the course from the basics and check your work in the browser console.
Explore Learn Python