@ -36,7 +36,7 @@ Django REST Framework fue creado por Tom Christie. El mismo creador de Starlette
///
/// check | Inspiró a **FastAPI** a
/// tip | Inspiró a **FastAPI** a
Tener una interfaz de usuario web de documentación automática de APIs.
@ -56,7 +56,7 @@ Esta separación de partes, y ser un "microframework" que podría extenderse par
Dada la simplicidad de Flask, parecía una buena opción para construir APIs. Lo siguiente a encontrar era un "Django REST Framework" para Flask.
/// check | Inspiró a **FastAPI** a
/// tip | Inspiró a **FastAPI** a
Ser un micro-framework. Haciendo fácil mezclar y combinar las herramientas y partes necesarias.
@ -98,7 +98,7 @@ def read_url():
Mira las similitudes entre `requests.get(...)` y `@app.get(...)`.
/// check | Inspiró a **FastAPI** a
/// tip | Inspiró a **FastAPI** a
* Tener un API simple e intuitivo.
* Usar nombres de métodos HTTP (operaciones) directamente, de una manera sencilla e intuitiva.
@ -118,7 +118,7 @@ En algún punto, Swagger fue entregado a la Linux Foundation, para ser renombrad
Es por eso que cuando se habla de la versión 2.0 es común decir "Swagger", y para la versión 3+ "OpenAPI".
/// check | Inspiró a **FastAPI** a
/// tip | Inspiró a **FastAPI** a
Adoptar y usar un estándar abierto para especificaciones de API, en lugar de usar un esquema personalizado.
@ -147,7 +147,7 @@ Estas funcionalidades son para lo que fue creado Marshmallow. Es un gran paquete
Pero fue creado antes de que existieran las anotaciones de tipos en Python. Así que, para definir cada <dfntitle="la definición de cómo deberían formarse los datos">esquema</dfn> necesitas usar utilidades y clases específicas proporcionadas por Marshmallow.
/// check | Inspiró a **FastAPI** a
/// tip | Inspiró a **FastAPI** a
Usar código para definir "esquemas" que proporcionen tipos de datos y validación automáticamente.
@ -163,13 +163,13 @@ Usa Marshmallow por debajo para hacer la validación de datos. Y fue creada por
Es una gran herramienta y la he usado mucho también, antes de tener **FastAPI**.
/// info | Información
/// note | Nota
Webargs fue creada por los mismos desarrolladores de Marshmallow.
///
/// check | Inspiró a **FastAPI** a
/// tip | Inspiró a **FastAPI** a
Tener validación automática de datos entrantes en una request.
@ -183,7 +183,7 @@ Pero la documentación todavía falta. Entonces APISpec fue creado.
Es un plug-in para muchos frameworks (y hay un plug-in para Starlette también).
La manera en que funciona es que escribes la definición del esquema usando el formato YAML dentro del docstring de cada función que maneja una ruta.
La manera en que funciona es que escribes la definición del esquema usando el formato YAML dentro del docstring de cada función que maneja un path.
Y genera esquemas OpenAPI.
@ -193,13 +193,13 @@ Pero luego, tenemos otra vez el problema de tener una micro-sintaxis, dentro de
El editor no puede ayudar mucho con eso. Y si modificamos parámetros o esquemas de Marshmallow y olvidamos también modificar ese docstring YAML, el esquema generado estaría obsoleto.
/// info | Información
/// note | Nota
APISpec fue creado por los mismos desarrolladores de Marshmallow.
///
/// check | Inspiró a **FastAPI** a
/// tip | Inspiró a **FastAPI** a
Soportar el estándar abierto para APIs, OpenAPI.
@ -225,13 +225,13 @@ Usarlo llevó a la creación de varios generadores de full-stack para Flask. Est
Y estos mismos generadores de full-stack fueron la base de los [Generadores de Proyectos **FastAPI**](project-generation.md).
/// info | Información
/// note | Nota
Flask-apispec fue creado por los mismos desarrolladores de Marshmallow.
///
/// check | Inspiró a **FastAPI** a
/// tip | Inspiró a **FastAPI** a
Generar el esquema OpenAPI automáticamente, desde el mismo código que define la serialización y validación.
@ -251,7 +251,7 @@ Pero como los datos de TypeScript no se preservan después de la compilación a
No puede manejar muy bien modelos anidados. Entonces, si el cuerpo JSON en la request es un objeto JSON que tiene campos internos que a su vez son objetos JSON anidados, no puede ser documentado y validado apropiadamente.
/// check | Inspiró a **FastAPI** a
/// tip | Inspiró a **FastAPI** a
Usar tipos de Python para tener un gran soporte del editor.
@ -271,7 +271,7 @@ Claramente inspiró a Uvicorn y Starlette, que actualmente son más rápidos que
///
/// check | Inspiró a **FastAPI** a
/// tip | Inspiró a **FastAPI** a
Encontrar una manera de tener un rendimiento impresionante.
@ -287,7 +287,7 @@ Está diseñado para tener funciones que reciben dos parámetros, un "request" y
Por lo tanto, la validación de datos, la serialización y la documentación, tienen que hacerse en código, no automáticamente. O tienen que implementarse como un framework sobre Falcon, como Hug. Esta misma distinción ocurre en otros frameworks que se inspiran en el diseño de Falcon, de tener un objeto request y un objeto response como parámetros.
/// check | Inspiró a **FastAPI** a
/// tip | Inspiró a **FastAPI** a
Buscar maneras de obtener un gran rendimiento.
@ -311,9 +311,9 @@ Requiere configuraciones un poquito más verbosas. Y dado que se basa en WSGI (e
El sistema de inyección de dependencias requiere pre-registrar las dependencias y las dependencias se resuelven en base a los tipos declarados. Por lo tanto, no es posible declarar más de un "componente" que proporcione cierto tipo.
Las rutas se declaran en un solo lugar, usando funciones declaradas en otros lugares (en lugar de usar decoradores que pueden colocarse justo encima de la función que maneja el endpoint). Esto se acerca más a cómo lo hace Django que a cómo lo hace Flask (y Starlette). Separa en el código cosas que están relativamente acopladas.
Los paths se declaran en un solo lugar, usando funciones declaradas en otros lugares (en lugar de usar decoradores que pueden colocarse justo encima de la función que maneja el endpoint). Esto se acerca más a cómo lo hace Django que a cómo lo hace Flask (y Starlette). Separa en el código cosas que están relativamente acopladas.
/// check | Inspiró a **FastAPI** a
/// tip | Inspiró a **FastAPI** a
Definir validaciones extra para tipos de datos usando el valor "default" de los atributos del modelo. Esto mejora el soporte del editor y no estaba disponible en Pydantic antes.
@ -335,13 +335,13 @@ Tiene una funcionalidad interesante e inusual: usando el mismo framework, es pos
Dado que se basa en el estándar previo para frameworks web Python sincrónicos (WSGI), no puede manejar Websockets y otras cosas, aunque aún así tiene un alto rendimiento también.
/// info | Información
/// note | Nota
Hug fue creado por Timothy Crosley, el mismo creador de [`isort`](https://github.com/timothycrosley/isort), una gran herramienta para ordenar automáticamente imports en archivos Python.
///
/// check | Ideas que inspiraron a **FastAPI**
/// tip | Ideas que inspiraron a **FastAPI**
Hug inspiró partes de APIStar, y fue una de las herramientas que encontré más prometedoras, junto a APIStar.
@ -375,7 +375,7 @@ Ya no era un framework web API, ya que el creador necesitaba enfocarse en Starle
Ahora APIStar es un conjunto de herramientas para validar especificaciones OpenAPI, no un framework web.
/// info | Información
/// note | Nota
APIStar fue creado por Tom Christie. El mismo que creó:
@ -385,7 +385,7 @@ APIStar fue creado por Tom Christie. El mismo que creó:
///
/// check | Inspiró a **FastAPI** a
/// tip | Inspiró a **FastAPI** a
Existir.
@ -409,7 +409,7 @@ Eso lo hace extremadamente intuitivo.
Es comparable a Marshmallow. Aunque es más rápido que Marshmallow en benchmarks. Y como está basado en las mismas anotaciones de tipos de Python, el soporte del editor es estupendo.
/// check | **FastAPI** lo usa para
/// tip | **FastAPI** lo usa para
Manejar toda la validación de datos, serialización de datos y documentación automática de modelos (basada en JSON Schema).
@ -452,7 +452,7 @@ No obstante, ya está siendo usado como un "estándar" por varias herramientas.
///
/// check | **FastAPI** lo usa para
/// tip | **FastAPI** lo usa para
Manejar todas las partes web centrales. Añadiendo funcionalidades encima.
@ -470,7 +470,7 @@ No es un framework web, sino un servidor. Por ejemplo, no proporciona herramient
Es el servidor recomendado para Starlette y **FastAPI**.
/// check | **FastAPI** lo recomienda como
/// tip | **FastAPI** lo recomienda como
El servidor web principal para ejecutar aplicaciones **FastAPI**.
Cuando declaras una *path operation function* con `def` normal en lugar de `async def`, se ejecuta en un threadpool externo que luego es esperado, en lugar de ser llamado directamente (ya que bloquearía el servidor).
### `fastapi dev` con path { #fastapi-dev-with-path }
### `fastapi dev` con path o con la opción CLI `--entrypoint`{ #fastapi-dev-with-path-or-with-entrypoint-cli-option }
También puedes pasar el path del archivo al comando `fastapi dev`, y adivinará el objeto app de FastAPI a usar:
@ -103,7 +103,13 @@ También puedes pasar el path del archivo al comando `fastapi dev`, y adivinará
$ fastapi dev main.py
```
Pero tendrías que recordar pasar el path correcto cada vez que llames al comando `fastapi`.
O también puedes pasar la opción `--entrypoint` al comando `fastapi dev`:
```console
$ fastapi dev --entrypoint main:app
```
Pero tendrías que recordar pasar el path\entrypoint correcto cada vez que llames al comando `fastapi`.
Adicionalmente, otras herramientas podrían no ser capaces de encontrarla, por ejemplo la [Extensión de VS Code](editor-support.md) o [FastAPI Cloud](https://fastapicloud.com), así que se recomienda usar el `entrypoint` en `pyproject.toml`.
@ -115,7 +121,7 @@ Por defecto, **auto-reload** está habilitado, recargando automáticamente el se
## `fastapi run` { #fastapi-run }
Ejecutar `fastapi run` inicia FastAPI en modo de producción por defecto.
Ejecutar `fastapi run` inicia FastAPI en modo de producción.
Por defecto, **auto-reload** está deshabilitado. También escucha en la dirección IP `0.0.0.0`, lo que significa todas las direcciones IP disponibles, de esta manera será accesible públicamente por cualquiera que pueda comunicarse con la máquina. Esta es la manera en la que normalmente lo ejecutarías en producción, por ejemplo, en un contenedor.
@ -179,7 +179,7 @@ Con **FastAPI** obtienes todas las funcionalidades de **Starlette** (ya que Fast
**FastAPI** es totalmente compatible con (y está basado en) [**Pydantic**](https://docs.pydantic.dev/). Por lo tanto, cualquier código adicional de Pydantic que tengas, también funcionará.
Incluyendo paquetes externos también basados en Pydantic, como <abbrtitle="Object-Relational Mapper – Mapeador Objeto-Relacional">ORM</abbr>s, <abbrtitle="Object-Document Mapper – Mapeador Objeto-Documento">ODM</abbr>s para bases de datos.
Incluyendo paquetes externos también basados en Pydantic, como <abbrtitle="Object-Relational Mapper - Mapeador Objeto-Relacional">ORM</abbr>s, <abbrtitle="Object-Document Mapper - Mapeador Objeto-Documento">ODM</abbr>s para bases de datos.
Esto también significa que, en muchos casos, puedes pasar el mismo objeto que obtienes de un request **directamente a la base de datos**, ya que todo se valida automáticamente.
@ -190,7 +190,7 @@ Con **FastAPI** obtienes todas las funcionalidades de **Pydantic** (ya que FastA
* **Sin complicaciones**:
* Sin micro-lenguaje de definición de esquemas nuevo que aprender.
* Si conoces los tipos en Python sabes cómo usar Pydantic.
* Se lleva bien con tu **<abbrtitle="Integrated Development Environment – Entorno de Desarrollo Integrado: similar a un editor de código">IDE</abbr>/<dfntitle="Un programa que verifica errores de código">linter</dfn>/cerebro**:
* Se lleva bien con tu **<abbrtitle="Integrated Development Environment - Entorno de Desarrollo Integrado: similar a un editor de código">IDE</abbr>/<dfntitle="Un programa que verifica errores de código">linter</dfn>/cerebro**:
* Porque las estructuras de datos de pydantic son solo instances de clases que defines; autocompletado, linting, mypy y tu intuición deberían funcionar correctamente con tus datos validados.
* Valida **estructuras complejas**:
* Uso de modelos jerárquicos de Pydantic, `List` y `Dict` de `typing` de Python, etc.
Al hacerlo, recibirás notificaciones (en tu email) cada vez que haya un nuevo lanzamiento (una nueva versión) de **FastAPI** con correcciones de bugs y nuevas funcionalidades.
## Conéctate con el autor { #connect-with-the-author }
Puedes conectar [conmigo (Sebastián Ramírez / `tiangolo`)](https://tiangolo.com), el autor.
Puedes:
* [Seguirme en **GitHub**](https://github.com/tiangolo).
* Ver otros proyectos de Código Abierto que he creado y que podrían ayudarte.
* Seguirme para ver cuándo creo un nuevo proyecto de Código Abierto.
* [Seguirme en **X (Twitter)**](https://x.com/tiangolo) o [Mastodon](https://fosstodon.org/@tiangolo).
* Contarme cómo usas FastAPI (me encanta oír eso).
* Enterarte cuando hago anuncios o lanzo nuevas herramientas.
* También puedes [seguir @fastapi en X (Twitter)](https://x.com/fastapi) (una cuenta aparte).
* [Seguirme en **LinkedIn**](https://www.linkedin.com/in/tiangolo/).
* Enterarte cuando hago anuncios o lanzo nuevas herramientas (aunque uso X (Twitter) más a menudo 🤷♂).
* Leer lo que escribo (o seguirme) en [**Dev.to**](https://dev.to/tiangolo) o [**Medium**](https://medium.com/@tiangolo).
* Leer otras ideas, artículos, y leer sobre las herramientas que he creado.
* Seguirme para leer lo que publico nuevo.
## Twittea sobre **FastAPI** { #tweet-about-fastapi }
[Twittea sobre **FastAPI**](https://x.com/compose/tweet?text=I'm loving @fastapi because... https://github.com/fastapi/fastapi) y dime a mí y a otros por qué te gusta. 🎉
Me encanta escuchar cómo se está utilizando **FastAPI**, qué te ha gustado, en qué proyecto/empresa lo estás usando, etc.
## Sigue al autor { #follow-the-author }
## Vota por FastAPI { #vote-for-fastapi }
Puedes seguir [a mí (Sebastián Ramírez / `tiangolo`)](https://tiangolo.com), el autor, en algunos lugares, para enterarte cuando tenga noticias para compartir sobre FastAPI y amigos:
* [Vota por **FastAPI** en Slant](https://www.slant.co/options/34241/~fastapi-review).
* [Vota por **FastAPI** en AlternativeTo](https://alternativeto.net/software/fastapi/about/).
* [Di que usas **FastAPI** en StackShare](https://stackshare.io/pypi-fastapi).
* [@tiangolo en **GitHub**](https://github.com/tiangolo).
* [@tiangolo en **X (Twitter)**](https://x.com/tiangolo)
* [@tiangolo.com en **Bluesky**](https://bsky.app/profile/tiangolo.com)
* [@tiangolo en **LinkedIn**](https://www.linkedin.com/in/tiangolo/).
## Ayuda a otros con preguntas en GitHub { #help-others-with-questions-in-github }
Puedes intentar ayudar a otros con sus preguntas en:
Puedes intentar ayudar a otros con sus preguntas en [GitHub Discussions](https://github.com/fastapi/fastapi/discussions/categories/questions?discussions_q=category%3AQuestions+is%3Aunanswered).
En muchos casos, probablemente ya conozcas la respuesta a esas preguntas. 🤓
En muchos casos, puede que ya conozcas la respuesta a esas preguntas. 🤓
Si estás ayudando mucho a la gente con sus preguntas, te convertirás en un [FastAPI Expert](fastapi-people.md#fastapi-experts) oficial. 🎉
Solo recuerda, el punto más importante es: trata de ser amable. La gente llega con sus frustraciones y, en muchos casos, no pregunta de la mejor manera, pero haz todo lo posible por ser amable. 🤗
La idea es que la comunidad de **FastAPI** sea amable y acogedora. Al mismo tiempo, no aceptes acoso o comportamiento irrespetuoso hacia los demás. Tenemos que cuidarnos unos a otros.
---
Aquí te explico cómo ayudar a otros con preguntas (en discusiones o issues):
### Entiende la pregunta { #understand-the-question }
* Revisa si puedes entender cuál es el **propósito** y el caso de uso de la persona que pregunta.
* Luego revisa si la pregunta (la gran mayoría son preguntas) es **clara**.
* En muchos casos, la pregunta planteada es sobre una solución imaginaria del usuario, pero podría haber una **mejor**. Si puedes entender mejor el problema y el caso de uso, podrías sugerir una mejor **solución alternativa**.
* Si no puedes entender la pregunta, pide más **detalles**.
### Reproduce el problema { #reproduce-the-problem }
Solo recuerda, el punto más importante es: intenta ser amable. 🤗
En la mayoría de los casos y preguntas hay algo relacionado con el **código original** de la persona.
### Cómo ayudar { #how-to-help }
En muchos casos solo copiarán un fragmento del código, pero eso no es suficiente para **reproducir el problema**.
* Puedes pedirles que proporcionen un [ejemplo mínimo, reproducible](https://stackoverflow.com/help/minimal-reproducible-example), que puedas **copiar-pegar** y ejecutar localmente para ver el mismo error o comportamiento que están viendo, o para entender mejor su caso de uso.
* Si te sientes muy generoso, puedes intentar **crear un ejemplo** así tú mismo, solo basado en la descripción del problema. Solo ten en cuenta que esto podría llevar mucho tiempo y podría ser mejor pedirles que aclaren el problema primero.
### Sugerir soluciones { #suggest-solutions }
* Después de poder entender la pregunta, puedes darles una posible **respuesta**.
* En muchos casos, es mejor entender su **problema subyacente o caso de uso**, porque podría haber una mejor manera de resolverlo que lo que están intentando hacer.
### Pide cerrar { #ask-to-close }
Si responden, hay una alta probabilidad de que hayas resuelto su problema, felicidades, ¡**eres un héroe**! 🦸
* Ahora, si eso resolvió su problema, puedes pedirles que:
* En GitHub Discussions: marquen el comentario como la **respuesta**.
* En GitHub Issues: **cierren** el issue.
## Observa el repositorio de GitHub { #watch-the-github-repository }
Puedes "observar" FastAPI en GitHub (haciendo clic en el botón "watch" en la parte superior derecha): [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). 👀
Si seleccionas "Watching" en lugar de "Releases only", recibirás notificaciones cuando alguien cree un nuevo issue o pregunta. También puedes especificar que solo deseas que te notifiquen sobre nuevos issues, discusiones, PRs, etc.
Luego puedes intentar ayudarlos a resolver esas preguntas.
Sigue la [guía sobre cómo ayudar](https://tiangolo.com/open-source/help/#help-others-with-questions-in-github) aquí.
## Haz preguntas { #ask-questions }
Puedes [crear una nueva pregunta](https://github.com/fastapi/fastapi/discussions/new?category=questions) en el repositorio de GitHub, por ejemplo, para:
Puedes [crear una nueva pregunta](https://github.com/fastapi/fastapi/discussions/new?category=questions) en el repositorio de GitHub, por ejemplo para:
* Hacer una **pregunta** o preguntar sobre un **problema**.
* Sugerir una nueva **funcionalidad**.
**Nota**: si lo haces, entonces te voy a pedir que también ayudes a otros. 😉
## Revisa Pull Requests { #review-pull-requests }
Puedes ayudarme a revisar pull requests de otros.
De nuevo, por favor, haz tu mejor esfuerzo por ser amable. 🤗
---
Aquí está lo que debes tener en cuenta y cómo revisar un pull request:
### Entiende el problema { #understand-the-problem }
* Primero, asegúrate de **entender el problema** que el pull request está intentando resolver. Podría tener una discusión más larga en una GitHub Discussion o issue.
* También hay una buena posibilidad de que el pull request no sea realmente necesario porque el problema se puede resolver de una manera **diferente**. Entonces puedes sugerir o preguntar sobre eso.
### No te preocupes por el estilo { #dont-worry-about-style }
* No te preocupes demasiado por cosas como los estilos de los mensajes de commit, yo haré squash y merge personalizando el commit manualmente.
* Tampoco te preocupes por las reglas de estilo, hay herramientas automatizadas verificando eso.
Y si hay alguna otra necesidad de estilo o consistencia, pediré directamente eso, o agregaré commits encima con los cambios necesarios.
### Revisa el código { #check-the-code }
* Revisa y lee el código, ve si tiene sentido, **ejecútalo localmente** y ve si realmente resuelve el problema.
* Luego **comenta** diciendo que hiciste eso, así sabré que realmente lo revisaste.
/// info | Información
Desafortunadamente, no puedo simplemente confiar en PRs que solo tienen varias aprobaciones.
Varias veces ha sucedido que hay PRs con 3, 5 o más aprobaciones, probablemente porque la descripción es atractiva, pero cuando reviso los PRs, en realidad están rotos, tienen un bug, o no resuelven el problema que dicen resolver. 😅
Así que, es realmente importante que realmente leas y ejecutes el código, y me hagas saber en los comentarios que lo hiciste. 🤓
///
* Si el PR se puede simplificar de alguna manera, puedes pedir eso, pero no hay necesidad de ser demasiado exigente, podría haber muchos puntos de vista subjetivos (y yo tendré el mío también 🙈), así que es mejor si puedes centrarte en las cosas fundamentales.
### Tests { #tests }
* Ayúdame a verificar que el PR tenga **tests**.
* Verifica que los tests **fallen** antes del PR. 🚨
* Luego verifica que los tests **pasen** después del PR. ✅
* Muchos PRs no tienen tests, puedes **recordarles** que agreguen tests, o incluso puedes **sugerir** algunos tests tú mismo. Eso es una de las cosas que consume más tiempo y puedes ayudar mucho con eso.
* Luego también comenta lo que intentaste, de esa manera sabré que lo revisaste. 🤓
## Crea un Pull Request { #create-a-pull-request }
Puedes [contribuir](contributing.md) al código fuente con Pull Requests, por ejemplo:
* Para corregir un error tipográfico que encontraste en la documentación.
* Para compartir un artículo, video o podcast que creaste o encontraste sobre FastAPI [editando este archivo](https://github.com/fastapi/fastapi/edit/master/docs/en/data/external_links.yml).
* Asegúrate de agregar tu enlace al inicio de la sección correspondiente.
* Para ayudar a [traducir la documentación](contributing.md#translations) a tu idioma.
* También puedes ayudar a revisar las traducciones creadas por otros.
* Para proponer nuevas secciones de documentación.
* Para corregir un issue/bug existente.
* Asegúrate de agregar tests.
* Para agregar una nueva funcionalidad.
* Asegúrate de agregar tests.
* Asegúrate de agregar documentación si es relevante.
## Ayuda a Mantener FastAPI { #help-maintain-fastapi }
¡Ayúdame a mantener **FastAPI**! 🤓
Hay mucho trabajo por hacer, y para la mayoría de ello, **TÚ** puedes hacerlo.
Las tareas principales que puedes hacer ahora son:
* [Ayudar a otros con preguntas en GitHub](#help-others-with-questions-in-github) (ver la sección arriba).
* [Revisar Pull Requests](#review-pull-requests) (ver la sección arriba).
Esas dos tareas son las que **consumen más tiempo**. Ese es el trabajo principal de mantener FastAPI.
Si puedes ayudarme con eso, **me estás ayudando a mantener FastAPI** y asegurando que siga **avanzando más rápido y mejor**. 🚀
## Únete al chat { #join-the-chat }
Únete al servidor de chat 👥 [Discord](https://discord.gg/VQjSZaeJmf) 👥 y charla con otros en la comunidad de FastAPI.
/// tip | Consejo
Para preguntas, házlas en [GitHub Discussions](https://github.com/fastapi/fastapi/discussions/new?category=questions), hay muchas más probabilidades de que recibas ayuda de parte de los [FastAPI Experts](fastapi-people.md#fastapi-experts).
Para preguntas, hazlas en GitHub Discussions, hay muchas más probabilidades de que recibas ayuda.
Usa el chat solo para otras conversaciones generales.
@ -241,16 +82,6 @@ Usa el chat solo para otras conversaciones generales.
Ten en cuenta que dado que los chats permiten una "conversación más libre", es fácil hacer preguntas que son demasiado generales y más difíciles de responder, por lo que es posible que no recibas respuestas.
En GitHub, la plantilla te guiará para escribir la pregunta correcta para que puedas obtener más fácilmente una buena respuesta, o incluso resolver el problema por ti mismo antes de preguntar. Y en GitHub puedo asegurarme de responder siempre todo, incluso si lleva tiempo. No puedo hacer eso personalmente con los sistemas de chat. 😅
Las conversaciones en los sistemas de chat tampoco son tan fácilmente buscables como en GitHub, por lo que las preguntas y respuestas podrían perderse en la conversación. Y solo las que están en GitHub cuentan para convertirse en un [FastAPI Expert](fastapi-people.md#fastapi-experts), por lo que probablemente recibirás más atención en GitHub.
Por otro lado, hay miles de usuarios en los sistemas de chat, por lo que hay muchas posibilidades de que encuentres a alguien con quien hablar allí, casi todo el tiempo. 😄
## Hazte sponsor del autor { #sponsor-the-author }
Si tu **producto/empresa** depende de o está relacionado con **FastAPI** y quieres llegar a sus usuarios, puedes hacerte sponsor del autor (de mí) a través de [GitHub sponsors](https://github.com/sponsors/tiangolo). Según el nivel, podrías obtener algunos beneficios extra, como una insignia en la documentación. 🎁
---
En GitHub, la plantilla te guiará para escribir la pregunta correcta para que puedas obtener más fácilmente una buena respuesta, o incluso resolver el problema tú mismo antes de preguntar.
¡Gracias! 🚀
Las conversaciones en los sistemas de chat tampoco son tan fáciles de buscar como en GitHub; se pierden.
Para saber más sobre [Pydantic, revisa su documentación](https://docs.pydantic.dev/).
@ -341,7 +341,7 @@ Todo esto puede sonar abstracto. No te preocupes. Verás todo esto en acción en
Lo importante es que al usar tipos estándar de Python, en un solo lugar (en lugar de agregar más clases, decoradores, etc.), **FastAPI** hará gran parte del trabajo por ti.
/// info | Información
/// note | Nota
Si ya revisaste todo el tutorial y volviste para ver más sobre tipos, un buen recurso es [la "cheat sheet" de `mypy`](https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html).
@ -4,7 +4,7 @@ Si estás construyendo una aplicación o una API web, rara vez podrás poner tod
**FastAPI** proporciona una herramienta conveniente para estructurar tu aplicación manteniendo toda la flexibilidad.
/// info | Información
/// note | Nota
Si vienes de Flask, esto sería el equivalente a los Blueprints de Flask.
@ -194,7 +194,7 @@ Tener `dependencies` en el `APIRouter` puede ser usado, por ejemplo, para requer
///
/// check | Revisa
/// tip | Consejo
Los parámetros `prefix`, `tags`, `responses`, y `dependencies` son (como en muchos otros casos) solo una funcionalidad de **FastAPI** para ayudarte a evitar la duplicación de código.
@ -339,7 +339,7 @@ También podríamos importarlos así:
from app.routers import items, users
```
/// info | Información
/// note | Nota
La primera versión es un "import relativo":
@ -382,7 +382,7 @@ Ahora, incluyamos los `router`s de los submódulos `users` y `items`:
Cuando trabajas en proyectos de Python probablemente deberías usar un **entorno virtual** (o un mecanismo similar) para aislar los paquetes que instalas para cada proyecto.
/// info | Información
/// note | Nota
Si ya sabes sobre entornos virtuales, cómo crearlos y usarlos, podrías querer saltar esta sección. 🤓
@ -18,7 +18,7 @@ Un **entorno virtual** es un directorio con algunos archivos en él.
///
/// info | Información
/// note | Nota
Esta página te enseñará cómo usar **entornos virtuales** y cómo funcionan.
Sebastián Ramírez
3 days ago
GitHub