Ícono de mensaje
Saltar al pie de página
  1. IronPDF for Python
  2. Blog de IronPDF para Python
  3. Comparaciones de productos
  4. FastAPI Python
COMPARACIONES DE PRODUCTOS

FastAPI Python (Cómo Funciona Para Desarrolladores)

Curtis Chau
Curtis Chau
Actualizado:

FastAPI is a modern, high-performance web framework for building APIs with Python. It is designed to be easy to use and learn while providing powerful features like automatic validation, serialization, and automatic interactive API documentation. Additionally, it works with any template engine and allows you to use any default template configuration needed for your project.

Let’s dive into the details of FastAPI, its features, and how to use it effectively. Later in this article, we will also look into IronPDF, a PDF generation Python package from Iron Software.

Key Features of FastAPI

  1. High Performance: FastAPI is one of the fastest Python frameworks available, comparable to Node.js and Go, thanks to its use of Starlette for the web parts and Pydantic for the data parts.
  2. Ease of Use: It is designed to be intuitive and reduce the time spent reading documentation. The framework leverages standard Python-type hints for data validation and serialization.
  3. Automatic Interactive Documentation: FastAPI automatically generates interactive API documentation using OpenAPI and JSON Schema, accessible via /docs (Swagger UI) and /redoc (ReDoc). Any updates to the API are automatically reflected in the documentation.
  4. Editor Support: Excellent support for code completion and type checking in editors like VS Code, making development faster and reducing errors.
  5. Standards-Based: It is based on (and fully compatible with) the open standards for APIs: OpenAPI and JSON Schema.

Installation

You can install FastAPI and Uvicorn (an ASGI server) using pip:

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

Creating Your First FastAPI Application

Here’s a simple example to get you started with FastAPI and expose Python data through a user interface:

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

To run the application, use Uvicorn:

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

This command will start a development server and automatically reload for code changes. You can access the interactive API documentation at http://127.0.0.1:8000/docs.

Advanced Features

FastAPI supports a wide range of advanced features, making it suitable for complex applications:

  1. Dependency Injection: FastAPI provides a powerful dependency injection system that allows you to manage dependencies cleanly and efficiently.
  2. Background Tasks: You can define background tasks to be run after returning a response, useful for tasks like sending emails or processing data.
  3. WebSockets: FastAPI supports WebSockets, enabling real-time communication between the client and server.
  4. Security: FastAPI includes tools for handling security, including OAuth2, JWT tokens, and more.
  5. Database Integration: FastAPI can be easily integrated with databases using libraries like SQLAlchemy or Tortoise-ORM.

Example: Building a CRUD API

Let’s build a simple CRUD (Create, Read, Update, Delete) API for managing items.

  1. Define the Data Model:
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. Create the FastAPI Application:
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

Introducing IronPDF

FastAPI Python (How It Works For Developers): Figure 1

IronPDF is a powerful Python library designed for creating, editing, and signing PDFs from HTML, CSS, images, and JavaScript. It offers commercial-grade performance with a low memory footprint. Key features include:

HTML to PDF Conversion

Convert HTML files, HTML strings, and URLs to PDFs. For example, render a webpage as a PDF using the Chrome PDF renderer.

Cross-Platform Support

Compatible with various .NET platforms, including .NET Core, .NET Standard, and .NET Framework. It supports Windows, Linux, and macOS.

Editing and Signing

Set properties, add security with passwords and permissions, and apply digital signatures to your PDFs.

Page Templates and Settings

Customize PDFs with headers, footers, page numbers, and adjustable margins. Supports responsive layouts and custom paper sizes.

Standards Compliance

Adheres to PDF standards such as PDF/A and PDF/UA. Supports UTF-8 character encoding and handles assets like images, CSS, and fonts.

Generate PDF Documents using IronPDF and 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

Code Explanation

This code snippet demonstrates the integration of IronPDF with FastAPI to dynamically generate PDF documents based on user inputs and serve them as a downloadable response.

  1. Setting License Key: Applies the IronPDF license key to enable its features.

  2. FastAPI Initialization: Initializes a FastAPI instance (app) to handle HTTP requests.

  3. Basic Route Handlers:

    • read_root(): Responds with a simple JSON message indicating "Hello IronPDF" when accessing the root URL (/).
    • read_item(): Accepts an item_id path parameter and an optional q query parameter. Returns a JSON response with these parameters.

  4. PDF Generation Route (/pdf):

    • get_pdf(): This async function handles GET requests to the /pdf endpoint with optional query parameters named greet1 and greet2.
    • Constructs an HTML string (content) that includes:
      • A header indicating the document's origin and purpose.
      • A paragraph demonstrating PDF generation using user inputs (greet1 and greet2).
    • Uses ChromePdfRenderer() from IronPDF to render the HTML content into a PDF (pdf = renderer.RenderHtmlAsPdf(content)).
    • Saves the generated PDF as "fastapi.pdf" (pdf.SaveAs("fastapi.pdf")).
  5. Serving the PDF:
    • Configures response headers to specify that the PDF should be viewed inline in the browser ("Content-Disposition": "inline; filename=sample.pdf").
    • Creates a FileResponse object pointing to the generated PDF file with the appropriate media type ("application/pdf").
    • Returns the FileResponse object, which triggers the download of the PDF document when the /pdf endpoint is accessed.

This code snippet illustrates how IronPDF can be seamlessly integrated with FastAPI to dynamically generate and serve PDF documents based on user inputs. It showcases the ability to convert HTML content into PDFs, making it suitable for applications requiring on-the-fly document generation and delivery over HTTP.

Output

Below shows the swagger output generated from the APIs

FastAPI Python (How It Works For Developers): Figure 2

PDF

FastAPI Python (How It Works For Developers): Figure 3

IronPDF License

IronPDF runs on the license key for Python. IronPDF for Python offers a free trial license key to allow users to check out features before purchase.

Place the License Key at the start of the script before using the IronPDF package:

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

Conclusion

FastAPI is a powerful and easy-to-use framework for building APIs in Python. FastAPI has high performance, automatic documentation, and advanced features make it an excellent choice for both beginners and experienced developers. Whether you’re building a simple API or a complex web application, FastAPI provides the tools you need to succeed.

IronPDF is a robust Python library for creating, manipulating, and rendering PDF documents from HTML content. It offers features like HTML to PDF conversion, interactive form creation, PDF manipulation (merging, splitting), and text extraction. Ideal for generating dynamic PDFs with ease and integrating into various Python applications.

Preguntas Frecuentes

¿Cómo puedo convertir contenido HTML a PDF en una aplicación Python?

Puedes usar el ChromePdfRenderer de IronPDF para convertir contenido HTML, CSS y JavaScript en un archivo PDF. Esto permite una integración fluida en aplicaciones Python para generar documentos PDF a partir de contenido web.

¿Cuáles son los beneficios de usar FastAPI para construir APIs?

FastAPI ofrece alto rendimiento, validación automática, serialización y documentación interactiva de API. Aprovecha Starlette y Pydantic para garantizar velocidad y eficiencia, comparable a Node.js y Go, al tiempo que admite estándares abiertos como OpenAPI.

¿Cómo puedo servir un documento PDF en FastAPI?

Puedes servir un documento PDF en FastAPI generándolo con IronPDF y retornándolo usando FileResponse de FastAPI. Este enfoque te permite crear y servir dinámicamente PDFs basados en solicitudes de clientes.

¿Qué hace que FastAPI sea adecuado para aplicaciones en tiempo real?

FastAPI admite WebSockets, lo que permite la comunicación en tiempo real entre el cliente y el servidor, convirtiéndolo en una elección ideal para aplicaciones que requieren actualizaciones instantáneas de datos o interacciones en vivo.

¿Cómo maneja FastAPI la validación y serialización de datos?

FastAPI utiliza modelos Pydantic y sugerencias de tipos estándar de Python para manejar la validación y serialización de datos. Esto asegura que los datos de entrada sean correctamente validados y convertidos al formato deseado, reduciendo el error.

¿Qué características de seguridad ofrece FastAPI?

FastAPI proporciona características de seguridad robustas, incluyendo OAuth2, autenticación JWT, e inyección de dependencias, permitiendo a los desarrolladores construir aplicaciones seguras con un esfuerzo mínimo.

¿Puede IronPDF ser usado en aplicaciones multiplataforma?

Sí, IronPDF está diseñado para ser multiplataforma, compatible con Windows, Linux y macOS. Esto lo convierte en una opción versátil para desarrolladores que buscan integrar la generación de PDF en aplicaciones que se ejecutan en diferentes sistemas operativos.

¿Cómo mejora FastAPI la productividad del desarrollador?

FastAPI mejora la productividad del desarrollador ofreciendo documentación automática de API, autocompletado de código y verificación de tipos. Esto reduce la necesidad de documentación manual extensa y ayuda a detectar errores temprano en el proceso de desarrollo.

Curtis Chau
Curtis Chau
  Chatea con el equipo de ingeniería ahora
Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Comenzar prueba gratuita