Foundations of Programming (Python) (E010) Exam Topics and Questions
These WGU Foundations of Programming (Python) (E010) exam topics are organized according to official exam domains to help candidates quickly verify coverage and focus on assessment rather than theory. Each domain is paired with topic-wise Foundations of Programming (Python) (E010) sample questions that reflect how objectives are tested in the actual exam. This structure enables efficient review, targeted self-assessment, and rapid identification of weak areas when preparing for the WGU Foundations of Programming (Python) certification exam.
Let's Practice Free WGU Foundations of Programming (Python) (E010) Questions Aligned with Official Exam Topics
Every Python program rests on a small set of ideas that show up in every other topic on this exam. Variables, types, and arithmetic are the foundation, and the exam tests whether you have them wired correctly at a mechanical level. Mistakes here are not conceptual gaps: they are the kind of quiet errors that produce wrong output without an obvious error message. That is exactly what makes them dangerous on a timed assessment. How Variables, Data Types, and Basic...
Every Python program rests on a small set of ideas that show up in every other topic on this exam. Variables, types, and arithmetic are the foundation, and the exam tests whether you have them wired correctly at a mechanical level. Mistakes here are not conceptual gaps: they are the kind of quiet errors that produce wrong output without an obvious error message. That is exactly what makes them dangerous on a timed assessment.
How Variables, Data Types, and Basic Operations is tested
Items in this area present short code fragments and ask you to trace what value a variable holds, what type an expression produces, or what happens when types mix unexpectedly. The traps are almost always in implicit behaviour: integer division truncating rather than rounding, string concatenation refusing to accept a number, or a boolean behaving as an integer in arithmetic. Items reward knowing the exact output of an expression, not a general description of how types work. Candidates lose marks by applying rules from other languages, such as assuming division always returns a float, or by forgetting that Python's type system is dynamic but still strict about certain operations. Assignment order and variable shadowing also appear. The most reliable preparation is tracing short snippets by hand before confirming with a mental model, because items are written to catch candidates who half-remember a rule rather than those who have never seen it.
The ITExamsTopics practice test lets you filter by topic so you can focus your first session entirely on types and operations. Running ten to fifteen items back-to-back quickly reveals whether a specific conversion rule is a genuine blind spot or just an occasional slip.
The question below targets one of the type-conversion edge cases that trip up candidates most often in this topic.
What distinguishes a terminal-based Python environment from other development environments?
Once you are confident about types and values, the exam moves to how your program decides what to do with them. Control flow questions look straightforward until the conditions get nested or the logical operators combine in ways that are easy to misread under time pressure. The cost of a mistake here is high because a wrong read of a compound condition can flip the entire meaning of a code block, and the exam knows this. How Control Flow and...
Once you are confident about types and values, the exam moves to how your program decides what to do with them. Control flow questions look straightforward until the conditions get nested or the logical operators combine in ways that are easy to misread under time pressure. The cost of a mistake here is high because a wrong read of a compound condition can flip the entire meaning of a code block, and the exam knows this.
How Control Flow and Decision Making is tested
Expect items that show a multi-branch if/elif/else chain and ask which branch executes for a given input, or that present a boolean expression and ask what it evaluates to. The logical operator questions are where most candidates drop marks: short-circuit evaluation means Python stops reading a condition as soon as the result is determined, and items are designed to test whether you know where that stop happens. Items also reward understanding operator precedence among and, or, and not, because parentheses change outcomes in ways that are easy to overlook. Conditional expressions (the ternary-style one-liners) appear as well. The trap is reading the condition the way you would say it in English rather than the way Python parses it. Candidates who slow down and evaluate each sub-expression left to right, respecting precedence, consistently outperform those who rely on intuition.
Working through a timed set of control-flow items in the ITExamsTopics practice test before your exam date shows you the item style and pacing you will face, without any cost beyond the free demo if you want to check coverage first.
Test your read of a compound condition with the question waiting below.
Complete the function add_item(numeric_list, new_number) that takes a list of numbers and a new number, and returns a new list that appends the new number to the end of the list.
For example, add_item([1, 2, 3], 4) should return [1, 2, 3, 4].
Control flow tells the program which path to take once; loops tell it how many times to walk that path. The shift from decision-making to iteration is where the exam starts layering concepts, because a loop body can itself contain conditions, and the loop's own control statements can exit or skip in ways that change the final state of a variable. Tracing a loop to its last iteration is a different mental skill from reading a single condition, and the...
Control flow tells the program which path to take once; loops tell it how many times to walk that path. The shift from decision-making to iteration is where the exam starts layering concepts, because a loop body can itself contain conditions, and the loop's own control statements can exit or skip in ways that change the final state of a variable. Tracing a loop to its last iteration is a different mental skill from reading a single condition, and the exam tests both.
How Loops and Iteration is tested
Items typically present a for or while loop with a variable that accumulates a value, then ask what that variable holds after the loop ends. The difficulty comes from break and continue: a break inside a nested condition exits the loop early, and candidates who do not trace that path carefully arrive at the wrong final value. Items on while loops often hinge on whether the loop condition is checked before or after the body executes, and off-by-one errors are a recurring trap. Iterating through a string versus a list looks similar but behaves differently when the items being processed are characters versus objects, and the exam uses that difference. Items reward methodical iteration: going through the loop one step at a time rather than estimating the result. Candidates who skip steps to save time are the ones who land on a plausible but wrong answer. Slow and deliberate wins here.
Volume matters for loop tracing: the more code fragments you step through, the faster your mental execution becomes. The ITExamsTopics PDF gives you a printable set you can annotate by hand, which suits the step-by-step tracing style this topic demands.
The question below puts a loop with an early-exit condition in front of you: trace it carefully before committing.
Loops and conditions operate on values directly; functions wrap that logic into named, reusable units. This topic is where the exam starts asking about program structure rather than just program behaviour. The questions are less about what a single expression produces and more about what happens when execution jumps into a function, does its work, and returns. Scope is the hidden variable in almost every tricky item here. How Functions and Modular Programming is tested Items present a function definition...
Loops and conditions operate on values directly; functions wrap that logic into named, reusable units. This topic is where the exam starts asking about program structure rather than just program behaviour. The questions are less about what a single expression produces and more about what happens when execution jumps into a function, does its work, and returns. Scope is the hidden variable in almost every tricky item here.
How Functions and Modular Programming is tested
Items present a function definition alongside a call, and ask what value the call produces or what a variable holds after the call returns. The scope questions are the sharpest: a variable defined inside a function does not exist outside it, and a variable defined outside is readable inside but not automatically writable. Items are built to catch candidates who assume a function can silently modify a variable in the enclosing scope without an explicit mechanism. Return value questions reward knowing that a function with no return statement gives back None, and that returning early exits the function immediately regardless of what follows. Parameter questions test whether you can distinguish between passing a value and the function modifying its own local copy. Candidates lose marks by conflating the parameter name with the argument name used at the call site. Keeping the call frame and the definition frame mentally separate is the skill these items are designed to measure.
If functions and scope feel uncertain, checking that specific area in the ITExamsTopics practice test is faster than re-reading a chapter: a cluster of wrong answers on scope items tells you exactly where to focus.
A function call with a scope-sensitive variable is waiting below: work through what each frame holds before you answer.
Functions give you a way to organise logic; data structures give you a way to organise information. This final topic pulls together the practical side of Python programming: storing collections of values, reading from a user or a file, and producing output. Items here often combine several earlier skills at once, making this the topic where gaps from any previous area tend to surface in a new form. How Data Structures and Input/Output is tested Items on lists, tuples, and...
Functions give you a way to organise logic; data structures give you a way to organise information. This final topic pulls together the practical side of Python programming: storing collections of values, reading from a user or a file, and producing output. Items here often combine several earlier skills at once, making this the topic where gaps from any previous area tend to surface in a new form.
How Data Structures and Input/Output is tested
Items on lists, tuples, and dictionaries test mutability and access patterns. A tuple cannot be changed after creation; a list can; a dictionary is accessed by key, not position. Items reward knowing what happens when you try to do something a structure does not allow: modifying a tuple, accessing a missing dictionary key, or indexing past the end of a list. Input and output items focus on the fact that input() always returns a string, so arithmetic on user input requires explicit conversion first. File handling items test whether you know the difference between reading all content at once and reading line by line, and what state the file object is in after reading. Candidates lose marks by assuming Python will silently coerce types at input, or by forgetting that a dictionary lookup on an absent key raises an error rather than returning a default. These are the kinds of runtime behaviours the exam uses to separate candidates who have run code from those who have only read about it.
The ITExamsTopics practice test covers all five topics in a single timed session, letting you see how your data-structures knowledge holds up when you are also managing the clock, which is the closest simulation of exam-day conditions available before you sit.
The question below draws on data structure behaviour that is easy to misremember under pressure: read the code carefully before selecting.
Ready to Start Practicing?
Access all questions and start your exam preparation journey
Upgrade to Full Foundations of Programming (Python) (E010) Exam Questions 🚀
