Python Interview Questions | Freshers to Advanced (2026 Update)

Python is one of the most important languages in Indian tech hiring in 2026. From TCS and Infosys service roles to startups, analytics teams, QA automation jobs, and product company interviews, python interview questions appear again and again because Python is used almost everywhere.

This guide is built like a complete interview notebook. Freshers can start with basics, 1–3 year developers can focus on intermediate concepts, experienced candidates can revise advanced Python, and data or testing candidates can jump to their own sections. Each answer uses simple language, real examples, and code wherever it makes sense.

Why Python Dominates Tech Interviews in 2026

Python dominates because it is easy to read, quick to build with, and powerful enough for real production work. For a student, Python feels like writing English. For a company, Python means faster development, easy automation, strong data libraries, and a huge hiring pool.

Python’s role across jobs — dev, data, AI, automation, testing

Python is no longer only a “beginner language.” A backend developer may use Python with Django, FastAPI, or Flask. A data analyst may use pandas and NumPy. A machine learning engineer may use scikit-learn, PyTorch, or TensorFlow. A QA engineer may use Selenium and pytest. A DevOps engineer may write scripts to automate deployments. That is why many interview questions for python start with simple syntax but quickly move into practical use cases.

What Indian companies actually ask

Indian companies usually test three things: whether you understand Python basics, whether you can solve coding problems, and whether you can apply Python in the role. For freshers, common python interview questions include data types, lists, tuples, dictionaries, OOPs, functions, loops, and basic programs. For experienced developers, interviewers ask decorators, generators, async, memory management, APIs, testing, design patterns, and performance.

How to use this guide by experience level

• Freshers: Finish the fresher section, OOPs section, and coding section first.
• 1–3 years: Focus on intermediate Python, file handling, modules, iterators, testing, and real examples.
• 3–5+ years: Revise decorators, GIL, async, multiprocessing, memory, descriptors, and clean code decisions.
• Data analysts: Add pandas, NumPy, SQLAlchemy, missing data, merge, groupby, and visualization basics.

Python Interview Questions for Freshers

This section covers python interview questions for freshers and python interview questions for beginners. The goal is not to memorize definitions like a school exam. The goal is to understand the idea so clearly that you can explain it in your own words during an interview.

What is Python? Key features explained simply

Python is a high-level, interpreted programming language. Think of it like a friendly notebook where you write instructions in simple English-like syntax, and Python executes them step by step. It is used for web development, automation, data analysis, AI, scripting, testing, and backend systems.

Key features: easy syntax, large library support, object-oriented programming, cross-platform usage, automatic memory management, and strong community support.

print("Hello, interview!")
name = "Aarav"
print(f"Welcome, {name}")

Interpreted vs compiled — what does it actually mean?

A compiled language is like cooking all food in the kitchen first and then serving it. An interpreted language is like preparing and serving step by step. Python code is first converted into bytecode and then executed by the Python Virtual Machine.

# You run Python directly:
python app.py
# You do not manually create an executable before running it.

Data types — int, float, string, bool with examples

Data types are like labels on boxes. If a box contains whole numbers, Python treats it as int. If it contains decimal values, it is float. If it contains text, it is str. If it contains true/false, it is bool.

age = 21          # int
price = 499.99    # float
course = "Python" # string
is_hired = True   # bool
print(type(age), type(price), type(course), type(is_hired))

Mutable vs immutable — the most asked fresher question

Mutable means changeable. Immutable means not changeable after creation. Imagine a notebook page and a printed certificate. You can edit the notebook page, but the certificate is fixed. Lists, dictionaries, and sets are mutable. Strings, tuples, integers, and floats are immutable.

marks = [80, 90, 95]
marks[0] = 85
print(marks)  # [85, 90, 95]
name = "Riya"
# name[0] = "P" gives an error because strings are immutable
name = "Piya"  # this creates a new string

List vs Tuple vs Set vs Dictionary — when to use what

These four are like different storage options in your room. A list is a school bag where order matters and items can repeat. A tuple is a sealed packet. A set is a unique-items box. A dictionary is a contact book with name-value pairs.

items = ["pen", "book", "pen"]
point = (10, 20)
unique_items = {"pen", "book"}
student = {"name": "Neha", "age": 20}

How does memory management work in Python?

Python manages memory automatically, like a hostel warden assigning and freeing rooms. When you create an object, Python gives it memory. When no variable is using that object, Python can remove it using reference counting and garbage collection.

x = [1, 2, 3]
y = x  # both x and y point to the same list
del x  # list still exists because y refers to it
print(y)

What is PEP 8 and why does it matter?

PEP 8 is Python’s style guide. It tells developers how to write clean and readable Python code. Think of it like traffic rules. Everyone reaches faster when everyone follows the same system.

# Good PEP 8 style
def calculate_total_price(price, tax):
    return price + tax

# Avoid unclear names
def ctp(p, t):
    return p + t

Namespaces and scope (LEGB rule)

A namespace is like a classroom attendance register. It stores names and the objects they refer to. Scope decides where a variable can be used. Python follows the LEGB rule: Local, Enclosing, Global, Built-in.

x = "global"
def outer():
    x = "enclosing"
    def inner():
        x = "local"
        print(x)
    inner()
outer()

if __name__ == “__main__” — what does it do?

This line checks whether the file is being run directly or imported into another file. Imagine a student preparing notes. If the student presents directly, they speak. If someone else uses their notes, they should not automatically start speaking.

def main():
    print("Program started")

if __name__ == "__main__":
    main()

Shallow copy vs deep copy

A shallow copy copies the outer box but still shares inner boxes. A deep copy copies everything, including inner boxes. This matters when working with nested lists and dictionaries.

import copy
original = [[1, 2], [3, 4]]
shallow = copy.copy(original)
deep = copy.deepcopy(original)
original[0][0] = 99
print(shallow)  # inner list changed
print(deep)     # fully independent copy

Intermediate Python Interview Questions

These python interview questions are common for candidates with 1–3 years of experience. At this stage, interviewers expect more than syntax. They want to know whether you can write clean, practical, maintainable Python.

List comprehensions vs generator expressions

A list comprehension creates the full list immediately. A generator expression gives values one by one when needed. Think of a list as ordering the full thali at once, and a generator as getting one roti at a time when you ask.

squares_list = [x * x for x in range(5)]
squares_gen = (x * x for x in range(5))
print(squares_list)
print(next(squares_gen))

*args and **kwargs with real examples

*args collects extra positional arguments. **kwargs collects extra keyword arguments. It is like a form where fixed fields are known, but extra fields can still be accepted.

def student_profile(name, *skills, **details):
    print("Name:", name)
    print("Skills:", skills)
    print("Details:", details)

student_profile("Ankit", "Python", "SQL", city="Pune", experience=1)

Lambda functions — when to use, when not to

A lambda is a small anonymous function. Use it for simple one-line operations. Do not use it when logic becomes complex, because readability matters more than looking clever.

numbers = [1, 2, 3, 4]
squares = list(map(lambda x: x * x, numbers))
print(squares)

map(), filter(), reduce() with analogies

map() transforms every item, like giving every student 5 bonus marks. filter() keeps only matching items, like selecting students who passed. reduce() combines values into one result, like adding all marks.

from functools import reduce
nums = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, nums))
evens = list(filter(lambda x: x % 2 == 0, nums))
total = reduce(lambda a, b: a + b, nums)
print(doubled, evens, total)

Exception handling — try/except/else/finally

Exception handling is like having a backup plan during a college fest. Python uses try for risky code, except for handling errors, else when no error happens, and finally for cleanup.

try:
    number = int(input("Enter number: "))
    result = 100 / number
except ZeroDivisionError:
    print("Cannot divide by zero")
except ValueError:
    print("Please enter a valid number")
else:
    print("Result:", result)
finally:
    print("Program completed")

File I/O and context managers

File I/O means reading from and writing to files. A context manager automatically closes the file, like a library system that checks the book back in when you finish reading.

with open("notes.txt", "w") as file:
    file.write("Python interview preparation")

with open("notes.txt", "r") as file:
    content = file.read()
    print(content)

Modules vs packages vs libraries

A module is one Python file. A package is a folder of modules. A library is a collection of packages and modules designed for a purpose. Think of a module as one chapter, a package as a subject book, and a library as the full bookshelf.

import math
print(math.sqrt(25))

Iterators vs iterables

An iterable is something you can loop over, like a playlist. An iterator is the actual remote that gives you the next song one by one. Lists, tuples, strings, and dictionaries are iterables.

names = ["Asha", "Ravi", "Meera"]
iterator = iter(names)
print(next(iterator))
print(next(iterator))

List, dict, set comprehensions together

Comprehensions are shortcuts for creating collections. They make code smaller and often cleaner, but do not overuse them when logic becomes hard to read.

nums = [1, 2, 3, 4]
list_comp = [x * x for x in nums]
dict_comp = {x: x * x for x in nums}
set_comp = {x % 2 for x in nums}
print(list_comp, dict_comp, set_comp)

OOPs in Python Interview Questions

OOPs concepts in python interview questions are extremely important for freshers and experienced candidates. Even if you are applying for data analyst or automation testing roles, OOPs helps you explain structure, reuse, and clean code.

The 4 pillars with real-world analogies

The four pillars are encapsulation, abstraction, inheritance, and polymorphism. Encapsulation is like a medicine capsule hiding ingredients inside. Abstraction is like using Google Pay without knowing banking internals. Inheritance is like a child receiving family traits. Polymorphism is like the word “run” meaning different things in cricket, software, and daily life.

Class vs object — the blueprint analogy

A class is a blueprint. An object is the actual house built from that blueprint. In Python, a class defines properties and behavior, while objects hold actual values.

class Student:
    def study(self):
        print("Student is studying Python")

s1 = Student()
s1.study()

__init__ method explained

The __init__ method runs automatically when an object is created. It is like a college admission form that stores initial student details.

class Student:
    def __init__(self, name, course):
        self.name = name
        self.course = course

s1 = Student("Priya", "Python")
print(s1.name, s1.course)

Inheritance types with code (single, multiple, multilevel)

Inheritance allows one class to reuse another class’s code. This avoids repetition and helps create logical relationships.

# Single inheritance
class Parent:
    def guide(self):
        print("Parent guidance")

class Child(Parent):
    pass

Child().guide()

# Multiple inheritance
class Writer:
    def write(self):
        print("Writing")

class Coder:
    def code(self):
        print("Coding")

class TechnicalBlogger(Writer, Coder):
    pass

tb = TechnicalBlogger()
tb.write()
tb.code()

Polymorphism — overriding vs overloading

Polymorphism means one interface, many behaviors. Method overriding happens when a child class gives a new version of a parent method. Python does not support traditional method overloading like Java, but you can use default arguments or *args.

class Animal:
    def sound(self):
        print("Some sound")

class Dog(Animal):
    def sound(self):
        print("Bark")

Dog().sound()

def add(a, b=0, c=0):
    return a + b + c

print(add(2))
print(add(2, 3, 4))

Encapsulation — private vs public attributes

Encapsulation protects data from direct unwanted access. In Python, a single underscore means “internal use,” while double underscore triggers name mangling.

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance

    def get_balance(self):
        return self.__balance

account = BankAccount(5000)
print(account.get_balance())

Abstraction with ABC module

Abstraction hides implementation details and forces child classes to provide required methods. It is like a college assignment format: every student must submit, but the content differs.

from abc import ABC, abstractmethod

class Payment(ABC):
    @abstractmethod
    def pay(self, amount):
        pass

class UpiPayment(Payment):
    def pay(self, amount):
        print(f"Paid Rs.{amount} using UPI")

UpiPayment().pay(500)

MRO and C3 linearization

MRO means Method Resolution Order. When multiple classes have the same method, Python decides which method to call using C3 linearization. Think of it like a queue system that follows a fixed rule instead of random selection.

class A:
    def show(self):
        print("A")

class B(A):
    pass

class C(A):
    pass

class D(B, C):
    pass

print(D.mro())
D().show()

Advanced Python Interview Questions

Advanced python interview questions are usually asked for backend roles, senior automation roles, platform teams, data engineering roles, and python interview questions for 5 years experience. Here, interviewers care about internals, trade-offs, performance, and design decisions.

Decorators — what, why, how

A decorator is like a gift wrapper. It adds something extra around a function without changing the original function’s core content. Decorators are used for logging, authentication, timing, caching, and permissions.

def logger(func):
    def wrapper():
        print("Function started")
        func()
        print("Function ended")
    return wrapper

@logger
def greet():
    print("Hello Python")

greet()

Generators and yield

A generator produces values one at a time using yield. It is useful when you do not want to store a huge list in memory. Imagine a water purifier filling one glass at a time instead of storing 1,000 glasses.

def count_up_to(n):
    count = 1
    while count <= n:
        yield count
        count += 1

for num in count_up_to(3):
    print(num)

GIL — what it is and why it exists

GIL stands for Global Interpreter Lock. In standard CPython, it allows only one thread to execute Python bytecode at a time. It exists mainly to simplify memory management and protect internal objects. For I/O-heavy tasks, threading still helps. For CPU-heavy tasks, multiprocessing is usually better.

import threading

def task():
    print("Thread running")

t = threading.Thread(target=task)
t.start()
t.join()

Multithreading vs Multiprocessing vs Async

This is one of the most practical advanced python interview questions. The answer depends on the type of work. If your program waits for network or files, threads or async can help. If your program performs heavy calculations, multiprocessing is better.

Async/await and asyncio

Async programming lets Python handle waiting tasks efficiently. Imagine one waiter serving many tables. Instead of standing near one table until food is ready, the waiter takes another order and returns later.

import asyncio

async def fetch_data():
    print("Fetching...")
    await asyncio.sleep(1)
    print("Done")

asyncio.run(fetch_data())

Type hints and annotations

Type hints tell readers and tools what kind of data is expected. Python still remains dynamically typed, but type hints improve readability, editor support, and bug detection.

def calculate_total(price: float, quantity: int) -> float:
    return price * quantity

print(calculate_total(199.5, 2))

Metaclasses

A metaclass is a class that creates classes. If a class is a blueprint for objects, a metaclass is the blueprint factory. Most developers rarely need custom metaclasses, but interviewers may ask them in senior Python roles.

class Meta(type):
    def __new__(cls, name, bases, attrs):
        attrs["created_by"] = "Meta"
        return super().__new__(cls, name, bases, attrs)

class MyClass(metaclass=Meta):
    pass

print(MyClass.created_by)

Descriptors and __slots__

Descriptors control attribute access using methods like __get__, __set__, and __delete__. __slots__ restricts object attributes and can reduce memory usage when creating many objects.

class Student:
    __slots__ = ["name", "age"]

    def __init__(self, name, age):
        self.name = name
        self.age = age

s = Student("Karan", 22)
print(s.name)

Memory management — reference counting + GC

Python uses reference counting to track how many names point to an object. When the count becomes zero, memory can be released. It also has a garbage collector for cyclic references, like two friends holding each other's bags and nobody else claiming them.

import sys
data = []
print(sys.getrefcount(data))

Context managers — __enter__ / __exit__ vs contextlib

Context managers handle setup and cleanup automatically. You can create them using a class with __enter__ and __exit__, or using contextlib for simpler cases.

from contextlib import contextmanager

@contextmanager
def open_resource():
    print("Resource opened")
    yield
    print("Resource closed")

with open_resource():
    print("Using resource")

Python Interview Questions for Data Analysts & Data Engineers

Python interview questions for data analyst roles are different from pure developer interviews. Here, Python is tested with pandas, NumPy, SQL, ETL thinking, and data cleaning.

pandas — Series vs DataFrame

A Series is like one column in Excel. A DataFrame is like the full Excel sheet with rows and columns.

import pandas as pd
series = pd.Series([10, 20, 30])
df = pd.DataFrame({"name": ["A", "B"], "marks": [80, 90]})
print(series)
print(df)

NumPy arrays vs lists

Python lists are flexible, but NumPy arrays are faster for numerical operations. A list is like a mixed shopping bag. A NumPy array is like a packed box of the same item type, optimized for calculations.

import numpy as np
arr = np.array([1, 2, 3])
print(arr * 2)

Handling missing data in pandas

Missing data is common in real projects. You can remove it, fill it, or investigate why it is missing. In interviews, explain the business impact before jumping to code.

import pandas as pd
df = pd.DataFrame({"age": [20, None, 25]})
df["age"] = df["age"].fillna(df["age"].mean())
print(df)

GroupBy, merge, join in pandas

groupby summarizes data, like calculating average marks per class. merge combines DataFrames like SQL joins. join is often index-based merging.

sales = pd.DataFrame({"city": ["Pune", "Pune", "Mumbai"], "amount": [100, 200, 300]})
print(sales.groupby("city")["amount"].sum())

Python for ETL pipelines

ETL means Extract, Transform, Load. Python is used to pull data from files, APIs, or databases, clean it, and load it into another system.

def extract():
    return [{"name": "A", "marks": "90"}]

def transform(rows):
    return [{"name": r["name"], "marks": int(r["marks"])} for r in rows]

def load(rows):
    print("Loaded:", rows)

data = extract()
load(transform(data))

SQLAlchemy basics

SQLAlchemy helps Python talk to databases. It can be used for raw SQL or ORM-style models. For data engineers, it is useful for database connections and pipeline work.

from sqlalchemy import create_engine, text
engine = create_engine("sqlite:///example.db")
with engine.connect() as conn:
    result = conn.execute(text("SELECT 1"))
    print(result.scalar())

matplotlib vs seaborn

Matplotlib gives low-level control over charts. Seaborn is built on top of matplotlib and makes statistical plots easier. In data interviews, explain when you used charts to find patterns, not just which library you used.

import matplotlib.pyplot as plt
x = [1, 2, 3]
y = [10, 20, 15]
plt.plot(x, y)
plt.title("Simple Trend")
plt.show()

Python for Automation & Testing Interview Questions

Python interview questions for automation testing focus on Selenium, pytest, unittest, assertions, fixtures, mocking, and scripting. The interviewer wants to know whether you can automate repeatable tasks reliably.

Selenium with Python

Selenium automates browsers. It is like a robot user that can open a website, click buttons, fill forms, and check page behavior.

from selenium import webdriver
from selenium.webdriver.common.by import By
driver = webdriver.Chrome()
driver.get("https://example.com")
heading = driver.find_element(By.TAG_NAME, "h1").text
print(heading)
driver.quit()

pytest vs unittest

unittest comes built into Python and follows a class-based style. pytest is simpler, flexible, and popular in modern projects.

def add(a, b):
    return a + b

def test_add():
    assert add(2, 3) == 5

Writing test cases — assert, fixtures, mocking

assert checks expected output. Fixtures prepare reusable test data. Mocking replaces real external calls, like pretending a payment gateway responded successfully during testing.

from unittest.mock import Mock
payment_gateway = Mock()
payment_gateway.pay.return_value = "success"
assert payment_gateway.pay(500) == "success"

Automating tasks — os, shutil, subprocess

Python can automate file movement, folder creation, command execution, and report generation. This is useful for QA, DevOps, and office automation.

import os, shutil, subprocess
os.makedirs("backup", exist_ok=True)
shutil.copy("notes.txt", "backup/notes.txt")
result = subprocess.run(["python", "--version"], capture_output=True, text=True)
print(result.stdout)

Python Coding Interview Questions

Coding rounds test how you think. You do not need to write fancy code. You need clean logic, edge cases, and time complexity. These are top python interview questions for coding rounds.

String reversal and palindrome check

A palindrome reads the same forward and backward, like "madam." Interviewers ask this to check string slicing and basic logic.

def is_palindrome(text):
    cleaned = text.lower().replace(" ", "")
    return cleaned == cleaned[::-1]

print(is_palindrome("madam"))
print(is_palindrome("hello"))

Find duplicates in a list

Use a set to track seen items. This is like checking names at a fest entry gate. If a name appears again, it is a duplicate.

def find_duplicates(items):
    seen = set()
    duplicates = set()
    for item in items:
        if item in seen:
            duplicates.add(item)
        else:
            seen.add(item)
    return list(duplicates)

print(find_duplicates([1, 2, 3, 2, 4, 1]))

Fibonacci — iterative vs recursive

Fibonacci is a sequence where each number is the sum of the previous two. Recursive code looks elegant but can be slower without memoization.

def fib_iterative(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a

def fib_recursive(n):
    if n <= 1:
        return n
    return fib_recursive(n - 1) + fib_recursive(n - 2)

print(fib_iterative(6))
print(fib_recursive(6))

Two-pointer problems

Two pointers are like two students checking a line from both ends. This technique is common for sorted arrays, pair sums, reversals, and palindrome checks.

def two_sum_sorted(nums, target):
    left, right = 0, len(nums) - 1
    while left < right:
        total = nums[left] + nums[right]
        if total == target:
            return [left, right]
        elif total < target:
            left += 1
        else:
            right -= 1
    return []

print(two_sum_sorted([1, 2, 4, 6, 8], 10))

Stack/queue using lists

A stack is like a pile of plates: last in, first out. A queue is like a ticket counter line: first in, first out.

# Stack
stack = []
stack.append("A")
stack.append("B")
print(stack.pop())

# Queue
from collections import deque
queue = deque()
queue.append("A")
queue.append("B")
print(queue.popleft())

Sorting algorithms

Python has built-in sorting using sorted() and list.sort(). For interviews, know basic ideas like bubble sort, selection sort, merge sort, and quicksort.

students = [{"name": "Asha", "marks": 80}, {"name": "Ravi", "marks": 95}]
sorted_students = sorted(students, key=lambda x: x["marks"], reverse=True)
print(sorted_students)

Big O time & space complexity

Big O explains how code performance grows as input grows. If one student checks one notebook, it is small. If one student checks 10,000 notebooks one by one, time grows linearly.

# O(n) time because we visit every item once
def find_max(nums):
    maximum = nums[0]
    for num in nums:
        if num > maximum:
            maximum = num
    return maximum

Quick Revision Cheat Sheet

Use this table for fast revision before interviews. It covers basic python interview questions, python interview questions and answers for freshers, and quick reminders for experienced candidates.

How to Prepare for Python Interviews in 2026

Preparation is not about reading 500 python interview questions in one night. It is about practicing concepts, writing code, explaining your thinking, and connecting Python to the job role.

Fresher roadmap (0–6 months)

1. Month 1: Learn syntax, variables, loops, functions, strings, lists, tuples, sets, and dictionaries.
2. Month 2: Practice basic python interview questions and write 30–40 small programs.
3. Month 3: Learn OOPs, exceptions, file handling, modules, and packages.
4. Month 4: Solve coding problems on strings, arrays, recursion, sorting, searching, and dictionaries.
5. Month 5: Build two small projects like a resume parser, expense tracker, or automation script.
6. Month 6: Revise python interview questions and answers, give mock interviews, and explain your projects clearly.

Experienced developer prep checklist

• Revise decorators, generators, iterators, context managers, and async basics.
• Prepare real examples from your work instead of only textbook definitions.
• Know when to use list, tuple, set, dict, generator, thread, process, and async.
• Practice debugging, unit testing, logging, API handling, and database queries.
• Prepare one performance optimization story from a real or practice project.

Best free + paid resources

For free learning, use Python's official documentation, W3Schools for quick syntax revision, Real Python articles, freeCodeCamp tutorials, Kaggle notebooks for data practice, and LeetCode or HackerRank for coding. For paid learning, choose structured courses that include projects, assignments, and interview practice, not just video watching.

What Indian product companies specifically test

Product companies usually test problem solving, clean code, data structures, APIs, database basics, system thinking, and debugging. They may give a real problem and watch how you break it down. Service companies focus more on fundamentals, OOPs, SQL, and project explanation. Startups often care about practical ability: can you build, debug, and ship quickly?

1. Repeat the question in your own words to confirm understanding.
2. Ask about constraints such as input size, edge cases, and expected output.
3. Start with a simple brute-force idea before optimizing.
4. Write clean code with meaningful variable names.
5. Test with normal, edge, and empty inputs.
6. Explain time and space complexity calmly.

Frequently Asked Questions

Final Thoughts

Python interviews become easier when you stop memorizing and start understanding. This guide covered python interview questions from fresher basics to advanced topics, including OOPs, coding, data analysis, automation testing, and preparation strategy. Read one section at a time, write the code yourself, and practice explaining answers aloud. Your goal is not to sound like a textbook. Your goal is to sound clear, confident, and practical. Keep building, keep revising, and walk into your next Python interview like someone who truly understands the language.