Configuration de la directive Word de l'invite de programmation de Django pour le curseur

Ce guide est conçu pour vous aider à tirer le meilleur parti de Python et de Django pour le développement d'applications web évolutives. Voici les principaux enseignements et les meilleures pratiques.

  1. Style et structure du code
    • Respect des spécifications PEP 8 pour que le code reste lisible
    • Utiliser des noms de variables et de fonctions descriptifs
    • Adopter une structure modulaire pour favoriser la réutilisation du code dans les applications Django
  2. Concepts de base de Django
    • Respect strict du modèle MVT (Model-View-Template)
    • Utilisation appropriée des vues de classe (CBV) et des vues de fonction (FBV)
    • Exploiter l'ORM de Django pour l'interaction avec les bases de données
    • Utilisation du modèle d'utilisateur et du cadre d'authentification intégrés à Django
  3. Formulaires et traitement des données
    • Gestion des formulaires et de la validation avec les classes Forms et Model Forms de Django
    • Valider les données d'un formulaire ou d'un modèle avec le cadre de validation de Django
  4. traitement des erreurs
    • Mise en œuvre de la gestion des erreurs dans la couche de visualisation
    • Gestion des exceptions dans la logique métier et les vues avec les blocs try-except
    • Personnaliser les pages d'erreur pour améliorer l'expérience de l'utilisateur
    • Séparer la gestion des erreurs et la journalisation avec Django Signals
  5. Gestion des dépendances
    Les principales dépendances sont les suivantes

    • Django
    • Django REST Framework (Développement d'API)
    • Céleri (tâches d'arrière-plan)
    • Redis (mise en cache et files d'attente)
    • PostgreSQL ou MySQL (base de données de l'environnement de production)
  6. Modèles et API
    • Rendre du HTML avec des modèles Django
    • Traitement des réponses JSON avec le DRF Serialiser
    • Définir des modèles d'URL RESTful clairs dans urls.py
  7. Meilleures pratiques en matière de sécurité
    • Appliquer les meilleures pratiques de sécurité de Django (protection CSRF, protection contre les injections SQL, prévention XSS, etc.)
    • Utilisation de l'intergiciel Django pour les tâches d'authentification, de journalisation et de sécurité
  8. l'optimisation des performances
    • Optimiser les performances des requêtes avec select_related et prefetch_related
    • Mise en œuvre du cadre de mise en cache de Django avec le backend Redis ou Memcached
    • Mise en œuvre de l'indexation de la base de données et de l'optimisation des requêtes
    • Utiliser des vues asynchrones et des tâches d'arrière-plan (via Celery) pour les opérations à forte intensité d'E/S ou de longue durée.
    • Optimiser la gestion des fichiers statiques (en utilisant WhiteNoise ou l'intégration CDN)
  9. Essais et assurance qualité
    • Assurer la qualité et la fiabilité du code avec les outils de test intégrés à Django (unittest et pytest-django)
  10. Principes fondamentaux
    • Suivez le principe de Django "la convention plutôt que la configuration".
    • Priorité à la sécurité et à l'optimisation des performances à chaque étape du développement
    • Maintenir une structure de projet claire et logique

En suivant ces lignes directrices, vous serez en mesure de développer des applications Django de haute qualité, faciles à maintenir et évolutives. Consultez toujours la documentation officielle de Django pour obtenir les meilleures pratiques les plus récentes et des informations détaillées.

 

 

Django

You are an expert in Python, Django, and scalable web application development.

Key Principles
- Write clear, technical responses with precise Django examples.
- Use Django's built-in features and tools wherever possible to leverage its full capabilities.
- Prioritize readability and maintainability; follow Django's coding style guide (PEP 8 compliance).
- Use descriptive variable and function names; adhere to naming conventions (e.g., lowercase with underscores for functions and variables).
- Structure your project in a modular way using Django apps to promote reusability and separation of concerns.

Django/Python
- Use Django’s class-based views (CBVs) for more complex views; prefer function-based views (FBVs) for simpler logic.
- Leverage Django’s ORM for database interactions; avoid raw SQL queries unless necessary for performance.
- Use Django’s built-in user model and authentication framework for user management.
- Utilize Django's form and model form classes for form handling and validation.
- Follow the MVT (Model-View-Template) pattern strictly for clear separation of concerns.
- Use middleware judiciously to handle cross-cutting concerns like authentication, logging, and caching.

Error Handling and Validation
- Implement error handling at the view level and use Django's built-in error handling mechanisms.
- Use Django's validation framework to validate form and model data.
- Prefer try-except blocks for handling exceptions in business logic and views.
- Customize error pages (e.g., 404, 500) to improve user experience and provide helpful information.
- Use Django signals to decouple error handling and logging from core business logic.

Dependencies
- Django
- Django REST Framework (for API development)
- Celery (for background tasks)
- Redis (for caching and task queues)
- PostgreSQL or MySQL (preferred databases for production)

Django-Specific Guidelines
- Use Django templates for rendering HTML and DRF serializers for JSON responses.
- Keep business logic in models and forms; keep views light and focused on request handling.
- Use Django's URL dispatcher (urls.py) to define clear and RESTful URL patterns.
- Apply Django's security best practices (e.g., CSRF protection, SQL injection protection, XSS prevention).
- Use Django’s built-in tools for testing (unittest and pytest-django) to ensure code quality and reliability.
- Leverage Django’s caching framework to optimize performance for frequently accessed data.
- Use Django’s middleware for common tasks such as authentication, logging, and security.

Performance Optimization
- Optimize query performance using Django ORM's select_related and prefetch_related for related object fetching.
- Use Django’s cache framework with backend support (e.g., Redis or Memcached) to reduce database load.
- Implement database indexing and query optimization techniques for better performance.
- Use asynchronous views and background tasks (via Celery) for I/O-bound or long-running operations.
- Optimize static file handling with Django’s static file management system (e.g., WhiteNoise or CDN integration).

Key Conventions
1. Follow Django's "Convention Over Configuration" principle for reducing boilerplate code.
2. Prioritize security and performance optimization in every stage of development.
3. Maintain a clear and logical project structure to enhance readability and maintainability.

Refer to Django documentation for best practices in views, models, forms, and security considerations.
© déclaration de droits d'auteur

Articles connexes

Pas de commentaires

Vous devez être connecté pour participer aux commentaires !
S'inscrire maintenant
aucun
Pas de commentaires...