Python Interview Preparation: Master Common Questions & Answers

Prepare for Python interviews with our comprehensive guide covering fundamental concepts, data structures, object-oriented programming, and practical coding problems. This resource is designed to help you ace technical interviews at all levels.

Python Fundamentals

1. What are the main features of Python?

Python is a high-level, interpreted programming language known for its simplicity and readability. Key features include:

  • Interpreted: Code is executed line by line without compilation
  • Dynamic typing: Variable types are determined at runtime
  • Garbage collection: Automatic memory management
  • Extensive libraries: Rich ecosystem of third-party packages
  • Cross-platform: Runs on Windows, macOS, and Linux
2. Explain the difference between Python 2 and Python 3

Python 3 is the current and actively maintained version, while Python 2 was deprecated in 2020. Key differences include:

Python 2 vs Python 3 Examples 
# Python 2
print "Hello World"  # Statement
xrange(10)           # Returns xrange object

# Python 3  
print("Hello World") # Function
range(10)            # Returns range object
3. How is Python interpreted?

Python code is executed by an interpreter that translates it line by line into machine code at runtime. The standard interpreter, CPython, follows this process:

  1. Source code is parsed into an Abstract Syntax Tree (AST)
  2. AST is compiled into bytecode
  3. Bytecode is executed by the Python Virtual Machine (PVM)
4. What is PEP 8 and why is it important?

PEP 8 is Python's official style guide that provides conventions for writing readable and consistent code. Following PEP 8 ensures:

  • Consistent code formatting across projects
  • Better readability and maintainability
  • Easier collaboration with other developers
  • Professional code quality standards

Data Structures

5. Explain the difference between lists, tuples, and sets

Python provides several built-in data structures, each with unique characteristics:

Lists

Mutability: Mutable

Order: Ordered

Duplicates: Allowed

Use Case: Dynamic collections, frequent modifications

Tuples

Mutability: Immutable

Order: Ordered

Duplicates: Allowed

Use Case: Fixed collections, data integrity

Sets

Mutability: Mutable

Order: Unordered

Duplicates: Not allowed

Use Case: Unique elements, mathematical operations

Data Structure Examples 
# Lists - mutable and ordered
fruits = ['apple', 'banana', 'orange']
fruits.append('grape')  # Can modify
fruits[0] = 'pear'     # Can change elements

# Tuples - immutable and ordered
coordinates = (10, 20)
# coordinates[0] = 30  # This would raise an error

# Sets - mutable and unordered
unique_numbers = {1, 2, 3, 3, 4}  # Duplicates removed
unique_numbers.add(5)              # Can add elements
6. How do dictionaries work in Python?

Dictionaries are Python's implementation of hash tables, providing O(1) average time complexity for insertions, deletions, and lookups. They store key-value pairs where keys must be hashable.

Dictionary Operations 
# Creating and accessing dictionaries
student = {
    'name': 'John Doe',
    'age': 20,
    'courses': ['Math', 'Physics', 'Chemistry']
}

# Accessing values
print(student['name'])           # Direct access
print(student.get('age', 0))    # Safe access with default

# Modifying dictionaries
student['age'] = 21             # Update existing key
student['grade'] = 'A'          # Add new key-value pair

# Dictionary methods
print(student.keys())            # dict_keys(['name', 'age', 'courses', 'grade'])
print(student.values())          # dict_values(['John Doe', 21, ['Math', 'Physics', 'Chemistry'], 'A'])

Object-Oriented Programming

7. What is the difference between a class and an object?

A class is a blueprint or template that defines the structure and behavior of objects, while an object is an instance of a class with actual data and behavior.

Class and Object Example 
class Car:
    def __init__(self, brand, model, year):
        self.brand = brand      # Instance variable
        self.model = model      # Instance variable
        self.year = year        # Instance variable
    
    def start_engine(self):     # Instance method
        return f"{self.brand} {self.model} engine started"
    
    def get_info(self):         # Instance method
        return f"{self.year} {self.brand} {self.model}"

# Creating objects (instances) of the Car class
my_car = Car("Toyota", "Camry", 2020)
your_car = Car("Honda", "Civic", 2019)

print(my_car.start_engine())   # Output: Toyota Camry engine started
print(your_car.get_info())     # Output: 2019 Honda Civic
8. Explain inheritance in Python

Inheritance allows a class to inherit attributes and methods from another class, promoting code reuse and establishing hierarchical relationships.

Inheritance Example 
class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        pass

class Dog(Animal):              # Dog inherits from Animal
    def speak(self):            # Method overriding
        return f"{self.name} says Woof!"
    
    def fetch(self):            # Dog-specific method
        return f"{self.name} fetches the ball"

class Cat(Animal):              # Cat inherits from Animal
    def speak(self):            # Method overriding
        return f"{self.name} says Meow!"

# Using inheritance
dog = Dog("Buddy")
cat = Cat("Whiskers")

print(dog.speak())              # Output: Buddy says Woof!
print(cat.speak())              # Output: Whiskers says Meow!
print(dog.fetch())              # Output: Buddy fetches the ball

Advanced Concepts

9. What are decorators in Python?

Decorators are functions that modify the behavior of other functions without changing their source code. They use the @ syntax and are commonly used for logging, authentication, and performance measurement.

Decorator Examples 
import time

def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} took {end_time - start_time:.4f} seconds")
        return result
    return wrapper

@timer_decorator
def slow_function():
    time.sleep(1)
    return "Function completed"

# Using the decorator
result = slow_function()  # Output: slow_function took 1.0012 seconds
10. Explain list comprehensions

List comprehensions provide a concise way to create lists based on existing sequences or iterables. They are more readable and often faster than traditional for loops.

List Comprehension Examples 
# Traditional for loop
squares = []
for i in range(10):
    squares.append(i ** 2)

# List comprehension (equivalent)
squares = [i ** 2 for i in range(10)]

# With conditional filtering
even_squares = [i ** 2 for i in range(10) if i % 2 == 0]

# Nested list comprehension
matrix = [[i + j for j in range(3)] for i in range(0, 9, 3)]

print(squares)        # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(even_squares)   # [0, 4, 16, 36, 64]
print(matrix)         # [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

Coding Problems

11. Reverse a string in Python

There are several ways to reverse a string in Python. Here are the most common approaches:

String Reversal Methods 
def reverse_string_slice(text):
    """Using string slicing - most Pythonic way"""
    return text[::-1]

def reverse_string_loop(text):
    """Using a loop - more explicit approach"""
    reversed_text = ""
    for char in text:
        reversed_text = char + reversed_text
    return reversed_text

def reverse_string_recursive(text):
    """Using recursion - elegant but not efficient for long strings"""
    if len(text) <= 1:
        return text
    return reverse_string_recursive(text[1:]) + text[0]

# Test the functions
test_string = "Hello, World!"
print(f"Original: {test_string}")
print(f"Slice method: {reverse_string_slice(test_string)}")
print(f"Loop method: {reverse_string_loop(test_string)}")
print(f"Recursive method: {reverse_string_recursive(test_string)}")
12. Find the first non-repeating character

This is a common interview question that tests understanding of data structures and algorithms:

First Non-Repeating Character 
from collections import Counter

def first_non_repeating_char(string):
    """
    Find the first non-repeating character in a string.
    Returns the character or None if all characters repeat.
    """
    # Count occurrences of each character
    char_count = Counter(string)
    
    # Find first character with count 1
    for char in string:
        if char_count[char] == 1:
            return char
    
    return None

# Test cases
test_cases = [
    "leetcode",      # Should return 'l'
    "loveleetcode",  # Should return 'v'
    "aabb",          # Should return None
    "python",        # Should return 'p'
]

for test in test_cases:
    result = first_non_repeating_char(test)
    print(f"'{test}' -> '{result}'")

Best Practices

13. Python coding best practices

Following best practices ensures your code is readable, maintainable, and follows Python conventions:

  • Use meaningful variable names: Choose descriptive names that explain the purpose
  • Follow PEP 8: Use consistent indentation, spacing, and naming conventions
  • Write docstrings: Document your functions and classes
  • Handle exceptions properly: Use try-except blocks for error handling
  • Use list comprehensions: When appropriate, they're more readable than loops
  • Keep functions small: Single responsibility principle
Best Practices Example 
def calculate_average_salary(employee_salaries):
    """
    Calculate the average salary from a list of employee salaries.
    
    Args:
        employee_salaries (list): List of numeric salary values
        
    Returns:
        float: Average salary rounded to 2 decimal places
        
    Raises:
        ValueError: If the input list is empty or contains non-numeric values
    """
    if not employee_salaries:
        raise ValueError("Employee salaries list cannot be empty")
    
    try:
        total_salary = sum(employee_salaries)
        average_salary = total_salary / len(employee_salaries)
        return round(average_salary, 2)
    except TypeError:
        raise ValueError("All salary values must be numeric")

# Good usage
try:
    salaries = [50000, 60000, 75000, 65000]
    avg = calculate_average_salary(salaries)
    print(f"Average salary: ${avg}")
except ValueError as e:
    print(f"Error: {e}")

Interview Tips

14. How to approach Python interview questions

Success in Python interviews requires both technical knowledge and problem-solving skills:

  1. Understand the problem: Ask clarifying questions before coding
  2. Plan your approach: Think about time and space complexity
  3. Start with brute force: Begin with a simple solution, then optimize
  4. Test your code: Use examples to verify your solution
  5. Discuss trade-offs: Explain the pros and cons of your approach
15. Common interview question categories

Python interviews typically cover these areas:

  • Language fundamentals: Data types, control structures, functions
  • Data structures: Lists, dictionaries, sets, tuples
  • Object-oriented programming: Classes, inheritance, polymorphism
  • Algorithms: Sorting, searching, recursion
  • Problem-solving: String manipulation, array problems
  • Best practices: Code quality, testing, debugging

Practice Makes Perfect

The key to success in Python interviews is consistent practice. Work on coding problems daily, understand the underlying concepts, and practice explaining your solutions clearly. Remember, interviews are not just about getting the right answer—they're about demonstrating your problem-solving process and communication skills.

Ready to practice?

Check out our Python exercises and projects to strengthen your skills, or explore our Python fundamentals for a solid foundation.

Additional Resources