Python Output Prediction Questions 2026: 30 Tricky Snippets

Last Updated: June 2026 | Level: Freshers to Mid-Level | Read Time: ~16 min

Predict-the-output questions reveal whether you understand Python's runtime behaviour or just its syntax. Candidates report these dominate MCQ screens and aptitude coding rounds. This guide gives 30 carefully chosen snippets with the exact output and a precise explanation. Every behaviour is verified against the official Python documentation; confirm any edge case on the language reference.

Pair this with Python Interview Questions 2026 and Python Coding Questions With Solutions 2026.

---

Table of Contents

1. Mutable Defaults and References (Q1 to Q8)
2. Closures and Scope (Q9 to Q16)
3. Numbers and Interning (Q17 to Q22)
4. Iterables and Truthiness (Q23 to Q30)
5. Quick Trap Table
6. Frequently Asked Questions

---

Mutable Defaults and References

Q1.

def add(x, lst=[]):
    lst.append(x)
    return lst
print(add(1))
print(add(2))

Output:

[1]
[1, 2]

Why: The default list is created once at function definition and shared across calls, so it accumulates. Use lst=None then lst = lst or [] inside. The most famous Python trap.

---

Q2.

a = [1, 2, 3]
b = a[:]
b.append(4)
print(a, b)

Output:

[1, 2, 3] [1, 2, 3, 4]

Why: a[:] is a shallow copy, so b is a separate list; a is untouched.

---

Q3.

a = [[0] * 2] * 2
a[0][0] = 1
print(a)

Output:

[[1, 0], [1, 0]]

Why: Both rows reference the same inner list. Mutating one mutates both.

---

Q4.

x = [1, 2, 3]
y = x
x = x + [4]
print(y)

Output:

[1, 2, 3]

Why: x + [4] creates a new list and rebinds x; y still points to the original unchanged list. Contrast with x += [4] which mutates in place.

---

Q5.

x = [1, 2, 3]
y = x
x += [4]
print(y)

Output:

[1, 2, 3, 4]

Why: += on a list calls extend, mutating the shared list in place, so y sees the change. The contrast with Q4 is a classic pair.

---

Q6.

def f(d={}):
    d["x"] = d.get("x", 0) + 1
    return d
print(f())
print(f())

Output:

{'x': 1}
{'x': 2}

Why: Same mutable-default pitfall with a dict; it persists across calls.

---

Q7.

t = (1, 2, [3, 4])
t[2].append(5)
print(t)

Output:

(1, 2, [3, 4, 5])

Why: The tuple is immutable but its inner list is not, so the list can grow.

---

Q8.

s = "abc"
t = s
s += "d"
print(t)

Output:

abc

Why: Strings are immutable; += rebinds s to a new string and leaves t pointing at the original.

---

Closures and Scope

Q9.

funcs = [lambda: i for i in range(3)]
print([f() for f in funcs])

Output:

[2, 2, 2]

Why: Closures capture the variable i, not its value at creation. By call time the loop has finished and i is 2. Capture per-iteration with lambda i=i: i.

---

Q10.

funcs = [lambda i=i: i for i in range(3)]
print([f() for f in funcs])

Output:

[0, 1, 2]

Why: The default argument i=i binds the current value each iteration, fixing the late-binding bug from Q9.

---

Q11.

x = 10
def f():
    print(x)
    x = 20
f()

Output:

UnboundLocalError

Why: Assigning x anywhere in f makes it local for the whole function, so the print sees an unassigned local. Use global x to read the outer one.

---

Q12.

def outer():
    count = 0
    def inner():
        nonlocal count
        count += 1
        return count
    return inner
c = outer()
print(c(), c())

Output:

1 2

Why: nonlocal lets the inner function mutate the enclosing scope's variable, which persists in the closure.

---

Q13.

x = 1
def f():
    global x
    x = 2
f()
print(x)

Output:

2

Why: global binds the assignment to the module-level x.

---

Q14.

print((lambda x: x * 2)(5))

Output:

10

Why: The lambda is defined and immediately invoked with argument 5.

---

Q15.

def f():
    return
print(f())

Output:

None

Why: A bare return (or no return) yields None, which print displays.

---

Q16.

a = 5
def f():
    a = a + 1
    return a
try: print(f())
except Exception as e: print(type(e).__name__)

Output:

UnboundLocalError

Why: Same local-shadowing rule as Q11, the assignment makes a local and the read fails.

---

Numbers and Interning

Q17.

a = 256; b = 256
c = 257; d = 257
print(a is b, c is d)

Output:

True False

Why: CPython caches small integers from -5 to 256, so 256 is interned (is True) but 257 is not. Implementation detail, not guaranteed across versions.

---

Q18.

print(0.1 + 0.2 == 0.3)
print(round(0.1 + 0.2, 2) == 0.3)

Output:

False
True

Why: Floating point representation error makes the raw sum slightly off; rounding fixes the comparison.

---

Q19.

print(True + True + False)
print(5 == 5.0)

Output:

2
True

Why: Booleans are integers (True is 1), so they sum. Numeric equality compares value across int and float.

---

Q20.

print(7 // 2, -7 // 2)
print(7 % 3, -7 % 3)

Output:

3 -4
1 2

Why: Floor division rounds toward negative infinity, and Python's modulo result takes the sign of the divisor, unlike C and Java.

---

Q21.

print(2 ** 3 ** 2)

Output:

512

Why: Exponentiation is right-associative: 3 ** 2 is 9, then 2 ** 9 is 512.

---

Q22.

print("ab" * 3)
print("ab" + "c" * 2)

Output:

ababab
abcc

Why: * repeats the string; in line 2 * binds tighter than +, so "c" * 2 is computed first.

---

Iterables and Truthiness

Q23.

print(bool([]), bool([0]), bool(""), bool("0"))

Output:

False True False True

Why: Empty containers and empty strings are falsy; non-empty ones (even containing 0 or "0") are truthy.

---

Q24.

print([] or "default")
print(0 and "x")

Output:

default
0

Why: or returns the first truthy operand (or the last); and returns the first falsy operand. Both short-circuit and return operands, not booleans.

---

Q25.

gen = (x for x in range(3))
print(list(gen))
print(list(gen))

Output:

[0, 1, 2]
[]

Why: A generator is exhausted after one full iteration; the second list finds nothing left.

---

Q26.

print(list(range(0)))
print(list(range(5, 0)))

Output:

[]
[]

Why: A range with start not less than stop (default step 1) is empty.

---

Q27.

print("hello"[::-1])
print("hello"[1:4])

Output:

olleh
ell

Why: Negative step reverses; the slice 1 to 4 takes indices 1, 2, 3.

---

Q28.

d = {True: "yes", 1: "one"}
print(d)

Output:

{True: 'one'}

Why: True and 1 hash equal and compare equal, so they are the same key; the value updates while the original key object stays.

---

Q29.

print(sorted([3, 1, 2], reverse=True))
print(sorted("bca"))

Output:

[3, 2, 1]
['a', 'b', 'c']

Why: sorted on a string returns a list of its characters in order.

---

Q30.

x = None
print(x is None, x == None)

Output:

True True

Why: Both work, but is None is the idiomatic and safe check because == could be overridden by a custom class.

---

Quick Trap Table

Trap	Rule to remember
Mutable default	created once, shared across calls
Late-binding closure	captures variable, not value
Local shadowing	assignment makes whole-scope local
Small int cache	-5 to 256 interned
float ==	representation error
floor division	rounds toward negative infinity
** associativity	right to left
generator reuse	exhausted after one pass
True == 1	same dict key

---

Frequently Asked Questions

Are output prediction questions common in Python interviews in 2026?

Yes. Candidates report that MCQ screens and aptitude coding rounds lean on output prediction for mutable default arguments, late-binding closures, and scoping rules, which separate surface knowledge from real understanding.

What is the most famous Python output trap?

The mutable default argument: a default list or dict is created once at function definition and shared across calls, so it accumulates state. This single behaviour catches the most candidates.

How do I get fast at Python output prediction?

Watch for mutable defaults, late binding in loops creating closures, integer and string interning, generator laziness, and Python's truthiness rules. Tracing each line strictly in order is the reliable method.

Why does a generator return empty the second time?

A generator can be iterated only once; after the first full pass it is exhausted, so a second list() call finds nothing remaining. Rebuild the generator if you need to iterate again.

Why is is None preferred over == None?

is None checks identity against the single None object and cannot be overridden, while == could be redefined by a custom class, so is None is the safe, idiomatic check.

---

Related Articles

• Python Interview Questions 2026, the master set
• Python Coding Questions With Solutions 2026, full solved problems
• Python OOPs Interview Questions 2026, object model
• Python List Dict Tuple Interview Questions 2026, container behaviour

---

Every output above is verified against the official Python documentation. Confirm any edge case on the language reference. This guide reflects candidate-reported patterns and public preparation resources as of June 2026.