The Foundations of Programming (Python) - E010 JIV1 exam, part of WGU Courses and Certifications, validates your ability to write, debug, and reason about Python code. This assessment is designed for learners entering programming or transitioning to Python as their primary language. This page maps the exam syllabus, explains question formats, and guides your study strategy so you can approach the test with confidence.
Use this topic map to guide your study for WGU Foundations-of-Programming-Python (Foundations of Programming (Python) - E010 JIV1) within the WGU Courses and Certifications path.
The exam combines multiple-choice and scenario-based items to assess both conceptual knowledge and practical reasoning. Questions progress in difficulty and reflect real coding decisions you'll encounter in development work.
Questions emphasize practical application, so expect scenarios that mirror common programming tasks such as data validation, list processing, and file handling.
An effective study plan maps each topic to weekly milestones and includes active practice with code review. Dedicate time to hands-on coding, reading about syntax is less effective than writing, running, and debugging small programs.
Explore other WGU certifications: view all WGU exams.
Strengthen your preparation with up-to-date resources from validexamdumps.com. These materials align to Foundations-of-Programming-Python and cover practical scenarios with clear explanations.
Visit the exam page to download the PDF, Online Practice Test, or get a Bundle Discount offer for both formats: Foundations of Programming (Python) - E010 JIV1.
Functions and Modular Programming and Data Structures and Input/Output typically account for a larger portion of the exam because they require integration of earlier concepts and reflect real-world coding tasks. However, all five topic areas are essential; weakness in Variables, Data Types, or Control Flow will make the later topics harder to master.
In practice, you use Variables and Data Types to store information, Control Flow to make decisions based on that data, Loops to process multiple records, Functions to organize and reuse your logic, and Data Structures with Input/Output to read, transform, and save results. A typical project, such as processing a CSV file of user records, touches all five areas in sequence.
Prioritize labs that require you to write complete, runnable programs rather than fill-in-the-blank exercises. Focus on labs involving file I/O, list processing with loops, and function definition. Working through debugging exercises, where you fix broken code, is especially valuable because the exam includes code-tracing questions.
Off-by-one errors in loops, confusion between list indexing and slicing, forgetting to return values from functions, and misunderstanding variable scope are frequent pitfalls. Additionally, many candidates misread scenario questions and choose syntax that is valid but doesn't solve the stated problem. Slow down on scenario items and reread the requirement before selecting your answer.
Review one topic per day, working through practice questions and tracing code by hand on paper. On day six, take a full-length timed practice test and review every question, correct and incorrect. On exam day, arrive early, read each question carefully, and flag items you're unsure about to review before submitting.
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].
The correct function uses the list method append() to add new_number to the end of numeric_list.
Correct code:
def add_item(numeric_list, new_number):
numeric_list.append(new_number)
return numeric_list
Example:
add_item([1, 2, 3], 4)
Result:
[1, 2, 3, 4]
Python's data structures documentation explains that list.append(x) adds an item to the end of the list.
Therefore, the correct answer isA.
SIMULATION
Write a complete function calculate_discount(price, discount_percent) that calculates and returns the final price after applying a discount percentage.
For example, calculate_discount(75, 20) should return 60.0.
def calculate_discount(price, discount_percent):
# TODO: Calculate and return the final price after discount
pass
==========
Step 1: The function receives the original price and the discount_percent.
Step 2: Convert the discount percentage into a decimal by dividing by 100.
Step 3: Subtract the discount from 1 to find the remaining price percentage.
Step 4: Multiply the original price by the remaining percentage.
Correct code:
def calculate_discount(price, discount_percent):
return price * (1 - discount_percent / 100)
Example:
print(calculate_discount(75, 20))
Output:
60.0
A program needs to display only positive, non-zero numbers from a list containing a mixture of integer and decimal values. Which conditional statement should be placed inside the loop?
To display only positive, non-zero numbers, the condition should check whether each number is greater than 0.
Correct condition:
if number > 0:
Example:
numbers = [-2, 0, 1, 3.5, -4.2]
for number in numbers:
if number > 0:
print(number)
Output:
1
3.5
The condition number > 0 works for both integers and decimal values. The condition number >= 1 would incorrectly exclude positive decimal values such as 0.5.
Therefore, the correct answer isA. if number > 0:.
What must a developer do to run Python code written in a text editor?
When Python code is written in a text editor, the developer should save the file, usually with a .py extension, and run it using the Python interpreter.
Example terminal command:
python script.py
Python's documentation explains that a Python module is a file containing Python definitions and statements, usually saved with the .py suffix.
Therefore, the correct answer isA. Save the file and use a Python interpreter.
SIMULATION
Fix the missing function call in this function that should return the uppercase version of a string.
def make_uppercase(text):
return text.upper
==========
Step 1: In Python, upper is a string method.
Step 2: A method must be called using parentheses ().
Step 3: text.upper refers to the method itself, but it does not execute it.
Step 4: Use text.upper() to return the uppercase version of the string.
Correct code:
def make_uppercase(text):
return text.upper()
Example:
print(make_uppercase('hello'))
Output:
HELLO
