* loop (as in async loop): loop (do not translate to "bucle" or "ciclo")
* hard dependencies: dependencias obligatorias (do not translate to "dependencias duras")
* locking: locking (do not translate to "bloqueo")
* testing (as in software testing): escribir pruebas (do not translate to "probar")
* code base: code base (do not translate to "base de código")
* default: por defecto (do not translate to "predeterminado")

* el context manager
* la corrutina
* la sesión de base de datos
* el disco
* el dominio
* el motor
* el X falso
* el método HTTP GET
* el ítem
* el paquete
* el lifespan
* el bloqueo
* el middleware
* la aplicación móvil
* el módulo
* el montaje
* la red
* el origen
* el override
* el payload
* el procesador
* la propiedad
* el proxy
* el pull request

/// warning | Advertencia

Probablemente puedas saltarte esto.

Estos son detalles muy técnicos de cómo funciona **FastAPI** en su interior.

Si tienes bastante conocimiento técnico (coroutines, hilos, bloqueo, etc.) y tienes curiosidad sobre cómo FastAPI maneja `async def` vs `def` normal, adelante.

///

### Funciones de *path operation* { #path-operation-functions }

**FastAPI** los utiliza internamente para lograr esto.

///

## Dependencias con `yield` y `HTTPException` { #dependencies-with-yield-and-httpexception }

Viste que puedes usar dependencias con `yield` y tener bloques `try` que intentan ejecutar algo de código y luego ejecutar código de salida después de `finally`.

También puedes usar `except` para capturar la excepción que se lanzó y hacer algo con ella.

```Python
async with lifespan(app):
    await do_stuff()
```

Cuando creas un context manager o un async context manager como arriba, lo que hace es que, antes de entrar al bloque `with`, ejecutará el código antes del `yield`, y al salir del bloque `with`, ejecutará el código después del `yield`.

En nuestro ejemplo de código arriba, no lo usamos directamente, pero se lo pasamos a FastAPI para que lo use.

///

También podemos usar este mismo enfoque para acceder al request body en un manejador de excepciones.

Todo lo que necesitamos hacer es manejar el request dentro de un bloque `try`/`except`:

{* ../../docs_src/custom_request_and_route/tutorial002_an_py310.py hl[14,16] *}

También está diseñado para funcionar como una referencia futura para que puedas volver y ver exactamente lo que necesitas.

## Ejecuta el código { #run-the-code }

Todos los bloques de código pueden ser copiados y usados directamente (de hecho, son archivos Python probados).

Para ejecutar cualquiera de los ejemplos, copia el código a un archivo `main.py`, y comienza `fastapi dev` con:

<div class="termy">

{* ../../docs_src/custom_response/tutorial008_py39.py hl[2,10:12,14] *}

1. Esta es la función generadora. Es una "función generadora" porque contiene declaraciones `yield` dentro.
2. Al usar un bloque `with`, nos aseguramos de que el objeto similar a un archivo se cierre después de que la función generadora termine. Así, después de que termina de enviar el response.

* o gerenciador de contexto
* a corrotina
* a sessão do banco de dados
* o disco
* o domínio
* o mecanismo
* o X falso
* o método HTTP GET
* o item
* a biblioteca
* o lifespan
* o bloqueio
* o middleware
* a aplicação mobile
* o módulo
* a montagem
* a rede
* a origem
* a sobrescrita
* a carga útil
* o processador
* a propriedade
* o proxy
* o pull request

* E muitas outras coisas

## Conclusão { #conclusion }

Se você leu e entendeu tudo isso, agora **você sabe muito mais** sobre ambientes virtuais do que muitos desenvolvedores por aí. 🤓