Python Full Stack Interview Questions

1. Basic Python Questions

• What are Python decorators? How are they used?
• Explain the difference between list, tuple, and set in Python.
• How does Python handle memory management?
• What is a lambda function in Python, and when would you use it?
• Explain the difference between shallow copy and deep copy in Python.

2. OOP and Advanced Concepts

• What is the difference between __init__ and __new__ methods?
• Explain method overloading and method overriding in Python.
• What is metaclass in Python? How is it useful?
• How would you handle exceptions in Python? Can you create custom exceptions?
• What are class methods and static methods? How are they different from instance methods?

3. Data Structures and Algorithms

• Write a Python function to reverse a linked list.
• How would you implement a stack using Python’s built-in data structures?
• How would you find the largest/smallest element in an unsorted list without using built-in functions?

4. Web Development Questions

• How do you manage sessions in Django or Flask?
• Explain the use of csrf_token in securing web forms.
• How do you handle file uploads in Django/Flask?
• What is the difference between GET and POST methods in HTTP?

5. Database and ORM

• How would you use Python’s SQLAlchemy or Django ORM to interact with a database?
• Explain how you would handle migrations in a Django project.
• How do you optimize database queries in a Python-based web application?

6. Testing

• What testing frameworks are available in Python, and how do you use them?
• How would you write a unit test for a Django or Flask view?
• How do you mock APIs or functions during testing?

7. Concurrency and Asynchronous Programming

• Explain the asyncio library in Python and its use cases.
• What is a GIL (Global Interpreter Lock), and how does it affect Python concurrency?
• How would you implement multithreading and multiprocessing in Python?

These questions cover a range of areas, including core Python, web development, databases, and advanced topics that a full stack developer might need.

Here are some advanced Python interview questions that focus on deeper concepts, optimizations, and advanced features of the language:

1. Decorators and Metaprogramming

• Q: What is a decorator in Python? How does it work? Can you create a decorator with arguments?
  • Explain how decorators work, using examples like function and class decorators, and creating decorators that accept arguments.
• Q: What are metaclasses in Python? How do you use them?
  • Explain the purpose of metaclasses, how to define them, and when they are useful, including practical use cases like altering class creation.

2. Memory Management and Optimization

• Q: How does Python’s memory management system work? Explain the role of reference counting and garbage collection.
  • Discuss memory allocation, object references, the garbage collector, and the gc module.
• Q: What are weak references in Python? How are they useful?
  • Explain the concept of weak references using the weakref module and their use in memory optimization, especially with cache systems.
• Q: How would you optimize the memory usage of a large data structure in Python?
  • Discuss strategies like using generators, __slots__ in classes, and libraries like numpy for more memory-efficient arrays.

3. Concurrency and Parallelism

• Q: Explain the Global Interpreter Lock (GIL) in Python. How does it affect multi-threading?
  • Detail the purpose of the GIL and how it limits true multi-threading in CPython, along with workarounds like multiprocessing or using asyncio.
• Q: What is the difference between multithreading and multiprocessing in Python? When would you use each?
  • Discuss Python’s threading and multiprocessing modules and use cases for CPU-bound and I/O-bound tasks.
• Q: Explain asynchronous programming in Python. How does asyncio work?
  • Discuss the event loop, async and await keywords, and how asynchronous programming can improve performance for I/O-bound tasks.

4. Descriptors and Class Customization

• Q: What is a descriptor in Python? How does it work in managing attributes?
  • Describe the descriptor protocol (__get__, __set__, __delete__) and how they are used in Python to control attribute access.
• Q: How does Python implement properties with the property() function or @property decorator?
  • Explain how properties are created and used for getter and setter methods, along with their use cases.

5. Dynamic and Functional Programming

• Q: How can you implement a dynamic method dispatch in Python?
  • Discuss techniques like using getattr() or method resolution order (MRO) for dynamically calling methods.
• Q: How would you implement a partial function in Python? What is its use case?
  • Explain how the functools.partial function works and how it can be used for function specialization.

6. Python Internals and Optimization

• Q: What are Python’s magic methods? Give examples of commonly used magic methods.
  • Discuss special methods like __init__, __call__, __str__, __repr__, and how they enhance class behavior in Python.
• Q: How does the __new__ method differ from __init__, and when would you override __new__?
  • Explain object creation and initialization, and why __new__ is useful for immutable types like tuple or str.
• Q: How do you profile the performance of a Python application?
  • Discuss tools like cProfile, timeit, and how to use them to optimize performance.

7. Type Hints and Static Typing

• Q: How does Python’s type hinting system work? Can you explain the use of mypy for static type checking?
  • Discuss how type hints are used, their benefits for large codebases, and how mypy can enforce type correctness.
• Q: What are generics in Python’s typing system? How would you define a generic class or function?
  • Explain the use of Generic and type variables in typing for defining classes and functions that operate on multiple types.

8. MetaProgramming with __getattr__, __setattr__, and __call__

• Q: What is the difference between __getattr__ and __getattribute__?
  • Discuss how Python retrieves attributes and the difference in usage between these two magic methods.
• Q: How does the __call__ method work in Python, and what is its use case?
  • Explain how objects can behave like functions by overriding __call__.

9. Serialization and Data Exchange

• Q: How would you serialize and deserialize Python objects? Compare pickle with json.
  • Discuss Python’s pickle and json modules, their use cases, and when one is preferred over the other.

10. Design Patterns in Python

• Q: Can you implement a Singleton design pattern in Python?
  • Demonstrate the Singleton pattern using Python’s flexibility (e.g., using a decorator or metaclass).
• Q: How would you implement the Observer pattern in Python?
  • Explain how to create the Observer pattern in Python, utilizing classes and instance methods for event handling.

These advanced questions cover deep knowledge of Python, including metaprogramming, memory management, concurrency, and Python internals. They are designed to assess an interviewee’s mastery of the language beyond the basics.