* el path `/`
* usando una <dfn title="un método HTTP GET"><code>get</code> operación</dfn>

/// info | Información sobre `@decorator`

Esa sintaxis `@algo` en Python se llama un "decorador".

Lo pones encima de una función. Como un bonito sombrero decorativo (supongo que de ahí viene el término).

Un "decorador" toma la función de abajo y hace algo con ella.

## Desactivar el resaltado de sintaxis { #disable-syntax-highlighting }

Por ejemplo, podrías desactivar el resaltado de sintaxis en Swagger UI.

Sin cambiar la configuración, el resaltado de sintaxis está activado por defecto:

<img src="/img/tutorial/extending-openapi/image02.png">

### Resumen { #recap }

En resumen, declaras **una vez** los tipos de parámetros, body, etc. como parámetros de función.

Lo haces con tipos estándar modernos de Python.

No tienes que aprender una nueva sintaxis, los métodos o clases de un paquete específico, etc.

Solo **Python** estándar.

Por ejemplo, para un `int`:

```Python
item_id: int
```

o para un modelo `Item` más complejo:

pasa el/los tipo(s) interno(s) como "parámetros de tipo" usando corchetes: `[` y `]`

```Python
my_list: list[str]
```

Eso es toda la sintaxis estándar de Python para declaraciones de tipo.

Usa esa misma sintaxis estándar para atributos de modelos con tipos internos.

Así, en nuestro ejemplo, podemos hacer que `tags` sea específicamente una "lista de strings":

![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)

### Solo Python moderno { #just-modern-python }

Todo está basado en declaraciones estándar de **tipos en Python** (gracias a Pydantic). Sin nueva sintaxis que aprender. Solo Python moderno estándar.

Si necesitas un repaso de 2 minutos sobre cómo usar tipos en Python (aunque no uses FastAPI), revisa el tutorial corto: [Tipos en Python](python-types.md).

something(some_argument, some_keyword_argument="foo")
```

entonces es un "callable".

## Clases como dependencias { #classes-as-dependencies_1 }

Puedes notar que para crear una instance de una clase en Python, utilizas esa misma sintaxis.

Por ejemplo:

```Python
class Cat:
    def __init__(self, name: str):
        self.name = name


fluffy = Cat(name="Mr Fluffy")
```

En este caso, `fluffy` es una instance de la clase `Cat`.

* declarar el parámetro de query `q` sin un `Query` ni ningún valor por defecto
* declarar el parámetro de path `item_id` usando `Path`
* tenerlos en un orden diferente
* no usar `Annotated`

...Python tiene una sintaxis especial para eso.

Pasa `*`, como el primer parámetro de la función.

# Introducción a Tipos en Python { #python-types-intro }

Python tiene soporte para "anotaciones de tipos" opcionales (también llamadas "type hints").

Estas **"anotaciones de tipos"** o type hints son una sintaxis especial que permite declarar el <dfn title="por ejemplo: str, int, float, bool">tipo</dfn> de una variable.

Al declarar tipos para tus variables, los editores y herramientas te pueden proporcionar un mejor soporte.

# Concurrencia y async / await { #concurrency-and-async-await }

Detalles sobre la sintaxis `async def` para *path operation functions* y algunos antecedentes sobre el código asíncrono, la concurrencia y el paralelismo.

## ¿Con prisa? { #in-a-hurry }

<abbr title="too long; didn't read - demasiado largo; no lo leí"><strong>TL;DR:</strong></abbr>

Si estás usando paquetes de terceros que te dicen que los llames con `await`, como:

```Python

Y genera esquemas OpenAPI.

Así es como funciona en Flask, Starlette, Responder, etc.

Pero luego, tenemos otra vez el problema de tener una micro-sintaxis, dentro de un string de Python (un gran YAML).

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.