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
• 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
• The programmer is correct — Python requires semicolons in production code

2. Which of the following statements about Python is false?

• 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++
• 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
• Python is fine for real-time processing — modern hardware makes the speed difference between Python and C++ negligible
• 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

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 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
• 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
• The code runs but indented blocks are silently skipped
• Python raises a TabError or IndentationError
• Only the lines with tabs produce output

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. 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++
• It returns 3.0 — Python’s / always gives a float; use // for integer division
• It raises a TypeError because both operands are integers
• 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, power=2):
    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)]
• [x for x in range(1, 10, 1) if odd(x)]
• (x for x in range(1, 10) if x % 2 != 0)

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 recognised 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
• 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++
• for line in lines: print(f'{lines.index(line)+1}: {line}') — use index() to find the position

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