Python Basics

Prerequisites: No programming experience is required. You need a text editor and a local or preconfigured terminal that can expose a CPython 3.12 runtime, saved source, working directory, and process evidence. No IDE, package manager, Git, or administrator access is assumed.

Unit outcomes

• Distinguish saved source, editor state, shell command, interpreter, process, working directory, stdout, stderr, exit status, and traceback.
• Identify the exact CPython 3.12 runtime and source-directory relationship while producing privacy-safe shareable evidence.
• Create and execute one exact UTF-8 source artifact from a known clean directory against a predeclared process contract.
• Trace straight-line statements, simple expressions, name bindings, and ordered output without confusing assignment, equality, or persistence.
• Capture ordinary output, diagnostics, and completion status independently for accepted and controlled-refusal fixtures.
• Classify command, source-path, parse-time syntax, and runtime name failures and repair one evidence-backed cause at a time.
• Make a controlled source change with frozen differences and invariants, preserving useful comments and immutable attempt chronology.
• Build and defend the Pocket Library welcome-command evidence bundle without exposing sensitive data or claiming untested behavior.

Guided practice

1. Label the saved-source, interpreter, process, stream, status, and expectation boundaries in a supplied run transcript.
2. Generate a privacy-safe runtime record and compare source-parent and working-directory relationships in two synthetic directories.
3. Create an exact three-line source artifact after declaring stdout, stderr, and status, then reject an added blank line.
4. Trace Pocket Library names and integer addition statement by statement, including a failed right-side name resolution.
5. Capture accepted and controlled-refusal process results and reject severe stdout wording that still returns zero.
6. Repair an unterminated string and a use-before-binding error while preserving separate failing and passing attempts.
7. Promote one synthetic label with a frozen one-line difference and reject an unpredicted collateral change.
8. Complete and defend the seven-artifact Pocket Library studio under reproducibility, evidence-integrity, privacy, and scope gates.

Lesson sequence

1. A Python Run Is an Evidence Chain · Free preview
2. Identify Your Interpreter and Working Directory
3. Create and Run an Exact Source File
4. Trace Statements, Expressions, and Names
5. Separate Output, Errors, and Exit Status
6. Read and Repair Syntax and Name Errors
7. Make Verifiable Changes and Use Comments Well
8. Module Studio: Pocket Library Welcome Command

12 checkpoint questions

Prerequisites: Complete Getting Started with Python or be able to create and run a UTF-8 file with CPython 3.12, predict straight-line execution, distinguish stdout, stderr, and status, and preserve failure evidence. No algebra beyond ordinary arithmetic, Boolean-logic vocabulary, or Unicode expertise is assumed.

Unit outcomes

• Distinguish source literals, runtime values, name bindings, types, expression results, and formatted text.
• Predict assignment and reassignment with complete state evidence, including failed right-side evaluation and unchanged prior bindings.
• Choose among str, int, float, bool, and None from fact meaning and permitted operations rather than visual appearance.
• Inspect current values with type() while explaining why observation does not permanently declare a name's type.
• Evaluate numeric expressions with explicit precedence, true division, floor division, remainder, exponentiation, and zero-boundary evidence.
• Create deliberate Unicode text with correct quoting, escapes, concatenation, length, case, and non-mutating transformation evidence.
• Evaluate comparisons into Boolean facts while preserving the distinction among False, empty text, zero, and None.
• Demonstrate binary floating-point representation limits and apply only the supplied measurement tolerance policy.
• Convert trusted representations under explicit policy and format display text without overwriting typed source values.
• Build and defend a deterministic Pocket Library scalar record and exact seven-line book-summary card.

Guided practice

1. Review a synthetic field schema and reject executable representations that lose identifier, count, Boolean, or absence meaning.
2. Trace successful and failed reassignments, recording right-side results, retained bindings, types, stdout, stderr, and status.
3. Predict arithmetic values and result types, then distinguish complete groups, remainders, and groups required at boundaries.
4. Compare direct float equality, representation evidence, tolerance-based measurement claims, and display rounding without conflating them.
5. Inspect Unicode, quote, escape, whitespace, and case transformations while preserving the authoritative text binding.
6. Build named Boolean propositions and classify known false, zero, empty, and absent facts under an explicit schema.
7. Convert trusted numeric text and render exact f-string output while proving source values and types remain unchanged.
8. Complete and defend the eight-artifact Pocket Library book-summary studio against normal, failure, and clean-but-wrong cases.

Lesson sequence

1. Choose Values Before You Name Them
2. Trace Assignment and Reassignment as State
3. Compute with Integers and Floating-Point Values
4. Treat Floating-Point Results as Measurements
5. Represent Text Deliberately
6. Make Facts Explicit with Comparisons and Booleans
7. Represent Absence with None
8. Convert by Policy; Format for People
9. Module Studio: Pocket Library Book Summary

12 checkpoint questions

Prerequisites: Complete Variables and Basic Data Types or be able to preserve scalar meaning, trace assignment, use strings, numeric types, comparisons, booleans, None, explicit conversion, and f-string formatting on CPython 3.12. General loops, functions, collections, exception architecture, locale parsing, files, and regular expressions are not assumed.

Unit outcomes

• Predict and prove that input() returns str, including for numeric-looking, whitespace-only, and empty responses.
• Write concise terminal prompts that identify the requested field, expected form, and useful constraint.
• Preserve raw responses separately from normalized candidates and converted values.
• Apply field-specific whitespace and case normalization without corrupting meaningful text.
• Distinguish presence, lexical, conversion, and domain validation and apply them in dependency order.
• Convert approved integer and decimal candidates through a narrow ValueError boundary.
• Produce neutral rejection messages that identify the condition, expectation, and next action.
• Trace a supplied three-attempt retry pattern and prove success, exhaustion, and response-consumption bounds.
• Prevent rejected or partially accepted fields from becoming a published record.
• Submit reproducible interaction evidence covering accepted, recovery, cancellation, hostile, and exact-output paths.

Guided practice

1. Capture numeric-looking, whitespace-padded, and empty responses and prove their exact representation and type.
2. Review ambiguous, inaccurate, blame-oriented, and default-implying prompts against a declared field contract.
3. Build normalization decision tables that preserve raw text, Unicode spelling, identifiers, and internal whitespace.
4. Classify empty, malformed, convertible, out-of-range, and accepted candidates by their first failing stage.
5. Execute int and float success and ValueError fixtures while leaving unrelated programming defects visible.
6. Map every field failure to one neutral condition, expectation, and next-action message.
7. Prove success on attempts one through three and exhaustion that leaves a valid fourth response unread.
8. Complete and defend the nine-artifact Pocket Library add-book studio against partial publication and hostile defects.

Lesson sequence

1. Treat the Terminal as a Text Boundary
2. Write Prompts as Interface Contracts
3. Preserve Raw Evidence; Normalize by Policy
4. Order Validation Before Trust
5. Convert Numeric Text at a Narrow Failure Boundary
6. Validate Meaning and Offer a Next Action
7. Bound Retry and Prove Termination
8. Protect the Record Across a Multi-Field Dialogue
9. Module Studio: Pocket Library Add-Book Dialogue

12 checkpoint questions

Prerequisites: Complete User Input and Data Conversion or be able to preserve raw evidence, normalize and validate by policy, convert values explicitly, distinguish strings from booleans and numbers, and execute top-level CPython 3.12 scripts. Functions, loops, collections beyond a supplied tuple, pattern matching, files, and exception architecture are not assumed.

Unit outcomes

• Trace a condition, its controlled suite, skipped work, and shared continuation on CPython 3.12.
• Translate strict, inclusive, equality, and inequality policy language into tested comparisons.
• Name Boolean propositions, prove their truth tables, and identify stale derived state.
• Compose conditions with and, or, and not while proving left-to-right short-circuit evaluation.
• Build exhaustive two-way decisions without overclaiming the false-path domain.
• Order exclusive rules so the first matching branch owns deliberate overlaps.
• Choose independent statements for multiple effects and exclusive chains for one classification.
• Validate complete format codes with tuple membership and reject truthy-operand and substring defects.
• Flatten nested policy without changing refusal, equality, overlap, or remainder behavior.
• Submit a reproducible nine-artifact Pocket Library decision defense covering every rule owner.

Guided practice

1. Trace true and false suites, indentation-only defects, and parse failures without inventing condition results.
2. Build below, at, and above matrices for page, capacity, and threshold rules.
3. Derive named propositions, complete truth tables, and stale-versus-fresh comparison evidence.
4. Compare safe and reversed short-circuit order with a zero-total failure fixture.
5. Repair overlapping status and shipping rules using explicit first-match precedence.
6. Separate accumulating advisories from one owned status and repair membership defects.
7. Prove nested and flat policy equivalence across every branch owner and refusal path.
8. Complete and defend the nine-artifact Pocket Library reading-status studio against hostile defects.

Lesson sequence

1. Trace a Condition and Its Suite
2. Translate Boundary Language into Comparisons
3. Name Boolean Decisions and Build Truth Tables
4. Make an Exhaustive Two-Way Decision
5. Order Exclusive Rules with elif
6. Compose Conditions and Prove Short-Circuiting
7. Separate Independent Rules from Exclusive Classification
8. Flatten Policy and Prove Branch Coverage
9. Module Studio: Pocket Library Reading-Status Policy

12 checkpoint questions

Prerequisites: Complete Conditional Logic or be able to preserve typed state, evaluate ordered if/elif/else decisions, use comparisons and equality membership, validate before mutation, and record exact CPython 3.12 stdout, stderr, status, and source identity. Learner-authored loops, comprehensions, functions, imports, exception handlers, dictionaries, sets, classes, files, generators, and custom sort keys are not assumed.

Unit outcomes

• Justify a list when order, positional access, mutability, and duplicate retention match the domain contract.
• Trace list objects, names, positions, values, aliases, and independently created equal states.
• Translate positive and negative indices into owned positions and refuse out-of-range access before mutation.
• Predict slice membership, clipped boundaries, positive steps, and fresh outer-list identity.
• Distinguish replacement, append, insertion, extension, and concatenation by exact state delta and ownership.
• Choose removal by equal value or owned position while preserving first-match, receipt, missing, and empty-state evidence.
• Enforce an at-most-one active identifier policy with equality membership, count evidence, and precondition-first refusal.
• Separate assignment aliases from shallow copies and state the shared nested-child limitation precisely.
• Distinguish in-place sorting, fresh sorted views, descending order, and structural reversal without losing priority.
• Derive cardinality, numeric totals, and extrema only when element types, units, and empty-state policy permit them.
• Apply an operation ledger so every accepted mutation and rejected request has reproducible preconditions and postconditions.
• Submit and defend a nine-artifact Pocket Library reading queue against hostile and unseen synthetic packets.

Guided practice

1. Draw object-position-value maps for aliases, equal independent lists, slices, and shallow copies before predicting mutations.
2. Build positive, negative, empty, and out-of-range index matrices with exact accepted or refused state evidence.
3. Derive slice index sets and distinguish clipped up-to requests from exact-width postconditions.
4. Compare replacement, append, insert, extend, concatenation, remove, pop, and del through frozen state-delta ledgers.
5. Enforce absent, uniquely active, and breached duplicate states without mutation after refusal.
6. Produce preview and report views that prove fresh outer identity and exact live-priority preservation.
7. Defend valid, empty, heterogeneous, and nested summary packets with explicit units and unavailable dispositions.
8. Complete the nine-artifact reading-queue studio and disposition every hostile defect and unseen transfer.

Lesson sequence

1. Model an Ordered Mutable Collection
2. Create Exact List State and Trace References
3. Translate and Validate List Indices
4. Select Fresh Views with Slices
5. Choose a List Growth or Replacement Operation
6. Remove by Value or by Position
7. Enforce Membership and Duplicate Policy
8. Separate Aliases from Shallow Copies
9. Sort Without Losing Priority Order
10. Derive Safe Collection Summaries
11. Module Studio: Pocket Library Reading Queue

12 checkpoint questions

Prerequisites: Complete Working with Lists or be able to preserve ordered mutable state, validate conditions before mutation, use equality membership and numeric operators, and record exact CPython 3.12 stdout, stderr, and status. Learner-authored functions, comprehensions, dictionaries, sets, imports, exceptions, files, classes, recursion, async iteration, and unbounded random interaction are not assumed.

Unit outcomes

• Classify repetition as value-driven, count-driven, or condition-driven and justify the selected loop form.
• Trace a for loop as successive target binding and suite execution across zero, one, and several iterations.
• Derive exact integer sequences from range(start, stop, step), including empty and descending cases.
• Pair positions and values with enumerate without maintaining redundant index state.
• Design counters, totals, flags, and selected-result accumulators from explicit invariants and postconditions.
• Select and classify values while preserving input order and rejection evidence.
• Trace nested loops, identify the loop affected by control transfer, and calculate bounded work growth.
• Maintain a while-loop progress invariant and defend its finite termination argument.
• Use break, continue, and loop else only when their exact control-flow meaning is testable.
• Avoid unsafe mutation during traversal through a stable view or a separate result.
• Freeze terminal interaction with a finite transcript, exact output contract, and explicit exhaustion behavior.
• Build and defend a bounded Pocket Library menu against normal, boundary, hostile, and unseen transcripts.

Guided practice

1. Trace zero, one, and many target bindings and reconcile each with exact suite execution.
2. Derive ascending, stepped, descending, and empty ranges before running them.
3. Compare enumerate with a manually maintained display counter under the same output contract.
4. Design accumulator ledgers whose initialization, update rule, and postcondition survive empty input.
5. Reconcile nested-loop traces with exact body counts and nearest-loop control effects.
6. Repair non-terminating while loops by stating and restoring the missing progress measure.
7. Reproduce mutation-during-traversal loss, then repair it with stable-source and result-building patterns.
8. Complete and defend the nine-artifact bounded-menu studio against unseen deterministic transcripts.

Lesson sequence

1. Choose and Trace Repetition over Values
2. Read Loop Suites and Binding State
3. Generate Exact Bounded Sequences with range
4. Pair Positions and Values with enumerate
5. Design Accumulators from Postconditions
6. Select and Classify without Losing Order
7. Trace Nested Loops and Work Growth
8. Prove while-Loop Progress and Termination
9. Control an Iteration Deliberately
10. Keep Traversal Stable while State Changes
11. Choose a Loop and Freeze Interaction Evidence
12. Module Studio: Bounded Pocket Library Menu

12 checkpoint questions

Prerequisites: Run CPython 3.12 scripts; use scalar values, lists, conditions, and bounded loops; validate before mutation; preserve ordering and duplicate policies; distinguish aliases from shallow outer copies; and capture exact process evidence. Learner-authored functions, comprehensions, sets, imports, exceptions, files, JSON parsing, classes, databases, recursion, and concurrency are not required.

Unit outcomes

• Choose a dictionary when stable key-to-value association, rather than numeric position, is the required access contract.
• Construct exact dictionary state with valid hashable keys and explain equality, insertion order, and key uniqueness at the taught boundary.
• Distinguish key membership from value search and absence from present None, False, zero, or empty text.
• Choose direct subscription, get, or an explicit sentinel from required-field and optional-field policy.
• Apply insertion, replacement, and multi-key update only after classifying the intended state transition.
• Remove entries with an explicit missing-key and receipt policy while preserving no-change refusal evidence.
• Traverse keys, values, and items deliberately without treating insertion order as record identity or mutating size during traversal.
• Validate a dictionary record's required fields, optional fields, value meanings, and extra-field policy without confusing shape with truth.
• Build a dictionary index from ordered records while detecting duplicate stable IDs before publication.
• Navigate nested structures and state precisely which nested objects remain shared after a shallow copy.
• Choose among list, dictionary, and tuple from mutability, order, identity, lookup, and duplicate requirements.
• Integrate these decisions into a finite Pocket Library catalog and defend it against unseen synthetic operation packets.

Guided practice

1. Compare an ordered queue, one named record, and a stable-ID index under reordered display output.
2. Classify absent, None, False, zero, empty-text, and nonempty optional-field states using membership and exact values.
3. Select subscription, an authorized default, or a unique sentinel for required and optional retrieval cases.
4. Trace insert, replacement, whole-patch refusal, removal receipt, and deterministic traversal with exact before/after evidence.
5. Validate required, optional, unknown, and cross-field record rules without mutating the candidate.
6. Build a candidate index that preserves first records and every duplicate occurrence before publication.
7. Draw a nested object graph and prove assignment, shallow outer copying, shared children, and explicit child rebuilding.
8. Replay normal and hostile catalog packets, reconcile the operation ledger, and transfer the contract to synthetic dispatch data.

Lesson sequence

1. Choose Named Association over Position
2. Construct Exact Dictionary State
3. Separate Presence from Stored Value
4. Retrieve Required and Optional Fields Deliberately
5. Classify Insert, Replace, and Update
6. Remove with a Missing and Receipt Policy
7. Traverse Keys, Values, and Items Intentionally
8. Validate a Dictionary Record Contract
9. Build an Index without Silent Overwrite
10. Navigate Nested State and Prove Copy Depth
11. Choose a Structure and Freeze Evidence
12. Module Studio: Pocket Library Catalog by Stable ID

12 checkpoint questions

Lesson sequence

1. Why Functions Are Useful
2. Defining and Calling a Function
3. Passing Function Arguments
4. Parameters and Arguments
5. Returning Values with return
6. Default Parameter Values
7. Keyword Arguments
8. Variable Scope
9. Decomposing a Problem into Functions
10. Importing Functions and Modules
11. Mini-Project: Calculation Toolkit

6 checkpoint questions

Lesson sequence

1. Introduction to Data Persistence
2. Understanding File Paths
3. Working with pathlib
4. Reading Text Files
5. Writing Text Files
6. Appending Content to a File
7. Introduction to JSON
8. Saving Structured Data
9. Loading Structured Data
10. Understanding Exceptions
11. Handling Exceptions with try and except
12. Using else and finally
13. Writing Clear Error Messages
14. Mini-Project: Persistent Score Tracker

6 checkpoint questions

Lesson sequence

1. From Data and Functions to Objects
2. Understanding Classes and Objects
3. Defining a Class
4. Initializing Objects with __init__()
5. Understanding the self Parameter
6. Defining Instance Attributes
7. Defining Instance Methods
8. Creating and Using Multiple Objects
9. Updating Object State
10. Introduction to Composition
11. Mini-Project: Library Item Manager

6 checkpoint questions

Lesson sequence

1. Understanding Bugs and Failures
2. Reading Tracebacks
3. Using Print-Based Debugging
4. Formulating Debugging Hypotheses
5. Using assert for Simple Checks
6. Introduction to Automated Testing
7. Writing Tests with pytest
8. Testing Return Values
9. Testing Expected Exceptions
10. Refactoring Code Safely
11. Mini-Project: Test an Existing Application

6 checkpoint questions

Lesson sequence

1. Defining the Project Requirements
2. Identifying Inputs, Processes, and Outputs
3. Selecting Appropriate Data Structures
4. Designing the Program Flow
5. Implementing the Minimum Viable Product
6. Splitting the Program into Functions
7. Adding Data Persistence
8. Handling Invalid Input and Runtime Errors
9. Writing Automated Tests
10. Refactoring and Improving Code Quality
11. Writing User Documentation
12. Final Project Review

6 checkpoint questions