PCEP Practice Test 8 — 10 Questions

Question 1

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 2

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 3

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 4

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 5

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 6

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 7

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 8

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 9

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 10

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