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

Question 1

Which TWO of the following expressions evaluate to True?

Accepted Answer

bool(1). `bool(1)` converts the integer 1 to a Boolean, and in Python any non-zero numeric value is considered truthy, so `bool(1)` returns `True`. Option D is correct because `bool('False')` converts the non-empty string `'False'` to a Boolean; in Python, any non-empty string is truthy, regardless of its textual content, so it returns `True`.

Answer

bool('')

Answer

bool([])

Answer

bool(0)

Question 2

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

Accepted Answer

The not operator is a logical operator that negates a condition.. The `not` operator is a logical operator in Python that returns the Boolean negation of its operand: if the operand is `True`, `not` returns `False`, and vice versa. This is fundamental to Boolean logic and conditional expressions in Python.

Answer

The ** operator is the bitwise XOR operator.

Answer

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

Question 3

Refer to the exhibit. What is the output of the Python code?

Accepted Answer

abcabcabc. The code `print('abc' * 3)` uses the multiplication operator on a string. In Python, multiplying a string by an integer repeats the string that many times, concatenating the copies without any separator. Therefore, `'abc' * 3` produces the string `'abcabcabc'`, which is printed. The correct output is `abcabcabc` (without quotes).

Answer

['abc', 'abc', 'abc']

Answer

abcabc abc

Answer

abc abc abc

Question 4

Refer to the exhibit. Which of the following shows the correct output?

Accepted Answer

3.3333333333333335
3
1. The code `print(10/3)` performs floating-point division in Python 3, yielding `3.3333333333333335`; `print(10//3)` performs floor division, which truncates to the nearest integer less than or equal to the result, giving `3`; and `print(10%3)` computes the remainder of the division, which is `1`.

Answer

3.3333333333333335
4
1

Answer

3.0
3.0
1.0

Answer

3
3
0

Question 5

A developer writes code to compute the average of two numbers entered by the user: x = input('Enter first number: '); y = input('Enter second number: '); avg = (x + y) / 2. The program produces an error. What is the best practice to fix the code?

Accepted Answer

Convert x and y to float before the operation: x = float(input(...)); y = float(input(...)). The `input()` function in Python always returns a string. When you use the `+` operator on two strings, it concatenates them (e.g., '5' + '3' = '53'), not adds them numerically. Dividing a concatenated string by 2 raises a TypeError. The best practice is to convert both inputs to `float` immediately after receiving them, ensuring the subsequent arithmetic works correctly.

Answer

Convert the result to int after the operation: avg = int((x + y) / 2)

Answer

Use int() on the input() values: x = int(input(...)); y = int(input(...))

Answer

Use type casting in the division: avg = (float(x) + float(y)) / 2

Question 6

A developer writes: x = 5; y = 2.0; z = x / y; print(type(z)). What is the output?

Accepted Answer

. In Python, the division operator (/) always returns a float, even when dividing two integers. Here, x is an integer (5) and y is a float (2.0), so the result is a float (2.5). The type() function returns , making D correct.

Answer

Answer

Answer

TypeError

Question 7

A program contains this code: print(1 and 2 or 3). What is the output?

Accepted Answer

2. In Python, the `and` and `or` operators short-circuit and return the last evaluated operand, not a boolean. `1 and 2` evaluates to `2` because both are truthy and `and` returns the last truthy value. Then `2 or 3` short-circuits because `2` is truthy, so `or` returns `2` without evaluating `3`. Thus, the output is `2`.

Answer

3

Answer

1

Answer

True

Question 8

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 9

A developer wants to store a person's age. Which of these variable names is invalid?

Accepted Answer

3rd_age. In Python, variable names must start with a letter or an underscore, not a digit. Option B (`3rd_age`) begins with a digit, which violates Python's identifier naming rules and will raise a `SyntaxError` if used in code.

Answer

_age

Answer

Age

Answer

age_3

Question 10

A developer writes: num = input('Enter a number: '); result = num * 2; print(result). If the user enters 5, what is the output?

Accepted Answer

55. The `input()` function always returns a string. When the user enters '5', `num` is the string '5', not the integer 5. The `*` operator on a string performs repetition, so `'5' * 2` produces '55', which is printed as 55.

Answer

Error: cannot multiply string by int

Answer

10

Answer

'5' * 2

Question 11

A developer needs to check if a variable x is between 10 and 20 (inclusive). Which expression is correct?

Accepted Answer

10 <= x <= 20. Python supports chained comparison operators, allowing `10 <= x <= 20` to evaluate whether `x` is between 10 and 20 inclusive. This expression is equivalent to `(10 <= x) and (x <= 20)`, which checks both boundaries simultaneously.

Answer

x > 10 and x < 20

Answer

x < 10 and x < 20

Answer

x >= 10 or x <= 20

Question 12

What is the output of: print(10 // 3, 10 % 3)?

Accepted Answer

3 1. The // operator performs floor division, returning the integer quotient (10 // 3 = 3), and the % operator returns the remainder (10 % 3 = 1). The print function outputs these two values separated by a space.

Answer

3.3333 1

Answer

3.0 1.0

Answer

1 3

Question 13

A developer accidentally wrote: print('Hello' + 5). What happens?

Accepted Answer

It raises a TypeError. In Python, the `+` operator is overloaded for string concatenation only when both operands are strings. Attempting to concatenate a string (`'Hello'`) with an integer (`5`) violates Python's strong dynamic typing rules, which do not perform implicit type coercion for this operation. This raises a `TypeError` with a message like 'can only concatenate str (not "int") to str'.

Answer

It prints 'Hello' and ignores the 5

Answer

It prints a warning but still runs

Answer

It prints 'Hello5'

Question 14

Which TWO of the following Python data types are mutable?

Accepted Answer

list. Lists in Python are mutable, meaning their elements can be changed, added, or removed after creation. This is a fundamental property of the list type, which supports operations like append(), extend(), and item assignment.

Answer

str

Answer

tuple

Answer

int

Question 15

Which THREE of the following are valid Python variable names?

Accepted Answer

myVar2. Python variable names must start with a letter or underscore, and can contain letters, digits, and underscores. 'myVar2' begins with a letter and uses only valid characters, making it a legal identifier.

Answer

my-var

Answer

2ndValue