Standard Library

Standard Library Quiz

Quiz

Question 1 of 56 (0 answered)

Question 1

What is the correct way to iterate over lines in a file?

for line in f.read(): for line in f.readline(): for line in f: for line in f.readall():

✓

Correct!

Iterating directly over the file object f yields lines efficiently. Using f.read() or f.readline() would iterate over characters, not lines.

✗

Incorrect

Iterating directly over the file object f yields lines efficiently. Using f.read() or f.readline() would iterate over characters, not lines.

The file object itself is iterable and yields lines.

Question 2

When using with open(), the file is automatically closed even if an exception occurs.

True False

✓

Correct!

The with statement implements context management, ensuring the file is properly closed regardless of whether the code block exits normally or via an exception.

✗

Incorrect

The with statement implements context management, ensuring the file is properly closed regardless of whether the code block exits normally or via an exception.

Think about what context managers guarantee.

Question 3

What happens when you run this code?

with open("test.txt", "w") as f:
    f.write("Hello\n")
with open("test.txt", "a") as f:
    f.write("World\n")
# File contains:

What will this code output?

Only "World\n" "Hello\nWorld\n" Error: file is locked "WorldHello\n"

✓

Correct!

Mode w writes “Hello” (truncating any existing content), then mode a appends “World” without truncating, resulting in both lines.

✗

Incorrect

Mode w writes “Hello” (truncating any existing content), then mode a appends “World” without truncating, resulting in both lines.

Remember: ‘w’ truncates, ‘a’ appends.

Question 4

Which file modes will create a file if it doesn’t exist?

r (read) w (write) a (append) r+ (read and write) w+ (read and write)

✓

Correct!

Modes w, a, and w+ will create the file if it doesn’t exist. Mode r and r+ require the file to exist.

✗

Incorrect

Modes w, a, and w+ will create the file if it doesn’t exist. Mode r and r+ require the file to exist.

Write and append modes are more forgiving about missing files.

Question 5

What method converts a JSON file to a Python dictionary?

✓

Correct!

The json.load() method reads from a file object and converts JSON to a Python dict. Note: json.loads() works with strings.

✗

Incorrect

The json.load() method reads from a file object and converts JSON to a Python dict. Note: json.loads() works with strings.

It’s a method from the json module that works with file objects.

Question 6

What is the key difference between json.load() and json.loads()?

json.load() - Reads from a file object

json.loads() - Reads from a string

Remember: the ’s’ in loads() stands for ‘string’!

Note: Both functions convert JSON into Python objects (not just dicts) — JSON objects→dict, arrays→list, strings→str, numbers→int/float, true/false→True/False, null→None

Did you get it right?

✓

Correct!

✗

Incorrect

Question 7

Complete the code to safely modify a config file atomically:

Fill in the missing module name

import _____ 
import os

with _____.NamedTemporaryFile('w', delete=False) as tf:
    tf.write(modified_content)
    temp_name = tf.name

os.replace(temp_name, 'config.yaml')

Your answer:

✓

Correct!

The tempfile module provides NamedTemporaryFile for safe atomic file modifications.

✗

Incorrect

The tempfile module provides NamedTemporaryFile for safe atomic file modifications.

Question 8

What does os.path.join('folder', 'subfolder', 'file.txt') ensure?

The path exists on the filesystem The path uses OS-appropriate separators (/ or \) The file is created if it doesn’t exist The path is converted to absolute form

✓

Correct!

os.path.join() combines path components using the correct separator for the current OS (e.g., / on Linux/Mac, \ on Windows). It doesn’t check existence or create files.

✗

Incorrect

os.path.join() combines path components using the correct separator for the current OS (e.g., / on Linux/Mac, \ on Windows). It doesn’t check existence or create files.

Think about cross-platform compatibility.

Question 9

Which of the following are valid ways to run external commands using subprocess?

subprocess.run(['ls', '-l']) subprocess.run('ls -l') subprocess.run('ls -l', shell=True) subprocess.run(['ls -l'])

✓

Correct!

Commands should be lists of arguments ['ls', '-l'] for safety, or strings with shell=True for shell features. ['ls -l'] treats the entire string as one command name.

✗

Incorrect

Commands should be lists of arguments ['ls', '-l'] for safety, or strings with shell=True for shell features. ['ls -l'] treats the entire string as one command name.

Think about argument parsing and shell safety.

Question 10

Using shell=True in subprocess is generally safer than passing a list of arguments.

True False

✓

Correct!

Using shell=True is generally LESS safe because it can be vulnerable to shell injection attacks. Passing a list like ['ls', '-l'] is the recommended, safer approach.

✗

Incorrect

Using shell=True is generally LESS safe because it can be vulnerable to shell injection attacks. Passing a list like ['ls', '-l'] is the recommended, safer approach.

Consider security implications of shell execution.

Question 11

What will be the output?

from collections import Counter
counts = Counter(['a', 'b', 'a', 'c', 'b', 'a'])
print(counts['a'], counts['missing'])

What will this code output?

3 KeyError 3 0 3 None Error: must initialize 'missing' first

✓

Correct!

Counter is a dict subclass that returns 0 for missing keys instead of raising KeyError. Since ‘a’ appears 3 times and ‘missing’ isn’t in the counter, it prints 3 0.

✗

Incorrect

Counter is a dict subclass that returns 0 for missing keys instead of raising KeyError. Since ‘a’ appears 3 times and ‘missing’ isn’t in the counter, it prints 3 0.

Counter has special behavior for missing keys.

Question 12

What is the main advantage of defaultdict(list) over a regular dict?

It’s faster for lookups It automatically creates an empty list for new keys It maintains insertion order It uses less memory

✓

Correct!

The key benefit of defaultdict(list) is automatic initialization - accessing a new key creates an empty list, avoiding KeyError and eliminating manual initialization.

✗

Incorrect

The key benefit of defaultdict(list) is automatic initialization - accessing a new key creates an empty list, avoiding KeyError and eliminating manual initialization.

Think about what happens when you access a key that doesn’t exist.

Question 13

What factory function would you pass to defaultdict to auto-initialize counters to 0?

✓

Correct!

Using defaultdict(int) initializes missing keys to 0, since int() returns 0. This is perfect for counting operations.

✗

Incorrect

Using defaultdict(int) initializes missing keys to 0, since int() returns 0. This is perfect for counting operations.

What built-in type returns 0 when called with no arguments?

Question 14

Why use namedtuple instead of a regular tuple?

Readability and Self-Documentation

user[0] vs user.name - the second is much clearer!

namedtuple provides:

Named field access (p.name instead of p[0])
Still works like a tuple (indexing, unpacking)
Immutable like tuples
More memory-efficient than classes or dicts

Did you get it right?

✓

Correct!

✗

Incorrect

Question 15

Predict the output:

from collections import namedtuple
Person = namedtuple('Person', ['name', 'age'])
p = Person('Alice', 30)
print(p[0], p.name)

What will this code output?

Alice Alice 0 Alice Error: can't use both indexing and attribute access ('Alice', 30) Alice

✓

Correct!

namedtuple supports both tuple-style indexing (p[0]) and attribute access (p.name). Both refer to the same field, so both print ‘Alice’.

✗

Incorrect

namedtuple supports both tuple-style indexing (p[0]) and attribute access (p.name). Both refer to the same field, so both print ‘Alice’.

namedtuple combines features of both tuples and objects.

Question 16

Which collections type is best for implementing a circular buffer with fixed size?

list Counter deque with maxlen defaultdict

✓

Correct!

deque(maxlen=n) automatically removes the oldest item when the buffer is full and a new item is added, making it perfect for fixed-size circular buffers.

✗

Incorrect

deque(maxlen=n) automatically removes the oldest item when the buffer is full and a new item is added, making it perfect for fixed-size circular buffers.

Look for automatic removal of old items.

Question 17

Arrange these log levels from LEAST to MOST severe:

Drag to arrange in order of increasing severity

⋮⋮ DEBUG

⋮⋮ INFO

⋮⋮ WARNING

⋮⋮ ERROR

⋮⋮ CRITICAL

✓

Correct!

The correct severity order is: DEBUG < INFO < WARNING < ERROR < CRITICAL. DEBUG is for detailed diagnostics, while CRITICAL indicates system-level failures.

✗

Incorrect

The correct severity order is: DEBUG < INFO < WARNING < ERROR < CRITICAL. DEBUG is for detailed diagnostics, while CRITICAL indicates system-level failures.

Question 18

When should you use logging.exception() instead of logging.error()?

Inside an except block When you want to capture the full stack trace For all error messages Only for critical errors When handling exceptions

✓

Correct!

logging.exception() should be used inside except blocks when you want to automatically capture and log the full stack trace. It’s equivalent to logging.error() but includes traceback.

✗

Incorrect

logging.exception() should be used inside except blocks when you want to automatically capture and log the full stack trace. It’s equivalent to logging.error() but includes traceback.

Think about when traceback information is available and useful.

Question 19

In a multi-file Python application, you should call logging.basicConfig() in every module that uses logging.

True False

✓

Correct!

You should call basicConfig() ONLY ONCE in your main entry point. In libraries and modules, use logger = logging.getLogger(__name__) instead. basicConfig() only works the first time it’s called.

✗

Incorrect

Think about configuration centralization.

Question 20

Complete the logging configuration to write to both file and console:

Fill in the missing handler type

import logging

logging.basicConfig(
    level=logging.INFO,
    handlers=[
        logging.FileHandler('app.log'),
        logging._____()
    ]
)

Your answer:

✓

Correct!

StreamHandler() writes logs to console (stderr by default). Combined with FileHandler, this sends logs to both file and console.

✗

Incorrect

StreamHandler() writes logs to console (stderr by default). Combined with FileHandler, this sends logs to both file and console.

Question 21

What is the difference between datetime.now() and datetime.now(timezone.utc)?

No difference, they return the same value The first returns local time, the second returns UTC with timezone info The first is faster The second includes milliseconds

✓

Correct!

datetime.now() returns the current local time (naive datetime), while datetime.now(timezone.utc) returns UTC time with timezone information (aware datetime).

✗

Incorrect

datetime.now() returns the current local time (naive datetime), while datetime.now(timezone.utc) returns UTC time with timezone information (aware datetime).

Think about timezone awareness.

Question 22

What will this print?

from datetime import datetime, timedelta
dt = datetime(2025, 1, 1)
future = dt + timedelta(days=7)
print((future - dt).days)

What will this code output?

7 604800 timedelta(days=7) Error: can't subtract datetimes

✓

Correct!

Subtracting two datetime objects returns a timedelta. The .days attribute gives the number of days, which is 7.

✗

Incorrect

Subtracting two datetime objects returns a timedelta. The .days attribute gives the number of days, which is 7.

What type is returned when you subtract datetimes?

Question 23

When should you use the time module vs the datetime module?

time module: Low-level time operations

Performance measurement (time.perf_counter())
Delays and waiting (time.sleep())
Unix timestamps (seconds since epoch)
System clock access

datetime module: High-level date/time handling

Business logic
User-facing timestamps
Calendar operations
Date/time arithmetic (timedelta)
Parsing and formatting dates

Rule of thumb: Use datetime for most application code; use time for performance measurement and delays.

Did you get it right?

✓

Correct!

✗

Incorrect

Question 24

What does re.search() return if no match is found?

An empty string None An empty Match object Raises ValueError

✓

Correct!

re.search() returns None if no match is found. This is why you should always check if match: before calling match.group().

✗

Incorrect

re.search() returns None if no match is found. This is why you should always check if match: before calling match.group().

This is why you need to check before accessing groups.

Question 25

What will this match?

import re
text = 'Error on line 42: failed after 3 attempts'
match = re.search(r'\d+', text)
if match:
    print(match.group())

What will this code output?

42 3 423 ['42', '3']

✓

Correct!

re.search() finds the FIRST match anywhere in the string. The first number encountered is 42, so that’s what match.group() returns.

✗

Incorrect

re.search() finds the FIRST match anywhere in the string. The first number encountered is 42, so that’s what match.group() returns.

search() finds the first match, not all matches.

Question 26

Which of the following correctly use raw strings for regex patterns?

r'\d+' '\\d+' r'\w+@\w+\.com' '\d+'

✓

Correct!

Raw strings r'...' are recommended for regex to avoid backslash escaping issues. r'\d+' and r'\w+@\w+\.com' correctly use raw strings. '\\d+' works but requires double backslashes.

✗

Incorrect

Raw strings r'...' are recommended for regex to avoid backslash escaping issues. r'\d+' and r'\w+@\w+\.com' correctly use raw strings. '\\d+' works but requires double backslashes.

Look for the ‘r’ prefix before the string.

Question 27

What method finds ALL matches of a pattern in a string and returns them as a list?

✓

Correct!

re.findall() returns a list of all matches. For example, re.findall(r'\d+', 'a1b2c3') returns ['1', '2', '3'].

✗

Incorrect

re.findall() returns a list of all matches. For example, re.findall(r'\d+', 'a1b2c3') returns ['1', '2', '3'].

Think about the method name that suggests ‘all’ matches.

Question 28

Complete the code to extract year, month, and day using named groups:

Fill in the pattern using named group syntax

import re
pattern = ___
match = re.search(pattern, '2025-01-26')
print(match.group('year'), match.group('month'), match.group('day'))

Your answer:

✓

Correct!

Named groups use the syntax (?P<name>...) where name is the identifier you’ll use with match.group('name') or match.groupdict(). Answer: r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})'

✗

Incorrect

Question 29

The regex pattern r'^\d+$' will match ‘123abc’.

True False

✓

Correct!

^ anchors to the start and $ anchors to the end, so ^\d+$ requires the ENTIRE string to be digits. ‘123abc’ has letters, so it won’t match.

✗

Incorrect

^ anchors to the start and $ anchors to the end, so ^\d+$ requires the ENTIRE string to be digits. ‘123abc’ has letters, so it won’t match.

What do the ^ and $ anchors require?

Question 30

In argparse, what does action='store_true' do?

Requires the user to provide ’true’ as a value Sets the value to True if the flag is present, False otherwise Validates that the input is the string ’true' Stores the boolean value provided by the user

✓

Correct!

action='store_true' creates a flag that doesn’t require a value. If --verbose is present, args.verbose is True; if absent, it’s False.

✗

Incorrect

action='store_true' creates a flag that doesn’t require a value. If --verbose is present, args.verbose is True; if absent, it’s False.

Think about command-line flags that don’t take arguments.

Question 31

Which argparse nargs values allow zero arguments?

nargs='+' nargs='*' nargs='?' nargs=3

✓

Correct!

nargs='*' accepts zero or more arguments, and nargs='?' accepts zero or one. nargs='+' requires at least one, and nargs=3 requires exactly 3.

✗

Incorrect

nargs='*' accepts zero or more arguments, and nargs='?' accepts zero or one. nargs='+' requires at least one, and nargs=3 requires exactly 3.

Think about which symbols traditionally mean ‘optional’ or ‘zero or more’.

Question 32

What will this Path operation return?

from pathlib import Path
p = Path('/home/user/file.txt')
print(p.stem)

What will this code output?

file.txt file /home/user/file .txt

✓

Correct!

The .stem attribute returns the filename without the extension. .name would return ‘file.txt’, .suffix would return ‘.txt’, .parent would return ‘/home/user’.

✗

Incorrect

The .stem attribute returns the filename without the extension. .name would return ‘file.txt’, .suffix would return ‘.txt’, .parent would return ‘/home/user’.

Think about the part of the filename without the extension.

Question 33

What problem does pathlib solve compared to os.path?

Readable, maintainable path operations

os.path: Verbose string manipulation (paths are strings)

os.path.join(os.path.expanduser('~'), '.config', 'myapp', 'settings.json')

pathlib: Clean, chainable, intuitive (paths are objects)

Path.home() / '.config' / 'myapp' / 'settings.json'

Paths become objects with methods, not strings with functions.

Did you get it right?

✓

Correct!

✗

Incorrect

Question 34

What’s the advantage of compiling a regex pattern with re.compile()?

It makes the regex case-insensitive It validates the pattern syntax It improves performance when reusing the pattern It enables multiline mode

✓

Correct!

Compiling a pattern with re.compile() improves performance when you use the same pattern multiple times, as the pattern is compiled once and reused.

✗

Incorrect

Compiling a pattern with re.compile() improves performance when you use the same pattern multiple times, as the pattern is compiled once and reused.

Think about efficiency when using a pattern in a loop.

Question 35

The regex pattern r'<div>.*</div>' with .* is greedy by default.

True False

✓

Correct!

By default, .* is greedy and matches as much as possible. To make it non-greedy (match as little as possible), use .*?.

✗

Incorrect

By default, .* is greedy and matches as much as possible. To make it non-greedy (match as little as possible), use .*?.

Think about what ‘greedy’ means in regex context.

Question 36

Complete the code to create a Path object for the home directory:

Fill in the missing method

from pathlib import Path
home_dir = Path._____

Your answer:

✓

Correct!

Path.home() returns a Path object representing the user’s home directory, similar to os.path.expanduser('~').

✗

Incorrect

Path.home() returns a Path object representing the user’s home directory, similar to os.path.expanduser('~').

Question 37

Which statements about Counter are true?

Counter is a subclass of dict Accessing a missing key raises KeyError Counter returns 0 for missing keys most_common(n) returns the n most frequent items Counter can only count strings

✓

Correct!

Counter is a dict subclass that returns 0 for missing keys (not KeyError), has a most_common(n) method, and can count any hashable objects.

✗

Incorrect

Counter is a dict subclass that returns 0 for missing keys (not KeyError), has a most_common(n) method, and can count any hashable objects.

Counter has special behavior for missing keys and helpful methods.

Question 38

What’s the difference between datetime.strftime() and datetime.strptime()?

No difference, they’re aliases strftime formats datetime to string, strptime parses string to datetime strftime is for files, strptime is for time zones strptime is deprecated

✓

Correct!

strftime() converts datetime → string (format time), while strptime() converts string → datetime (parse time). Remember: ‘f’ for format out, ‘p’ for parse in.

✗

Incorrect

strftime() converts datetime → string (format time), while strptime() converts string → datetime (parse time). Remember: ‘f’ for format out, ‘p’ for parse in.

Think about ‘f’ for format and ‘p’ for parse.

Question 39

What will be printed?

from collections import deque
dq = deque([1, 2, 3], maxlen=3)
dq.append(4)
dq.append(5)
print(list(dq))

What will this code output?

[1, 2, 3] [3, 4, 5] [4, 5] [1, 2, 3, 4, 5]

✓

Correct!

With maxlen=3, the deque automatically removes the oldest items when full. Adding 4 removes 1, adding 5 removes 2, leaving [3, 4, 5].

✗

Incorrect

With maxlen=3, the deque automatically removes the oldest items when full. Adding 4 removes 1, adding 5 removes 2, leaving [3, 4, 5].

The deque has a maximum length of 3.

Question 40

What subprocess parameter should you set to True to automatically raise an exception if a command fails?

✓

Correct!

Setting check=True in subprocess.run() raises CalledProcessError if the command returns a non-zero exit code.

✗

Incorrect

Setting check=True in subprocess.run() raises CalledProcessError if the command returns a non-zero exit code.

It’s a boolean parameter that validates the command succeeded.

Question 41

Using Path.mkdir(parents=True, exist_ok=True) will raise an error if the directory already exists.

True False

✓

Correct!

With exist_ok=True, no error is raised if the directory exists. parents=True creates parent directories as needed. This is a safe, idempotent operation.

✗

Incorrect

With exist_ok=True, no error is raised if the directory exists. parents=True creates parent directories as needed. This is a safe, idempotent operation.

Think about what ’exist_ok’ means.

Question 42

Arrange the high-level steps for running an external command with subprocess:

Drag to arrange in the correct order

⋮⋮ Run: subprocess.run(cmd, capture_output=True, text=True)

⋮⋮ Define command as a list: ["ls", "-l"]

⋮⋮ Import subprocess

⋮⋮ Access result.stdout, result.stderr, result.returncode

⋮⋮ Handle subprocess.CalledProcessError in a try/except

✓

Correct!

The workflow: import → define command as a list (safer than a string) → run with capture_output=True and text=True → access result attributes → handle errors. Using check=True means a non-zero returncode automatically raises CalledProcessError.

✗

Incorrect

Question 43

What does subprocess.run() return?

A string containing the command output A CompletedProcess object with returncode, stdout, and stderr An integer exit code A tuple of (stdout, stderr)

✓

Correct!

subprocess.run() returns a CompletedProcess object. You access output via result.stdout, errors via result.stderr, and the exit code via result.returncode. Output is only available if you pass capture_output=True.

✗

Incorrect

It’s an object, not a raw string or integer.

Question 44

Which two subprocess.run() parameters do you need to capture command output as Python strings (not bytes)?

capture_output=True text=True shell=True check=True

✓

Correct!

capture_output=True redirects stdout and stderr so they’re stored in the result (otherwise they go directly to the terminal). text=True decodes the captured bytes into strings. Without text=True, result.stdout would be b'hello\n' instead of 'hello\n'.

✗

Incorrect

One captures the output, the other converts bytes to strings.

Question 45

What will result.returncode print for a successful command?

import subprocess
result = subprocess.run(["echo", "hello"], capture_output=True, text=True)
print(result.returncode)

What will this code output?

0 1 None True

✓

Correct!

A return code of 0 means success in Unix convention. Non-zero values indicate failure — this is the convention that check=True relies on to decide whether to raise CalledProcessError.

✗

Incorrect

A return code of 0 means success in Unix convention. Non-zero values indicate failure — this is the convention that check=True relies on to decide whether to raise CalledProcessError.

Unix convention: 0 = success, non-zero = failure.

Question 46

Complete the robust subprocess pattern with proper error handling:

Fill in the missing exception type

import subprocess
try:
    result = subprocess.run(
        ["ls", "/fake/path"],
        capture_output=True,
        text=True,
        check=True
    )
    print(result.stdout)
except subprocess._____:
    print("Command failed!")

Your answer:

✓

Correct!

subprocess.CalledProcessError is raised when check=True and the command returns a non-zero exit code. The exception object has .returncode, .cmd, .stdout, and .stderr attributes for debugging.

✗

Incorrect

Question 47

Arrange the high-level steps for building a CLI tool with argparse:

Drag to arrange in the correct order

⋮⋮ Create parser: ArgumentParser(description='...')

⋮⋮ Use the values: args.filename, args.verbose

⋮⋮ Import argparse

⋮⋮ Add arguments: positional ('filename') and optional ('--verbose')

⋮⋮ Parse: args = parser.parse_args()

✓

Correct!

The workflow: import → create parser → add arguments (positional args have no ‘–’ prefix, optional args use ‘–’) → parse_args() reads sys.argv and validates inputs → access values via args.*.

✗

Incorrect

Question 48

In argparse, what distinguishes a positional argument from an optional argument?

Positional arguments use a single dash (-), optional use double dash (--) Positional arguments have no -- prefix and are required by default; optional arguments use -- and are optional by default Positional arguments are defined first; optional arguments are defined last There is no difference — only required=True matters

✓

Correct!

Positional arguments (parser.add_argument('filename')) are matched by position and required by default. Optional arguments (parser.add_argument('--output')) use the -- prefix and are optional by default. This naming convention is the core design of argparse.

✗

Incorrect

Look at whether the argument name starts with --.

Question 49

Complete the final step to make parsed arguments available:

Fill in the missing method call

import argparse

parser = argparse.ArgumentParser(description='Process files')
parser.add_argument('filename', help='Input file')
parser.add_argument('--verbose', action='store_true')

args = parser._____
print(args.filename)

Your answer:

✓

Correct!

parser.parse_args() reads sys.argv, validates inputs against defined arguments, and returns a Namespace object. Accessing args.filename and args.verbose is only possible after this call.

✗

Incorrect

parser.parse_args() reads sys.argv, validates inputs against defined arguments, and returns a Namespace object. Accessing args.filename and args.verbose is only possible after this call.

Question 50

In a multi-file application, why should library modules use logger = logging.getLogger(__name__) instead of calling logging.info() directly?

It creates a separate log file per module It’s faster than using the root logger It identifies which module a log came from and doesn’t interfere with the app’s centralized configuration It allows each module to override the global log level

✓

Correct!

logging.getLogger(__name__) creates a logger named after the module (e.g., myapp.database), which identifies the source in log output. Crucially, modules should never call basicConfig() — only the entry point does. Module loggers inherit configuration from the root logger set up by basicConfig().

✗

Incorrect

Think about where configuration should live and how you’d trace a log back to its source.

Question 51

Which exception should you specifically catch when a file you’re trying to open may not exist?

IOError FileNotFoundError OSError ValueError

✓

Correct!

FileNotFoundError is the specific exception raised when a file doesn’t exist. While OSError (and its alias IOError) would also catch it as a parent class, catching FileNotFoundError specifically makes your intent clear and avoids masking unrelated OS errors.

✗

Incorrect

Python 3 has specific exception types for common file errors — prefer the most specific one.

Question 52

Arrange the high-level steps for working with files in Python:

Drag to arrange in the correct order

⋮⋮ Choose file mode (r, w, a, r+)

⋮⋮ Handle errors (FileNotFoundError, PermissionError)

⋮⋮ Open file: with open(filename, mode) as f

⋮⋮ Import required modules (json, tempfile, etc.)

⋮⋮ Perform read/write operations on the file object

✓

Correct!

The workflow: import modules → open with with open() (ensures cleanup) → pick mode appropriate for your operation → read/write → wrap in try/except for error handling. The with statement guarantees the file is closed even if an exception occurs.

✗

Incorrect

Question 53

Arrange the high-level steps for setting up logging in a Python application:

Drag to arrange in the correct order

⋮⋮ Call logging.basicConfig() once at the entry point (set level, format, handlers)

⋮⋮ In library modules, get a module logger: logger = logging.getLogger(__name__)

⋮⋮ Import logging

⋮⋮ Log messages using the appropriate level (debug, info, warning, error, critical)

⋮⋮ Use logging.exception() inside except blocks to capture stack traces

✓

Correct!

The workflow: import → configure once in main (not in modules) → modules get their own named logger → log at the right level for each message → use exception() (not error()) inside except blocks to automatically include the traceback.

✗

Incorrect

Question 54

Arrange the high-level steps for working with the os module:

Drag to arrange in the correct order

⋮⋮ Inspect contents and check existence (os.listdir, os.path.exists, os.path.isfile)

⋮⋮ Check environment variables (os.getenv, os.environ)

⋮⋮ Import os

⋮⋮ Build paths safely across platforms (os.path.join)

⋮⋮ Find or change current location (os.getcwd, os.chdir)

⋮⋮ Create, rename, or remove files and directories (mkdir, remove, replace)

✓

Correct!

The workflow: import → check environment (API keys, config) → locate yourself (cwd) → inspect the filesystem → build paths with os.path.join (cross-platform safe) → modify the filesystem. For path operations, prefer pathlib.Path which is more readable and object-oriented.

✗

Incorrect

Question 55

Arrange the high-level steps for working with regex in Python:

Drag to arrange in the correct order

⋮⋮ Check if match: before calling .group() to avoid AttributeError

⋮⋮ Import re

⋮⋮ Choose the right function: search(), match(), findall(), or sub()

⋮⋮ Write pattern using raw strings r'...' to avoid backslash issues

⋮⋮ Compile with re.compile() when reusing the pattern multiple times

✓

Correct!

The workflow: import → write pattern as raw string (r’…’ prevents Python from interpreting backslashes) → choose the right function for your goal → always check if match exists before accessing groups → compile for performance when reusing in loops.

✗

Incorrect

Question 56

Arrange the high-level steps for working with dates and times using datetime:

Drag to arrange in the correct order

⋮⋮ Perform arithmetic using timedelta (add or subtract durations)

⋮⋮ Import datetime, timedelta, and timezone as needed

⋮⋮ Format for display with strftime() or parse a string with strptime()

⋮⋮ Obtain or create a datetime object (datetime.now(), fromisoformat(), strptime())

⋮⋮ Use timezone.utc when timezone-awareness is required

✓

Correct!

The workflow: import → get/create a datetime object → apply timedelta arithmetic → add timezone info if needed → format for output or storage. Remember: strftime = format datetime TO string, strptime = PARSE string to datetime.

✗

Incorrect

Quiz Results

Score

0/0

Accuracy

Right

Wrong

Skipped

Last updated on March 20, 2026

OOP Fundamentals Advanced Functions