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

Question 1

Which TWO of the following are valid Python data types?

Accepted Answer

int. `int` is a built-in numeric data type in Python used to represent whole numbers without a fractional component. Python's `int` type has arbitrary precision, meaning it can handle arbitrarily large integers limited only by available memory.

Answer

string

Answer

char

Answer

double

Question 2

Which THREE of the following expressions evaluate to True?

Accepted Answer

3 == int("3"). Option A is correct because int("3") converts the string "3" to the integer 3, and 3 == 3 evaluates to True. Option C is correct because bool(1) returns True since any nonzero integer is truthy in Python. Option E is correct because 3 == 3.0 compares an int and a float with equal numeric value, and Python considers them equal, yielding True. Option B is not correct because "3" == 3 compares a string to an integer, and different types with unequal values evaluate to False. Option D is not correct because bool(0) returns False since zero is falsy in Python.

Answer

"3" == 3

Answer

bool(0)

Question 3

Refer to the exhibit. A beginner Python programmer executes the code and gets an error. What is the most likely cause?

Accepted Answer

The variables x and y are of incompatible types for the + operator. The error occurs when the + operator is used between incompatible types, such as a string (x) and an integer (y). In Python, the + operator performs concatenation for strings and addition for numbers, but mixing types without explicit conversion raises a TypeError. The code likely defines x as a string (e.g., '10') and y as an integer (e.g., 5), causing the error.

Answer

The + operator cannot be used with print()

Answer

The variable y should be converted to an integer using int()

Answer

The print function is misspelled

Question 4

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

Accepted Answer

value_2. Option C, value_2, is a valid Python identifier because it starts with a letter and contains only letters, digits, and underscores, with digits allowed after the first character. Option E, _value, is also valid since a leading underscore is permitted in Python variable names. Option A, for, is invalid because it is a reserved keyword in Python and cannot be used as an identifier. Option B, 2nd_value, is invalid because identifiers cannot begin with a digit. Option D, val-ue, is invalid because hyphens are not allowed in Python identifiers; only underscores may be used as separators.

Answer

for

Answer

2nd_value

Answer

val-ue

Question 5

Which two of the following expressions return the value 5? (Choose two.)

Accepted Answer

10 // 2. Option B, 10 // 2, is correct because // is Python's floor-division operator, and 10 // 2 evaluates to the integer 5. Option E, 5 * 1, is correct because multiplication of 5 by 1 yields the integer 5. Option A, 10 % 5, is not correct because % is the modulo operator and 10 % 5 returns the remainder 0, not 5. Option C, 10 ** 0, is not correct because ** is exponentiation and any nonzero number raised to the power 0 equals 1. Option D, 10 / 2, is not correct because / is true division in Python 3 and returns the float 5.0, not the integer value 5.

Answer

10 % 5

Answer

10 ** 0

Answer

10 / 2

Question 6

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.. 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 7

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).. 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 8

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 (type(x) == int) is correct because type() returns the exact class of the object, so comparing it directly to int confirms x is precisely an integer (and not a bool or subclass). Option D (isinstance(x, int)) is correct because isinstance() checks whether x is an instance of int or any subclass of int, which is the standard, inheritance-aware way to test integer type. Option B (x.isint()) is invalid because Python integers have no isint() method; that method does not exist on int objects. Option C (x.__class__ == int) is not among the marked answers and, while it resembles A, it is not one of the two accepted correct choices here. Option E (int(x) == x) is unreliable because it can succeed for non-integers such as 3.0 (float) or True, since int(3.0) == 3.0 evaluates True, so it does not truly determine integer type.

Answer

x.isint()

Answer

x.__class__ == int

Answer

int(x) == x

Question 9

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())). 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.

Question 10

A developer is writing a program to calculate the average of three test scores. The current code reads scores as integers: a=int(input()); b=int(input()); c=int(input()); avg = (a+b+c)/3; print(avg). For scores 7, 8, and 9, the output is 8.0, but the requirement is to print the integer average (8), rounded to the nearest whole number. Which modification should the developer make to meet the requirement?

Accepted Answer

Use round(avg): print(round(avg)). The requirement is to print the integer average rounded to the nearest whole number. Using `round(avg)` correctly rounds the floating-point result (8.0) to the nearest integer (8) and prints it as an integer, satisfying the requirement. Option D is correct because `round()` performs standard rounding (banker's rounding in Python 3) and returns an integer when called with a single argument.

Answer

Use integer division after multiplying sum

Answer

Use integer division: avg = (a+b+c)//3

Answer

Use int(avg): print(int(avg))

Question 11

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

Accepted Answer

data_1. (data_1) is correct because Python variable names can contain letters, digits, and underscores, but must not start with a digit. 'data_1' starts with a letter and includes an underscore and digit, all of which are allowed.

Answer

for

Answer

2nd_place

Answer

my-var

Question 12

A developer is building a simple calculator that accepts two numbers and an operator string. The code:

x = float(input("First: "))
y = float(input("Second: "))
op = input("Operator (+, -, *, /): ")
if op == "+":
    result = x + y
elif op == "-":
    result = x - y
elif op == "*":
    result = x * y
elif op == "/":
    result = x / y
print("Result:", result)

When the user enters 10, 3, and "/", the output is "Result: 3.3333333333333335". The developer wants to display only two decimal places. Which code change will achieve this without introducing errors?

Accepted Answer

Change print to: print("Result:", format(result, ".2f")). The `format()` function with the format specifier `.2f` converts the floating-point result to a string rounded to two decimal places, which is exactly what the developer needs. This approach does not alter the original variable and works reliably for display purposes.

Answer

Change print to: print("Result: " + str(result)[:4])

Answer

Change print to: print("Result:", result.toFixed(2))

Answer

Change print to: print("Result:", round(result, 2))

Question 13

A beginner Python learner writes a script to swap two numbers:

a = 10
b = 20
a = b
b = a
print("a =", a, "b =", b)

The output is "a = 20 b = 20". The learner expected "a = 20 b = 10". Which of the following is the most Pythonic way to fix the code?

Accepted Answer

Use tuple unpacking: a, b = b, a. Tuple unpacking is the most Pythonic and idiomatic way to swap two variables. It leverages Python's ability to evaluate the right-hand side as a tuple before assignment, so the original values of `a` and `b` are captured simultaneously, avoiding the overwrite issue in the original code.

Answer

Use bitwise XOR: a ^= b; b ^= a; a ^= b

Answer

Use a temporary variable: temp = a; a = b; b = temp

Answer

Use integer arithmetic: a = a + b; b = a - b; a = a - b

Question 14

A programmer is writing a script to read a number, determine if it is even or odd, and then also use the number to calculate its square. The code:

num = input("Enter a number: ")
if num % 2 == 0:
    print("Even")
else:
    print("Odd")
square = num ** 2
print("Square:", square)

When run, a TypeError occurs on the modulo line. Which fix will resolve the error and allow the later calculation to work?

Accepted Answer

Change the input to: num = int(input("Enter a number: ")). The `input()` function always returns a string, and the modulo operator `%` and exponentiation operator `**` require numeric operands. By converting the input to an integer with `int(input(...))`, both the modulo and exponentiation operations work correctly, resolving the TypeError and allowing the square calculation to proceed.

Answer

Change the condition to: if num // 2 == 0:

Answer

Change the condition to: if float(num) % 2 == 0:

Answer

Change the condition to: if int(num) % 2 == 0:

Question 15

A developer is working on a project that requires handling large numbers. They write:

x = 10000000000
y = 3.0
z = x / y
print(int(z))

The output is 3333333333. However, the developer expected 3333333333 (same). But they suspect that integer division might be better. They try:

x = 10000000000
y = 3
z = x // y
print(z)

Output: 3333333333. Both give same. Now they test with negative numbers:

x = -10
y = 3
z1 = x / y
z2 = x // y
print(z1, z2)

The output is -3.3333333333333335 and -4. The developer is confused why z2 is -4 instead of -3. Which of the following explains the behavior?

Accepted Answer

Floor division always rounds down toward negative infinity, so -10 // 3 = -4 because -3.33 floor is -4.. Python's floor division (`//`) always rounds down toward negative infinity, not toward zero. For `-10 // 3`, the exact result is approximately -3.333, and the floor (largest integer ≤ the value) is -4, not -3. This is consistent with the mathematical definition of floor division used in Python. Option B is incorrect because Python's `//` is not truncation; it is floor division, and Python does not have a bug. Options A and D also misstate the behavior.

Answer

The division operator / rounds toward zero, while // rounds toward negative infinity.

Answer

Truncation division always rounds toward zero, so -10 // 3 should be -3, but Python has a bug.

Answer

The result depends on the types; using float y yields different result.