Select Two (Multi-Select) Questions

StringError

Why it fails: Not a standard Python exception.

NumberError

Why it fails: Not a standard Python exception.

ListError

Why it fails: Not a standard Python exception.

A while loop always executes its body at least once, even if the condition is initially false.

Why it fails: A while loop checks its condition before each iteration, so if the condition is false initially, the body never executes. A loop that always runs at least once would be a do-while loop, which Python does not have natively. This statement describes a common misconception from other languages.

The break statement can be used outside a loop to terminate the program.

Why it fails: break is only valid inside a loop (for or while). Using it outside a loop raises a SyntaxError. To terminate a program, one would use sys.exit() or raise SystemExit. The break statement is strictly for early loop termination and cannot be used as a general program exit mechanism.

The continue statement exits the current loop entirely and resumes execution after the loop.

Why it fails: continue does not exit the loop; it skips the remaining statements in the current iteration and proceeds to the next iteration. Exiting the loop entirely is the role of break. Confusing continue with break leads to incorrect control flow, such as skipping only one element instead of stopping the loop.

Lists have a fixed size once created.

Why it fails: Lists are dynamic; size can change.

Lists can only contain elements of the same data type.

Why it fails: Lists can contain mixed data types.

(1, 2, 3)

Why it fails: Parentheses with commas produce a tuple, which is immutable and cannot be modified after creation. It is tempting because the syntax closely mirrors list literals, but square brackets are what create a mutable list. Tuples suit fixed records where immutability is intended.

{1, 2, 3}

Why it fails: Curly braces with comma-separated values create a set, which stores unique unordered elements and rejects duplicates. It looks similar to list syntax, but sets cannot be indexed or hold duplicates. Sets are correct when membership testing or deduplication is required.

It can be used with an optional else clause.

Why it fails: False: the else clause belongs to the loop, not to break.

It can be used in an if statement outside any loop.

Why it fails: False: break outside a loop causes a SyntaxError.

for i in range(5): if i%2==0: print(i); else: continue

Why it fails: Prints all even numbers: 0,2,4.

i=0; while i<3: print(i); i+=1; else: print('done')

Why it fails: Prints 0,1,2,done (extra 'done').

i=0; while i<3: print(i)

Why it fails: Missing increment; infinite loop printing 0 repeatedly.

str

Why it fails: Strings are immutable: any operation that appears to modify one returns a new str object, leaving the original unchanged. The mutable built-in sequence types are list, dict and set. str would be the correct answer only if the question asked which types are immutable.

tuple

Why it fails: Tuples are immutable: once created, their elements cannot be reassigned, so they cannot satisfy a question asking for mutable types. They are tempting because they hold ordered collections like lists, and would be correct where a hashable, unchangeable sequence is required, such as a dictionary key.

int

Why it fails: Integers are immutable: any arithmetic operation returns a new int object rather than altering the existing one, so int cannot satisfy a mutability question. They tempt because they are the default numeric type, and would be the right answer where an unchangeable numeric constant or dictionary key is needed.

list = [1, 2, 3]]

Why it fails: Extra closing bracket causes SyntaxError.

list = (1, 2, 3)

Why it fails: Creates a tuple, not a list.

list = [1; 2; 3]

Why it fails: Invalid syntax; semicolons not allowed in list literals.

keyset()

Why it fails: Python dictionaries expose keys(), not keyset(); the method name simply does not exist, so calling it raises AttributeError. It tempts because Java's Map interface offers keySet(), and candidates familiar with Java may assume Python mirrors that naming convention.

entries()

Why it fails: Python dictionaries provide items(), not entries(); entries() is undefined and raises AttributeError at runtime. The name tempts because Java's Map exposes entrySet() and JavaScript's Object.entries() returns key-value pairs, so the concept feels familiar despite the wrong identifier.

pairs()

Why it fails: No pairs() method exists on Python dictionaries; iteration over key-value tuples is done via items(), so pairs() raises AttributeError. It tempts because the name describes what items() returns, and similar pair-oriented helpers appear in other languages and libraries.

my_list.add(5)

Why it fails: Python lists expose append, extend and insert; add belongs to sets, so my_list.add(5) raises AttributeError. It is tempting because add genuinely mutates other Python collections, notably sets, where it inserts a single hashable element — correct there, but lists are ordered sequences with no add method.

my_list.push(5)

Why it fails: Python lists expose append, extend and insert; push belongs to stack implementations in other languages, so my_list.push(5) raises AttributeError. It is tempting because push genuinely adds elements to array-backed structures elsewhere, such as JavaScript arrays, but Python's list API never defines it.

The ** operator is the bitwise XOR operator.

Why it fails: In Python, ** performs exponentiation; bitwise XOR is the ^ operator. It is tempting because ** resembles the caret notation used for XOR in some other languages and mathematics, so candidates assume the symbols map across, but Python reserves ** for raising to a power.

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

Why it fails: In Python 3, / performs true division and returns a float even when both operands are integers; floor division uses //. It is tempting because in Python 2 and many statically typed languages integer division truncates, so candidates carry that behaviour across to Python 3.

'0' == 0

Why it fails: Comparing a string with an integer returns False in Python 3; no implicit type coercion occurs, so '0' == 0 is False. It tempts because both look like zero, but '0' == '0' or 0 == 0 would each evaluate to True.

2 == True

Why it fails: Python compares int and bool numerically, so True equals 1, making 2 == True False. It tempts because True is often treated as truthy in conditions, yet equality here is value-based; 1 == True would evaluate to True.

None == False

Why it fails: None equals False is False, since None is the sole NoneType object and False is a bool; equality compares type and value, so they differ. It tempts because both are falsy in boolean contexts, yet falsiness does not imply equality.

True == 1

Why it fails: True == 1 evaluates to the Boolean True, not the integer 1, because equality comparison returns a bool in Python. It is tempting since bool subclasses int and True equals 1 numerically. Expressions returning the actual int type, such as 1 // 1 or int(1.0), satisfy the question.

1 * 1.0

Why it fails: Multiplying an int by a float yields a float in Python, so 1 * 1.0 evaluates to 1.0, not the integer 1. It is tempting because the numeric value equals one, but type matters here. Integer-preserving expressions such as 1 // 1 or int(1.0) would qualify.

list

Why it fails: Lists are mutable: append, remove and item assignment all modify the object in place, so they cannot be immutable. They are tempting because they hold ordered collections like tuples, but tuples are the immutable sequence; lists are chosen when the collection must change after creation.

dict

Why it fails: A dict is mutable: keys and values can be added, removed, or reassigned after creation, so it fails the immutability test. It is tempting because dict keys must themselves be hashable and immutable, but the dictionary object as a whole is not.

not

Why it fails: `not` is a unary logical operator returning a Boolean negation, not a membership test. It is tempting because it appears alongside `in` in conditional expressions, yet `in` and `not in` are the membership operators; `not` alone would be correct only for inverting a truth value.

is

Why it fails: `is` is an identity operator comparing object references, not membership. It is tempting because it resembles `in` syntactically and appears in similar conditional contexts, but identity testing is distinct; `is` would be correct when checking whether two names reference the same object.

and

Why it fails: `and` is a Boolean logical operator combining two expressions, not a membership test. It is tempting because it frequently appears with `in` inside conditions, but membership requires `in` or `not in`; `and` would be the correct choice for questions about logical operators.

"5"

Why it fails: "5" is a string literal containing the character five, so its type is str, not int. It is tempting because it displays as 5. A string is correct where text is required, such as reading user input or concatenating values, not for integer arithmetic.

5.0

Why it fails: 5.0 is a float literal, so its type is float, not int, regardless of the displayed value. It is tempting because the numeric value equals five. A float would be the correct choice where fractional precision or floating-point arithmetic is required, such as scientific calculations.

10 / 2

Why it fails: In Python 3, / performs true division, so 10 / 2 evaluates to the float 5.0, not the integer 5. It is tempting because the quotient is a whole number. Floor division with // would be correct when an integer result is required.

bool('')

Why it fails: bool('') converts an empty string, which is falsy, so it evaluates to False. It is tempting because empty strings are often treated as absent values in other languages, and bool('') would be correct only if the string contained a non-empty truthy value such as 'False' or '0'.

bool([])

Why it fails: bool([]) converts an empty list, which is falsy, so it evaluates to False. It is tempting because non-empty lists are truthy, and bool([]) would be correct only when the list contains at least one element, making the expression evaluate to True.

bool(0)

Why it fails: bool(0) returns False because zero is falsy, so it cannot satisfy a question asking for True expressions. It tempts candidates who recall that bool() converts any integer, but that conversion preserves truthiness: only non-zero integers yield True.

my_dict = {a:1, b:2}

Why it fails: Unquoted keys a and b are treated as variable names, raising NameError unless those variables exist; dictionary literals require string or other hashable literals as keys. It is tempting because quoted string keys look almost identical, and that quoted form is the standard literal dictionary syntax.

my_dict = dict(['a',1],['b',2])

Why it fails: dict() accepts a single iterable of key-value pairs or keyword arguments, not two separate list arguments, so this raises TypeError. It is tempting because the two lists resemble the pairs accepted by dict(), but each pair must be nested inside one outer iterable.

my_dict = ["a":1, "b":2]

Why it fails: Square brackets denote a list, and the colon syntax inside them is invalid Python; dictionaries require curly braces. It is tempting because both literals use commas and quotes, and would fit where the stem asked for a list of key-value pairs or a dict() call with tuple arguments.

Strings are mutable.

Why it fails: Strings are immutable.

Sets are immutable.

Why it fails: Sets are mutable (though elements must be immutable).

It can be used with a while loop condition

Why it fails: A for loop iterates over an iterable and takes no boolean condition; combining it with a while condition is a syntax error. The temptation arises because while loops test a condition each pass, which suits sentinel-driven repetition, and that is exactly the scenario where while, not for, is the correct construct.

It always executes at least once

Why it fails: A for loop iterates over a sequence, so an empty sequence causes zero executions; only a while loop with a condition true at entry guarantees at least one pass. It is tempting because loop bodies often run, but that reflects typical inputs, not guaranteed behaviour.

It is the only loop in Python

Why it fails: Python also provides the while loop, so the for loop cannot be the only iteration construct. It is tempting because for loops dominate iteration over sequences, ranges and generators, and in idiomatic Python they replace most manual index handling, but while remains necessary for condition-driven repetition.