PCEP · topic practice

Computer Programming and Python Fundamentals practice questions

Q: How should I use these Computer Programming and Python Fundamentals practice questions?

Read each scenario carefully and choose your answer before revealing the explanation. Then check why your choice was right or wrong. Repeat until the reasoning feels automatic.

Q: Can I practise just Computer Programming and Python Fundamentals questions in a focused session?

Yes — use the session launcher on this page to start a 10-, 20-, 30- or 50-question session drawn entirely from the Computer Programming and Python Fundamentals domain.

This domain covers the foundations every PCEP candidate needs: how Python source is structured, how names and literals are written, and how basic expressions evaluate. Questions are short code-reading and output-prediction items, plus PEP 8 style recognition and choosing the right built-in data structure for a described configuration or record.

Courseiva uses original exam-style practice questions designed for learning and revision. The goal is to understand the concepts, recognise exam patterns, and improve through explanations — not memorise copied exam dumps.

Editorial oversight:Johnson Ajibi· MSc IT Security, IEEE Senior Member

18 questionsDomain: Computer Programming and Python Fundamentals

Practice 10 questions Browse domain →

What the exam tests

What to know about Computer Programming and Python Fundamentals

You must read short snippets and state exactly what prints, and recognize idiomatic Python naming and structure choices. The single most important thing is to trace expression evaluation and slicing precisely, remembering that slice stops are exclusive and that ** has higher precedence than unary minus.

PEP 8 naming conventions for variables, constants, functions, classes, and modules

Python literal and operator behavior, including exponentiation, precedence, and integer versus float results

Indexing and slicing of sequences, including negative indices and slice end exclusivity

Selecting appropriate built-in types such as list, tuple, dict, and set for a given data shape

Why learners struggle

Why Computer Programming and Python Fundamentals questions are commonly missed

RAM questions are commonly missed because learners confuse physical form factors (DIMM vs SO-DIMM) and fail to distinguish between memory speed (MHz) and latency (CL).

·DIMM vs SO-DIMM — desktop vs laptop form factor confusion
·DDR3 vs DDR4 vs DDR5 — notch position and voltage differences
·MHz vs CL — speed vs latency trade-offs in performance
·Single-channel vs dual-channel — bandwidth impact misconception
·ECC vs non-ECC — error correction support in servers vs desktops
·32-bit vs 64-bit — maximum addressable RAM limit

Watch out for

Common Computer Programming and Python Fundamentals exam traps

▸Assuming a slice like [-3:-1] includes the last element; the stop index is always excluded, so the final item is dropped.
▸Forgetting that ** binds tighter than unary minus and multiplication, so -2 ** 2 evaluates to -4, not 4.
▸Using camelCase or single-letter names for constants; PEP 8 expects UPPER_CASE_WITH_UNDERSCORES for module-level constants.

Practice set

Computer Programming and Python Fundamentals questions

18 questions · select your answer, then reveal the explanation

Question 1easymultiple choice

Study the full Python automation breakdown →

A developer writes a script that prompts the user for their age and stores it in a variable. Which code snippet correctly converts the input to an integer?

Trap 1: age = int(input)

int(input) passes the built-in function object itself to int(), which raises TypeError rather than converting text. It is tempting because input is the function that reads console data, but conversion requires calling it first: int(input()).

Trap 2: age = input("Enter age: ", int)

input() accepts only a prompt argument; passing int as a second argument raises TypeError, and no conversion occurs. It is tempting because int appears alongside input, but the integer conversion must wrap the returned string: int(input("Enter age: ")).

Trap 3: age = input(int("Enter age: "))

int("Enter age: ") attempts to convert the literal prompt text to an integer, raising ValueError before input() ever runs. It is tempting because it nests the two functions, but the correct order calls input() first, then wraps its result in int().

Study all Computer Programming and Python Fundamentals common traps →

A
age = int(input)
Why it fails: int(input) passes the built-in function object itself to int(), which raises TypeError rather than converting text. It is tempting because input is the function that reads console data, but conversion requires calling it first: int(input()).
B
age = int(input("Enter age: "))
The int() constructor parses the string returned by input() and returns an integer object, so age holds a numeric value usable in arithmetic. Without the cast, input() always yields a string, which would break numeric comparisons.
C
age = input("Enter age: ", int)
Why it fails: input() accepts only a prompt argument; passing int as a second argument raises TypeError, and no conversion occurs. It is tempting because int appears alongside input, but the integer conversion must wrap the returned string: int(input("Enter age: ")).
D
age = input(int("Enter age: "))
Why it fails: int("Enter age: ") attempts to convert the literal prompt text to an integer, raising ValueError before input() ever runs. It is tempting because it nests the two functions, but the correct order calls input() first, then wraps its result in int().

Full breakdown with real-world context →

Question 2hardmultiple choice

Study the full Python automation breakdown →

Given the code: a = [1, 2, 3]; b = a; b.append(4). What is the value of a?

Trap 1: Error

No error occurs: b = a binds the same list object, and append mutates it in place, so the statement executes cleanly. It tempts because mutation through an alias can surprise newcomers, but that confusion produces a wrong value, not an exception.

Trap 2: [1, 2, 3]

Assignment binds the same list object rather than copying it, so append(4) mutates the list a also references. It tempts because it matches the literal before the append, which is what a shallow copy via a[:] or list(a) would preserve.

Trap 3: [1, 2, 3, [4]]

Appending 4 to `b` mutates the single list object that both names reference, so `a` becomes `[1, 2, 3, 4]`; nesting only occurs if you append a list, as in `b.append([4])`. The nested form is tempting because `append` adds its argument as one element, which is correct when that argument is itself a list.

Study all Computer Programming and Python Fundamentals common traps →

A
[1, 2, 3, 4]
Assignment binds b to the same list object as a, so append mutates that shared object in place. Both names therefore reference [1, 2, 3, 4]; no copy occurs, which is the aliasing behaviour the question tests.
B
Error
Why it fails: No error occurs: b = a binds the same list object, and append mutates it in place, so the statement executes cleanly. It tempts because mutation through an alias can surprise newcomers, but that confusion produces a wrong value, not an exception.
C
[1, 2, 3]
Why it fails: Assignment binds the same list object rather than copying it, so append(4) mutates the list a also references. It tempts because it matches the literal before the append, which is what a shallow copy via a[:] or list(a) would preserve.
D
[1, 2, 3, [4]]
Why it fails: Appending 4 to `b` mutates the single list object that both names reference, so `a` becomes `[1, 2, 3, 4]`; nesting only occurs if you append a list, as in `b.append([4])`. The nested form is tempting because `append` adds its argument as one element, which is correct when that argument is itself a list.

Full breakdown with real-world context →

Question 3mediummultiple choice

Study the full Python automation breakdown →

A student writes the code: x = 10; if x > 5: print("big"); else: print("small"). What is the output?

Trap 1: small

Since x is 10, the condition x > 5 evaluates True, so the if branch runs and prints big; the else branch is skipped. It is tempting because small is the else output, which would print only if x were 5 or less.

Trap 2: SyntaxError

The code is syntactically valid: the if/else structure, colons and indentation are all correct, so no SyntaxError occurs. It is tempting because SyntaxError is a real Python exception, and would be correct if a colon or the required indentation were missing.

Trap 3: big small

Only one branch executed.

Study all Computer Programming and Python Fundamentals common traps →

A
small
Why it fails: Since x is 10, the condition x > 5 evaluates True, so the if branch runs and prints big; the else branch is skipped. It is tempting because small is the else output, which would print only if x were 5 or less.
B
SyntaxError
Why it fails: The code is syntactically valid: the if/else structure, colons and indentation are all correct, so no SyntaxError occurs. It is tempting because SyntaxError is a real Python exception, and would be correct if a colon or the required indentation were missing.
C
big small
Why it fails: Only one branch executed.
D
big
The condition x > 5 evaluates to True since 10 exceeds 5, so the if branch executes and prints big. The else branch is skipped entirely. Indentation correctly delimits each branch, so no syntax error occurs.

Full breakdown with real-world context →

Question 4hardmulti select

Study the full Python automation breakdown →

Which TWO of the following code snippets will result in a SyntaxError? (Choose two.)

Trap 1: a = 1; b = 2

Valid syntax: multiple statements separated by semicolons are allowed on one line.

Trap 2: print('hello')

Valid syntax: `print('hello')` is a correct function call in Python 3.

Trap 3: for i in range(5): print(i)

Valid syntax: the `for` loop has a colon and proper indentation.

Study all Computer Programming and Python Fundamentals common traps →

A
a = 1; b = 2
Why it fails: Valid syntax: multiple statements separated by semicolons are allowed on one line.
B
print('hello')
Why it fails: Valid syntax: `print('hello')` is a correct function call in Python 3.
C
for i in range(5): print(i)
Why it fails: Valid syntax: the `for` loop has a colon and proper indentation.
D
if x > 5 print('big')
SyntaxError: the `if` statement is missing a colon after the condition.
E
if x > 5: print('big')
Why it fails: Valid syntax: the `if` statement has a colon and proper indentation.

Full breakdown with real-world context →

Question 5mediummultiple choice

Study the full Python automation breakdown →

A system administrator is writing a Python script to monitor disk usage. The script uses the psutil library (not part of PCEP scope, but the scenario is generic). The administrator writes:

import psutil

disk = psutil.disk_usage('/')

print(disk.free)

But the script fails with an ImportError because psutil is not installed. The administrator decides to handle this gracefully: if the module is missing, the script should print a custom error message and exit without crashing. Which code snippet achieves this?

Trap 1: import psutil if not psutil: print('psutil not installed.')…

A failed import raises ImportError before the module name is bound, so the script aborts and the subsequent truthiness check on psutil never executes. The if not psutil pattern suits optional variables already assigned, not missing imports. Catching ImportError around the import statement is what handles an absent module gracefully.

Trap 2: try: import psutil except ImportError: print('psutil not…

The except block prints the message but does not exit, so execution continues and the later psutil.disk_usage call raises NameError, crashing the script. The stem requires exiting without crashing. sys.exit(1) inside the handler, or equivalent termination, is needed to satisfy that requirement.

Trap 3: try: import psutil except: print('Module missing.')…

The bare except catches ImportError, prints the message, then the raise statement re-raises the exception, terminating the script with a traceback rather than exiting gracefully. The stem asks for a clean exit. Catching ImportError specifically and calling sys.exit(1) avoids the unhandled exception.

Study all Computer Programming and Python Fundamentals common traps →

A
try: import psutil except ImportError: print('psutil not installed. Please install.') sys.exit(1)
Wrapping the import in try/except ImportError catches the missing-module failure, prints the custom message, and calls sys.exit(1) to terminate cleanly. This satisfies the requirement to exit gracefully without an unhandled traceback when psutil is absent.
B
import psutil if not psutil: print('psutil not installed.') sys.exit(1)
Why it fails: A failed import raises ImportError before the module name is bound, so the script aborts and the subsequent truthiness check on psutil never executes. The if not psutil pattern suits optional variables already assigned, not missing imports. Catching ImportError around the import statement is what handles an absent module gracefully.
C
try: import psutil except ImportError: print('psutil not installed. Please install.')
Why it fails: The except block prints the message but does not exit, so execution continues and the later psutil.disk_usage call raises NameError, crashing the script. The stem requires exiting without crashing. sys.exit(1) inside the handler, or equivalent termination, is needed to satisfy that requirement.
D
try: import psutil except: print('Module missing.') raise
Why it fails: The bare except catches ImportError, prints the message, then the raise statement re-raises the exception, terminating the script with a traceback rather than exiting gracefully. The stem asks for a clean exit. Catching ImportError specifically and calling sys.exit(1) avoids the unhandled exception.

Full breakdown with real-world context →

Question 6mediummultiple choice

Study the full Python automation breakdown →

A developer writes a Python script that calculates the average of a list of numbers. The script sometimes produces a ZeroDivisionError. Which of the following is the MOST appropriate way to handle this error to keep the script running?

Trap 1: Check if len(numbers) == 0 before division and skip calculation if…

Prevents error but requires explicit check; not the most Pythonic way if the list can be modified concurrently.

Trap 2: Use an if statement to check if the list is empty and print a…

Prevents error but does not handle the case where the list becomes empty after the check.

Trap 3: Remove the last element from the list if it is empty.

Modifies the list arbitrarily; not a correct solution.

Study all Computer Programming and Python Fundamentals common traps →

A
Check if len(numbers) == 0 before division and skip calculation if true.
Why it fails: Prevents error but requires explicit check; not the most Pythonic way if the list can be modified concurrently.
B
Use an if statement to check if the list is empty and print a warning message.
Why it fails: Prevents error but does not handle the case where the list becomes empty after the check.
C
Remove the last element from the list if it is empty.
Why it fails: Modifies the list arbitrarily; not a correct solution.
D
Wrap the division in a try/except block and catch ZeroDivisionError, then set the average to 0.
Handles the error gracefully and allows continuation.

Full breakdown with real-world context →

Question 7easymultiple choice

Study the full Python automation breakdown →

A Python script contains the following line: x = 5. Later in the script, the programmer wants to check if x is an integer. Which of the following is the BEST way to perform this check?

Trap 1: if x is integer:

Invalid syntax.

Trap 2: if x == 'integer':

Compares value, not type.

Trap 3: if type(x) == int:

Works but not recommended; isinstance is preferred.

Study all Computer Programming and Python Fundamentals common traps →

A
if isinstance(x, int):
Correct and Pythonic.
B
if x is integer:
Why it fails: Invalid syntax.
C
if x == 'integer':
Why it fails: Compares value, not type.
D
if type(x) == int:
Why it fails: Works but not recommended; isinstance is preferred.

Full breakdown with real-world context →

Question 8mediummulti select

Study the full Python automation breakdown →

Which TWO of the following are valid Python variable names? (Choose two.)

Trap 1: for

Reserved keyword.

Trap 2: my-var

Hyphen not allowed.

Trap 3: 1var

Cannot start with a digit.

Study all Computer Programming and Python Fundamentals common traps →

A
for
Why it fails: Reserved keyword.
B
var123
Valid: letters and digits.
C
my-var
Why it fails: Hyphen not allowed.
D
1var
Why it fails: Cannot start with a digit.
E
_myVar
Valid: starts with underscore.

Full breakdown with real-world context →

Question 9mediummultiple choice

Study the full Python automation breakdown →

What is the output of the code in the exhibit?

Exhibit

Refer to the exhibit.

```
x = '10'
y = 5
result = x + y
print(result)
```

Trap 1: '105'

Quoting the digits makes this a string, but the exhibit's expression evaluates to a numeric value, so no quotation marks appear in the output. String results tempt candidates whenever concatenation or input() is involved; here the operands are numeric, producing an int.

Trap 2: 105

The exhibit's operators produce a different value than 105, so this misapplies precedence or the arithmetic itself. Unquoted integers are tempting because PCEP frequently tests numeric output, but the specific expression here does not evaluate to 105.

Trap 3: 15

The exhibit's arithmetic yields a different value, so 15 misreads the operators or operand order actually evaluated. Numeric literals without quotes are tempting because integer outputs are common in PCEP questions, yet here the expression's precedence or concatenation produces another result.

Study all Computer Programming and Python Fundamentals common traps →

A
TypeError
The exhibit concatenates a string with an integer, or calls a method on an incompatible type, so Python raises TypeError rather than coercing operands. Python does not implicitly convert between str and int for the + operator, so the interpreter halts at that expression instead of printing a value.
B
'105'
Why it fails: Quoting the digits makes this a string, but the exhibit's expression evaluates to a numeric value, so no quotation marks appear in the output. String results tempt candidates whenever concatenation or input() is involved; here the operands are numeric, producing an int.
C
105
Why it fails: The exhibit's operators produce a different value than 105, so this misapplies precedence or the arithmetic itself. Unquoted integers are tempting because PCEP frequently tests numeric output, but the specific expression here does not evaluate to 105.
D
15
Why it fails: The exhibit's arithmetic yields a different value, so 15 misreads the operators or operand order actually evaluated. Numeric literals without quotes are tempting because integer outputs are common in PCEP questions, yet here the expression's precedence or concatenation produces another result.

Full breakdown with real-world context →

Question 10hardmultiple choice

Study the full Python automation breakdown →

What is the output of the code in the exhibit?

Exhibit

Refer to the exhibit.

```
my_list = [1, 2, 3, 4, 5]
my_list[1:3] = [10, 20]
print(my_list)
```

Trap 1: [1, 2, 10, 20, 5]

Indices incorrect: slice 1:3 replaces elements at positions 1 and 2.

Trap 2: [1, 2, 3, 10, 20, 4, 5]

That would be insertion, not replacement.

Trap 3: [1, 10, 20, 3, 4, 5]

Indices incorrect.

Study all Computer Programming and Python Fundamentals common traps →

A
[1, 2, 10, 20, 5]
Why it fails: Indices incorrect: slice 1:3 replaces elements at positions 1 and 2.
B
[1, 10, 20, 4, 5]
Correct replacement.
C
[1, 2, 3, 10, 20, 4, 5]
Why it fails: That would be insertion, not replacement.
D
[1, 10, 20, 3, 4, 5]
Why it fails: Indices incorrect.

Full breakdown with real-world context →

Question 11hardmultiple choice

Study the full Python automation breakdown →

A Python script uses the following code to open a file: f = open('data.txt', 'w'). The programmer then writes multiple lines to the file. After writing, which of the following is the BEST practice to ensure data integrity?

Trap 1: Call f.close() after writing.

Works but not exception-safe.

Trap 2: Call f.flush() after writing.

Flushes buffer but does not close file.

Trap 3: No action needed; Python automatically closes files.

Not guaranteed; depends on garbage collection.

Study all Computer Programming and Python Fundamentals common traps →

A
Call f.close() after writing.
Why it fails: Works but not exception-safe.
B
Call f.flush() after writing.
Why it fails: Flushes buffer but does not close file.
C
No action needed; Python automatically closes files.
Why it fails: Not guaranteed; depends on garbage collection.
D
Use a with statement to open the file.
Ensures proper closing even on exceptions.

Full breakdown with real-world context →

Question 12mediummultiple choice

Study the full Python automation breakdown →

A junior developer is tasked with writing a Python script that reads a list of integers from a file, removes any duplicate numbers, and then writes the unique numbers back to the same file in ascending order. The file 'numbers.txt' currently contains one integer per line. The developer writes the following code:

with open('numbers.txt', 'r') as f:

numbers = [int(line.strip()) for line in f] unique = list(set(numbers)) unique.sort()

with open('numbers.txt', 'w') as f:
    for num in unique:

f.write(str(num) + '\n')

The script runs without errors, but the output file contains the numbers in descending order instead of ascending. The developer checks the sort() method and confirms it sorts in ascending order. What is the MOST likely cause of the issue?

Trap 1: The numbers were read as strings and the sort() method sorted them…

The code converts to int.

Trap 2: The file was opened in read mode before writing, but the read…

Reading does not truncate.

Trap 3: The file was opened in append mode instead of write mode, causing…

The code uses 'w' mode, so it overwrites.

Study all Computer Programming and Python Fundamentals common traps →

A
The numbers were read as strings and the sort() method sorted them lexicographically, putting '10' before '2'.
Why it fails: The code converts to int.
B
The set() operation reordered the elements, and the sort() method was called on a different list that was not saved.
If the developer wrote unique = list(set(numbers)).sort(), unique would be None. But the code shows separate lines; however, this is the most likely error given the symptom.
C
The file was opened in read mode before writing, but the read operation truncated the file.
Why it fails: Reading does not truncate.
D
The file was opened in append mode instead of write mode, causing the sorted numbers to be appended after the original unsorted numbers.
Why it fails: The code uses 'w' mode, so it overwrites.

Full breakdown with real-world context →

Question 13mediummatching

Study the full Python automation breakdown →

Match each Python list method to its effect.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts

Matches

Adds an item to the end of the list

Inserts an item at a given position

Removes the first occurrence of a value

Removes and returns an item at a given index

Sorts the list in ascending order in place

Trap 1: append: Extends the list by appending elements from an iterable.

This describes the extend method, not append.

Trap 2: extend: Adds an element to the end of the list.

This describes the append method, not extend.

Study all Computer Programming and Python Fundamentals common traps →

A
append: Extends the list by appending elements from an iterable.
Why it fails: This describes the extend method, not append.
B
extend: Adds an element to the end of the list.
Why it fails: This describes the append method, not extend.
C
insert: Inserts an element at a given index.
Correct: insert adds an element at a specified position.
D
remove: Removes the first occurrence of a value.
Correct: remove deletes the first instance of the given value.
E
pop: Removes and returns the element at a given index (default last).
Correct: pop removes and returns an element by index.

Full breakdown with real-world context →

Question 14mediummultiple choice

Study the full Python automation breakdown →

A data scientist has a list: scores = [88, 92, 79, 93, 85]. They want to add 5 bonus points to each score and store the new scores. Which code accomplishes this?

Trap 1: scores = [s+5] for s in scores

Syntax error (missing brackets).

Trap 2: for s in scores: s += 5

Does not modify list elements.

Trap 3: scores = scores + 5

Can't add int to list.

Study all Computer Programming and Python Fundamentals common traps →

A
scores = [s+5] for s in scores
Why it fails: Syntax error (missing brackets).
B
scores = [s + 5 for s in scores]
The list comprehension iterates over each element, adds 5, and rebuilds the list, assigning the result back to scores. This applies the bonus to every entry in one expression, satisfying the requirement to store the updated values.
C
for s in scores: s += 5
Why it fails: Does not modify list elements.
D
scores = scores + 5
Why it fails: Can't add int to list.

Full breakdown with real-world context →

Question 15mediummultiple choice

Study the full Python automation breakdown →

A developer wants to extract the file extension from a filename: 'report.pdf'. Which string method will return 'pdf'?

Trap 1: 'report.pdf'.replace('.', '')

Returns 'reportpdf'.

Trap 2: 'report.pdf'.split('.')[1]

Also returns 'pdf' but only works with one dot.

Trap 3: 'report.pdf'.removeprefix('report.')

Removes prefix, not safe.

Study all Computer Programming and Python Fundamentals common traps →

A
'report.pdf'.replace('.', '')
Why it fails: Returns 'reportpdf'.
B
'report.pdf'.split('.')[-1]
Splitting on the period produces ['report', 'pdf'], and index [-1] retrieves the final element, 'pdf'. This satisfies the requirement to extract the extension without the dot, correctly handling the given filename where exactly one period separates name and extension.
C
'report.pdf'.split('.')[1]
Why it fails: Also returns 'pdf' but only works with one dot.
D
'report.pdf'.removeprefix('report.')
Why it fails: Removes prefix, not safe.

Full breakdown with real-world context →

Question 16hardmulti select

Study the full Python automation breakdown →

Which THREE of the following will correctly iterate over all keys and values of a dictionary d = {'a':1, 'b':2}?

Trap 1: for i, k in enumerate(d):

enumerate(d) yields index-value pairs where the value is each key, not the key-value pair, so unpacking into i, k never exposes dictionary values. It is tempting because enumerate is genuinely useful for tracking iteration position alongside keys.

Trap 2: for v in d.values(): print(v) -- only values

Iterating d.values() yields only the values, so the keys are never retrieved, failing the requirement to iterate over both. It is tempting because it is a valid, readable way to process values alone when keys are irrelevant.

Study all Computer Programming and Python Fundamentals common traps →

A
for i, k in enumerate(d):
Why it fails: enumerate(d) yields index-value pairs where the value is each key, not the key-value pair, so unpacking into i, k never exposes dictionary values. It is tempting because enumerate is genuinely useful for tracking iteration position alongside keys.
B
for k in d: print(d[k])
Iterating `for k in d` yields each key directly, so `d[k]` retrieves the matching value — covering every key–value pair in `{'a':1, 'b':2}`. This satisfies the requirement to access both keys and values, since the key is bound to `k` and its value printed via subscription.
C
for v in d.values(): print(v) -- only values
Why it fails: Iterating d.values() yields only the values, so the keys are never retrieved, failing the requirement to iterate over both. It is tempting because it is a valid, readable way to process values alone when keys are irrelevant.
D
for k, v in d.items():
Iterating with `d.items()` yields each key–value pair as a tuple, which unpacks directly into `k` and `v`, so both are available in one pass. This satisfies the requirement to iterate over all keys and values simultaneously, unlike `d.keys()` or `d.values()`, which expose only one side.
E
for k in d.keys(): print(d[k])
Iterating `d.keys()` yields each key, then `d[k]` retrieves its paired value, so both keys and values are accessed. This satisfies the requirement to iterate over all keys and values, since every key maps to exactly one value in the dictionary.

Full breakdown with real-world context →

Question 17easymultiple choice

Study the full Python automation breakdown →

Consider the following code:

x = input('Enter a number: ')

print(x + x)

A user enters 5 at the prompt. What is printed?

Exhibit

Refer to the exhibit.
# Python script: convert.py
x = input('Enter number: ')
y = x * 2
print(y)
--- End of exhibit ---

Trap 1: 10

The input() function returns a string, so x holds "5", and adding two strings concatenates them rather than performing arithmetic. The output is "55", not 10. This option tempts because numeric addition is the intuitive reading, and it would be correct had the value been converted with int(x) before adding.

Trap 2: 5

input() returns the string '5', so x + x concatenates to '55', not '5'. The option is tempting because a user typing 5 expects numeric behaviour, and print(x) alone would indeed output 5; the doubling operation is what changes the result.

Trap 3: 25

String concatenation of '5' and '5' yields '55', not the arithmetic product 25. This option tempts anyone assuming input() converts to int automatically, which it never does; int(input()) would be needed before multiplication could produce 25.

Study all Computer Programming and Python Fundamentals common traps →

A
55
`input()` returns a string, so `x` holds `'5'`, not the integer 5. The `+` operator on two strings performs concatenation rather than arithmetic addition, joining `'5'` and `'5'` into `'55'`. No implicit conversion to a number occurs, satisfying the stem's literal input-handling behaviour.
B
10
Why it fails: The input() function returns a string, so x holds "5", and adding two strings concatenates them rather than performing arithmetic. The output is "55", not 10. This option tempts because numeric addition is the intuitive reading, and it would be correct had the value been converted with int(x) before adding.
C
5
Why it fails: input() returns the string '5', so x + x concatenates to '55', not '5'. The option is tempting because a user typing 5 expects numeric behaviour, and print(x) alone would indeed output 5; the doubling operation is what changes the result.
D
25
Why it fails: String concatenation of '5' and '5' yields '55', not the arithmetic product 25. This option tempts anyone assuming input() converts to int automatically, which it never does; int(input()) would be needed before multiplication could produce 25.

Full breakdown with real-world context →

Question 18hardmultiple choice

Study the full Python automation breakdown →

The above JSON is loaded into a Python dictionary named data using json.load(). A developer writes:

print(data['languages'][1][:3])

What is printed?

Exhibit

Refer to the exhibit.
{
  "name": "Alice",
  "age": 30,
  "city": "New York",
  "languages": ["Python", "Java"]
}
--- End of exhibit ---

Trap 1: IndexError

Index 1 is valid.

Trap 2: Java

Slice [:3] gives only 3 chars.

Trap 3: Pyt

Index 0 is 'Python'.

Study all Computer Programming and Python Fundamentals common traps →

A
IndexError
Why it fails: Index 1 is valid.
B
Jav
Indexing `data['languages']` yields the list of language strings, and `[1]` selects the second element, `"Java"`. Slicing that string with `[:3]` returns characters from index 0 up to but excluding index 3, giving `"Jav"`. The slice bound is exclusive, so the fourth character is omitted.
C
Java
Why it fails: Slice [:3] gives only 3 chars.
D
Pyt
Why it fails: Index 0 is 'Python'.

Full breakdown with real-world context →

Continue with 20-question session →

Free account

Track your progress over time

Create a free account to save your results and see which topics improve across sessions.

Focused Computer Programming and Python Fundamentals sessions

Start a Computer Programming and Python Fundamentals only practice session

Every question in these sessions is drawn from the Computer Programming and Python Fundamentals domain — nothing else.

10 questions 20 questions 30 questions 50 questions

Browse all Computer Programming and Python Fundamentals questions →Mixed PCEP session

Frequently asked questions

What does the PCEP exam test about Computer Programming and Python Fundamentals?: You must read short snippets and state exactly what prints, and recognize idiomatic Python naming and structure choices. The single most important thing is to trace expression evaluation and slicing precisely, remembering that slice stops are exclusive and that ** has higher precedence than unary minus.
How should I use these practice questions?: Select your answer before revealing the explanation. Then read why each option is right or wrong — this active recall approach builds retention far faster than re-reading notes.
Can I practise just Computer Programming and Python Fundamentals questions in a focused session?: Yes — the session launcher on this page draws every question from the Computer Programming and Python Fundamentals domain. Use a 10-question session first to gauge your baseline, then move to 20 or 30 once the weak spots are clear.
Where can I practise other PCEP topics?: Use the topic links above to move to related areas, or go back to the PCEP question bank to see all topics.
Are these real exam questions or dumps?: These are original practice questions written to test the same concepts the PCEP exam covers. They are not copied from any real exam or dump site.

Computer Programming and Python Fundamentals only

10 questions 20 questions 30 questions 50 questions

Mixed PCEP session

Track your progress

A free account saves results across sessions and highlights which topics need work.

Study resources

All PCEP questions Computer Programming and Python Fundamentals domain overview PCEP exam guide

Exam traps to avoid

▸Assuming a slice like [-3:-1] includes the last element; the stop index is always excluded, so the final item is dropped.
▸Forgetting that ** binds tighter than unary minus and multiplication, so -2 ** 2 evaluates to -4, not 4.
▸Using camelCase or single-letter names for constants; PEP 8 expects UPPER_CASE_WITH_UNDERSCORES for module-level constants.

Computer Programming and Python Fundamentals practice questions

What to know about Computer Programming and Python Fundamentals

Why Computer Programming and Python Fundamentals questions are commonly missed

Common Computer Programming and Python Fundamentals exam traps

Computer Programming and Python Fundamentals questions

A developer writes a script that prompts the user for their age and stores it in a variable. Which code snippet correctly converts the input to an integer?

Given the code: a = [1, 2, 3]; b = a; b.append(4). What is the value of a?

A student writes the code: x = 10; if x > 5: print("big"); else: print("small"). What is the output?

Which TWO of the following code snippets will result in a SyntaxError? (Choose two.)

A developer writes a Python script that calculates the average of a list of numbers. The script sometimes produces a ZeroDivisionError. Which of the following is the MOST appropriate way to handle this error to keep the script running?

A Python script contains the following line: x = 5. Later in the script, the programmer wants to check if x is an integer. Which of the following is the BEST way to perform this check?

Which TWO of the following are valid Python variable names? (Choose two.)

What is the output of the code in the exhibit?

Exhibit

What is the output of the code in the exhibit?

Exhibit

A Python script uses the following code to open a file: f = open('data.txt', 'w'). The programmer then writes multiple lines to the file. After writing, which of the following is the BEST practice to ensure data integrity?

Match each Python list method to its effect.

A data scientist has a list: scores = [88, 92, 79, 93, 85]. They want to add 5 bonus points to each score and store the new scores. Which code accomplishes this?

A developer wants to extract the file extension from a filename: 'report.pdf'. Which string method will return 'pdf'?

Which THREE of the following will correctly iterate over all keys and values of a dictionary d = {'a':1, 'b':2}?

Exhibit

Exhibit

Track your progress over time

Start a Computer Programming and Python Fundamentals only practice session

Related PCEP topic practice pages

Control Flow, Loops, Lists and Logic practice questions