Icône de message
Passer au contenu du pied de page
  1. Génération PDF en Python
  2. Blog IronPDF for Python
  3. Comparaisons de produits
  4. FastAPI Python
COMPARAISONS DE PRODUITS

FastAPI Python (Comment cela fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

FastAPI est un cadre web moderne et performant pour créer des APIs avec Python. Il est conçu pour être facile à utiliser et à apprendre tout en offrant des fonctionnalités puissantes comme la validation automatique, la sérialisation et la documentation interactive automatique de l'API. De plus, il fonctionne avec n'importe quel moteur de template et vous permet d'utiliser n'importe quelle configuration de template par défaut nécessaire pour votre projet.

Plongeons dans les détails de FastAPI, ses fonctionnalités et comment l'utiliser efficacement. Plus tard dans cet article, nous examinerons également IronPDF, un package Python de génération de PDF de Iron Software.

Caractéristiques clés de FastAPI

  1. Haute performance : FastAPI est l'un des frameworks Python les plus rapides disponibles, comparable à Node.js et Go, grâce à son utilisation de Starlette pour les composants Web et de Pydantic pour les composants de données.
  2. Facilité d'utilisation : Il est conçu pour être intuitif et réduire le temps passé à lire la documentation. Le cadre tire parti des indications de type standard de Python pour la validation et la sérialisation des données.
  3. Documentation interactive automatique : FastAPI génère automatiquement une documentation API interactive utilisant OpenAPI et JSON Schema, accessible via /docs (Swagger UI) et /redoc (ReDoc). Toute mise à jour de l'API est automatiquement reflétée dans la documentation.
  4. Prise en charge des éditeurs : Excellente prise en charge de la saisie semi-automatique et de la vérification des types dans les éditeurs comme VS Code, ce qui accélère le développement et réduit les erreurs.
  5. Basé sur des normes : Il est basé sur (et entièrement compatible avec) les normes ouvertes pour les API : OpenAPI et JSON Schema.

Installation

Vous pouvez installer FastAPI et Uvicorn (un serveur ASGI) en utilisant pip :

pip install fastapi
pip install "uvicorn[standard]"
pip install fastapi
pip install "uvicorn[standard]"
SHELL

Créer votre première application FastAPI

Voici un exemple simple pour vous lancer avec FastAPI et exposer des données Python via une interface utilisateur :

from fastapi import FastAPI

# Create a FastAPI 'app' instance
app = FastAPI()

# Root path operation
@app.get("/")
def read_root():
    return {"Hello": "World"}

# Path operation for items including query parameter 'q'
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}
from fastapi import FastAPI

# Create a FastAPI 'app' instance
app = FastAPI()

# Root path operation
@app.get("/")
def read_root():
    return {"Hello": "World"}

# Path operation for items including query parameter 'q'
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}
PYTHON

Pour exécuter l'application, utilisez Uvicorn :

uvicorn main:app --reload
uvicorn main:app --reload
SHELL

Cette commande démarre un serveur de développement et recharge automatiquement lors des modifications de code. Vous pouvez accéder à la documentation API interactive à l'adresse http://127.0.0.1:8000/docs.

Fonctionnalités avancées

FastAPI prend en charge une large gamme de fonctionnalités avancées, ce qui le rend adapté aux applications complexes :

  1. Injection de dépendances : FastAPI fournit un système d'injection de dépendances puissant qui vous permet de gérer les dépendances de manière propre et efficace.
  2. Tâches en arrière-plan : Vous pouvez définir des tâches en arrière-plan à exécuter après le renvoi d'une réponse, utiles pour des tâches telles que l'envoi d'e-mails ou le traitement de données.
  3. WebSockets : FastAPI prend en charge les WebSockets, permettant une communication en temps réel entre le client et le serveur.
  4. Sécurité : FastAPI inclut des outils pour gérer la sécurité, notamment OAuth2, les jetons JWT, et plus encore.
  5. Intégration de bases de données : FastAPI peut être facilement intégré aux bases de données à l'aide de bibliothèques telles que SQLAlchemy ou Tortoise-ORM.

Exemple : Création d'une API CRUD

Construisons une API CRUD simple (Créer, Lire, Mettre à jour, Supprimer) pour gérer des éléments.

  1. Définir le modèle de données :
from pydantic import BaseModel

# Define a Pydantic model for the item with default description and tax
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None
from pydantic import BaseModel

# Define a Pydantic model for the item with default description and tax
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None
PYTHON
  1. Créez l'application FastAPI :
from fastapi import FastAPI, HTTPException

# Initialize 'app' instance and an empty 'items' dictionary
app = FastAPI()
items = {}

# Create operation: Add a new item
@app.post("/items/")
def create_item(item: Item):
    item_id = len(items) + 1
    items[item_id] = item
    return item

# Read operation: Retrieve an item by 'item_id'
@app.get("/items/{item_id}")
def read_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[item_id]

# Update operation: Replace an existing item
@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[item_id] = item
    return item

# Delete operation: Remove an item by 'item_id'
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[item_id]
    return {"message": "Item deleted"}
from fastapi import FastAPI, HTTPException

# Initialize 'app' instance and an empty 'items' dictionary
app = FastAPI()
items = {}

# Create operation: Add a new item
@app.post("/items/")
def create_item(item: Item):
    item_id = len(items) + 1
    items[item_id] = item
    return item

# Read operation: Retrieve an item by 'item_id'
@app.get("/items/{item_id}")
def read_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[item_id]

# Update operation: Replace an existing item
@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[item_id] = item
    return item

# Delete operation: Remove an item by 'item_id'
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[item_id]
    return {"message": "Item deleted"}
PYTHON

Présentation d'IronPDF

FastAPI Python (Fonctionnement pour les développeurs) : Figure 1

IronPDF est une bibliothèque Python puissante conçue pour créer, éditer et signer des PDF à partir de HTML, CSS, images et JavaScript. Elle offre des performances de qualité commerciale avec une empreinte mémoire faible. Les fonctionnalités clés incluent :

Conversion HTML en PDF

Convertissez des fichiers HTML, des chaînes HTML et des URLs en PDFs. Par exemple, vous pouvez rendre une page web en PDF en utilisant le moteur de rendu Chrome PDF.

Support multi-plateforme

Compatible avec diverses plateformes .NET, y compris .NET Core, .NET Standard et .NET Framework. Il prend en charge Windows, Linux et macOS.

Édition et signature

Définissez des propriétés, ajoutez de la sécurité avec des mots de passe et des permissions, et appliquez des signatures numériques à vos PDFs.

Templates de page et réglages

Personnalisez les PDFs avec des en-têtes, des pieds de page, des numéros de page et des marges ajustables. Prend en charge les mises en page adaptatives et les formats de papier personnalisés.

Conformité aux normes

Respecte les normes PDF telles que PDF/A et PDF/UA. Prend en charge l'encodage de caractères UTF-8 et gère les ressources comme les images, CSS et polices.

Générer des documents PDF avec IronPDF et FastAPI

pip install fastapi
pip install ironPDF
pip install fastapi
pip install ironPDF
SHELL 
from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import *

# Apply your IronPDF license key
License.LicenseKey = "key"

# Initialize 'app' instance
app = FastAPI()

# Route for simple greeting
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}

# Route that reads items with path and query parameters
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

# Route for generating a PDF document
@app.get("/pdf")
async def get_pdf(greet1: str = None, greet2: str = None):
    # Use ChromePdfRenderer to create PDF from HTML
    renderer = ChromePdfRenderer()
    content = "<h1>Document Generated using IronPDF with FastAPI GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs</p>"
    content += f"<p>Greetings from: {greet1}</p>"
    content += f"<p>And Greetings from: {greet2}</p>"
    pdf = renderer.RenderHtmlAsPdf(content)

    # Save the PDF to a file
    pdf.SaveAs("fastapi.pdf")

    # Create a response with the generated PDF
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }
    return FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)
from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import *

# Apply your IronPDF license key
License.LicenseKey = "key"

# Initialize 'app' instance
app = FastAPI()

# Route for simple greeting
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}

# Route that reads items with path and query parameters
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

# Route for generating a PDF document
@app.get("/pdf")
async def get_pdf(greet1: str = None, greet2: str = None):
    # Use ChromePdfRenderer to create PDF from HTML
    renderer = ChromePdfRenderer()
    content = "<h1>Document Generated using IronPDF with FastAPI GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs</p>"
    content += f"<p>Greetings from: {greet1}</p>"
    content += f"<p>And Greetings from: {greet2}</p>"
    pdf = renderer.RenderHtmlAsPdf(content)

    # Save the PDF to a file
    pdf.SaveAs("fastapi.pdf")

    # Create a response with the generated PDF
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }
    return FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)
PYTHON

Explication du code

Cet extrait de code montre l'intégration de IronPDF avec FastAPI pour générer dynamiquement des documents PDF basés sur les saisies des utilisateurs et les servir comme réponse téléchargeable.

  1. Définir la clé de licence : Applique la clé de licence IronPDF pour activer ses fonctionnalités.

  2. Initialisation de FastAPI : Initialise une instance FastAPI (app) pour gérer les requêtes HTTP.

  3. Gestionnaires de route basiques :

    • read_root(): Répond par un simple message JSON indiquant " Bonjour IronPDF" lors de l'accès à l'URL racine (/).
    • read_item(): Accepte un paramètre de chemin item_id et un paramètre de requête optionnel q. Renvoie une réponse JSON avec ces paramètres.

  4. Route de génération de PDF (/pdf) :

    • get_pdf(): Cette fonction asynchrone gère les requêtes GET vers le point de terminaison /pdf avec des paramètres de requête optionnels nommés greet1 et greet2.
    • Construit une chaîne HTML (content) qui comprend :
      • Un en-tête indiquant l'origine et le but du document.
      • Un paragraphe illustrant la génération de PDF à l'aide des entrées de l'utilisateur (greet1 et greet2).
    • Utilise ChromePdfRenderer() d' IronPDF pour convertir le contenu HTML en PDF (pdf = renderer.RenderHtmlAsPdf(content)).
    • Enregistre le PDF généré sous le nom " fastapi.pdf " (pdf.SaveAs("fastapi.pdf")).
  5. Servir le PDF :
    • Configure les en-têtes de réponse pour spécifier que le PDF doit être visualisé directement dans le navigateur ("Content-Disposition": "inline; filename=sample.pdf").
    • Crée un objet FileResponse pointant vers le fichier PDF généré avec le type de média approprié ("application/pdf").
    • Renvoie l'objet FileResponse, qui déclenche le téléchargement du document PDF lorsque le point de terminaison /pdf est accédé.

Cet extrait de code illustre comment IronPDF peut être intégré sans couture avec FastAPI pour générer et servir dynamiquement des documents PDF basés sur les saisies des utilisateurs. Il montre la capacité de convertir le contenu HTML en PDF, le rendant adapté aux applications nécessitant une génération de documents à la volée et une livraison via HTTP.

Sortie

Ci-dessous, le résultat swagger généré par les API

FastAPI Python (Fonctionnement pour les développeurs) : Figure 2

PDF

FastAPI Python (Fonctionnement pour les développeurs) : Figure 3

Licence IronPDF

IronPDF fonctionne sur la clé de licence pour Python. IronPDF for Python offre une clé de licence d'essai gratuit pour permettre aux utilisateurs de découvrir les fonctionnalités avant l'achat.

Placez la clé de licence au début du script avant d'utiliser le package IronPDF :

from ironpdf import *
# Apply your license key
License.LicenseKey = "key"
from ironpdf import *
# Apply your license key
License.LicenseKey = "key"
PYTHON

Conclusion

FastAPI est un cadre puissant et facile à utiliser pour créer des APIs en Python. FastAPI a une haute performance, une documentation automatique et des fonctionnalités avancées qui en font un excellent choix pour les débutants et les développeurs expérimentés. Que vous construisiez une API simple ou une application web complexe, FastAPI fournit les outils nécessaires pour réussir.

IronPDF est une bibliothèque Python robuste pour créer, manipuler et rendre des documents PDF à partir de contenu HTML. Il offre des fonctionnalités telles que la conversion HTML en PDF, la création de formulaires interactifs, la manipulation de PDF (fusion, division) et l'extraction de texte. Idéal pour générer des PDFs dynamiques avec facilité et s'intégrer dans diverses applications Python.

Questions Fréquemment Posées

Comment puis-je convertir du contenu HTML en PDF dans une application Python ?

Vous pouvez utiliser ChromePdfRenderer d'IronPDF pour convertir du contenu HTML, CSS, et JavaScript en fichier PDF. Cela permet une intégration transparente dans les applications Python pour générer des documents PDF à partir de contenu web.

Quels sont les avantages d'utiliser FastAPI pour créer des API ?

FastAPI offre une haute performance, une validation automatique, la sérialisation, et une documentation API interactive. Il exploite Starlette et Pydantic pour garantir rapidité et efficacité, comparables à Node.js et Go, tout en supportant des standards ouverts comme OpenAPI.

Comment puis-je servir un document PDF dans FastAPI ?

Vous pouvez servir un document PDF dans FastAPI en le générant avec IronPDF et en le retournant à l'aide de FileResponse de FastAPI. Cette approche vous permet de créer et de servir dynamiquement des PDF basés sur les demandes des clients.

Qu'est-ce qui rend FastAPI adapté aux applications en temps réel ?

FastAPI supporte WebSockets, qui permettent une communication en temps réel entre le client et le serveur, ce qui en fait un choix idéal pour les applications nécessitant des mises à jour de données instantanées ou des interactions en direct.

Comment FastAPI gère-t-il la validation et la sérialisation des données ?

FastAPI utilise des modèles Pydantic et des annotations de type standard de Python pour gérer la validation et la sérialisation des données. Cela garantit que les données d'entrée sont validées correctement et converties au format souhaité, réduisant les risques d'erreurs.

Quelles fonctionnalités de sécurité FastAPI offre-t-il ?

FastAPI fournit des fonctionnalités de sécurité robustes, y compris l'authentification OAuth2, JWT, et l'injection de dépendances, permettant aux développeurs de créer des applications sécurisées avec un minimum d'effort.

IronPDF peut-il être utilisé dans des applications multiplateformes ?

Oui, IronPDF est conçu pour être multiplateforme, supportant Windows, Linux, et macOS. Cela en fait un choix polyvalent pour les développeurs souhaitant intégrer la génération de PDF dans des applications fonctionnant sur différents systèmes d'exploitation.

Comment FastAPI améliore-t-il la productivité des développeurs ?

FastAPI améliore la productivité des développeurs en offrant une documentation API automatique, une complétion de code, et une vérification de type. Cela réduit le besoin d'une documentation manuelle extensive et aide à détecter des erreurs tôt dans le processus de développement.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi