Question 1

Floor division result

Accepted Answer

The // operator is floor division - it divides and rounds down to the nearest integer. 7 // 2 gives 3, not 3.5 (that's true division with /) or 4 (round-half-up). When both operands are ints the result is also an int.

Question 2

Adding int and float

Accepted Answer

Python automatically promotes int to float when you mix them in arithmetic. 3 + 1.0 produces 4.0, a float, and type(4.0).__name__ is 'float'. This implicit widening rule applies to all arithmetic operators, not just addition.

Question 3

Augmented assignment on immutable

Accepted Answer

Integers are immutable. When you write a += 3, Python creates a new int object 8 and rebinds 'a' to it. 'b' still points at the original object 5 - nothing changed it. This is different from mutating a list in place, where b would reflect the change.

Question 4

Which type is mutable?

Accepted Answer

Lists are mutable - you can add, remove, or change elements after creation. Ints, tuples, and strings are all immutable: any 'modification' creates a new object. The distinction matters for function arguments: passing a list lets the callee change it in place.

Question 5

None compared to zero

Accepted Answer

None is its own singleton type - it is not equal to 0, False, or an empty string. Even though False == 0 is True in Python, None == False is False. The canonical way to check for None is 'x is None', not 'x == None'.

Question 6

Boolean arithmetic

Accepted Answer

In Python, bool is a subclass of int. True has an integer value of 1 and False has a value of 0. So True + True + False is just 1 + 1 + 0 = 2. This quirk comes up in patterns like sum(x > 0 for x in lst) to count elements meeting a condition.

Question 7

String repetition

Accepted Answer

The * operator on a string repeats it n times end-to-end. 'ab' * 3 concatenates three copies: 'ab' + 'ab' + 'ab' = 'ababab'. This works for lists too: [0] * 3 gives [0, 0, 0] - though watch out when the element is mutable.

Question 8

Variable rebinding changes type

Accepted Answer

Python variables are just names bound to objects - there is no declared type. Each assignment rebinds x to a brand-new object of a different type. By the final line, x points to the list [1, 2], so type(x).__name__ is 'list'.

Question 9

Chained comparisons

Accepted Answer

Python supports chained comparisons: 1 < x < 10 means '1 < x AND x < 10', which is True for x = 5. 1 < x > 10 means '1 < x AND x > 10'. The first part (1 < 5) is True, but the second (5 > 10) is False, so the whole chain is False. Each value is evaluated only once, which matters if it's a function call with side effects.

Question 10

Floor division with negatives

Accepted Answer

Floor division always rounds toward negative infinity, not toward zero. -7 / 2 is -3.5, and the floor of -3.5 is -4. Many people expect -3 (truncating toward zero), but Python's floor division truly floors. This distinction matters whenever you apply // to negative numbers.

Question 11

Dividing two ints

Accepted Answer

In Python 3, the / operator always returns a float, even when dividing two integers that divide evenly. 6 / 2 is 3.0, not 3, so the type is 'float'. This was a deliberate change from Python 2, where 6 / 2 returned 3. Use // if you need an integer result.

Question 12

Which type is immutable?

Accepted Answer

Tuples are immutable - once created, you cannot add, remove, or replace their elements. Lists, dicts, and sets are all mutable and support in-place modification. Immutability makes tuples hashable, which is why they can be used as dictionary keys while lists cannot.

Question 13

Boolean as index

Accepted Answer

Because bool is a subclass of int, True and False are valid list indices with integer values 1 and 0, respectively. items[True] is items[1] which is 'yes', and items[False] is items[0] which is 'no'. You'll rarely do this on purpose, but it can show up as a subtle bug when a boolean sneaks into an indexing expression.

Question 14

String repetition with zero

Accepted Answer

Multiplying a string by 0 produces an empty string. The * operator repeats the sequence zero times, leaving nothing. repr('') prints two single quotes, showing you explicitly that the result is an empty string rather than None or some other value. The same behavior applies to lists: [1, 2] * 0 gives [].

Question 15

Chained equality comparison

Accepted Answer

Chaining works with == too: a == b == c means 'a == b AND b == c'. All three are 1, so that's True. Adding == 2 extends the chain: a == b == c == 2 means every adjacent pair must be equal - but c (which is 1) is not equal to 2, so the result is False. This is cleaner than writing a == b and b == c yourself, and Python only evaluates each subexpression once.