Interview Questions
A Python Full Stack Developer is proficient in both frontend (HTML, CSS, JavaScript) and backend development, primarily using Python frameworks like Django, Flask, or FastAPI for server-side logic.
Python uses an automatic memory management system known as garbage collection. It
automatically manages the allocation and deallocation of memory for objects in the heap.
Python keeps track of all objects and frees memory that is no longer in use (garbage
collection) to make it available for future use.
Flask is a microframework that provides more control and flexibility, suitable for small projects. Django is a comprehensive framework with built-in features for larger projects.
Django, Flask, and FastAPI are popular frameworks. Django is full-featured and ideal for large projects, Flask is lightweight and flexible, while FastAPI is optimized for high-performance APIs.
Inheritance allows one class (subclass/child class) to inherit the attributes and methods of
another class (superclass/parent class). It promotes code reuse and allows you to create a
hierarchy of classes.
virtualenv creates isolated Python environments, ensuring that dependencies are contained within a project and preventing conflicts with other projects.
The Global Interpreter Lock (GIL) is a mutex (or lock) that allows only one thread to
execute Python bytecode at a time. This means that even on multi-core systems, Python
threads can't fully utilize multiple cores because threads are limited to run on a single
core at any given time due to the GIL. However, it is important to note that the GIL only
affects threads that are executing Python bytecode (e.g., running Python code). It does not
prevent multi-threading in general, as non-Python code (e.g., I/O-bound tasks, certain
libraries written in C) can still run concurrently.
Django manages static files through the STATICFILES_DIRS setting. During deployment, static files are collected using the collectstatic command to serve them efficiently in production.
Django middleware is a series of hooks that process requests and responses globally. Middleware components can modify requests before they reach the view and responses before they are returned to the client. Examples include authentication, session management, and security features.
Optimizing a Python web application involves several strategies, such as using caching (e.g., Redis, Memcached) to reduce database queries, employing asynchronous processing for long-running tasks (e.g., Celery), optimizing database queries using indexing, and minimizing the use of global variables to improve memory management.
