# Características
## Características de FastAPI
**FastAPI** te provee lo siguiente:
### Basado en estándares abiertos
* OpenAPI para la creación de APIs, incluyendo declaraciones de path operations, parámetros, body requests, seguridad, etc.
* Documentación automática del modelo de datos con JSON Schema (dado que OpenAPI mismo está basado en JSON Schema).
* Diseñado alrededor de estos estándares después de un estudio meticuloso. En vez de ser una capa añadida a último momento.
* Esto también permite la **generación automática de código de cliente** para muchos lenguajes.
### Documentación automática
Documentación interactiva de la API e interfaces web de exploración. Hay múltiples opciones, dos incluídas por defecto, porque el framework está basado en OpenAPI.
* Swagger UI, con exploración interactiva, llama y prueba tu API directamente desde tu navegador.
* Documentación alternativa de la API con ReDoc.
### Simplemente Python moderno
Todo está basado en las declaraciones de tipo de **Python 3.8** estándar (gracias a Pydantic). No necesitas aprender una sintáxis nueva, solo Python moderno.
Si necesitas un repaso de 2 minutos de cómo usar los tipos de Python (así no uses FastAPI) prueba el tutorial corto: [Python Types](python-types.md){.internal-link target=_blank}.
Escribes Python estándar con tipos así:
```Python
from datetime import date
from pydantic import BaseModel
# Declaras la variable como un str
# y obtienes soporte del editor dentro de la función
def main(user_id: str):
return user_id
# Un modelo de Pydantic
class User(BaseModel):
id: int
name: str
joined: date
```
Este puede ser usado como:
```Python
my_user: User = User(id=3, name="John Doe", joined="2018-07-19")
second_user_data = {
"id": 4,
"name": "Mary",
"joined": "2018-11-30",
}
my_second_user: User = User(**second_user_data)
```
!!! info
`**second_user_data` significa:
Pasa las keys y los valores del dict `second_user_data` directamente como argumentos de key-value, equivalente a: `User(id=4, name="Mary", joined="2018-11-30")`
### Soporte del editor
El framework fue diseñado en su totalidad para ser fácil e intuitivo de usar. Todas las decisiones fueron probadas en múltiples editores antes de comenzar el desarrollo para asegurar la mejor experiencia de desarrollo.
En la última encuesta a desarrolladores de Python fue claro que la característica más usada es el "autocompletado".
El framework **FastAPI** está creado para satisfacer eso. El autocompletado funciona en todas partes.
No vas a tener que volver a la documentación seguido.
Así es como tu editor te puede ayudar:
* en Visual Studio Code:
* en PyCharm:
Obtendrás completado para tu código que podrías haber considerado imposible antes. Por ejemplo, el key `price` dentro del JSON body (que podría haber estado anidado) que viene de un request.
Ya no pasará que escribas los nombres de key equivocados, o que tengas que revisar constantemente la documentación o desplazarte arriba y abajo para saber si usaste `username` o `user_name`.
### Corto
Tiene **configuraciones por defecto** razonables para todo, con configuraciones opcionales en todas partes. Todos los parámetros pueden ser ajustados para tus necesidades y las de tu API.
Pero, todo **simplemente funciona** por defecto.
### Validación
* Validación para la mayoría (¿o todos?) los **tipos de datos** de Python incluyendo:
* Objetos JSON (`dict`).
* JSON array (`list`) definiendo tipos de ítem.
* Campos de texto (`str`) definiendo longitudes mínimas y máximas.
* Números (`int`, `float`) con valores mínimos y máximos, etc.
* Validación para tipos más exóticos como:
* URL.
* Email.
* UUID.
* ...y otros.
Toda la validación es manejada por **Pydantic**, que es robusto y sólidamente establecido.
### Seguridad y autenticación
La seguridad y la autenticación están integradas. Sin ningún compromiso con bases de datos ni modelos de datos.
Todos los schemes de seguridad están definidos en OpenAPI incluyendo:
* HTTP Basic.
* **OAuth2** (también con **JWT tokens**). Prueba el tutorial en [OAuth2 with JWT](tutorial/security/oauth2-jwt.md){.internal-link target=_blank}.
* API keys en:
* Headers.
* Parámetros de Query.
* Cookies, etc.
Más todas las características de seguridad de Starlette (incluyendo **session cookies**).
Todo ha sido construido como herramientas y componentes reutilizables que son fácilmente integrados con tus sistemas, almacenamiento de datos, bases de datos relacionales y no relacionales, etc.
### Dependency Injection
FastAPI incluye un sistema de Dependency Injection extremadamente poderoso y fácil de usar.
* Inclusive las dependencias pueden tener dependencias creando una jerarquía o un **"grafo" de dependencias**.
* Todas son **manejadas automáticamente** por el framework.
* Todas las dependencias pueden requerir datos de los requests y aumentar las restricciones del *path operation* y la documentación automática.
* **Validación automática** inclusive para parámetros del *path operation* definidos en las dependencias.
* Soporte para sistemas complejos de autenticación de usuarios, **conexiones con bases de datos**, etc.
* **Sin comprometerse** con bases de datos, frontends, etc. Pero permitiendo integración fácil con todos ellos.
### "Plug-ins" ilimitados
O dicho de otra manera, no hay necesidad para "plug-ins". Importa y usa el código que necesites.
Cualquier integración está diseñada para que sea tan sencilla de usar (con dependencias) que puedas crear un "plug-in" para tu aplicación en dos líneas de código usando la misma estructura y sintáxis que usaste para tus *path operations*.
### Probado
* Cobertura de pruebas al 100%.
* Base de código 100% anotada con tipos.
* Usado en aplicaciones en producción.
## Características de Starlette
**FastAPI** está basado y es completamente compatible con Starlette. Tanto así, que cualquier código de Starlette que tengas también funcionará.
`FastAPI` es realmente una sub-clase de `Starlette`. Así que, si ya conoces o usas Starlette, muchas de las características funcionarán de la misma manera.
Con **FastAPI** obtienes todas las características de **Starlette** (porque FastAPI es simplemente Starlette en esteroides):
* Desempeño realmente impresionante. Es uno de los frameworks de Python más rápidos, a la par con **NodeJS** y **Go**.
* Soporte para **WebSocket**.
* Soporte para **GraphQL**.
* Tareas en background.
* Eventos de startup y shutdown.
* Cliente de pruebas construido con HTTPX.
* **CORS**, GZip, Static Files, Streaming responses.
* Soporte para **Session and Cookie**.
* Cobertura de pruebas al 100%.
* Base de código 100% anotada con tipos.
## Características de Pydantic
**FastAPI** está basado y es completamente compatible con Pydantic. Tanto así, que cualquier código de Pydantic que tengas también funcionará.
Esto incluye a librerías externas basadas en Pydantic como ORMs y ODMs para bases de datos.
Esto también significa que en muchos casos puedes pasar el mismo objeto que obtuviste de un request **directamente a la base de datos**, dado que todo es validado automáticamente.
Lo mismo aplica para el sentido contrario. En muchos casos puedes pasarle el objeto que obtienes de la base de datos **directamente al cliente**.
Con **FastAPI** obtienes todas las características de **Pydantic** (dado que FastAPI está basado en Pydantic para todo el manejo de datos):
* **Sin dificultades para entender**:
* No necesitas aprender un nuevo micro-lenguaje de definición de schemas.
* Si sabes tipos de Python, sabes cómo usar Pydantic.
* Interactúa bien con tu **IDE/linter/cerebro**:
* Porque las estructuras de datos de Pydantic son solo instances de clases que tu defines, el auto-completado, el linting, mypy y tu intuición deberían funcionar bien con tus datos validados.
* **Rápido**:
* En benchmarks Pydantic es más rápido que todas las otras libraries probadas.
* Valida **estructuras complejas**:
* Usa modelos jerárquicos de modelos de Pydantic, `typing` de Python, `List` y `Dict`, etc.
* Los validadores también permiten que se definan fácil y claramente schemas complejos de datos. Estos son chequeados y documentados como JSON Schema.
* Puedes tener objetos de **JSON profundamente anidados** y que todos sean validados y anotados.
* **Extensible**:
* Pydantic permite que se definan tipos de datos a la medida o puedes extender la validación con métodos en un modelo decorado con el decorador de validación.
* Cobertura de pruebas al 100%.