PCEP Data Types, Variables, Basic I/O and Operators Practice Test 12 — 15 Questions

Question 1

A junior developer created a Python script to calculate the average of three quiz scores entered by the user. The script reads three numbers using input(), converts them to float, calculates the sum, and divides by 3. However, when a user enters a non-numeric value like 'ten', the script crashes with a ValueError. The developer needs to modify the script to handle such errors gracefully, allowing the user to re-enter the invalid input until a valid number is provided. Which approach should the developer implement to meet this requirement most effectively while following Python best practices?

Accepted Answer

Implement a while True loop that attempts to convert the input inside a try block. If successful, break out of the loop; if ValueError occurs, print an error message and continue the loop.. Option A is correct because it uses a `while True` loop with a `try` block to repeatedly attempt conversion of user input to `float`. If a `ValueError` is raised (e.g., for non-numeric input like 'ten'), the exception is caught, an error message is printed, and the loop continues until valid input is provided. This pattern follows Python best practices for input validation by separating the conversion logic from the loop control and avoiding reliance on fragile string checks like `.isdigit()`.

Answer

Use an if statement to check if the input is numeric using .isdigit(), and if not, ask again.

Answer

Use a try-except block to catch ValueError and prompt the user again, looping until valid input is provided.

Answer

Use a function that returns a default value of 0 if the input is invalid, to avoid script crashes.

Question 2

A system administrator wrote a Python script to monitor disk usage. The script reads the output of a system command that returns a string like 'Used: 45%' and extracts the percentage. The code uses slicing to get the numeric part and converts to int. However, on some servers, the output format changes to 'Used: 45.2%', causing a ValueError when converting to int. The administrator needs a robust solution that works with both integer and floating-point percentages while still producing an integer result (e.g., 45 for 45.2%). Which option is the best approach?

Accepted Answer

Use a try-except block to attempt int conversion first; if a ValueError occurs, convert to float and then convert to int (which truncates the decimal part).. Option D is correct because it uses a try-except block to first attempt int conversion for integer percentages, and if a ValueError occurs (due to a decimal point), it converts to float and then to int, which truncates the decimal part. This approach handles both '45%' and '45.2%' formats without raising an error, producing an integer result as required.

Answer

Use string splitting to extract the numeric part, then convert to float and round to the nearest integer.

Answer

Use a regular expression to extract the number and convert to float, then convert to int.

Answer

Use the .replace() method to remove the '%' character and then convert to int.

Question 3

A beginner writes: x = 10; y = "20"; print(x + y). What will happen?

Accepted Answer

It raises a TypeError. Option D is correct because Python does not allow implicit type conversion between a string and an integer in an addition operation. The `+` operator with a string and an integer raises a `TypeError`, as Python's dynamic typing requires explicit conversion (e.g., `int(y)` or `str(x)`) for such mixed-type operations.

Answer

It prints 30 as a string

Answer

It prints 1020

Answer

It prints 30

Question 4

A program calculates BMI. User inputs weight and height as strings. Which line correctly converts to float?

Accepted Answer

weight = float(input()). Option C is correct because `float(input())` first reads the user's input as a string via `input()`, then converts that string to a floating-point number using the `float()` function. This is the standard Python pattern for converting user input to a numeric type.

Answer

weight = float(input)

Answer

weight = input().float()

Answer

weight = input(float())

Question 5

After executing: a = 5; b = 2; c = a // b; d = a % b; e = a ** b. What is the value of (c + d) * 2 - e?

Accepted Answer

-19. After executing the code, a=5, b=2, c=5//2=2 (floor division), d=5%2=1 (remainder), e=5**2=25 (exponentiation). Then (c+d)*2-e = (2+1)*2-25 = 3*2-25 = 6-25 = -19. Option B is correct because it matches this calculation.

Answer

-20

Answer

-11

Answer

-15

Question 6

Which of the following is NOT a valid variable name in Python?

Accepted Answer

2nd_var. Option C is correct because Python variable names cannot start with a digit. The name '2nd_var' begins with '2', which violates Python's identifier naming rules. Valid variable names must start with a letter (a-z, A-Z) or an underscore (_), and can be followed by letters, digits, or underscores.

Answer

_myvar

Answer

myVar2

Answer

my_var

Question 7

A developer needs to read an integer from user input and store it. Which code snippet accomplishes this?

Accepted Answer

x = int(input()). Option A is correct because `int(input())` first calls `input()` to read a string from the user, then passes that string to `int()` to convert it to an integer. This is the standard Python pattern for reading an integer from standard input.

Answer

x = read_int()

Answer

x = input(int())

Answer

x = int(input)

Question 8

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 9

Which operator is used for integer division in Python?

Accepted Answer

//. Option D is correct because the // operator in Python performs floor division, which returns the integer quotient after dividing two numbers, discarding any fractional remainder. For example, 7 // 2 yields 3, not 3.5, making it the explicit integer division operator.

Answer

%

Answer

**

Answer

/

Question 10

A program prints a greeting: name = input("Enter name: "); print("Hello, " + name + "!"). If user enters "Alice", what is output?

Accepted Answer

Hello, Alice!. Option A is correct because the `print` function concatenates the string literals and the variable `name` using the `+` operator exactly as specified. When the user enters "Alice", the expression `"Hello, " + name + "!"` becomes `"Hello, Alice!"` — the space after the comma is part of the first string literal, and the exclamation mark is part of the last string literal, producing the output exactly as shown in option A.

Answer

Hello,Alice !

Answer

Hello,Alice!

Answer

Hello, Alice !

Question 11

Consider: x = True; y = False; z = x and not y or x. What is the value of z?

Accepted Answer

True. The expression `x and not y or x` is evaluated with operator precedence: `not` has the highest precedence, then `and`, then `or`. Given `x = True` and `y = False`, `not y` evaluates to `True`. Then `x and True` is `True and True`, which is `True`. Finally, `True or x` (where `x` is `True`) short-circuits to `True`. Thus, `z` is `True`.

Answer

None

Answer

Error

Answer

False

Question 12

Which TWO of the following are valid ways to determine if a variable 'x' is an integer? (Select two.)

Accepted Answer

type(x) == int. Option A is correct because the `type()` function returns the type of the object, and comparing it directly to `int` checks if the variable is exactly an integer. This is a straightforward and reliable way to test the type in Python.

Answer

x.isint()

Answer

x.__class__ == int

Answer

int(x) == x

Question 13

Which THREE of the following expressions evaluate to the integer 1? (Select three.)

Accepted Answer

int(1.0). Option A is correct because `int(1.0)` explicitly converts the float `1.0` to an integer by truncating the decimal part, yielding the integer `1`. This is a standard type conversion function in Python.

Answer

True == 1

Answer

1 * 1.0

Question 14

Which TWO of the following expressions evaluate to 0? (Select two.)

Accepted Answer

False * 1. Option A is correct because in Python, `False` is treated as 0 in arithmetic contexts, so `False * 1` evaluates to `0 * 1 = 0`. Option D is correct because `int(0.5)` truncates the decimal part toward zero, resulting in the integer 0.

Answer

5 // 2 * 2

Answer

True == 0

Answer

5 % 2

Question 15

A company runs a script that processes user input temperatures. The script expects integers but sometimes users enter floats. The current code is: temp = int(input("Enter temperature: ")). When a user enters "36.5", the script crashes with a ValueError. The developer needs to modify the script to handle both integer and float inputs gracefully, converting the input to an integer (by truncation) for processing. Which of the following is the best course of action?

Accepted Answer

Use temp = int(float(input())). Option A is correct because it first converts the input string to a float (handling both integer and float strings), then truncates the float to an integer via int(). This gracefully processes inputs like '36.5' without crashing, meeting the requirement to truncate rather than round.

Answer

Use input with a regex check to ensure only integers are entered.

Answer

Use a try-except block to catch ValueError and ask the user to re-enter.

Answer

Use float(input()) and do not convert to int, store as float.