Python Programming — Level 1 | Understand, Run, Build

Explain what a simple Python program does

Read short Python code and describe inputs, operations, output and side effects before editing it.

Predict simple Python output

Trace expressions and statements to predict exact output before running the code.

Use Run as evidence, not as guessing

Compare a written prediction with actual execution and explain any mismatch.

Create and update variables intentionally

Use names to store values, reassign them and explain how program state changes.

Build expressions from values and operators

Combine literals, variables and operators into expressions with predictable results.

Trace variable state across statements

Track values line by line and identify the final state of a small program.

Write clear if / elif / else decisions

Translate requirements into mutually understandable branches with explicit conditions.

Combine comparisons with boolean logic

Use and, or and not to model multi-condition decisions correctly.

Test decision boundaries

Choose examples around thresholds and branches to verify every path behaves as intended.

Iterate over sequences with for loops

Use for loops to process each item in a collection and explain iteration state.

Use while loops with explicit stop conditions

Build while loops whose progress and termination can be reasoned about.

Choose between for and while intentionally

Select the loop form that best matches known collections versus condition-driven repetition.

Create, access and modify lists

Use indexing, append, remove and assignment while reasoning about list state.

Use tuples for fixed structured values

Recognize when immutable ordered data is a better fit than a mutable list.

Choose list versus tuple from requirements

Select collection semantics based on mutability, order and intended use.

Use dictionaries for keyed data

Create, read, update and safely query mappings using keys and get().

Use sets for uniqueness and membership

Apply set creation, membership and set operations to deduplicate and compare data.

Choose the right collection for the job

Compare list, tuple, dict and set behavior against access, order, uniqueness and mutation needs.

Define functions with clear parameters

Write functions whose parameters represent the data required to perform one focused task.

Return values instead of hiding results

Use return to expose computed results and distinguish returning from printing.

State and verify a function contract

Describe valid inputs, expected output and important side effects before implementation.

Reason about local and global scope

Predict which variables are visible or changed inside and outside a function.

Use default arguments safely

Define defaults for optional behavior while avoiding mutable-default traps.

Accept flexible arguments deliberately

Use *args and **kwargs when variability is justified and keep the function contract understandable.

Index, slice and search strings

Use string operations to locate and extract meaningful text segments.

Normalize and clean textual input

Apply strip, case normalization and replacement while preserving intended meaning.

Format readable text with f-strings

Build output that combines values, labels, precision and alignment clearly.

Open files with explicit mode and encoding

Read and write text files using appropriate mode and encoding choices.

Use context managers for file lifetime

Ensure files close correctly on success and failure using with blocks.

Reason about paths and missing files

Construct paths deliberately and recognize when file operations can fail.

Define classes with meaningful instance state

Use __init__ to establish object state needed by the model.

Create and inspect independent objects

Instantiate multiple objects and reason about how their state differs.

Choose a class only when state and behavior belong together

Distinguish simple data/functions from cases that benefit from object modeling.

Write instance methods using self correctly

Read and change instance state through methods with clear responsibilities.

Protect invariants through class behavior

Keep object state valid by controlling how important changes occur.

Differentiate class and instance attributes

Use shared class-level data only when it is truly common to all instances.

Express expected behavior with assertions

Write simple assertions that compare actual outcomes with precise expectations.

Turn examples into repeatable tests

Convert manual checks into test cases that can be rerun after changes.

Read a failing assertion for evidence

Use expected-versus-actual output to locate what behavior is wrong.

Write unit tests for focused behavior

Test one function or unit of behavior with clear setup, action and assertion.

Cover boundaries and edge cases

Include empty, minimum, maximum and unusual-but-valid inputs where relevant.

Keep tests isolated and deterministic

Avoid shared state, execution-order dependence and uncontrolled external behavior.

Identify a repetitive task worth automating

Break a manual repeated workflow into deterministic inputs, steps and outputs.

Automate file or text processing safely

Use Python to process repeated local data tasks while preserving original data when appropriate.

Report automation results clearly

Produce summaries, counts or status output that makes success and failure visible.

Read and write JSON data

Convert between Python objects and JSON while preserving expected data shape.

Call an HTTP API and inspect the response

Send a basic request, check status and extract needed response data.

Validate external API data before use

Check required fields and handle missing or unexpected response data safely.

Turn a project idea into explicit requirements

Define user goal, inputs, outputs, constraints and acceptance criteria for a small Python project.

Decompose the project into modules and tasks

Plan functions, classes, files and milestones before implementation.

Choose verification criteria before coding

Decide which examples and tests will prove the project is complete.

Implement the planned project incrementally

Build the project in small working slices and integrate features without large unverified jumps.

Run and inspect behavior during development

Use execution output and targeted examples to validate each increment.

Write tests for critical project behavior

Protect the most important requirements and edge cases with repeatable tests.