Python Full Stack Interview Questions and Answers

1. How do you implement WebSockets in Flask?

Answer:
Flask supports WebSockets through extensions like Flask-SocketIO. This allows for real-time communication between the server and client.

Example:

from flask_socketio import SocketIO, emit app = Flask(__name__) socketio = SocketIO(app) @socketio.on('message') def handle_message(data): emit('response', {'data': 'Message received!'}) if __name__ == '__main__': socketio.run(app)

2. Explain the concept of Celery and its integration with Flask.

Answer:
Celery is an asynchronous task queue/job queue based on distributed message passing. It's used to handle background tasks in Flask applications, such as sending emails, processing long-running tasks, etc. Celery uses a message broker like RabbitMQ or Redis to queue tasks.

Example integration with Flask:

from celery import Celery from flask import Flask app = Flask(__name__) app.config['CELERY_BROKER_URL'] = 'redis://localhost:6379/0' app.config['CELERY_RESULT_BACKEND'] = 'redis://localhost:6379/0' celery = Celery(app.name, broker=app.config['CELERY_BROKER_URL']) celery.conf.update(app.config) @celery.task def long_running_task(): # long task return 'Task complete!' @app.route('/start_task') def start_task(): long_running_task.apply_async() return "Task started!"

3. What are Flask’s Application Context and Request Context?

Answer:

• Application Context: It contains information about the Flask application itself. It is pushed to the context stack when the application starts processing a request.

• Request Context: It contains information about the current HTTP request. It includes objects like request, session, and g.

4. How do you improve the performance of a Django application?

Answer:
You can improve Django performance through several techniques:

• Database optimization: Use indexing, select_related, and prefetch_related for optimizing database queries.

• Caching: Implement caching using Django’s caching framework (e.g., Memcached, Redis).

• Optimize static files: Compress and minify static files, use CDN for delivering assets.

• Database sharding: Split large databases into smaller chunks to reduce load.

5. Explain the concept of Docker Compose.

Answer:
Docker Compose is a tool for defining and running multi-container Docker applications. Using a docker-compose.yml file, you can configure the services, networks, and volumes required to run your application.

Example docker-compose.yml for Flask:

version: '3' services: web: build: . ports: - "5000:5000" db: image: postgres:latest environment: POSTGRES_PASSWORD: example

6. How do you use Redis for caching in Flask?

Answer:
You can integrate Redis into Flask using the Flask-Redis or redis-py library. Redis is often used to cache frequent queries and session data.

Example:

from flask import Flask, request from redis import Redis app = Flask(__name__) redis = Redis(host='localhost', port=6379) @app.route('/get_data') def get_data(): cached_data = redis.get('data') if cached_data: return cached_data else: data = "Expensive query result" redis.set('data', data) return data

7. Explain Django’s Middleware and how to write custom middleware.

Answer:
Middleware is a lightweight, low-level plugin system for globally altering the request and response objects. It’s useful for tasks like authentication, logging, and modifying request/response objects.

Example of custom middleware:

from django.utils.deprecation import MiddlewareMixin class MyCustomMiddleware(MiddlewareMixin): def process_request(self, request): # Modify request object here pass def process_response(self, request, response): # Modify response object here return response

8. What are Django’s signals, and how do you use them?

Answer:
Signals allow certain senders to notify other parts of the application when certain actions occur. They help decouple application components. For example, you can use signals for automatic tasks like sending emails after a user registers.

Example:

from django.db.models.signals import post_save from django.dispatch import receiver @receiver(post_save, sender=User) def send_welcome_email(sender, instance, **kwargs): send_email(instance.email)

9. What are the best practices for handling security in Django?

Answer:

• Enable CSRF protection (enabled by default in Django).

• Use HTTPS for secure communication.

• Hash passwords using PBKDF2, bcrypt, or Argon2 (Django uses PBKDF2 by default).

• Implement permissions and access control using Django's permission system.

• Use Django security middleware to prevent clickjacking, XSS, and SQL injection.

10. How do you implement a microservice architecture using Python (Django/Flask)?

Answer:
You can implement microservices by breaking down a large application into smaller, independently deployable services. Each service typically handles a specific domain and communicates via RESTful APIs or message brokers (e.g., RabbitMQ, Kafka).

Example:

• User Service (handles user registration)

• Order Service (handles order processing)

Each service can be built with Flask or Django and deployed independently, while they communicate with each other through HTTP or a message queue.

11. How do you handle rate limiting in a Flask application?

Answer:
Flask-Limiter is a popular extension for handling rate limiting in Flask. It helps prevent abuse of your API by limiting the number of requests a user can make within a certain period.

Example:

from flask_limiter import Limiter from flask import Flask app = Flask(__name__) limiter = Limiter(app) @app.route('/api', methods=['GET']) @limiter.limit("5 per minute") def api(): return "Rate limited API"

12. How would you implement JWT authentication in Flask?

Answer:
JWT (JSON Web Token) is commonly used for authentication in Flask applications. Flask-JWT-Extended is an extension for handling JWT-based authentication.

Example:

from flask_jwt_extended import JWTManager, jwt_required, create_access_token from flask import Flask app = Flask(__name__) app.config['JWT_SECRET_KEY'] = 'supersecretkey' jwt = JWTManager(app) @app.route('/login', methods=['POST']) def login(): access_token = create_access_token(identity='user') return {'access_token': access_token} @app.route('/protected', methods=['GET']) @jwt_required() def protected(): return "You are authorized!"

13. What is the difference between a synchronous and asynchronous application?

Answer:

• Synchronous: In a synchronous application, each request is handled one at a time, blocking until the current request is completed.

• Asynchronous: In an asynchronous application, requests can be handled concurrently without blocking, enabling better handling of I/O-bound tasks like HTTP requests or database queries.

Flask and Django are typically synchronous, but you can make them asynchronous using libraries like Celery or AsyncIO.

14. How do you scale a Flask/Django application?

Answer:
Scaling a Flask/Django application involves:

• Vertical scaling: Increasing the resources (CPU, memory) of the server.

• Horizontal scaling: Running multiple instances of the application behind a load balancer.

• Database sharding: Distributing data across multiple databases.

• Caching: Using tools like Redis or Memcached to cache frequently accessed data.

• CDN: Using a Content Delivery Network to serve static files.

15. What is a Load Balancer, and how is it used in scaling?

Answer:
A load balancer is a device or service that distributes incoming traffic across multiple instances of an application. It helps ensure high availability and fault tolerance by preventing any single server from being overwhelmed.

Example services: AWS Elastic Load Balancer, NGINX, HAProxy.

16. What is Flask-Admin, and how do you use it?

Answer:
Flask-Admin is an extension that adds an administrative interface to Flask applications. It automatically generates CRUD interfaces for models and integrates with SQLAlchemy.

Example:

from flask_admin import Admin from flask_admin.contrib.sqla import ModelView from flask import Flask from flask_sqlalchemy import SQLAlchemy app = Flask(__name__) db = SQLAlchemy(app) admin = Admin(app, name='Admin Dashboard') admin.add_view(ModelView(User, db.session))

17. Explain the concept of database migrations and how Alembic works in Flask.

Answer:
Alembic is a lightweight database migration tool for SQLAlchemy. It helps keep track of changes in the database schema and apply them incrementally.

Commands:

flask db init flask db migrate flask db upgrade

**18. How do you implement asynchronoustasks in Django using Celery?** Answer:
You can implement asynchronous tasks by integrating Celery into Django and using a message broker (e.g., Redis).

Example:

from celery import Celery from django.conf import settings app = Celery('tasks', broker=settings.CELERY_BROKER_URL) @app.task def add(x, y): return x + y

19. What is Django ORM and how does it differ from raw SQL?

Answer:
Django ORM (Object-Relational Mapping) allows developers to interact with the database using Python objects rather than writing raw SQL queries. It abstracts SQL queries into higher-level Python methods.

Example:

# ORM query users = User.objects.filter(age__gte=18) # Raw SQL query users = User.objects.raw('SELECT * FROM user WHERE age >= 18')

20. How do you manage database transactions in Django?

Answer:
Django provides transaction management to wrap a set of database operations into a single unit, ensuring all operations are committed successfully or rolled back in case of failure.

Example:

from django.db import transaction with transaction.atomic(): user = User.objects.create(name="John") profile = Profile.objects.create(user=user)

21. How do you integrate third-party services (e.g., payment gateways, email providers) into a Flask app?

Answer:
You can integrate third-party services by installing relevant libraries or using REST APIs. Most services like Stripe or SendGrid provide Python SDKs.

Example with Stripe:

import stripe stripe.api_key = 'your_secret_key' @app.route('/charge', methods=['POST']) def charge(): stripe.Charge.create( amount=500, currency='usd', source=request.form['stripeToken'] ) return 'Charge successful!'

22. How do you implement search functionality in a Flask/Django application?

Answer:
You can implement search using Elasticsearch or database queries with text search capabilities.

Example using SQLAlchemy:

@app.route('/search') def search(): query = request.args.get('query') results = Item.query.filter(Item.name.contains(query)).all() return render_template('results.html', results=results)

23. What are some strategies for securing a Flask API?

Answer:

• Use JWT or OAuth for authentication.

• Enable CORS only for trusted domains.

• Use rate limiting to prevent abuse.

• Sanitize user input to prevent SQL injection.

• Use HTTPS to encrypt communication.

24. What are some common performance bottlenecks in Django applications, and how do you optimize them?

Answer:

• Database queries: Optimize queries using indexing, select_related, and prefetch_related.

• Caching: Use Redis or Memcached for caching query results or views.

• Static files: Use CDNs and compress/minify static files.

25. Explain how to deploy a Flask/Django app to production using Docker.

Answer:
To deploy using Docker, you create a Dockerfile for your application and build a Docker image. The application is then run in a container.

Example Dockerfile for Flask:

FROM python:3.8-slim WORKDIR /app COPY requirements.txt . RUN pip install -r requirements.txt COPY . . CMD ["python", "app.py"]

Then, build and run the container:

docker build -t myapp . docker run -p 5000:5000 myapp

These advanced questions and answers will deepen your understanding of Python Full Stack development and prepare you for challenging technical interviews. Let me know if you need further clarification!