Python Essentials: Scripting & Automation

1. A C++ programmer sees this Python file and says: “This must be wrong — there’s no main() function and no semicolons.” What should you tell them?

• Python requires a main() function but it is inferred automatically

  Scripting languages (Python, Ruby, Bash) execute the file top-to-bottom — there is no inferred entry point. The if __name__ == '__main__' idiom is a convention for when a file is also imported as a module, not a required entry point. The C/C++/Java requirement of a main() is a language-design choice, not a property of all languages.

• Python scripts execute top-to-bottom without a main() entry point; semicolons are replaced by newlines and indentation
• Python is actually compiled, it just hides the main() function internally

  CPython does compile each script to .pyc bytecode at runtime, but transparently — the programmer never invokes a compiler, no main() is generated, and there is no separate build artifact to ship. C++ requires an explicit, ahead-of-time compile step that produces a native binary; Python does not.

• The programmer is correct — Python requires semicolons in production code

  There is no production-vs-script Python. Python’s grammar accepts an optional ; to put two statements on one line, but it is never required. A teammate insisting otherwise is recalling a different language (likely C, Java, or JavaScript).

2. Which of the following statements about Python are correct? (select all that apply)

• Python is garbage-collected, so you never call delete or free()
• Python is dynamically typed — you do not declare variable types
• Python must be compiled before running, just like C++

  CPython does produce .pyc bytecode, but transparently and at runtime — the programmer never invokes a compiler and there is no separate build artifact to ship. C++ requires an explicit, ahead-of-time compile step that produces a native binary; Python does not.

• Python is strong at rapid prototyping, automation, and data processing

3. In which scenario is Python a better choice than a shell script?

• Renaming 10 files using a simple glob pattern
• Starting and stopping system services
• Parsing a 50-column CSV, computing statistics, and writing a report
• Chaining three Unix commands with a pipe

4. A teammate is choosing between Python and C++ for a new project. The project needs to process 10 GB of sensor data as fast as possible in real time, with strict latency requirements. Another teammate suggests Python because “it’s easier.” Evaluate both suggestions. Which response best captures the trade-off?

• Python is always slower than C++, so C++ is the only correct choice for any project with performance requirements

  Real systems are layered: a slow glue layer driving a fast hot path is the standard pattern (NumPy in Python wraps C; PyTorch wraps CUDA). Choosing C++ for every line because the hot path needs it picks the wrong scope for the decision — most code in any project isn’t latency-critical.

• Python is fine for real-time processing — modern hardware makes the speed difference between Python and C++ negligible

  CPython is roughly 30–100× slower than C++ for tight numeric loops; that gap is intrinsic to the interpreter, not something hardware closes over time. Real-time latency budgets (sub-millisecond) cannot absorb a 30× constant factor regardless of how fast the CPU gets.

• C++ is better for the real-time core due to speed, but Python is ideal for prototyping and non-latency-critical parts like config and visualization
• They should use Bash — piping data between Unix tools is faster than either Python or C++ for data processing

  Pipes are great for line-oriented text streams, but a 10 GB sensor stream with strict latency needs zero-copy buffer management, fixed-rate scheduling, and concurrency primitives — none of which cat | awk | grep provides. Unix tools shine when the data is text and the timing is loose; that’s the opposite of this scenario.

1. What does type(3.14) return in Python?

• double
• float
• decimal
• number

2. Which of the following correctly uses an f-string to print "Price: €12.50"?

• print("Price: €" + price)
• print(f"Price: €{price:.2f}")
• printf("Price: €%.2f", price)
• print("Price: %s" % price)

3. A student runs x = "5" + 3 in Python and gets a TypeError. They say: “But Python is dynamically typed — it should convert automatically!” Analyze their misunderstanding. What is wrong with their reasoning?

• They are correct — dynamically typed languages should convert between types automatically, so this is a Python bug

  Dynamic and weak are independent properties: dynamic describes WHEN types are checked (runtime); weak describes HOW aggressively the language coerces between them. JavaScript is dynamic + weak ("5" + 3 gives "53"); Python is dynamic + strong on purpose — silent coercion is a famous bug source.

• Dynamic typing means types are checked at runtime, not that types don’t exist. Python is strongly typed and refuses to implicitly convert str + int
• The error happens because x was already declared as a string elsewhere, and Python does not allow reassignment to a different type

  In Python, types live on values, not on names — x = "5" then x = 3 is fine. The error here is purely about the + operator’s two operands at the moment of evaluation. Languages where a variable’s type is fixed at declaration (C/C++/Java) make this rule look stricter than it actually is.

• Python only allows concatenation through the explicit concat() function, not the + operator which is reserved for numbers

4. A student writes x = 42 in Python. What is the type of x?

• integer
• int
• number
• float

1. A student writes the following Python and gets IndentationError: expected an indented block:

for item in inventory:
print(item)

• Add a semicolon at the end of the for line
• Add braces: for item in inventory: { print(item) }
• Indent print(item) with 4 spaces so it is inside the for block
• Use for (item in inventory) C-style syntax

2. In Python, what marks the start of a new indented block (instead of { in C++)?

• An opening brace { — same as C++ and Java
• The begin keyword — like Pascal or Ruby
• A colon : at the end of the control statement
• A semicolon ; followed by increased indentation

3. A student accidentally mixes tabs and spaces for indentation in the same Python file. What will happen when they run it?

• Python auto-converts tabs to spaces and runs fine

  Python 3’s parser refuses to guess whether a tab counts as 1, 4, or 8 spaces, because every guess could change the program’s meaning. Auto-conversion would silently re-bind code to a different block — the language designers chose loud failure over silent miscompilation. (Editor settings can enforce a convention, but the parser still won’t second-guess what’s on disk.)

• The code runs but indented blocks are silently skipped

  Python halts on any indentation inconsistency at parse time, before any code runs — there is no partial execution where some blocks are skipped. The runtime never sees a half-broken program; it sees the SyntaxError instead.

• Python raises a TabError or IndentationError
• Only the lines with tabs produce output

  Python parses the whole file before running anything; there is no per-line execution where some lines succeed and others fail. The whole script either parses or doesn’t.

4. A teammate argues: “Python’s indentation-as-syntax is worse than C++’s braces because you can’t see block boundaries as clearly.” Another teammate replies: “It’s better because it forces everyone to format consistently.” Evaluate both claims. Which assessment is most accurate?

• The first teammate is right — braces are always superior because you can collapse blocks and see structure without relying on whitespace
• The second teammate is right — indentation-as-syntax is strictly better because it eliminates an entire category of bugs with zero tradeoffs
• Both have valid points: indentation eliminates formatting inconsistency and reduces visual clutter, but it can cause subtle bugs when copy-pasting code or mixing editors with different tab settings
• Neither is right — the choice of block syntax has no practical effect on code quality

1. What is the output of the following code?

def describe(item, label="unknown"):
    return f"{item} is {label}"

print(describe("gold", "rare"))
print(describe("rock"))

• gold is rare then rock is unknown
• gold is rare then rock is rare
• SyntaxError — default parameters must come before non-default
• gold is unknown then rock is unknown

2. A C++ programmer writes a Python function and is confused that it “doesn’t return anything”:

def double(x):
    x * 2
print(double(5))  # prints None

• Python functions cannot perform multiplication — the * operator only works for string repetition
• The function is missing return. In C++, the last expression may be implicitly returned; in Python, no return means None
• double is a reserved word in Python (like C++’s double type), so it shadows the function definition
• The function needs a type annotation like def double(x: int) -> int: before Python will return a value

3. What does mean([10, 20]) return if mean is defined as return sum(numbers) / len(numbers)?

• 15 (an int)
• 15.0 (a float)
• [15] (a list)
• TypeError — sum() doesn’t work on lists

4. (Spaced review — Step 1: Python Execution Model) A teammate is confused: “I wrote a Python file with a helper function and some test prints, but when I import it from another file, all the test prints run too.” What should they use to prevent this?

• Move the test prints into a main() function — Python automatically detects and skips main() during import
• Wrap the test prints in if __name__ == '__main__': — this block only runs when the file is executed directly, not when imported
• Use #pragma once at the top of the file to prevent double execution, similar to C++ header guards
• Add import guard at the top — this is Python’s built-in mechanism to prevent code from running during import

5. Arrange the lines to define a function that returns the larger of two numbers, with a default for b. (arrange in order)

1. def max_of(a, b=0):
2. if a >= b:
3. return a
4. else:
5. return b

• return a, b

1. What is the most useful type annotation for this function?

def parse_csv_row(line):
    return line.split(',')

• def parse_csv_row(line: str) -> list[str]:
• def parse_csv_row(line: str) -> str:

  split(',') returns a list, not a str. The string is the input here, not the output.

• def parse_csv_row(line: List) -> tuple[str]:

  split() returns a list, not a tuple. Also, capital-L List would require from typing import List — modern Python uses lowercase list[str].

• def parse_csv_row(line) -> list:

  Bare list is better than nothing, but list[str] is more informative — it tells static checkers what the element type is, so callers can be flagged for passing the wrong shape.

2. What happens at runtime when you call add('1', '2') on this function?

def add(a: int, b: int) -> int:
    return a + b

• Python raises TypeError: argument 'a' must be int, not str because of the type annotation

  Annotations are stored on add.__annotations__ but Python never raises a TypeError from them. That check is the job of mypy or your IDE, not the interpreter.

• Python returns the string '12' — the annotation is ignored at runtime, and '1' + '2' is valid string concatenation
• Python raises SyntaxError — type annotations only work with literal types like int(1)

  Type annotations are part of Python’s syntax (PEP 526 / PEP 3107) — there’s no SyntaxError. The whole point is that they parse fine but are not enforced.

• Python silently coerces the strings to integers and returns 3

  Python does not auto-coerce here. '1' + '2' is valid string concatenation, so the function happily returns '12'. No coercion, no error from the interpreter.

3. Given two annotated functions:

def add(a: int, b: int) -> int:
    return a + b

def repeat(s: str, n: int) -> str:
    return s * n

• add(1, 2) — both 1 and 2 are int

  Both arguments match the annotations and the runtime succeeds. Nothing to flag and nothing to raise.

• add('a', 'b') — passing strings where ints are annotated
• repeat('hi', 3) — both arguments match

  Both arguments match the annotations and 'hi' * 3 is valid string repetition. Quiet on both sides.

• repeat('hi', '3') — passing a string where int is annotated

  mypy would flag this — but Python also raises TypeError: can't multiply sequence by non-int of type 'str'. The runtime error is real, just from *, not from the annotation. The question asks for cases where Python runs without raising; this one isn’t.

4. (Spaced review — Step 4: Functions) Which function signature correctly combines type hints with a default parameter?

• def greet(name: str, greeting = 'Hello': str) -> None:

  The order is name: type = default — the annotation goes between the name and the equals sign, not after the default value.

• def greet(name: str, greeting: str = 'Hello') -> None:
• def greet(name = 'World': str, greeting: str) -> None:

  Defaulted parameters must come after required ones (same rule as in C++).

• def greet(name, greeting): -> None # type: str, str

  Modern Python uses inline annotations (PEP 526). The # type: comment style is a legacy form from before annotations were syntax.

5. A teammate calls first_n([1.5, 2.5, 3.5], 2) against this annotated function:

def first_n(items: list[int], n: int) -> list[int]:
    return items[:n]

• Runtime: returns [1.5, 2.5] (annotation ignored). mypy: error — list[float] is not list[int].
• Runtime: TypeError (annotation enforced). mypy: error.

  Python does not enforce annotations at runtime — they are documentation that tools read.

• Runtime: returns [1.5, 2.5]. mypy: ok (floats can be passed where ints are expected).

  mypy treats list[float] and list[int] as distinct (they’re invariant in their type parameter, per PEP 484). It would flag this call as an error.

• Runtime: returns [1, 2] (Python silently truncates floats to ints). mypy: ok.

  Python doesn’t silently coerce values to match annotations. The list elements stay as floats.

1. Which of the following iterates over a list and gives both the index and the item?

• for i, x in index(nums):
• for i, x in enumerate(nums):
• for i in nums.keys():
• for i in range(nums):

2. What does list(range(2, 8, 2)) evaluate to?

• [2, 4, 6, 8]
• [2, 4, 6]
• [2, 3, 4, 5, 6, 7]
• [2, 8]

3. A C++ programmer expects 6 / 2 to return the integer 3 in Python. What actually happens?

• It returns the integer 3 — Python division works just like C++

  Python 3 deliberately split the operator: / is always float division, // is always floor division — regardless of whether the operands are int or float. C/C++/Java pick the operator’s behavior based on the operand types, but PEP 238 broke that link in Python 3 precisely because too many learners were surprised by integer truncation.

• It returns 3.0 — Python’s / always gives a float; use // for integer division
• It raises a TypeError because both operands are integers

  Python is happy to mix int and float; the result is just promoted to float. The TypeError pattern shows up for non-numeric mixing ("5" + 3), not for arithmetic between two numbers.

• It returns the fraction object fractions.Fraction(6, 2) — Python automatically converts integer division to a rational number

4. What are the values of a and b after this line?

a, b = (3, 7)

• a = (3, 7), b is undefined
• a = 3, b = 7
• a = 7, b = 3
• TypeError — cannot assign a tuple to two variables

5. (Spaced review — Step 4: Functions) What does this function return when called as compute(10)?

def compute(x: int, power: int = 2) -> int:
    return x ** power

• 20 — x * power
• 100 — 10 ** 2
• 12 — 10 + 2
• TypeError — missing required argument

1. Which list comprehension correctly produces only the odd numbers from 1 to 9?

• [x for x in range(1, 10) if x % 2 != 0]
• [x if x % 2 != 0 for x in range(1, 10)]

  Swapping if before for is a syntax error — the filter condition must come after the iteration: [expr for var in iterable if condition].

• [x for x in range(1, 10, 1) if odd(x)]

  odd() is not a built-in Python function. Use x % 2 != 0 as the filter condition.

• (x for x in range(1, 10) if x % 2 != 0)

  Parentheses () create a generator expression, not a list. Use square brackets [] for a list comprehension.

2. A student rewrites [x**2 for x in range(5)] as a for-loop and gets the same result. Why would a Python programmer prefer the list comprehension?

• List comprehensions run faster than for-loops for all input sizes
• List comprehensions are more readable and concise for simple transformations, and are a recognized Python idiom
• For-loops are deprecated in Python 3
• List comprehensions avoid creating a temporary list in memory

3. Analyze this code. What does it produce, and could a list comprehension replace it?

result = []
for name in ["Alice", "Bob", "Charlie"]:
    if len(name) > 3:
        result.append(name.upper())

• ['ALICE', 'CHARLIE'] — yes: [name.upper() for name in [...] if len(name) > 3]
• ['Alice', 'Charlie'] — no: comprehensions can’t call methods
• ['ALICE', 'BOB', 'CHARLIE'] — the if is ignored
• ['alice', 'charlie'] — upper() converts to lowercase

4. (Spaced review — Step 2: f-Strings) What does this expression produce?

items = [3, 1, 4]
print(f"Count: {len(items)}, Sum: {sum(items)}")

• Count: 3, Sum: 8
• Count: [3, 1, 4], Sum: [3, 1, 4]
• SyntaxError — you can’t call functions inside f-strings
• Count: 3, Sum: 4

1. A student writes this code and asks why Python is better than C++ for this task:

with open("log.txt") as f:
    errors = [line for line in f if "ERROR" in line]

• Python runs faster than C++ for file I/O operations
• Python’s with statement, built-in file iteration, and list comprehensions make this 3-4 lines vs 20+ lines in C++ with error handling
• C++ cannot open text files, only binary files
• Python files never need to be closed because the OS does it automatically

2. What does line.strip() do when reading lines from a file?

• Removes all spaces from the middle of the line
• Removes leading and trailing whitespace, including the newline character \n at the end
• Converts the line to lowercase
• Splits the line into a list of characters

3. A teammate proposes reading a 2 GB log file with text = f.read() (loading the entire file into memory). Another proposes for line in f: (iterating line by line). Evaluate both approaches. Which is better for a 2 GB file, and why?

• Both are identical in behavior and memory usage — Python handles buffering automatically regardless of which method you use
• f.read() is better because reading the entire file into one string is faster than processing line by line due to fewer I/O calls
• for line in f: is better — it processes one line at a time, using constant memory regardless of file size, while f.read() would load 2 GB into RAM
• Neither works — Python can’t handle files over 1 GB

4. (Spaced review — Step 3: Indentation) What is wrong with this code?

with open("data.txt") as f:
for line in f:
    print(line)

• Nothing — the code is correct
• The for line needs to be indented inside the with block
• You need to call f.close() after the loop
• open() requires a mode argument like 'r'

5. (Spaced review — Step 2: String Quotes) A student writes this Python code and gets a SyntaxError. Why?

message = 'It's a beautiful day'

• Single quotes can’t be used for strings in Python
• The apostrophe in It's ends the string early because it matches the opening '. Fix: use double quotes ("It's a beautiful day") or escape the apostrophe ('It\'s a beautiful day')
• Python strings must use double quotes
• The string is too long for single quotes

6. Arrange the lines to read a file and count total words. (arrange in order)

1. total = 0
2. with open('data.txt') as f:
3. for line in f:
4. total += len(line.split())
5. print(f'Words: {total}')

• f.close()

1. What does re.findall(r'\d+', 'boot in 3... 2... 1...') return?

• '3 2 1'
• ['3', '2', '1']
• '321'
• 3 (just the count)

2. You want to know whether a log line contains an IP address, but you don’t need to extract it. Which function is most appropriate?

• re.findall() — it returns all matches, so you can check len() > 0
• re.search() — it returns a match object (truthy) or None (falsy) for a single check
• re.sub() — it can test for a match while replacing
• re.compile() — it tests patterns without needing a string

if re.search(r'\d+\.\d+\.\d+\.\d+', line):
    print("has IP")

3. Why are raw strings (r'\d+') preferred over regular strings ('\\d+') for regex patterns?

• Raw strings run faster because Python skips Unicode processing
• Raw strings prevent Python from interpreting backslashes before the re module sees them, so \d stays as two characters \ and d
• The re module only accepts raw strings and will raise a TypeError otherwise
• Raw strings automatically escape special regex characters like . and *

4. Analyze this code. What does results contain after execution?

import re
text = "alice@example.com and bob@test.org"
results = re.findall(r'\w+@\w+\.\w+', text)

• ['alice@example.com', 'bob@test.org']
• ['alice', 'bob'] — findall only returns the first group
• 2 — findall returns a count
• 'alice@example.com' — findall returns the first match as a string

5. (Spaced review — Step 6: List Comprehensions) Which expression produces ['ERROR Connection failed: timeout', 'ERROR Disk usage at 94%'] from a variable lines containing all log lines as a list of strings?

• [line for line in lines if 'ERROR' in line]
• lines.filter('ERROR')
• [line if 'ERROR' for line in lines]
• lines.find('ERROR')

1. A script is run with python3 myscript.py hello world. What is sys.argv[0]?

• "hello"
• "world"
• "myscript.py"
• None

2. Why should error messages be written to sys.stderr rather than printed normally?

• stderr is faster than stdout in Python
• stdout can only handle one line at a time
• Separating stdout and stderr lets users redirect normal output and errors independently
• Python automatically color-codes stderr messages in red

3. A script should exit with code 1 and print an error if the user provides no arguments. Evaluate these two approaches. Which is correct Python? Approach A:

import sys
if len(sys.argv) == 1:
    print("Error: no arguments", file=sys.stderr)
    sys.exit(1)

import sys
if len(sys.argv) == 1:
    print("Error: no arguments")
    sys.exit(1)

• Both are correct and equivalent
• Only A is correct — errors must go to stderr so they don’t contaminate stdout (which may be piped)
• Only B is correct — file=sys.stderr is not valid Python syntax
• Neither is correct — you should use raise SystemExit(1) instead

4. (Spaced review — Step 5: Loops) A student writes this code to print each word with its position number. What is wrong?

words = ["apple", "banana", "cherry"]
for i in words:
    print(f"{i}: {words[i]}")

• Nothing is wrong — for i in words gives i as the index, and words[i] retrieves each element correctly
• i is the word itself (not an index), so words[i] causes TypeError. Use enumerate(words) to get both index and value
• The f-string syntax is incorrect — f-strings cannot contain variable references inside braces, so {i} fails at runtime
• The loop should use range(words) instead — passing a list to range() automatically generates valid indices

5. (Spaced review — Step 7: File I/O) What happens if you forget the with keyword and write f = open("data.txt") instead?

• The file opens but you must manually call f.close() — if an exception occurs before close(), the file stays open
• Python raises a SyntaxError — open() can only be used with with
• The file opens in read-only mode instead of read-write
• Nothing different — with is just syntactic sugar with no functional effect

6. (Spaced review — Step 2: String Quotes) In C++, 'A' is a char and "Alice" is a string — they are different types. What is the equivalent distinction in Python?

• Python also distinguishes 'A' as a character and "Alice" as a string
• There is no distinction — Python has no char type. Single quotes ('...') and double quotes ("...") both create str objects and are fully interchangeable
• Single quotes create byte strings, double quotes create Unicode strings
• Single quotes are for single characters, but Python stores them as length-1 strings

1. You need to count the number of unique IP addresses in a log file. You have a list of all IP addresses (with duplicates): ips = ['10.0.0.1', '10.0.0.2', '10.0.0.1']. Which approach is most Pythonic?

• Use a for-loop to check each IP against a list of already-seen IPs
• len(set(ips)) — convert to a set (which removes duplicates) and count
• ips.unique() — lists have a built-in unique method
• len(ips) - len(duplicates) — count total minus duplicates

2. Evaluate this code for a log analyzer. What is the bug?

import sys, re

filename = sys.argv[1]
with open(filename) as f:
    text = f.read()

errors = re.findall(r'ERROR.*', text)
warnings = re.findall(r'WARNING.*', text)
ips = re.findall(r'\d+\.\d+\.\d+\.\d+', text)

print(f"Errors: {len(errors)}")
print(f"Warnings: {len(warnings)}")
print(f"Unique IPs: {len(ips)}")

• The regex patterns are wrong — ERROR.* only matches the literal characters E-R-R-O-R, not the full line
• Two bugs: no sys.argv check (crashes with IndexError if no filename given), and len(ips) counts total IPs including duplicates (should use set(ips))
• The file is never properly closed because with blocks do not support the .read() method on the file handle
• There is no bug — the with statement, regex patterns, and f-string formatting are all correct as written

3. Analyze the design of a log analyzer script. A student puts all logic in one long script with no functions. Another student breaks it into functions: parse_args(), read_log(), count_by_level(), extract_ips(), print_report(). Which approach is better, and why?

• The single-script approach is better — functions add unnecessary complexity for a short script
• Both are equivalent — it’s purely a matter of style
• The function-based approach is better — each function is testable, reusable, and has a clear responsibility. It also makes the top-level flow self-documenting
• The function-based approach is worse — Python functions are slower than inline code

4. (Spaced review — Step 5: Loops) You need to process a list of log lines and print each line’s number alongside it (starting from 1). Which approach is most Pythonic?

• for i in range(len(lines)): print(f'{i+1}: {lines[i]}') — use range to generate index numbers

  This works but is unpythonic — range(len(...)) then indexing is the C/Java pattern. enumerate() is the idiomatic Python way to get both index and value.

• for n, line in enumerate(lines, 1): print(f'{n}: {line}') — enumerate gives index and value together, and start=1 avoids the +1
• i = 0; for line in lines: i += 1; print(f'{i}: {line}') — manually track the counter like in C++

  Manually tracking a counter variable is C-style — verbose and error-prone. enumerate() handles this automatically.

• for line in lines: print(f'{lines.index(line)+1}: {line}') — use index() to find the position

  .index() scans the entire list each iteration — O(n²) overall — and returns the first match, so it breaks silently on duplicate lines. Use enumerate() instead.

5. (Spaced review — Step 8: Regular Expressions) A log analyzer needs to extract all timestamps matching the pattern 2024-01-15 14:30:22 from a log string. Which re call is correct?

• re.search(r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}', log) — search finds the first match only
• re.findall(r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}', log) — findall returns a list of all matching strings
• re.match(r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}', log) — match scans the entire string for all occurrences
• re.split(r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}', log) — split extracts everything that matches the pattern

1. Which three dunder methods does @dataclass write for you by default (no extra kwargs)?

• __init__, __eq__, __repr__
• __init__, __del__, __str__

  __del__ is for destructors (rare in Python — garbage collection handles it). @dataclass doesn’t write either of these. __repr__, not __str__, is what @dataclass generates.

• __init__, __eq__, __hash__

  Close — but __hash__ is only generated when you also pass frozen=True (or eq=False). By default, a non-frozen dataclass is unhashable to discourage using mutable objects as dict keys.

• __new__, __copy__, __format__

  These aren’t related. @dataclass focuses on the standard data-holder boilerplate: construction, equality, and string representation.

2. Given:

@dataclass(frozen=True)
class Point:
    x: int
    y: int

p = Point(3, 4)
p.x = 99

• It silently succeeds — frozen=True only affects equality, not assignment

  frozen=True is specifically about preventing mutation — that’s its whole purpose. Equality is generated by eq=True (the default), separately.

• It raises AttributeError — the field is read-only because it has no setter

  AttributeError is what you get from @property without a setter, or from accessing a missing attribute. Frozen dataclasses raise their own dedicated exception.

• It raises FrozenInstanceError — frozen dataclasses override __setattr__ to forbid mutation
• It raises TypeError — 99 is not declared int in this context

  Type annotations are not enforced at runtime (Step 5). The assignment fails because the class is frozen, not because of any type check.

3. Which of these statements about @property are true? (Select all that apply.) (select all that apply)

• It lets you read a method’s result as an attribute, without parentheses
• It makes the underlying field private — no callers can read it

  @property is purely about interface shape (p.x vs p.x()). It doesn’t make anything private. Python’s privacy convention is the underscore prefix (_internal), and even that is only a convention — there are no hard private fields.

• It can be combined with a setter (using @<name>.setter) to control writes
• It is a special form of __getattr__

  @property is implemented as a descriptor on the class, not via __getattr__. __getattr__ is the per-instance fallback for missing attributes — completely different mechanism.

4. (Spaced review — Step 7: List Comprehensions) What is points[2] after this line?

points = [Point(x, x * 2) for x in range(5)]

• Point(2, 2)

  x * 2 for x = 2 is 4, not 2. The y-coordinate is the doubled value.

• Point(2, 4)
• Point(4, 8)

  Indexing is 0-based: points[2] corresponds to x = 2, not x = 4.

• (2, 4) — a plain tuple, since list comprehensions don’t return objects

  List comprehensions can absolutely produce class instances. Point(x, x*2) is a function call expression — it constructs a Point for each iteration.

5. Evaluate. For which use case is @dataclass(frozen=True) the best fit?

• A shopping cart whose items are added and removed throughout the session

  Shopping carts mutate over time — adding/removing items requires assignment to fields or methods that change state. A frozen dataclass would block all of that.

• A 2D grid coordinate (row, col) used as a dictionary key
• A database connection that holds a socket and a transaction state

  Connections have identity (this specific socket) and changing internal state (buffer, transaction). They are reference objects, not value objects. Frozen dataclasses fit values where two with equal fields are interchangeable — connections aren’t.

• A logger object that buffers messages and flushes them periodically

  Loggers buffer messages — internal state changes constantly. Also, two loggers with equal configuration aren’t interchangeable; they have identity.

6. (Spaced review — Step 5: Type Hints) Given:

@dataclass(frozen=True)
class Point:
    x: int
    y: int

• Runtime: TypeError — Python rejects floats where ints are annotated.

  Type annotations on dataclass fields are not enforced by Python at runtime — same rule as Step 5. The annotations only tell @dataclass what to put in the auto-generated __init__ signature; they do not gate the values.

• Runtime: Point(3.5, 4.5) is constructed (p.x == 3.5). mypy: would flag — float is not int.
• Runtime: Point(3, 4) (Python silently truncates floats). mypy: ok.

  Python does not coerce floats to ints in dataclass construction — p.x stays 3.5. The annotation is documentation, not a converter.

• Runtime: depends on whether frozen=True is set.

  frozen=True controls post-construction mutation, not what types the constructor accepts. Annotations are inert at runtime regardless of frozen.