DEV Community: interview pitch

Python Interview Questions Freshers Often Get Wrong (With Code)

interview pitch — Sat, 10 Oct 2026 08:32:16 +0000

Python Interview Questions Freshers Often Get Wrong (With Code)

Python interviews for freshers usually do not begin with complicated algorithms. Instead, interviewers often ask deceptively simple questions to check whether you actually understand how Python behaves.

The problem is that many candidates memorize definitions such as "Python is dynamically typed" or "lists are mutable" without understanding what those statements mean when real code is placed in front of them.

In this article, we will look at some common Python interview questions freshers often get wrong, understand why the obvious answer may be incorrect, and walk through practical code examples.

If you are preparing for Python interviews, you can also explore more curated interview questions and coding preparation resources at InterviewPitch.com .

1. What Is the Output of This Python Code?

a = [1, 2, 3]
b = a

b.append(4)

print(a)
print(b)

A common fresher answer is:

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

But that is incorrect.

The actual output is:

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

Why?

The statement:

b = a

does not create another list.

Both variables refer to the same list object in memory. Therefore, modifying the list through b also affects what you see through a.

You can verify this:

print(a is b)

Output:

True

How Do You Create a Copy?

a = [1, 2, 3]
b = a.copy()

b.append(4)

print(a)
print(b)

Output:

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

2. What Is the Difference Between == and is?

This is one of the most frequently misunderstood Python interview questions.

Consider:

a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)
print(a is b)

Output:

True
False

Why?

== compares values.

is checks whether two variables refer to the exact same object.

Therefore:

a == b

is True because both lists contain the same values.

But:

a is b

is False because they are two different list objects.

A good interview answer is:

== checks value equality, while is checks object identity.

3. Why Does This Function Behave Strangely?

def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item("Python"))
print(add_item("Java"))

Many freshers expect:

['Python']
['Java']

Actual output:

['Python']
['Python', 'Java']

Why?

Default arguments are evaluated when the function is defined, not every time the function is called.

That means the same list is reused across calls.

Better Approach

def add_item(item, items=None):

    if items is None:
        items = []

    items.append(item)

    return items

Now:

print(add_item("Python"))
print(add_item("Java"))

Output:

['Python']
['Java']

This is an excellent example of why understanding Python behavior matters more than memorizing syntax.

4. What Is the Difference Between a List and a Tuple?

Most freshers immediately answer:

Lists are mutable, while tuples are immutable.

That answer is correct, but interviewers often expect a little more.

List Example

numbers = [10, 20, 30]

numbers[0] = 100

print(numbers)

Output:

[100, 20, 30]

Tuple Example

numbers = (10, 20, 30)

numbers[0] = 100

This produces an error because tuples cannot be modified this way.

When Would You Use a Tuple?

Tuples are useful when:

The collection should not be modified.
You want to represent fixed records.
You need hashable data in situations where the contents permit it.
You want to communicate that the sequence is conceptually fixed.

5. What Will range(5) Produce?

A surprising number of beginners answer:

1 2 3 4 5

But:

for i in range(5):
    print(i)

produces:

The ending value is excluded.

In general:

range(start, stop, step)

includes start but excludes stop.

Example:

for i in range(2, 10, 2):
    print(i)

Output:

6. What Is the Output?

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

Output:

False
True
False
True

The Trap

A list containing 0 is still a non-empty list. Therefore:

bool([0])

is True.

Similarly:

bool("False")

is also True because the string is not empty. Python is not evaluating the meaning of the word "False".

Common Falsy Values

False
None
0
0.0
""
[]
{}
()
set()

7. What Is the Difference Between append() and extend()?

Using append()

numbers = [1, 2]

numbers.append([3, 4])

print(numbers)

Output:

[1, 2, [3, 4]]

Using extend()

numbers = [1, 2]

numbers.extend([3, 4])

print(numbers)

Output:

[1, 2, 3, 4]

append() adds one object to the end of the list.

extend() iterates over another iterable and adds its elements to the existing list.

8. What Happens When You Use break, continue and pass?

These three keywords are sometimes confused during interviews.

break

Stops the loop completely.

for i in range(5):

    if i == 3:
        break

    print(i)

Output:

0
1
2

continue

Skips the current iteration.

for i in range(5):

    if i == 2:
        continue

    print(i)

Output:

pass

Does nothing. It is often used as a placeholder where Python requires a statement syntactically.

def future_feature():
    pass

9. What Is the Difference Between remove(), pop() and del?

remove()

Removes a specific value.

numbers = [10, 20, 30]

numbers.remove(20)

print(numbers)

Output:

[10, 30]

pop()

Removes an item by index and returns the removed value.

numbers = [10, 20, 30]

value = numbers.pop(1)

print(value)
print(numbers)

Output:

20
[10, 30]

del

Deletes by index, slice, or even a variable binding.

numbers = [10, 20, 30]

del numbers[1]

print(numbers)

10. Why Doesn't This Swap Need a Temporary Variable?

In languages such as C or Java, beginners often learn:

temp = a
a = b
b = temp

Python can do this directly:

a = 10
b = 20

a, b = b, a

print(a)
print(b)

Output:

20
10

Python evaluates the values on the right side and then assigns them to the targets on the left.

11. What Is a List Comprehension?

An interviewer may first ask you to produce squares using a loop.

squares = []

for number in range(1, 6):
    squares.append(number * number)

print(squares)

Then they may ask for the Pythonic version:

squares = [number * number for number in range(1, 6)]

print(squares)

Output:

[1, 4, 9, 16, 25]

You can also add a condition:

even_squares = [
    number * number
    for number in range(1, 11)
    if number % 2 == 0
]

print(even_squares)

12. What Is the Difference Between Shallow Copy and Deep Copy?

This question is slightly more advanced, but freshers increasingly encounter it.

import copy

original = [[1, 2], [3, 4]]

shallow = copy.copy(original)
deep = copy.deepcopy(original)

original[0][0] = 100

print(original)
print(shallow)
print(deep)

A shallow copy creates a new outer container but may still refer to nested objects from the original.

A deep copy recursively creates independent copies of nested objects where possible.

This distinction becomes important when working with nested lists, configuration structures and complex objects.

13. Does Python Pass Arguments by Reference?

This question often produces confusing answers such as:

Python uses pass-by-reference.

That explanation is incomplete.

A better way to think about Python is that names are bound to objects, and function arguments receive references to those objects.

Consider:

def modify(items):
    items.append(4)

numbers = [1, 2, 3]

modify(numbers)

print(numbers)

Output:

[1, 2, 3, 4]

The function mutates the same list object.

Now consider:

def modify(number):
    number = 100

value = 10

modify(value)

print(value)

Output:

Inside the function, the local name number is rebound to another object. That does not rebind the caller's value variable.

14. Can Dictionary Keys Be Lists?

No.

This will fail:

data = {
    [1, 2]: "value"
}

Dictionary keys must be hashable. Because lists are mutable, they are not hashable and cannot normally be dictionary keys.

A tuple can often be used instead:

data = {
    (1, 2): "value"
}

print(data[(1, 2)])

Output:

value

15. What Is the Output of This Slicing Question?

text = "PYTHON"

print(text[::-1])

Output:

NOHTYP

The slice syntax is:

sequence[start:stop:step]

A step of -1 moves backward through the sequence, which is a common Python technique for reversing strings and lists.

What Interviewers Are Really Testing

The questions above may look simple, but they test several important Python concepts:

Mutable vs immutable objects
Object identity
References and assignment
Default function arguments
Truthiness
List operations
Slicing
Copy behavior
Functions and argument handling
Pythonic coding style

The best way to prepare is not simply to memorize the expected answer. Before reading the solution, run the code yourself and try to explain why Python produced that result.

Quick Python Interview Checklist for Freshers

Before attending your interview, make sure you are comfortable with:

Strings and string methods
Lists, tuples, sets and dictionaries
Mutable vs immutable types
Functions and arguments
*args and **kwargs
Loops and comprehensions
Exception handling
Classes and objects
Inheritance
Iterators and generators
Lambda functions
File handling
Modules and packages
Basic time and space complexity
Common coding problems

Continue Your Python Interview Preparation

Getting Python interview questions right requires both conceptual understanding and hands-on coding practice.

If you want to practice more interview questions, coding rounds and role-focused preparation, visit:

👉 InterviewPitch.com — Interview Questions, Coding Rounds & Interview Preparation

InterviewPitch provides curated interview preparation resources across Python, Java, JavaScript, React, SQL, system design and many other technical topics.

The goal is simple: understand the concepts, practice the code, and walk into your next interview knowing why an answer works rather than merely remembering it.

What Python question confused you during your first interview? Share it in the comments — it might help another developer preparing for the same question.

The 30-Day Coding Interview Prep Plan (For People Who Don't Have 6 Months)

interview pitch — Thu, 10 Sep 2026 08:14:23 +0000

Most interview prep advice assumes you have 3-6 months and unlimited free evenings. Most people don't. Maybe you got a call for an interview loop in three weeks. Maybe you're job hunting on top of a full-time job. Maybe you just don't want to spend half a year grinding LeetCode before you feel "ready."

Here's a realistic 30-day plan that assumes 1-2 hours a day, and focuses on the things that actually move the needle in an interview — not just problem count.

The plan only works if you stop doing this first

Before the schedule: the single biggest time-waster in interview prep is solving random problems in random order with no plan for why you got one wrong. If a problem stumps you and you just look at the solution, read it, and move on — you'll forget it in a week. You have to know which pattern you missed, not just which problem you missed.

That's the whole plan, really: organize your practice by pattern, not by problem number.

Week 1 — Foundations + the 4 highest-frequency patterns

Spend day 1 reviewing time/space complexity and the patterns you'll drill: two pointers, sliding window, hashmaps, and binary search. These four alone cover a disproportionate share of "easy" and "medium" interview questions.

Days 2-4: two pointers + sliding window (aim for 3-4 problems per pattern, timed)
Days 5-6: hashmaps for frequency/lookup problems
Day 7: binary search, including the "search on the answer" variant that trips people up

By end of week 1, you should be able to name the pattern in a new problem within 2-3 minutes, even if you can't solve it yet.

Week 2 — Trees, graphs, and recursion

This is where most people's pace collapses, because trees and graphs have more variations than arrays. Don't try to memorize every traversal — understand the three or four templates (DFS, BFS, backtracking, and topological sort) deeply enough to adapt them.

Days 8-10: tree traversals + BST properties
Days 11-13: graph BFS/DFS, including grid-based problems (very common)
Day 14: recursion + backtracking basics (permutations, subsets)
Week 3 — Dynamic programming + a system design primer

DP is the pattern people fear most, and it's also the one where "practice by pattern" pays off the most, because most DP problems reduce to a handful of shapes (0/1 knapsack, unbounded knapsack, longest common subsequence, and interval DP).

Days 15-18: DP — 1D problems first (climbing stairs, house robber), then 2D
Days 19-20: if your target role includes system design, start now — don't leave it for the last week. Learn the vocabulary (load balancers, caching, sharding, CAP theorem) even before you can design a full system end to end
Day 21: rest or catch-up day — use it, don't skip it
Week 4 — Mock interviews and weak-spot triage

This is the week most self-taught plans skip entirely, and it's the highest-leverage week you have.

Days 22-25: timed mock interviews (with a friend, mentor, or a structured tool) — explaining your thinking out loud is a completely different skill from solving quietly, and you only build it by doing it
Days 26-28: revisit your weak pattern, not a random new one. If sliding window kept tripping you up in week 1, redo it now with fresh eyes.
Days 29-30: light review only. Sleep matters more than one more problem at this stage.
What actually separates a "pass" from a "borderline pass"

Having reviewed a lot of prep timelines, the difference usually isn't raw problem count. It's:

Talking through your approach before coding — interviewers are grading reasoning, not typing speed
Knowing your weak pattern and deliberately drilling it, instead of doing more of what you're already good at
Getting real timed practice under mild pressure before the actual interview, so the format isn't a surprise

If you want a structured way to follow this — organized by pattern instead of random problem lists, plus mock interview practice and language-specific Q&A — I built [InterviewPitch ](https://interviewpitch.com/)around exactly this approach. It's free.

What's your weak pattern? Curious what trips people up most under time pressure — drop it in the comments.

7 DSA Patterns That Show Up in Almost Every Coding Interview

interview pitch — Wed, 09 Sep 2026 10:05:37 +0000

If you've been grinding LeetCode without a plan, you already know the problem: there are thousands of questions, but only a handful of underlying patterns. Once you recognize the pattern, most "new" problems stop feeling new.

Here are the 7 patterns that keep showing up across interviews at companies of every size — and how to recognize them fast.

Two Pointers

Signal: Sorted array, or you're comparing pairs/windows from both ends.

Classic problems: Pair sum in sorted array, container with most water, remove duplicates in place.

Why it works: You collapse an O(n²) brute-force scan into O(n) by moving two indices toward each other based on a comparison.

Sliding Window

Signal: "Longest/shortest substring/subarray that satisfies X."

Classic problems: Longest substring without repeating characters, max sum subarray of size k, minimum window substring.

Why it works: Instead of recomputing a window from scratch every time, you slide it — adding one element, removing one — keeping the computation incremental.

Fast & Slow Pointers (Tortoise and Hare)

Signal: Anything involving cycles or finding a "middle" without extra space.

Classic problems: Detect a cycle in a linked list, find the middle node, find duplicate number in an array.

Why it works: Two pointers moving at different speeds will eventually meet if there's a cycle — no hash set required.

Merge Intervals

Signal: You're given a list of ranges and need to combine, insert, or check for overlaps.

Classic problems: Merge overlapping intervals, insert interval, meeting rooms.

Why it works: Sort by start time first — almost every interval problem becomes trivial once sorted.

Top-K Elements (Heap)

Signal: "Find the k largest/smallest/most frequent..."

Classic problems: Kth largest element, top k frequent words, k closest points to origin.

Why it works: A heap keeps the k best candidates without sorting the entire dataset — O(n log k) instead of O(n log n).

Backtracking

Signal: "Generate all possible..." or "find all valid combinations."

Classic problems: Permutations, subsets, N-Queens, Sudoku solver.

Why it works: You explore a decision tree, and prune branches early the moment they can't lead to a valid answer — that pruning is what keeps it from being pure brute force.

Dynamic Programming (the one everyone fears)

Signal: "Maximum/minimum/number of ways to..." with overlapping subproblems.

Classic problems: Climbing stairs, coin change, longest common subsequence, knapsack.

Why it works: You cache the answer to subproblems so you never recompute the same thing twice. The trick isn't the code — it's correctly defining the state and the transition.

How to actually practice this (not just read about it)

Recognizing a pattern in an article is easy. Recognizing it cold, in a 35-minute interview, under pressure, is a different skill entirely. A few things that actually move the needle:

Drill by pattern, not by difficulty. Doing 10 sliding-window problems back to back builds pattern recognition far faster than doing 10 random "medium" problems.
Time yourself. If you can't identify the pattern in the first 3 minutes, you need more reps on that pattern specifically, not a harder problem.
Explain out loud as you solve. Interviewers are grading your reasoning, not just your final code.

If you want a structured, topic-wise way to drill these (plus language-specific interview Q&A, system design, and mock interviews), I put together InterviewPitch — it's free and organized so you can practice pattern by pattern instead of jumping between random blog posts.

What pattern do you find hardest to spot under pressure? Curious what trips people up most — drop it in the comments.