Python Institute · Entry-Level Certification

PCEP™ – Certified Entry-Level Python Programmer: Exam Syllabus

The official examination scope for PCEP-30-03. Review the knowledge and practical skills assessed across five sections, from Python fundamentals to file handling and module imports.

PCEP-30-03General-Purpose ProgrammingRevised November 2, 2026
View Exam SyllabusAbout PCEP Certification

Looking for PCEP-30-02? Explore the PCEP-30-02 exam syllabus.

PCEP certification badgePCEP™ CertificationYour foundation in Python programming
PCEP-30-03Exam code
EntryCertification level
35Questions
50 minExam duration
70%Passing score
5 yearsValidity
About the exam

About PCEP-30-03

The PCEP™ – Certified Entry-Level Python Programmer exam validates foundational knowledge of programming language concepts, Python syntax and structure, literals and variables, operators and expressions, control flow, data collections, functions, exception handling, file operations, and standard library modules.

The exam emphasizes practical understanding of Python code rather than advanced software development. Candidates are expected to read, interpret, trace, complete, and write simple Python programs that solve clearly defined problems.

Exam structure

Exam Sections and Weighting

The exam contains 35 questions distributed across five weighted sections. The following table shows the planned item allocation and relative weight of each section.

SectionSection nameQuestionsWeight
01Computer Programming and Python Fundamentals6
17%
02Control Flow: Conditional Blocks and Loops8
23%
03Data Collections: Lists, Tuples, Sets, Dictionaries, and Strings9
26%
04Functions and Exceptions7
20%
05File Handling and Module Imports5
14%
Total35100%
Full exam syllabus

PCEP-30-03 Exam Syllabus

Blueprint version 1.5 · Last revised November 2, 2026 · 35 objectives across five sections

View the complete PCEP-30-03 syllabusExpand to see all five sections, assessment objectives, and topic requirements
Section 01

Computer Programming and Python Fundamentals

17%6 questions · 6 objectives

1.1 Programming Language Fundamentals

Objective 1.1.1 Explain the fundamental concepts of programming language structure and code execution (1 item)
  1. Define lexis, syntax, and semantics, and explain their roles in a programming language.
  2. Distinguish between lexical, syntactic, and semantic errors in program code.
  3. Define interpretation and compilation, and explain the roles of an interpreter and a compiler.
  4. Compare interpreted and compiled execution models, including how source code is processed and executed.
  5. Explain how Python source code is processed and executed, from source code to program execution.

1.2 Python Program Logic and Structure

Objective 1.2.1 Apply the fundamental structural rules of Python programs (1 item)
  1. Recognize Python keywords and explain why they cannot be used as identifiers.
  2. Distinguish between expressions, statements, and keywords.
  3. Use indentation to define blocks of code.
  4. Recognize errors caused by incorrect or inconsistent indentation.
  5. Use comments to document code and temporarily disable selected lines of code.

1.3 Literals and Variables

Objective 1.3.1 Represent data using Python literals (1 item)
  1. Recognize the basic Python data types represented by literals, including int, float, str, and bool.
  2. Use Boolean literals to represent logical values.
  3. Use integer and floating-point literals to represent numeric values.
  4. Explain limitations in the accuracy and representation of floating-point numbers.
  5. Construct string literals using appropriate quotation marks.
Objective 1.3.2 Create and manage variables according to Python naming conventions (1 item)
  1. Create variables and assign values.
  2. Explain how variables reference values during program execution.
  3. Select valid and meaningful variable names.
  4. Distinguish between valid and invalid Python identifiers.
  5. Apply relevant PEP 8 recommendations to variable names and assignment statements.

1.4 Operators, Expressions, and Console Operations

Objective 1.4.1 Use operators and expressions (1 item)
  1. Use numeric operators, including **, *, /, %, //, +, and -.
  2. Use + and * with strings where appropriate.
  3. Use assignment and augmented assignment operators.
  4. Distinguish between unary and binary operators.
  5. Apply operator precedence, associativity, and binding rules.
  6. Use the Boolean operators not, and, and or.
  7. Construct and evaluate Boolean expressions.
  8. Use relational operators, including ==, !=, >, >=, <, and <=.
Objective 1.4.2 Perform console I/O operations and type conversions (1 item)
  1. Display values using the print() function.
  2. Read user input using the input() function.
  3. Explain that the input() function returns a string.
  4. Convert values between compatible data types using functions such as int(), float(), and str().
  5. Convert input values to appropriate data types before processing them.
  6. Combine console input, data conversion, processing, and output in a simple program.
Back to syllabus contents ↑
Section 02

Control Flow: Conditional Blocks and Loops

23%8 questions · 8 objectives

2.1 Conditional Execution

Objective 2.1.1 Control program flow using if and if-else statements (1 item)
  1. Use an if statement to execute code when a condition is true.
  2. Use an if-else structure to select between two execution paths.
  3. Construct conditions using Boolean expressions.
  4. Trace which branch is executed based on the result of a condition.
  5. Recognize when a conditional block is skipped.
Objective 2.1.2 Select among multiple execution paths using if-elif-else statements (1 item)
  1. Use an if-elif structure to evaluate multiple conditions.
  2. Use an if-elif-else structure to provide a fallback execution path.
  3. Explain that conditions are evaluated in order until a matching branch is found.
  4. Trace the execution of multi-branch conditional structures.
  5. Recognize incorrectly ordered, redundant, or unreachable conditional branches.
Objective 2.1.3 Construct compound and nested conditional structures (1 item)
  1. Use multiple conditional statements within the same program.
  2. Nest conditional statements inside other conditional branches.
  3. Combine Boolean expressions within conditional structures.
  4. Trace the execution of compound conditional structures.
  5. Identify unreachable, redundant, or incorrectly ordered conditional branches.

2.2 Iterative Execution

Objective 2.2.1 Create condition-controlled loops using while (1 item)
  1. Use a while loop to repeat instructions while a condition remains true.
  2. Initialize and update loop-control variables (sentinel values).
  3. Trace the execution of a condition-controlled loop.
  4. Recognize conditions that may result in an infinite loop.
  5. Use assignment expressions with the walrus operator := where appropriate.
Objective 2.2.2 Iterate through sequences and iterable objects using for and in (1 item)
  1. Use a for loop to iterate through a sequence or iterable object.
  2. Use the in operator to retrieve successive elements from an iterable.
  3. Iterate through common iterable objects such as strings, lists, and tuples.
  4. Process each element of an iterable within a loop.
  5. Trace the values assigned to the loop variable during execution.
Objective 2.2.3 Generate numeric iterations using range() (1 item)
  1. Use range() to generate integer sequences for loop iteration.
  2. Use the start, stop, and step arguments of range().
  3. Use positive and negative step values.
  4. Trace the values produced by range() during loop execution.
Objective 2.2.4 Construct nested loops and combined control structures (1 item)
  1. Nest one loop inside another loop.
  2. Combine loops with conditional statements.
  3. Trace the execution order of nested loops.
  4. Use nested loops to process multidimensional or grouped data.
Objective 2.2.5 Control loop execution using break, continue, and pass (1 item)
  1. Use break to terminate a loop before its normal completion.
  2. Use continue to skip the remainder of the current iteration.
  3. Use pass as a syntactic placeholder for an empty block.
  4. Trace loops that contain break, continue, or pass.
Back to syllabus contents ↑
Section 03

Data Collections: Lists, Tuples, Sets, Dictionaries, and Strings

26%9 questions · 9 objectives

3.1 Lists

Objective 3.1.1 Construct lists and access their elements (1 item)
  1. Create empty and populated lists.
  2. Store values of the same or different data types in a list.
  3. Access list elements using positive and negative indexes.
  4. Extract portions of a list using slicing.
  5. Use slice start, stop, and step values.
  6. Create copies of lists using slicing.
Objective 3.1.2 Modify, search, sort, and iterate through lists (1 item)
  1. Add elements using methods such as append() and insert().
  2. Locate elements using methods such as index().
  3. Remove list elements using appropriate methods or the del keyword.
  4. Sort list data using the sorted() function and relevant list methods.
  5. Iterate through list elements using a for loop.
  6. Initialize and update values while processing a list.
  7. Use the in and not in operators to test list membership.
  8. Determine the number of elements in a list using the len() function.
Objective 3.1.3 Create, access, and modify multidimensional lists (1 item)
  1. Use lists of lists to represent two-dimensional structures such as matrices.
  2. Use deeper levels of nesting to represent three-dimensional structures such as cubes.
  3. Access elements in multidimensional lists using multiple indexes.
  4. Modify values stored in nested lists.

3.2 Tuples

Objective 3.2.1 Construct, access, and use tuples effectively (1 item)
  1. Create empty, single-element, and multi-element tuples.
  2. Access tuple elements using positive and negative indexes, and extract portions of tuples using slicing.
  3. Explain tuple immutability and compare the characteristics and common use cases of tuples and lists.
  4. Create nested tuples and lists by storing one collection inside another.
  5. Access elements within nested tuples using appropriate indexing.

3.3 Sets

Objective 3.3.1 Collect and process unique values using sets (1 item)
  1. Explain the defining characteristics of the set data type.
  2. Create empty and populated sets.
  3. Explain why sets do not preserve positional indexing.
  4. Add elements to a set.
  5. Remove elements from a set using appropriate methods.
  6. Test membership using the in and not in operators.

3.4 Dictionaries

Objective 3.4.1 Construct, modify, and process dictionary data (1 item)
  1. Create empty and populated dictionaries containing key-value pairs.
  2. Access dictionary values using keys, and use the in and not in operators to determine whether a key exists.
  3. Add new key-value pairs and update values associated with existing keys.
  4. Remove key-value pairs.
  5. Iterate through dictionaries, including their keys, values, and key-value pairs using the keys(), values(), and items() methods.

3.5 Strings

Objective 3.5.1 Construct strings and access their contents (1 item)
  1. Create strings using single quotation marks, double quotation marks, and triple quotation marks.
  2. Use escape sequences introduced by the backslash character.
  3. Include quotation marks and apostrophes inside string literals.
  4. Create multiline strings.
  5. Access characters using positive and negative indexes.
  6. Extract substrings using slicing.
  7. Use slice start, stop, and step values with strings.
  8. Explain string immutability.
  9. Determine the length of a string using the len() function.
  10. Use the in and not in operators to test whether a substring is present.
Objective 3.5.2 Process and transform strings (1 item)
  1. Change letter case using lower(), upper(), capitalize(), title(), and swapcase().
  2. Search for characters or substrings using find().
  3. Split strings into substrings using split().
  4. Join multiple strings using join().
  5. Remove whitespace or selected characters from string boundaries using strip(), lstrip(), and rstrip().
  6. Replace selected characters or substrings using replace().
  7. Recognize that string methods return new strings rather than modifying the original string.
Objective 3.5.3 Format values as strings (1 item)
  1. Construct formatted string literals using f-strings.
  2. Insert variables and expressions into f-string replacement fields enclosed in {}.
  3. Recognize basic formatting performed using the format() method.
  4. Recognize basic legacy string formatting performed using the % operator.
Back to syllabus contents ↑
Section 04

Functions and Exceptions

20%7 questions · 7 objectives

4.1 Functions

Objective 4.1.1 Define and invoke user-defined functions (1 item)
  1. Explain how functions support code decomposition, reuse, and maintainability.
  2. Define a function using the def keyword.
  3. Create valid function names according to Python naming rules.
  4. Define a function body using correct indentation.
  5. Invoke a user-defined function.
  6. Trace the order in which function definitions and function calls are executed.
Objective 4.1.2 Return values from functions (1 item)
  1. Use the return statement to return a result from a function.
  2. Assign a returned value to a variable.
  3. Use returned values in expressions and function calls.
  4. Explain the difference between returning a value and displaying a value with print().
  5. Explain how return terminates the current function call.
  6. Return multiple values from a function.
  7. Recognize when a function implicitly returns None.
  8. Use the None value to represent the absence of a meaningful result.
Objective 4.1.3 Define parameters and pass arguments to functions (1 item)
  1. Distinguish between parameters in function definitions and arguments in function calls.
  2. Pass arguments by position and keyword, and combine them in the correct order.
  3. Define parameters with default values.
  4. Call functions using default values or override them with explicit arguments.
  5. Use keyword arguments with built-in functions such as print(), including sep and end.
  6. Recognize invalid function calls caused by missing, duplicated, or incorrectly ordered arguments.
Objective 4.1.4 Accept variable numbers of arguments (1 item)
  1. Use *args to collect additional positional arguments.
  2. Explain that *args stores collected arguments in a tuple.
  3. Iterate through values received through *args.
  4. Use **kwargs to collect additional keyword arguments.
  5. Explain that **kwargs stores collected arguments in a dictionary.
  6. Access and process keys and values received through **kwargs.
  7. Combine standard parameters, default parameters, *args, and **kwargs in a valid function definition.
Objective 4.1.5 Manage variable scope (1 item)
  1. Distinguish between local and global name scopes.
  2. Explain how names created inside a function are resolved.
  3. Recognize namespaces and variable shadowing.
  4. Use the global keyword to modify a global variable from inside a function.
  5. Explain the risks associated with excessive use of global variables.

4.2 Exceptions

Objective 4.2.1 Explain and recognize basic Python exceptions (1 item)
  1. Explain the purpose of exceptions in Python programs.
  2. Explain how an exception interrupts the flow of program execution.
  3. Recognize common situations in which Python raises exceptions.
  4. Recognize basic built-in exceptions, including ValueError, TypeError, ZeroDivisionError, IndexError, KeyError, and NameError.
  5. Relate common exception types to the operations that may cause them.
Objective 4.2.2 Handle runtime exceptions with try and except (1 item)
  1. Use try and except to handle runtime exceptions.
  2. Handle specific exception types using one or more except branches.
  3. Use multiple except branches to handle different exception types.
  4. Trace simple exception-handling flow when an exception occurs or does not occur.
Back to syllabus contents ↑
Section 05

File Handling and Module Imports

14%5 questions · 5 objectives

5.1 File Handling

Objective 5.1.1 Work with text files (1 item)
  1. Open text files using appropriate modes, including r, w, and a.
  2. Read data from a text file.
  3. Write and append data to a text file.
  4. Use the with statement to manage file access safely.
  5. Recognize common errors when opening or accessing files.
Objective 5.1.2 Work with CSV files (1 item)
  1. Explain the basic structure of a CSV file.
  2. Import and use the csv module.
  3. Read CSV data using csv.reader().
  4. Write CSV data using csv.writer().
  5. Process rows and values read from a CSV file.

5.2 Modules and Imports

Objective 5.2.1 Import and use modules (1 item)
  1. Explain the purpose and benefits of importing existing code.
  2. Use the import keyword to load a module.
  3. Access objects provided by an imported module.
Objective 5.2.2 Perform mathematical evaluations using the math module (1 item)
  1. Import and use the math module.
  2. Round values upward using ceil().
  3. Round values downward using floor().
  4. Remove the fractional part of a value using trunc().
  5. Calculate square roots using sqrt().
Objective 5.2.3 Generate and select pseudorandom values using the random module (1 item)
  1. Import and use the random module.
  2. Generate pseudorandom floating-point values using random().
  3. Initialize the pseudorandom number generator using seed().
  4. Explain how setting a seed can produce repeatable results.
  5. Select a random element from a sequence using choice().
  6. Select multiple unique elements using sample().
Back to syllabus contents ↑
Candidate expectations

Minimally Qualified Candidate (MQC) Profile

A minimally qualified PCEP-30-03 candidate demonstrates sufficient entry-level competence to read, trace, complete, and write simple Python programs using familiar language constructs.

Programming fundamentals

Understands how Python programs are structured and executed. Can work with syntax, indentation, comments, literals, variables, operators, expressions, type conversions, and console input/output.

Control flow and problem-solving

Can break well-defined problems into basic programming steps, construct and trace conditional statements and loops, and use loop-control statements appropriately.

Collections and strings

Can create, access, and process lists, tuples, sets, dictionaries, and strings, including common indexing, slicing, iteration, membership, and formatting operations.

Functions and exceptions

Can define and call functions, pass arguments, use return values, recognize local and global scope, and identify and handle basic runtime exceptions.

Files and modules

Can read, write, and append text data, perform basic CSV operations, and import and use selected Python standard library modules, including math and random.

Passing requirement

Pass the PCEP-30-03 Exam

The passing score is 70%, based on the minimum competency standard defined for this certification. The final passing standard is established through psychometric analysis, exam-form difficulty, and item performance.

70%Passing score

Ready to begin your certification journey?

Explore the PCEP credential, review the exam requirements, and prepare for PCEP-30-03.

Explore PCEP Certification