- What the Seven Domains Actually Represent
- How the 45 Questions Are Delivered
- Domain 1: Data Types and Operators
- Domain 2: Conditionals
- Domain 3: Loops
- Domain 4: Program Structure
- Domain 5: Error Handling
- Domain 6: Lists
- Domain 7: Strings
- Sequencing Your Preparation Around the Domains
- Vouchers, Proctoring, and Results
- Frequently Asked Questions
- CodeHS Python Level 1 covers exactly seven official topic groups; the overview does not publish percentage weights for them.
- The exam has 45 multiple-choice questions, a 90-minute limit, and a 60% passing score.
- Continue, one- and two-dimensional lists, list and string methods, indexing, and slicing are explicitly named in the overview.
- You get a Python examination reference sheet, but running code in another website or program is prohibited.
What the Seven Domains Actually Represent
The CodeHS Python Level 1 Certification overview lists seven top-level topic headings: Data Types and Operators, Conditionals, Loops, Program Structure, Error Handling, Lists, and Strings. These are official exam-topic groups. They are not course modules, and they are not a percentage-weighted blueprint. No published source tells you that Loops is worth a certain share of the 45 questions, so any article claiming exact domain percentages is guessing.
That matters for how you prepare. Without weights, the safe strategy is to reach competence in all seven groups rather than gambling on a favorite. Your score report, which includes topic-level performance, will show where you were strong or weak, but you only see that after the attempt. This guide walks through each domain, what it realistically demands, and how to connect the seven areas into a preparation plan.
How the 45 Questions Are Delivered
Before studying content, know the container it arrives in. The exam is online, takes place in a single sitting, and gives you 90 minutes for 45 multiple-choice questions. That works out to an average of two minutes per question, which is generous for recall items but tighter for questions that ask you to trace code by hand.
| Feature | CodeHS Python Level 1 |
|---|---|
| Question count | 45 multiple-choice questions |
| Time limit | 90 minutes, one sitting |
| Passing score | 60% |
| Question selection | Randomly selected questions |
| Allowed aids | Python examination reference sheet; paper, pencil, and calculator suggested |
| Prohibited | External websites, collaboration, sharing questions, running code elsewhere |
Because the questions are multiple choice and you cannot run code in another program, the exam rewards the ability to read Python and predict its behavior. Expect to trace loops, evaluate expressions, and decide which output a snippet produces. For the difference between the 60% threshold and a pass rate, see CHS-P1 Passing Score 2026: Exactly What You Need to Pass. No official cohort pass rate has been verified, which is covered in CHS-P1 Pass Rate 2026: What the Data Shows.
Domain 1: Data Types and Operators
Data Types and Operators
This is the foundation layer. Every other domain assumes you can look at a value and know its type and what an operator will do to it.
- Integers, floats, strings, and booleans, and how each behaves in expressions
- Arithmetic operators, including integer division, modulus, and exponentiation
- Comparison and logical operators, and operator precedence
- Type conversion with functions such as int(), float(), and str()
- Variables and assignment, including reassignment and augmented operators
The classic traps live here. Division with / always yields a float, while // floors the result. The modulus operator shows up constantly in even/odd checks and in wrapping values around a range. Mixing a string and a number with + raises a type problem, so you need to recognize when a conversion is required. A calculator can help with arithmetic, but it cannot tell you what Python will do with a mixed-type expression, so practice reading precedence rules until they are automatic.
Domain 2: Conditionals
Conditionals
Conditionals test whether you can follow branching logic precisely, usually through short code snippets with a single correct output.
- if, elif, and else chains and how Python evaluates them in order
- Boolean expressions built with and, or, and not
- Nested conditionals and the effect of indentation
- Truthiness of comparisons and the difference between = and ==
The key skill is ordering. In an if/elif chain, only the first true branch runs, so a question may hinge on whether an earlier condition swallows a later one. A separate series of independent if statements behaves differently, and exam items like to contrast the two. Practice by writing out the value of each condition line by line rather than eyeballing the answer.
Domain 3: Loops
Loops
Loops are where tracing skill pays off most, and the issuer overview explicitly includes continue.
- for loops over ranges, lists, and strings
- while loops and the conditions that end them
- range() with start, stop, and step arguments
- break and continue, and exactly where execution resumes after each
- Nested loops and accumulator patterns such as running totals and counters
Off-by-one reasoning is the recurring theme: range(5) stops at 4, and range(2, 10, 3) yields a specific, short sequence. With continue, execution skips the remainder of the current iteration and jumps to the next, so any statement after it in the loop body is bypassed for that pass. A good drill is to trace a loop on paper, recording the loop variable and any accumulator after every iteration. Nested loops multiply the work, so write the inner loop's full run for each outer value.
Domain 4: Program Structure
Program Structure
This group covers how a Python program is organized, with functions as the central concept.
- Defining and calling functions, including parameters and return values
- The difference between printing a value and returning it
- Variable scope, local versus global, and how it affects what a function can see
- Default and keyword arguments
- Reading input, producing output, and organizing code into a readable flow
The most common stumble is confusing print with return. A function that prints but returns nothing yields None when its result is assigned to a variable, and a question may build an entire snippet around that fact. Scope is the other frequent test: a variable assigned inside a function is local, so referencing it outside fails. When you review, ask of every function: what are the inputs, what is returned, and what, if anything, escapes the function's scope?
Domain 5: Error Handling
Error Handling
Error handling is often the least familiar domain for students whose coursework focused on writing working programs rather than anticipating failure.
- Recognizing common error types, such as syntax, type, name, value, index, and zero-division errors
- try and except blocks and which code runs when an error is raised
- Reading a snippet and deciding whether it will raise an error, and which kind
- Distinguishing errors that stop a program from logic mistakes that produce wrong output without crashing
Practice by taking short snippets and predicting the failure: a string added to an integer, an index past the end of a list, a name used before assignment, division by zero. For try/except, trace which lines execute before the error, which are skipped, and what the except block does. Because this domain is easy to underweight, give it deliberate attention rather than treating it as an afterthought.
Domain 6: Lists
Lists
The overview explicitly names one- and two-dimensional lists, list methods, indexing, and slicing.
- Creating lists, accessing elements by index, and negative indexing
- Slicing with start, stop, and step, and the exclusive stop value
- List methods such as append, insert, remove, pop, and sort
- Iterating through lists with for loops and with index-based ranges
- Two-dimensional lists: accessing grid[row][col] and looping with nested loops
- Mutability and how modifying a list inside a function affects the original
Two-dimensional lists reward careful reading: the first index selects the row and the second selects the element within it. Nested loops over a grid are a natural place for the loop and list domains to combine. Slicing returns a new list and never raises an index error for out-of-range bounds, a detail worth remembering because indexing a single position past the end does raise one. Methods also differ in what they return, so know which ones modify the list in place and which produce a value.
Domain 7: Strings
Strings
Strings share indexing and slicing with lists, but they are immutable and carry their own set of methods.
- Indexing and slicing strings, including negative indices
- String methods such as upper, lower, strip, replace, find, split, and join
- Concatenation, repetition, and the len() function
- Iterating through characters in a for loop
- Immutability: string methods return new strings rather than changing the original
The immutability point generates plenty of questions. Calling s.upper() without assigning the result leaves s unchanged, and a snippet may rely on exactly that. Split turns a string into a list, which links this domain back to lists, while join does the reverse. When studying, compare strings and lists side by side, since the shared indexing and slicing syntax makes it easy to forget which of the two you can modify in place.
Sequencing Your Preparation Around the Domains
The domains build on one another, so order matters more than hours. The recommended preparation course, Introduction to Python Programming, is described as recommended rather than required, and a matching Certification Practice course is listed in the CodeHS catalog. Those are preparation resources, not additional exam domains. A sensible sequence moves from foundations upward:
Foundations: Domains 1 and 2
- Drill operators, precedence, and type conversion
- Trace if/elif/else chains until output prediction is automatic
Control flow and structure: Domains 3 and 4
- Hand-trace for and while loops, including break and continue
- Practice print versus return and variable scope
Collections and failure modes: Domains 6, 7, and 5
- Work lists, 2D lists, and strings together, since indexing and slicing overlap
- Predict errors and trace try/except behavior
Mixed review
- Take timed sets of mixed questions under the 90-minute limit
- Revisit the domains where your practice results are weakest
Lists and strings come before error handling in this plan because the most common index and type errors arise from them, which makes error handling easier to learn afterward. For a fuller walkthrough, see the CHS-P1 Study Guide 2026: How to Pass on Your First Attempt, and keep the CHS-P1 Cheat Sheet 2026: One-Page Review of Must-Know Facts handy for final review. If you want to gauge difficulty before committing to a schedule, read How Hard Is the CHS-P1 Exam? Complete Difficulty Guide 2026.
Key Takeaway
Use timed practice questions to find which of the seven domains costs you the most points, then rebalance your remaining study time toward those areas. Because the official overview gives no weights, an even baseline across all seven beats betting on any single one.
Vouchers, Proctoring, and Results
Content mastery is half the picture; the other half is knowing the mechanics. CodeHS offers school and district voucher pricing by direct quote, and no public numeric fee was verified, so cost questions go to your school or district. Each purchased voucher permits one attempt. Retakes have no numerical limit, but every additional attempt requires another purchased voucher, and unused school or district vouchers expire at the end of the contract term without rolling over between school years. Details are collected in CHS-P1 Certification Cost 2026: Complete Pricing Breakdown.
There are no certification prerequisites, as explained in CHS-P1 Requirements 2026: Eligibility, Prerequisites & How to Qualify. Testing can happen at home or at school, monitored by a teacher or authorized proctor through the CodeHS Certifications app and Proctor Dashboard. The exam uses an Honor Code, randomly selected questions, and Focus Mode, which blocks navigation to other CodeHS pages. It is not described as a system-wide browser lockdown, but the rules still prohibit external websites and running code elsewhere. Extended-time and read-aloud accommodations are supported, and other requests go through platform review.
Results are released within 36 hours on school days with an overall score and a topic-level performance report. Successful candidates receive a downloadable certificate, which expires after 10 years. If your attempt falls short, the topic-level report is your guide to which of the seven domains to rework before purchasing another voucher. For scheduling details, see CHS-P1 Exam Dates 2026: Testing Windows, Deadlines & Scheduling.
Frequently Asked Questions
The issuer overview lists seven top-level topic groups: Data Types and Operators, Conditionals, Loops, Program Structure, Error Handling, Lists, and Strings. These are official topic groups, not course modules.
No weights were verified. The overview presents the seven headings without percentages, so plan to be competent in every domain rather than relying on an assumed distribution.
Yes. The overview expressly includes one- and two-dimensional lists, list and string methods, indexing, slicing, and the continue statement.
No. Running code in another website or program is prohibited, along with external websites and collaboration. A Python examination reference sheet is provided, and paper, a pencil, and a calculator are suggested.
Results are released within 36 hours on school days and include an overall score plus a topic-level performance report, which shows your performance by topic area.