Interview Questions — Python Questions with Answers

Answer: A — olleh

A slice with step -1 walks the string backwards, reversing it: 'olleh'. The idiomatic Python reverse - also used to check palindromes with s == s[::-1].

SlicingReverse

def f(a, b=None):
    if b is None:
        b = []
    b.append(a)
    return b

Answer: A — [1] then [1, 2] - the default list is created ONCE and reused across calls

The mutable default argument trap. The default [] is created once at definition and shared by every call that omits b, so it accumulates. Fix: use b=None and create the list inside.

Mutable defaultsCommon traps

import math
print(math.isclose(0.1 + 0.2, 0.3))   # True

Answer: A — False - floating-point rounding makes 0.1 + 0.2 = 0.30000000000000004

Floats are binary approximations; 0.1 and 0.2 can't be represented exactly. Never compare floats with ==; use math.isclose(a, b) or round to a few decimals.

Floating pointisclose

Answer: A — [1, 2, 3, 4] - a and b are two names for the SAME list

b = a does not copy; both names reference one list. Mutating through b is visible through a. For an independent copy: b = a.copy() or b = a[:].

ReferencesAliasing

Answer: A — 512 - ** is right-associative, so it's 2 ** (3 ** 2) = 2 ** 9

Exponentiation groups right-to-left (unlike most operators). So 3 ** 2 = 9 first, then 2 ** 9 = 512. A favorite precedence gotcha.

Operator precedenceAssociativity

Answer: A — True True 2 - bool is a subclass of int (True is 1, False is 0)

Booleans ARE integers under the hood: True equals 1, False equals 0, and they do arithmetic. That's why sum([True, False, True]) counts the Trues (2).

bool as intTruthiness

Answer: A — False True - an empty list is falsy but NOT equal to False

[] == False compares a list to a boolean (different values) -> False. But bool([]) converts the empty list to False first -> True. Truthiness (used by if) is different from == equality.

Truthiness vs equality

Answer: A — [0, 1, 2, 0, 2, 4]

First comprehension: [0, 1, 2]. Second: [0, 2, 4]. + concatenates the two lists -> [0, 1, 2, 0, 2, 4].

ComprehensionsList concatenation

Answer: A — True True - 1 equals True, so the lists compare equal too

1 == True is True (bool is int). List equality compares elements: 1 == True is True, so [1] == [True]. Consistent once you know True behaves as 1.

bool as intList equality

Answer: A — True True False - 'in' checks for a contiguous SUBSTRING

in tests substrings: 'a' and 'ba' appear in 'banana', but 'ab' does not (the letters aren't adjacent in that order). Substring, not subsequence.

in operatorSubstrings

Answer: A — 2 - finally's return OVERRIDES the try's return

finally always runs, and its return replaces the pending one from try. This is why returning inside finally is discouraged - it silently swallows the real result (and even exceptions).

try/finallyreturn

Answer: B — abababc

* binds tighter than +: 3 * "ab" = "ababab" first, then + "c" -> "abababc". Precedence applies to string operators too.

Operator precedenceString operations

Answer: A — [1, 2, 3] [1, 2, 3, 4] - x[:] made an independent copy

x[:] creates a shallow copy, so y is a separate list. Appending to y leaves x unchanged. (Contrast with y = x, which would share the list.)

SlicingCopying

Answer: A — True True False False

Any NON-EMPTY string is truthy - even "False" and "0". Only the empty string is falsy. The number 0 is falsy. So: True, True, False, False.

TruthinessGotchas

Answer: A — (1, 2, [3, 4, 5]) - the tuple is immutable but its inner LIST is mutable

A tuple can't have its elements REPLACED, but if an element is itself mutable (a list), that object can still be modified. Immutability is shallow.

Tuple immutabilityMutable elements

Answer: A — 4 - Python 3 strings count CHARACTERS, not bytes

In Python 3, strings are sequences of Unicode characters, so 'café' has length 4 regardless of how many bytes it takes to encode. (Encoded as UTF-8 bytes it would be 5.)

Unicodelen()

Answer: A — [] [] [] - all three ranges are empty

range(0) and range(5,5) produce nothing. range(3, 0) is also empty because it counts UP by default and 3 is already past 0 - you'd need range(3, 0, -1) to count down.

range()Empty ranges

Answer: A — 55 55 10

"5" + "5" joins strings -> "55". "5" * 2 repeats -> "55". int("5") + 5 does math -> 10. Same-looking data behaving three ways depending on type.

Type behaviorOperators

Answer: A — {3} {1,2,3,4,5} {1,2,4,5}

& intersection (common: {3}), | union (all: {1,2,3,4,5}), ^ symmetric difference (in one but not both: {1,2,4,5}).

Set operations

Answer: A — [1, 3] [2, 4] [4, 2]

[::2] every other from start -> [1,3]. [1::2] every other from index 1 -> [2,4]. [::-2] every other going backwards -> [4,2].

SlicingStep

Answer: A — False - sorted() returns a NEW list each call, so they're different objects

Both calls produce equal lists ([1,2,3]), but they're separate objects in memory, so 'is' (identity) is False. == would be True. Classic is-vs-== distinction.

is vs ==sorted()

Answer: A — ['a', 'b'] [1, 2]

Iterating a dict directly gives its KEYS (['a', 'b']); .values() gives the values ([1, 2]). A frequent point of confusion when looping dicts.

Dict iterationkeys/values

Answer: A — -1 1 - find returns -1 when not found, else the index

find returns the index of the substring, or -1 if absent. 'd' isn't there (-1); 'b' is at index 1. (index() would raise ValueError instead of returning -1.)

find()index()

Answer: A — [1, 9, 25] - keep odds (1,3,5), then square them

filter keeps values where x % 2 is truthy (odd): 1, 3, 5. map squares them: 1, 9, 25. Read inside-out. A comprehension would be [x**2 for x in range(6) if x % 2].

map()filter()lambda

Answer: A — [1, 2, 3] [1, 2, 3] - += mutates the shared list in place

a and b point to the same list. For lists, += calls extend (in-place mutation), so both names see [1, 2, 3]. (For an int, += would rebind and NOT affect the other name.)

AliasingIn-place operators

Answer: A — 0-1-2

The comprehension makes ['0', '1', '2'] (join needs strings, not ints), then join glues them with '-' -> '0-1-2'.

join()Comprehensions

Answer: A — 12 (on one line) - end="" removes the newline after the first print

end="" replaces the default trailing newline with nothing, so the second print continues on the same line: '1' then '2' -> '12'.

print endOutput formatting

Answer: A — banana banana - one by LENGTH, the other alphabetically (b > a)

With key=len, max compares lengths: 'banana' (6) wins. Without key, max compares alphabetically: 'banana' > 'apple' because 'b' > 'a'. Both give 'banana' here, for different reasons.

max()key functions

Answer: A — True True True - all three confirm [] is a list

type([]) is the list class. == compares it to list (True); is checks identity - and classes are singletons, so True; isinstance is the preferred check (True). All three agree here, but isinstance is best because it respects subclasses.

type()isinstance()

Answer: A — 2 - the loop variable survives with its LAST value after the loop

Unlike comprehensions, a for-loop variable leaks into the surrounding scope and keeps its final value (2, the last item of range(3)). If range were empty, i would never be defined.

Loop variable scopeGotchas