PCEP Practice Test 3 — 30 Questions

Question 1

Which THREE of the following statements about Python operators are true?

Accepted Answer

The not operator is a logical operator that negates a condition.. Option A is correct because 'not' is Python's logical negation operator, returning True for a falsy operand and False for a truthy one, so it negates a condition. Option B is correct because '//' performs floor division, dividing operands and rounding the result down to the nearest integer (e.g., 7 // 2 == 3, and -7 // 2 == -4). Option E is correct because '%' is the modulo operator, returning the remainder of integer or float division (e.g., 7 % 3 == 1). Option C is wrong because '**' is the exponentiation (power) operator, while bitwise XOR is '^'. Option D is wrong because '/' performs true division in Python 3 and always returns a float, even when both operands are integers (e.g., 4 / 2 == 2.0).

Answer

The ** operator is the bitwise XOR operator.

Answer

The / operator always returns an integer if both operands are integers.

Question 2

A developer writes a script to read user input using input() and then prints it. However, the program crashes when the user enters a number. What is the most likely cause?

Accepted Answer

The input is read as a string, but the code treats it as a number without conversion.. The `input()` function in Python 3 always returns a string, regardless of what the user types. If the user enters a number, the program may crash if the code later performs an operation (like arithmetic or comparison) on that string without first converting it to an integer or float using `int()` or `float()`. This mismatch between the string type and the expected numeric type causes a `TypeError`.

Answer

The script uses Python 2, where input() evaluates input as code.

Answer

The print() function expects a string, but the input is a number.

Answer

The input() function cannot handle numeric input.

Question 3

A developer wants to generate a list of squares of integers from 1 to 10 inclusive. Which list comprehension is correct?

Accepted Answer

[x**2 for x in range(1, 11)]. `range(1, 11)` generates integers from 1 to 10 inclusive, and the list comprehension `[x**2 for x in range(1, 11)]` squares each integer, producing the desired list of squares. The `range()` function's stop value is exclusive, so `range(1, 11)` stops at 10, covering all numbers from 1 to 10.

Answer

[x**2 for x in range(11)]

Answer

[x**2 for x in range(10)]

Answer

[x**2 for x in range(1, 10)]

Question 4

A programmer needs to store configuration settings keyed by string, where each key maps to a list of allowed values. Which data structure is most appropriate?

Accepted Answer

A dictionary where keys are strings and values are lists.. A dictionary in Python provides direct key-to-value mapping, making it ideal for storing configuration settings where each string key must map to a list of allowed values. Dictionaries offer O(1) average-time complexity for lookups, which is efficient for retrieving the list of values for a given key. This structure directly models the requirement without unnecessary nesting or indirection.

Answer

A tuple of lists where each list starts with the key.

Answer

A list of tuples where each tuple contains a key and a list of values.

Answer

A set of strings representing the keys, with a separate list for values.

Question 5

A list of numbers is defined as nums = [1, 2, 3, 4, 5]. Which expression returns the last element?

Accepted Answer

nums[-1]. Python uses zero-based indexing, so the first element is at index 0 and the last element is at index -1. Negative indices count from the end of the list, so nums[-1] directly accesses the last element (5) without needing to know the list length.

Answer

nums[5]

Answer

nums[0]

Answer

nums[-2]

Question 6

Which data type is the result of: value = 10 // 3?

Accepted Answer

int. The // operator in Python performs floor division, which divides the left operand by the right operand and returns the largest integer less than or equal to the result. Since both 10 and 3 are integers, the result is an integer (3), not a float. Therefore, the data type of value is int.

Answer

float

Answer

str

Answer

bool

Question 7

What is the result of the expression: (1 and 0) or (not False and True)?

Accepted Answer

True. 1 and 0 evaluates to 0 (falsy). not False evaluates to True, so not False and True evaluates to True. 0 or True evaluates to True (the last truthy value).

Answer

False

Answer

0

Answer

1

Question 8

Refer to the exhibit. What is the output when the code is executed?

Accepted Answer

2 2 2. The code defines a tuple `t = (0, 1, 2)`. The `for` loop iterates over the tuple, but each iteration prints `t[2]`, which is the third element (index 2) with value 2. Since the value is constant, it prints '2' three times. Hence the output is '2 2 2'.

Answer

0 1 2

Answer

0 0 0

Answer

3 3 3

Question 9

Which TWO of the following expressions evaluate to True in Python? (Choose two.)

Accepted Answer

1 == True. Option A (1 == True) is correct because Python's bool is a subclass of int, so True has the integer value 1 and the equality comparison returns True. Option B (0 == False) is correct for the same reason: False has the integer value 0, so comparing it to 0 yields True. Option C ('0' == 0) is not correct because a str and an int are different types and are never equal in Python. Option D (2 == True) is not correct because True equals 1, not 2. Option E (None == False) is not correct because None is a distinct object that is only equal to None, not to False.

Answer

'0' == 0

Answer

2 == True

Answer

None == False

Question 10

What is the output of the following dictionary comprehension?

{x: x**2 for x in range(3)}

Accepted Answer

{0:0, 1:1, 2:4}. The dictionary comprehension `{x: x**2 for x in range(3)}` iterates over `x` values 0, 1, and 2 (from `range(3)`). For each `x`, it creates a key-value pair where the key is `x` and the value is `x**2` (x squared). This produces `{0: 0**2, 1: 1**2, 2: 2**2}`, which evaluates to `{0:0, 1:1, 2:4}`.

Answer

{0:1, 1:2, 2:3}

Answer

{0:0, 1:2, 2:4}

Answer

{1:1, 2:4}

Question 11

What does the following code print?

x = 10
if x > 5:
    if x > 15:
        print("A")
    else:
        print("B")
else:
    print("C")

Accepted Answer

B. The code first checks if x > 5, which is true because x = 10. Then it checks if x > 15, which is false, so the else branch of the inner if-else executes, printing 'B'. The outer else is skipped entirely.

Answer

No output

Answer

C

Answer

A

Question 12

What is the output of the following code? print(type(3.0) == float)

Accepted Answer

True. The expression `type(3.0) == float` compares the result of `type(3.0)` (which is `<class 'float'>`) directly to the `float` class. In Python, `type()` returns the class object, and comparing it with `==` to the built-in class `float` yields `True` because they are the same object. Therefore, `print(True)` outputs `True`.

Answer

Answer

False

Answer

Error

Question 13

A developer writes a function to calculate the average of a list of numbers, but the function sometimes returns a wrong result when the list contains non-numeric values. What is the best way to handle this?

Accepted Answer

Check that all items are numeric before calculation, and raise TypeError otherwise.. It explicitly validates that all items are numeric before performing the calculation, raising a TypeError if any non-numeric value is found. This follows Python's principle of explicit error handling and ensures the function's contract is clear: it only works with numeric data. Returning None (A) or silently ignoring values (B) can lead to subtle bugs, while converting to strings (C) would produce a concatenated string, not an average.

Answer

Return None if any non-numeric value is encountered.

Answer

Use try-except to ignore non-numeric values and proceed with the remaining numbers.

Answer

Convert all values to string and concatenate them.

Question 14

What is the output of the following code?

def greet(name, greeting='Hello'):
    print(greeting, name)

greet('Alice')

Accepted Answer

Hello Alice. The function `greet` has a default parameter `greeting='Hello'`. When called with only one argument (`'Alice'`), the default value is used for `greeting`, so the output is `Hello Alice`. The `print` function outputs both arguments separated by a space.

Answer

Hello

Answer

SyntaxError

Answer

Alice

Question 15

A student writes the following code to calculate the average of two numbers:
```python
num1 = input("Enter first number: ")
num2 = input("Enter second number: ")
avg = (num1 + num2) / 2
print("Average:", avg)
```
When executed, the code raises a TypeError. What is the most likely cause?

Accepted Answer

The input() function returns a string, not a number, so arithmetic operations are invalid without conversion. The `input()` function in Python always returns a string, regardless of what the user types. Attempting to use the `+` operator on two strings performs concatenation, not numeric addition, and then dividing a concatenated string by an integer with `/` raises a `TypeError` because the `/` operator is not defined for strings. To fix this, the inputs must be explicitly converted to numbers using `int()` or `float()` before arithmetic operations.

Answer

The division operator '/' is not allowed for integers

Answer

The addition operator '+' cannot be used with strings

Answer

The variable names num1 and num2 are reserved keywords

Question 16

A developer writes the following code: x = 5; y = 2; print(x // y). What is the output?

Accepted Answer

2. The floor division operator (//) in Python returns the largest integer less than or equal to the result of the division. Since 5 divided by 2 equals 2.5, the floor is 2, and the result is an integer (int) because both operands are integers. Therefore, the output is 2.

Answer

1

Answer

2.0

Answer

2.5

Question 17

Consider code:
def outer():
    x = 1
    def inner():
        nonlocal x
        x = 2
    inner()
    print(x)
outer()
What is printed?

Accepted Answer

2. The `nonlocal` declaration inside `inner()` binds the variable `x` to the `x` defined in the enclosing `outer()` function. When `inner()` assigns `x = 2`, it modifies that outer `x`, so after `inner()` returns, `print(x)` in `outer()` outputs 2.

Answer

1

Answer

Error

Answer

None

Question 18

Order the steps to create and use a list in Python.

Accepted Answer

1. Create a list with brackets: my_list = []
2. Assign it to a variable: my_list = [1, 2, 3]
3. Access elements by index: print(my_list[0])
4. Modify elements by assignment: my_list[0] = 10
5. Grow the list with methods: my_list.append(4). Lists are created with brackets, assigned to variables, accessed by index, modified by assignment, and grown with methods.

Answer

1. Access elements by index: my_list[0]
2. Create a list with brackets: []
3. Assign it to a variable: my_list = []
4. Modify elements by assignment: my_list[0] = 10
5. Grow the list with methods: my_list.append(4)

Answer

1. Create a list with brackets: my_list = []
2. Access elements by index: print(my_list[0])
3. Assign it to a variable: my_list = [1, 2, 3]
4. Modify elements by assignment: my_list[0] = 10
5. Grow the list with methods: my_list.append(4)

Answer

1. Create a list with brackets: my_list = []
2. Assign it to a variable: my_list = [1, 2, 3]
3. Grow the list with methods: my_list.append(4)
4. Access elements by index: print(my_list[0])
5. Modify elements by assignment: my_list[0] = 10

Question 19

A developer runs the following code: x = 0.1; y = 0.2; print(x + y == 0.3). What is the output and why?

Accepted Answer

False, due to floating-point precision. Floating-point numbers in Python (and most programming languages) are stored in binary (IEEE 754 double-precision), and values like 0.1 and 0.2 cannot be represented exactly. The sum 0.1 + 0.2 yields a result slightly greater than 0.3 (approximately 0.30000000000000004), so the equality comparison returns False.

Answer

False, because the + operator is not defined for floats

Answer

True, because Python rounds to 0.3

Answer

True, because Python uses decimal arithmetic

Question 20

Match each Python data structure to its characteristic.

Accepted Answer

List: mutable, ordered, allows duplicates. Python data structures have distinct properties: lists and tuples are ordered sequences (lists mutable, tuples immutable); sets are unordered and contain unique elements; dictionaries map keys to values. Common confusions include mixing mutability/order between lists and tuples, and assuming sets maintain order.

Answer

List: immutable and ordered

Answer

Set: ordered collection of elements