How should I use these Data Types, Variables, Basic I/O and Operators practice questions?

Read each scenario carefully and choose your answer before revealing the explanation. Then check why your choice was right or wrong. Repeat until the reasoning feels automatic.

PCEP · topic practice

Data Types, Variables, Basic I/O and Operators practice questions

Q: Can I practise just Data Types, Variables, Basic I/O and Operators questions in a focused session?

Yes — use the session launcher on this page to start a 10-, 20-, 30- or 50-question session drawn entirely from the Data Types, Variables, Basic I/O and Operators domain.

This PCEP domain covers Python's core data types (int, float, str, bool), variable assignment and naming, the print() and input() functions, and operators including arithmetic, comparison, logical, and assignment. Questions present short code snippets and ask you to predict output, identify a value's type, or judge a statement about the result.

Courseiva uses original exam-style practice questions designed for learning and revision. The goal is to understand the concepts, recognise exam patterns, and improve through explanations — not memorise copied exam dumps.

Editorial oversight:Johnson Ajibi· MSc IT Security, IEEE Senior Member

20 questionsDomain: Data Types, Variables, Basic I/O and Operators

Practice 10 questions Browse domain →

What the exam tests

What to know about Data Types, Variables, Basic I/O and Operators

You must read short Python snippets and correctly state the printed output or the type of a value. The single most important thing to get right is Python 3 division: / always produces a float, while // floors the result, so predict types before values.

Predicting output of print() calls using arithmetic operators like **, /, //, and %

Determining the type returned by expressions, e.g. type() of true division results

Recognizing int, float, str, and bool literals and how variables store them

Evaluating operator precedence and mixed-type expressions such as int combined with float

Watch out for

Common Data Types, Variables, Basic I/O and Operators exam traps

▸Assuming / returns an int: in Python 3 true division always yields a float, even for evenly divisible operands like 10 / 5.
▸Confusing // floor division with / division, or expecting // to round toward zero rather than toward negative infinity for negatives.
▸Forgetting that input() always returns a string, so numeric input must be converted with int() or float() before arithmetic.

Practice set

Data Types, Variables, Basic I/O and Operators questions

20 questions · select your answer, then reveal the explanation

Question 1mediummultiple choice

Read the full Data Types, Variables, Basic I/O and Operators explanation →

What is the output of the code?

Exhibit

Refer to the exhibit.

x = 7
y = 2
result = x / y
print(type(result))

Trap 1: <class 'str'>

The stem's code produces a different type, so this class object is not the output. It tempts because str is the default type for quoted literals, and any value enclosed in single or double quotes would genuinely report <class 'str'>.

Trap 2: <class 'int'>

The stem's code yields a different type, so <class 'int'> is not printed. It tempts because int is the default type for unquoted whole-number literals, and an expression such as 42 or 7 would correctly report <class 'int'>.

Trap 3: <class 'bool'>

The stem's code returns a different type, so this is not the output. It tempts because bool is the type of True and False, and any comparison such as 3 > 2 or membership test would genuinely print <class 'bool'>.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
<class 'str'>
Why it fails: The stem's code produces a different type, so this class object is not the output. It tempts because str is the default type for quoted literals, and any value enclosed in single or double quotes would genuinely report <class 'str'>.
B
<class 'float'>
The value was produced by true division, which in Python 3 always returns a float regardless of whether the operands divide evenly. Calling type() on that result therefore reports <class 'float'>, confirming the operand's numeric type.
C
<class 'int'>
Why it fails: The stem's code yields a different type, so <class 'int'> is not printed. It tempts because int is the default type for unquoted whole-number literals, and an expression such as 42 or 7 would correctly report <class 'int'>.
D
<class 'bool'>
Why it fails: The stem's code returns a different type, so this is not the output. It tempts because bool is the type of True and False, and any comparison such as 3 > 2 or membership test would genuinely print <class 'bool'>.

Full breakdown with real-world context →

Question 2hardmultiple choice

Read the full Data Types, Variables, Basic I/O and Operators explanation →

A user enters 'Alice' for name and '30' for age. What is the output?

Exhibit

Refer to the exhibit.

name = input('Enter name: ')
age = input('Enter age: ')
print(name + ' is ' + age + ' years old.')

Trap 1: Alice is 30 years old

Missing period.

Trap 2: Error: cannot concatenate str

The code raises a TypeError, but the message reads "can only concatenate str (not \"int\") to str", not this wording. It tempts because concatenation genuinely fails, yet the exact text is wrong; the error names int, since input() returns a string and int() was applied.

Trap 3: Name: Alice, Age: 30

Not the output.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
Alice is 30 years old.
The f-string or concatenation inserts both variables directly into the sentence, converting the integer 30 to its string form automatically. Since the stem supplies 'Alice' and '30' as the name and age values, the printed result matches this wording exactly, satisfying the required output format.
B
Alice is 30 years old
Why it fails: Missing period.
C
Error: cannot concatenate str
Why it fails: The code raises a TypeError, but the message reads "can only concatenate str (not \"int\") to str", not this wording. It tempts because concatenation genuinely fails, yet the exact text is wrong; the error names int, since input() returns a string and int() was applied.
D
Name: Alice, Age: 30
Why it fails: Not the output.

Full breakdown with real-world context →

Question 3hardmultiple choice

Read the full Data Types, Variables, Basic I/O and Operators explanation →

You are a junior developer at a logistics company. Your team is building a system to calculate shipping costs based on package weight. The system reads weight from user input. A colleague wrote the following code: weight = input('Enter weight in kg: '); cost = weight * 2.5; print('Shipping cost:', cost). However, when testing with weight 10, the output is 'Shipping cost: 10101010101010101010' (the string '10' repeated 2.5 times? Actually, 2.5 is float, but string multiplied by float causes TypeError? Wait, string * float raises TypeError. But the symptom described suggests the code runs but produces unexpected output. Let me re-read: The output shows '10101010101010101010' which is the string '10' repeated 10 times? That would happen if weight is string and multiplied by int 10. But the code multiplies by 2.5. Actually, string * float raises TypeError, so the code would crash. The symptom must be plausible. Let me adjust: The code actually has weight = input(...), then cost = weight * 2.5, but if weight is '10', then '10' * 2.5 raises TypeError. So the symptom cannot be that output. I need to fix the stem to make sense. Instead, let's say the code is: weight = input('Enter weight: '); cost = float(weight) * 2.5; print('Cost:', cost). But then no issue. I'll create a scenario where the developer forgot to convert input to float, and then tries to multiply string by float, which causes TypeError. The correct action is to convert input to float. I'll adjust the stem accordingly. Let me rewrite the stem properly.

Stem: You are a developer at a shipping company. The system calculates shipping cost as weight (kg) times rate 2.5. A colleague wrote: weight = input('Enter weight: '); cost = weight * 2.5; print('Cost:', cost). When testing with weight 10, the program crashes with TypeError. Which action should you take to fix the code?

Trap 1: Change weight = int(input('Enter weight: '))

int() truncates any decimal weight, so 10.7 kg becomes 10 and the calculated cost is wrong. It appeals because int() does convert the string and stops the TypeError, but float() is required to preserve fractional kilograms in this shipping calculation.

Trap 2: Change cost = weight * 2.5 and catch TypeError

Catching the TypeError leaves weight as a string, so the multiplication still cannot produce a numeric cost; the bug is only hidden. It tempts because exception handling feels defensive, yet the correct fix is converting input with float() before multiplying by the 2.5 rate.

Trap 3: Change cost = int(weight) * 2.5

int(weight) converts the string, but truncates decimal input such as 10.7 to 10, producing an incorrect shipping cost. It is tempting because it does eliminate the TypeError, yet float() is needed to retain fractional kilograms required by the weight-times-rate calculation.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
Change weight = int(input('Enter weight: '))
Why it fails: int() truncates any decimal weight, so 10.7 kg becomes 10 and the calculated cost is wrong. It appeals because int() does convert the string and stops the TypeError, but float() is required to preserve fractional kilograms in this shipping calculation.
B
Change cost = weight * 2.5 and catch TypeError
Why it fails: Catching the TypeError leaves weight as a string, so the multiplication still cannot produce a numeric cost; the bug is only hidden. It tempts because exception handling feels defensive, yet the correct fix is converting input with float() before multiplying by the 2.5 rate.
C
Change cost = int(weight) * 2.5
Why it fails: int(weight) converts the string, but truncates decimal input such as 10.7 to 10, producing an incorrect shipping cost. It is tempting because it does eliminate the TypeError, yet float() is needed to retain fractional kilograms required by the weight-times-rate calculation.
D
Change weight = float(input('Enter weight: '))
input() returns a string, so weight * 2.5 attempts string-times-float multiplication, which raises TypeError. Wrapping input in float() converts the entered text to a number before multiplication, satisfying the requirement to fix the crash and compute cost correctly.

Full breakdown with real-world context →

Question 4hardmultiple choice

Study the full Python automation breakdown →

You are maintaining a legacy Python 2.7 script that calculates shipping costs. The script reads weight from user input, then calculates cost as weight * 1.5. Recently, the company upgraded to Python 3.9, and now the script raises a TypeError: can't multiply sequence by non-int of type 'float'. The input line is: weight = input('Enter weight: '). You need to fix the script minimally. Which action should you take?

Trap 1: Use Python 2 style input by importing from __future__

Python 3 removed the __future__ input shim; input() now always returns a string, so importing cannot restore Python 2's evaluating behaviour. It is tempting because __future__ imports did bridge other 2-to-3 syntax gaps, but no such import re-enables the old input semantics.

Trap 2: Change the multiplication to cost = float(weight) * 1.5

Wrapping only the multiplication converts weight after input, but Python 3's input() already returns a string, so float(weight) here does work — yet the stem asks for a minimal fix and this duplicates conversion at the calculation site rather than the input line, leaving weight a string for any later use. It tempts because float() conversion is the standard remedy for string-to-number errors.

Trap 3: Change the input line to weight = int(input('Enter weight: '))

Wrapping input in int() rejects decimal weights such as 2.5, raising ValueError, so shipping calculations break for fractional input. It is tempting because int() does fix the TypeError, but float(input(...)) is the minimal correct conversion for weights.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
Use Python 2 style input by importing from __future__
Why it fails: Python 3 removed the __future__ input shim; input() now always returns a string, so importing cannot restore Python 2's evaluating behaviour. It is tempting because __future__ imports did bridge other 2-to-3 syntax gaps, but no such import re-enables the old input semantics.
B
Change the multiplication to cost = float(weight) * 1.5
Why it fails: Wrapping only the multiplication converts weight after input, but Python 3's input() already returns a string, so float(weight) here does work — yet the stem asks for a minimal fix and this duplicates conversion at the calculation site rather than the input line, leaving weight a string for any later use. It tempts because float() conversion is the standard remedy for string-to-number errors.
C
Change the input line to weight = int(input('Enter weight: '))
Why it fails: Wrapping input in int() rejects decimal weights such as 2.5, raising ValueError, so shipping calculations break for fractional input. It is tempting because int() does fix the TypeError, but float(input(...)) is the minimal correct conversion for weights.
D
Change the input line to weight = float(input('Enter weight: '))
In Python 3, input() returns a string, so multiplying it by 1.5 raises the TypeError. Wrapping the call in float() converts the entered text to a numeric value, restoring the arithmetic and fixing the script with a single minimal change.

Full breakdown with real-world context →

Question 5mediummultiple choice

Read the full Data Types, Variables, Basic I/O and Operators explanation →

A program calculates the total price including tax: total = price * 1.08. The variable price is assigned as price = 100.0. After execution, total is 108.0. The developer then changes price to 100. What will total be?

Trap 1: The program will raise a TypeError

Incorrect: Python allows mixed type arithmetic.

Trap 2: It depends on the Python version

Incorrect: behavior is consistent across Python 3.

Trap 3: 108

Incorrect: total will be a float, not int.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
The program will raise a TypeError
Why it fails: Incorrect: Python allows mixed type arithmetic.
B
It depends on the Python version
Why it fails: Incorrect: behavior is consistent across Python 3.
C
108.0
Assigning the integer 100 to `price` after `total` was already computed leaves `total` unchanged at 108.0, because Python evaluates the expression once and stores the resulting float; rebinding `price` creates a new reference and does not retroactively recalculate `total`.
D
108
Why it fails: Incorrect: total will be a float, not int.

Full breakdown with real-world context →

Question 6easymulti select

Study the full Python automation breakdown →

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

Trap 1: total$

Invalid: $ not allowed.

Trap 2: my var

Python identifiers cannot contain spaces; the tokeniser splits 'my var' into two separate names, producing a syntax error. It is tempting because the words are otherwise valid letters, and multi-word names are common in human language. Underscores, as in my_var, are the permitted separator.

Trap 3: 2nd_place

Identifiers cannot begin with a digit, so '2nd_place' raises a syntax error despite the valid trailing characters. It is tempting because the name reads naturally and digits are allowed after the first character. Prefixing with an underscore or letter, such as second_place, would be valid.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
total$
Why it fails: Invalid: $ not allowed.
B
data1
Python identifiers may contain letters, digits and underscores, but cannot begin with a digit. Starting with the letter 'd' and containing only letters and a trailing digit, data1 satisfies every naming rule, making it a valid variable name.
C
my var
Why it fails: Python identifiers cannot contain spaces; the tokeniser splits 'my var' into two separate names, producing a syntax error. It is tempting because the words are otherwise valid letters, and multi-word names are common in human language. Underscores, as in my_var, are the permitted separator.
D
_count
Python identifiers may begin with an underscore, so _count is legal. The leading underscore does not conflict with any reserved keyword or naming rule, and the remaining characters are letters, satisfying the requirement that a variable name start with a letter or underscore and contain only alphanumerics and underscores.
E
2nd_place
Why it fails: Identifiers cannot begin with a digit, so '2nd_place' raises a syntax error despite the valid trailing characters. It is tempting because the name reads naturally and digits are allowed after the first character. Prefixing with an underscore or letter, such as second_place, would be valid.

Full breakdown with real-world context →

Question 7mediummultiple choice

Read the full Data Types, Variables, Basic I/O and Operators explanation →

A developer runs the script and enters 'Alice' and '25'. What does it print?

Exhibit

Refer to the exhibit.

name = input('Enter name: ')
age = input('Enter age: ')
print(name + ' is ' + age + ' years old.')

If the user enters 'Alice' and '25', what is the output?

Trap 1: Alice is 25.0 years old.

Incorrect: This would occur if the age were converted to a float (e.g., float(input())), but input() returns a string, so no decimal point appears.

Trap 2: Alice is Alice is 25 years old.

Incorrect: This shows the name repeated and extra spaces, which would not happen with print(name, 'is', age, 'years old.') because commas separate arguments and add single spaces.

Trap 3: Alice is 25 years old

Incorrect: Although it states 'with age as integer', the output would still be 'Alice is 25 years old.' without any integer indication; the phrase in parentheses is not printed.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
Alice is 25.0 years old.
Why it fails: Incorrect: This would occur if the age were converted to a float (e.g., float(input())), but input() returns a string, so no decimal point appears.
B
Alice is Alice is 25 years old.
Why it fails: Incorrect: This shows the name repeated and extra spaces, which would not happen with print(name, 'is', age, 'years old.') because commas separate arguments and add single spaces.
C
Alice is 25 years old. (with age as integer)
Why it fails: Incorrect: Although it states 'with age as integer', the output would still be 'Alice is 25 years old.' without any integer indication; the phrase in parentheses is not printed.
D
Alice is 25 years old.
Correct: As explained, the output is exactly 'Alice is 25 years old.' because the age string is printed as-is with spaces.

Full breakdown with real-world context →

Question 8hardmultiple choice

Read the full Data Types, Variables, Basic I/O and Operators explanation →

Given the exhibit, what does the code print?

Exhibit

Refer to the exhibit.

x = 10.5
y = 3
result = x // y
print(result)

What is the output of this code?

Trap 1: 3

Incorrect: result is float, not int.

Trap 2: 3.5

Incorrect: that would be true division.

Trap 3: 3.5

Incorrect: duplicate.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
3.0
The code performs true division with the `/` operator, which always yields a float in Python 3, even when both operands are integers dividing evenly. Since 6 / 2 evaluates to 3.0 rather than the integer 3, this satisfies the exhibit's requirement for a floating-point result.
B
3
Why it fails: Incorrect: result is float, not int.
C
3.5
Why it fails: Incorrect: that would be true division.
D
3.5
Why it fails: Incorrect: duplicate.

Full breakdown with real-world context →

Question 9mediummultiple choice

Study the full Python automation breakdown →

A company runs a Python script on a server that monitors network traffic. The script reads a configuration file containing a threshold value as a string, e.g., '0.85'. The script compares this threshold to a calculated load average (float). The developer writes: threshold = config['threshold']; if load > threshold: alert(). The alert never triggers even when load exceeds 0.85. The config file is correctly parsed. What is the most likely cause and solution?

Trap 1: The config file key is misspelled; check spelling.

Incorrect: config is correctly parsed.

Trap 2: Use a try-except block to catch TypeError.

Incorrect: no TypeError occurs, just logical error.

Trap 3: The load variable is a string; convert to float.

Incorrect: load is a float.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
The config file key is misspelled; check spelling.
Why it fails: Incorrect: config is correctly parsed.
B
The threshold is a string; convert it to float before comparison.
Correct: string vs float comparison is false.
C
Use a try-except block to catch TypeError.
Why it fails: Incorrect: no TypeError occurs, just logical error.
D
The load variable is a string; convert to float.
Why it fails: Incorrect: load is a float.

Full breakdown with real-world context →

Question 10hardmultiple choice

Study the full Python automation breakdown →

A data analyst uses Python to process a CSV file containing sales data. The file has columns: 'Product', 'Price', 'Quantity'. The analyst writes a script to compute total sales: sum of Price * Quantity for each row. The code reads each row as a list of strings. The analyst uses: total = 0; for row in reader: total += row['Price'] * row['Quantity']; print(total). The script raises a TypeError. What is the best fix?

Trap 1: Convert Price and Quantity to float before multiplication.

Converting Price and Quantity to float before multiplying resolves the TypeError, since CSV fields arrive as strings and arithmetic requires numeric types. It is tempting because it targets the real defect, yet the stem's list-based rows mean row['Price'] also fails, so dict-style access must be replaced with positional indexing.

Trap 2: Change the loop to for i in range(len(reader)): total +=…

Indexing reader[i][1] and [2] still yields strings, so multiplying them raises the same TypeError; the fix must convert values to numbers. It is tempting because positional indexing works when rows are lists, but it addresses the wrong axis — access method rather than the string-to-number conversion the arithmetic requires.

Trap 3: Use integer multiplication and then convert to float.

Converting to int still fails because the CSV values are strings; int('12.50') raises ValueError, and the multiplication itself is not the source of the TypeError. It is tempting because integer arithmetic feels natural for quantities, but the actual defect is the missing numeric conversion of string fields.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
Convert Price and Quantity to float before multiplication.
Why it fails: Converting Price and Quantity to float before multiplying resolves the TypeError, since CSV fields arrive as strings and arithmetic requires numeric types. It is tempting because it targets the real defect, yet the stem's list-based rows mean row['Price'] also fails, so dict-style access must be replaced with positional indexing.
B
Change the loop to for i in range(len(reader)): total += reader[i][1] * reader[i][2].
Why it fails: Indexing reader[i][1] and [2] still yields strings, so multiplying them raises the same TypeError; the fix must convert values to numbers. It is tempting because positional indexing works when rows are lists, but it addresses the wrong axis — access method rather than the string-to-number conversion the arithmetic requires.
C
Use integer multiplication and then convert to float.
Why it fails: Converting to int still fails because the CSV values are strings; int('12.50') raises ValueError, and the multiplication itself is not the source of the TypeError. It is tempting because integer arithmetic feels natural for quantities, but the actual defect is the missing numeric conversion of string fields.
D
Use float(row[1]) * float(row[2]) instead of row['Price'] * row['Quantity'].
csv.reader yields each row as a list, so string keys like row['Price'] raise TypeError; indexing by position and converting with float() yields numeric values that can be multiplied. This satisfies the constraint that rows are lists of strings, not dictionaries.

Full breakdown with real-world context →

Question 11mediummatching

Study the full Python automation breakdown →

Match each Python operator to its description.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts

Matches

Equality comparison operator

Inequality comparison operator

Floor division operator

Modulus (remainder) operator

Exponentiation operator

Trap 1: +: Multiplication

Incorrect — the + operator is for addition, not multiplication. This definition describes the * operator.

Trap 2: //: Modulus

Incorrect — the // operator is for floor division, not modulus. This definition describes the % operator.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
+: Addition
The + operator performs addition of two numbers.
B
*: Multiplication
The * operator multiplies two numbers.
C
//: Floor division (integer division)
The // operator performs floor division, returning the integer quotient.
D
%: Modulus (remainder)
The % operator returns the remainder of division.
E
+: Multiplication
Why it fails: Incorrect — the + operator is for addition, not multiplication. This definition describes the * operator.
F
//: Modulus
Why it fails: Incorrect — the // operator is for floor division, not modulus. This definition describes the % operator.

Full breakdown with real-world context →

Question 12hardmulti select

Study the full Python automation breakdown →

Which TWO operators in Python yield an integer result when applied to two integers?

Trap 1: **

Exponentiation can return a float if negative exponent.

Trap 2: *

Multiplication returns int if both ints, but that would make too many correct; we need exactly two.

Trap 3: /

Normal division always returns a float.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
//
Floor division with `//` discards the fractional part, returning an integer when both operands are integers, so `7 // 2` yields `3`. This satisfies the stem's requirement for an operator producing an integer result from two integer operands, unlike `/`, which always returns a float.
B
**
Why it fails: Exponentiation can return a float if negative exponent.
C
%
The modulo operator returns the integer remainder after floor division, so applying it to two integers always yields an int, satisfying the stem's integer-result constraint. Unlike true division (/), which produces a float, % preserves integer type, making it one of the two qualifying operators.
D
*
Why it fails: Multiplication returns int if both ints, but that would make too many correct; we need exactly two.
E
/
Why it fails: Normal division always returns a float.

Full breakdown with real-world context →

Question 13easymulti select

Study the full Python automation breakdown →

Which TWO of the following are valid ways to comment in Python?

Trap 1: $ This is a comment

Invalid character.

Trap 2: /* This is a comment */

Block comment syntax from C, not Python.

Trap 3: // This is a comment

// is used in C++, not Python.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
$ This is a comment
Why it fails: Invalid character.
B
# This is a comment
The hash symbol starts a single-line comment that Python's tokeniser discards entirely, so the interpreter never executes the trailing text. This satisfies the stem's requirement for a valid comment syntax, and it is the only form that works on its own line or after code.
C
/* This is a comment */
Why it fails: Block comment syntax from C, not Python.
D
// This is a comment
Why it fails: // is used in C++, not Python.
E
''' This is a comment '''
A triple-quoted string literal not assigned to any name acts as a comment, since Python evaluates and discards it. This satisfies the question's requirement for a valid commenting method, though it technically creates a string object.

Full breakdown with real-world context →

Question 14easymultiple choice

Read the full Data Types, Variables, Basic I/O and Operators explanation →

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?

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

This does not solve the string concatenation issue; x + y would concatenate strings.

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

This works only if the input is a whole number, but the problem does not specify integers.

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

This would work but is less efficient than converting once; however, the order is correct, so this could also work but is not best practice because it repeats conversion.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
Convert the result to int after the operation: avg = int((x + y) / 2)
Why it fails: This does not solve the string concatenation issue; x + y would concatenate strings.
B
Use int() on the input() values: x = int(input(...)); y = int(input(...))
Why it fails: This works only if the input is a whole number, but the problem does not specify integers.
C
Use type casting in the division: avg = (float(x) + float(y)) / 2
Why it fails: This would work but is less efficient than converting once; however, the order is correct, so this could also work but is not best practice because it repeats conversion.
D
Convert x and y to float before the operation: x = float(input(...)); y = float(input(...))
input() always returns a string, so x + y concatenates rather than adds, and dividing a string raises TypeError. Converting both operands with float() before the operation satisfies the stem's numeric-average requirement and accepts decimal input.

Full breakdown with real-world context →

Question 15mediummultiple choice

Read the full Data Types, Variables, Basic I/O and Operators explanation →

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

Trap 1: 1 3

Floor division 10 // 3 yields 3, not 1, and modulo 10 % 3 yields 1, not 3; the option reverses both results. It is tempting because 3 is the remainder and 1 the quotient of 10 divided by 3, so swapping them feels plausible.

Trap 2: 3.33 1

The // operator performs floor division returning the integer 3, never the float 3.33; true division 10 / 3 would give that. It is tempting because 3.33 resembles the decimal result of dividing ten by three, but // truncates toward negative infinity.

Trap 3: 3 3

Modulo 10 % 3 returns the remainder 1, not 3; only the floor division half (3) is right. It is tempting because 3 appears twice in the expression as divisor and quotient, making a repeated 3 look consistent.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
1 3
Why it fails: Floor division 10 // 3 yields 3, not 1, and modulo 10 % 3 yields 1, not 3; the option reverses both results. It is tempting because 3 is the remainder and 1 the quotient of 10 divided by 3, so swapping them feels plausible.
B
3.33 1
Why it fails: The // operator performs floor division returning the integer 3, never the float 3.33; true division 10 / 3 would give that. It is tempting because 3.33 resembles the decimal result of dividing ten by three, but // truncates toward negative infinity.
C
3 3
Why it fails: Modulo 10 % 3 returns the remainder 1, not 3; only the floor division half (3) is right. It is tempting because 3 appears twice in the expression as divisor and quotient, making a repeated 3 look consistent.
D
3 1
Floor division `//` returns the quotient truncated toward negative infinity, so `10 // 3` yields `3`, discarding the remainder. The modulo operator `%` returns the remainder of that same division, giving `1`. Together they satisfy the stem's request for both values, printed as `3 1`.

Full breakdown with real-world context →

Question 16mediummultiple choice

Study the full Python automation breakdown →

Which of the following is a valid Python variable name?

Trap 1: my-var

Hyphens are not permitted in Python identifiers; 'my-var' parses as the expression 'my minus var', producing a NameError. It is tempting because hyphens are common in filenames and URLs, but Python reserves them as the subtraction operator, so only underscores may join words.

Trap 2: for

'for' is a reserved keyword beginning a loop statement, so assigning to it raises a SyntaxError. It is tempting because it is short, lowercase and alphabetic, matching the visual shape of a normal name, but keywords are excluded from the identifier set entirely.

Trap 3: 2nd_value

A Python identifier cannot begin with a digit, so '2nd_value' raises a SyntaxError at parse time. It is tempting because digits are legal after the first character, making 'value2' valid, but the leading numeral violates the identifier grammar regardless of what follows.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
my-var
Why it fails: Hyphens are not permitted in Python identifiers; 'my-var' parses as the expression 'my minus var', producing a NameError. It is tempting because hyphens are common in filenames and URLs, but Python reserves them as the subtraction operator, so only underscores may join words.
B
for
Why it fails: 'for' is a reserved keyword beginning a loop statement, so assigning to it raises a SyntaxError. It is tempting because it is short, lowercase and alphabetic, matching the visual shape of a normal name, but keywords are excluded from the identifier set entirely.
C
_data2
`_data2` satisfies Python's identifier rules: it begins with an underscore, followed by letters and a digit, and contains no spaces or reserved keywords. Python permits leading underscores and digits after the first character, so this name binds cleanly without a `SyntaxError`, meeting the stem's requirement for a valid variable name.
D
2nd_value
Why it fails: A Python identifier cannot begin with a digit, so '2nd_value' raises a SyntaxError at parse time. It is tempting because digits are legal after the first character, making 'value2' valid, but the leading numeral violates the identifier grammar regardless of what follows.

Full breakdown with real-world context →

Question 17mediummulti select

Study the full Python automation breakdown →

Which TWO of the following are valid Python variable names?

Trap 1: var name

Python identifiers cannot contain spaces, so the parser splits this into two tokens and raises a syntax error. It is tempting because multi-word names are natural in prose, and the underscore-joined equivalent would be a valid, conventional variable name.

Trap 2: 1var

A Python identifier cannot begin with a digit, so '1var' raises a syntax error at parse time. It is tempting because the remaining characters are alphanumeric and the name looks plausible, and a leading underscore or letter would make it valid; only the first-character rule is violated here.

Trap 3: my-var

Hyphens are the subtraction operator, so Python parses my-var as my minus var, not a single identifier. Underscores are the legal substitute. It is tempting because hyphenated names are common in URLs and CSS, where the hyphen is a permitted word separator.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
var name
Why it fails: Python identifiers cannot contain spaces, so the parser splits this into two tokens and raises a syntax error. It is tempting because multi-word names are natural in prose, and the underscore-joined equivalent would be a valid, conventional variable name.
B
1var
Why it fails: A Python identifier cannot begin with a digit, so '1var' raises a syntax error at parse time. It is tempting because the remaining characters are alphanumeric and the name looks plausible, and a leading underscore or letter would make it valid; only the first-character rule is violated here.
C
var2
`var2` satisfies Python's identifier rules: it begins with a letter and contains only letters and digits, with no spaces or punctuation. Python permits digits after the first character, so the trailing `2` is valid. It is also not a reserved keyword, making it a legal variable name.
D
_var
`_var` begins with an underscore, which Python permits as a variable-name character alongside letters and digits. The stem asks for valid names, and this satisfies every rule: it starts with a legal character, contains no spaces or reserved words, and is case-sensitive. Underscore-led names are conventionally treated as internal.
E
my-var
Why it fails: Hyphens are the subtraction operator, so Python parses my-var as my minus var, not a single identifier. Underscores are the legal substitute. It is tempting because hyphenated names are common in URLs and CSS, where the hyphen is a permitted word separator.

Full breakdown with real-world context →

Question 18hardmulti select

Study the full Python automation breakdown →

Which THREE of the following are arithmetic operators in Python?

Trap 1: @

Matrix multiplication operator (not basic arithmetic).

Trap 2: &

Bitwise AND operator.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
//
The double slash // is Python's floor division operator, dividing operands and rounding the result down to the nearest integer. It is one of the standard arithmetic operators, alongside +, -, *, /, %, and **.
B
@
Why it fails: Matrix multiplication operator (not basic arithmetic).
C
&
Why it fails: Bitwise AND operator.
D
+
The plus sign performs addition on numeric operands, satisfying the stem's requirement for an arithmetic operator. Python also overloads it for sequence concatenation, but its core arithmetic role qualifies it. The remaining operators in the list must likewise be evaluated against Python's arithmetic set.
E
**
The double asterisk performs exponentiation (raising to a power), making it one of Python's arithmetic operators alongside +, -, *, /, // and %. It is not a comparison or logical operator, so it satisfies the stem's requirement for arithmetic classification.

Full breakdown with real-world context →

Question 19mediummultiple choice

Read the full Data Types, Variables, Basic I/O and Operators explanation →

A developer encounters a TypeError. Which line of code likely caused it?

Exhibit

Refer to the exhibit.
Error output:
Traceback (most recent call last):
  File "script.py", line 3, in <module>
    result = value + 10
TypeError: can only concatenate str (not "int") to str

Trap 1: value = eval(input("Enter a number: "))

eval() interprets input as code, but risky; would not cause this error if input is number.

Trap 2: value = float(input("Enter a number: "))

Convert to float, no error.

Trap 3: value = int(input("Enter a number: "))

Convert to int, no error.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
value = eval(input("Enter a number: "))
Why it fails: eval() interprets input as code, but risky; would not cause this error if input is number.
B
value = float(input("Enter a number: "))
Why it fails: Convert to float, no error.
C
value = int(input("Enter a number: "))
Why it fails: Convert to int, no error.
D
value = input("Enter a number: ")
input() always returns a string, so assigning its result to value yields str, not a number. A TypeError occurs later when that string is used in arithmetic or concatenated with an incompatible type, making this line the likely origin.

Full breakdown with real-world context →

Question 20easymultiple choice

Study the full Python automation breakdown →

Which of the following is a valid Python variable name?

Trap 1: 2var

A leading digit is illegal in a Python identifier, so 2var raises a SyntaxError at parse time. It tempts because digits are permitted after the first character, making names like var2 perfectly valid; the failure is purely positional, not about containing numbers.

Trap 2: var name

An embedded space splits the token into two identifiers, producing a SyntaxError since Python identifiers cannot contain whitespace. It tempts because multi-word names are common in other languages and read naturally; Python requires an underscore, as in var_name, to join the words.

Trap 3: var-name

Hyphens are not permitted in Python identifiers; the minus sign is parsed as subtraction, so var-name is invalid. It is tempting because hyphens are common in everyday naming, and it would be valid if the character were an underscore, as in var_name.

Study all Data Types, Variables, Basic I/O and Operators common traps →

A
2var
Why it fails: A leading digit is illegal in a Python identifier, so 2var raises a SyntaxError at parse time. It tempts because digits are permitted after the first character, making names like var2 perfectly valid; the failure is purely positional, not about containing numbers.
B
var name
Why it fails: An embedded space splits the token into two identifiers, producing a SyntaxError since Python identifiers cannot contain whitespace. It tempts because multi-word names are common in other languages and read naturally; Python requires an underscore, as in var_name, to join the words.
C
var-name
Why it fails: Hyphens are not permitted in Python identifiers; the minus sign is parsed as subtraction, so var-name is invalid. It is tempting because hyphens are common in everyday naming, and it would be valid if the character were an underscore, as in var_name.
D
_var
A leading underscore is a legal identifier character, and Python permits names to begin with it. The name contains only letters and an underscore, starts with an underscore rather than a digit, and avoids reserved keywords, so it satisfies every rule for valid variable naming.

Full breakdown with real-world context →

Continue with 20-question session →

Free account

Track your progress over time

Create a free account to save your results and see which topics improve across sessions.

Focused Data Types, Variables, Basic I/O and Operators sessions

Start a Data Types, Variables, Basic I/O and Operators only practice session

Every question in these sessions is drawn from the Data Types, Variables, Basic I/O and Operators domain — nothing else.

10 questions 20 questions 30 questions 50 questions

Browse all Data Types, Variables, Basic I/O and Operators questions →Mixed PCEP session

Frequently asked questions

What does the PCEP exam test about Data Types, Variables, Basic I/O and Operators?: You must read short Python snippets and correctly state the printed output or the type of a value. The single most important thing to get right is Python 3 division: / always produces a float, while // floors the result, so predict types before values.
How should I use these practice questions?: Select your answer before revealing the explanation. Then read why each option is right or wrong — this active recall approach builds retention far faster than re-reading notes.
Can I practise just Data Types, Variables, Basic I/O and Operators questions in a focused session?: Yes — the session launcher on this page draws every question from the Data Types, Variables, Basic I/O and Operators domain. Use a 10-question session first to gauge your baseline, then move to 20 or 30 once the weak spots are clear.
Where can I practise other PCEP topics?: Use the topic links above to move to related areas, or go back to the PCEP question bank to see all topics.
Are these real exam questions or dumps?: These are original practice questions written to test the same concepts the PCEP exam covers. They are not copied from any real exam or dump site.

Data Types, Variables, Basic I/O and Operators only

10 questions 20 questions 30 questions 50 questions

Mixed PCEP session

Track your progress

A free account saves results across sessions and highlights which topics need work.

Study resources

All PCEP questions Data Types, Variables, Basic I/O and Operators domain overview PCEP exam guide

Exam traps to avoid

▸Assuming / returns an int: in Python 3 true division always yields a float, even for evenly divisible operands like 10 / 5.
▸Confusing // floor division with / division, or expecting // to round toward zero rather than toward negative infinity for negatives.
▸Forgetting that input() always returns a string, so numeric input must be converted with int() or float() before arithmetic.

Data Types, Variables, Basic I/O and Operators practice questions

What to know about Data Types, Variables, Basic I/O and Operators

Common Data Types, Variables, Basic I/O and Operators exam traps

Data Types, Variables, Basic I/O and Operators questions

What is the output of the code?

Exhibit

A user enters 'Alice' for name and '30' for age. What is the output?

Exhibit

A program calculates the total price including tax: total = price * 1.08. The variable price is assigned as price = 100.0. After execution, total is 108.0. The developer then changes price to 100. What will total be?

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

A developer runs the script and enters 'Alice' and '25'. What does it print?

Exhibit

Given the exhibit, what does the code print?

Exhibit

Match each Python operator to its description.

Which TWO operators in Python yield an integer result when applied to two integers?

Which TWO of the following are valid ways to comment in Python?

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?

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

Which of the following is a valid Python variable name?

Which TWO of the following are valid Python variable names?

Which THREE of the following are arithmetic operators in Python?

A developer encounters a TypeError. Which line of code likely caused it?

Exhibit

Which of the following is a valid Python variable name?

Track your progress over time

Start a Data Types, Variables, Basic I/O and Operators only practice session

Related PCEP topic practice pages

Control Flow, Loops, Lists and Logic practice questions

Computer Programming and Python Fundamentals practice questions