Dessa forma, se qualquer parte do código interno, extensão ou plug-in do Starlette lançar um `HTTPException` do Starlette, o seu manipulador poderá capturar e tratá-lo.

Neste exemplo, para poder ter ambos os `HTTPException` no mesmo código, a exceção do Starlette é renomeada para `StarletteHTTPException`:

```Python

Se você gerar um cliente para uma aplicação FastAPI usando tags, normalmente também separará o código do cliente com base nas tags.

Dessa forma, você poderá ter as coisas ordenadas e agrupadas corretamente para o código do cliente:

<img src="/img/tutorial/generate-clients/image06.png">

Nesse caso você tem:

* `ItemsService`
* `UsersService`

##### Porque usar hashing de senha { #why-use-password-hashing }

Se o seu banco de dados for roubado, o ladrão não terá as senhas em texto simples dos seus usuários, apenas os hashes.

Assim, o ladrão não poderá tentar usar essas mesmas senhas em outro sistema (como muitos usuários usam a mesma senha em todos os lugares, isso seria perigoso).

{* ../../docs_src/security/tutorial003_an_py310.py hl[82:85] *}

Ao retornar o resultado chamando `generate_html_response()`, você já está retornando uma `Response` que irá sobrescrever o comportamento padrão do **FastAPI**.

Mas como você passou `HTMLResponse` em `response_class` também, o **FastAPI** saberá como documentar isso no OpenAPI e na documentação interativa como um HTML com `text/html`:

<img src="/img/tutorial/custom-response/image01.png">

## Respostas disponíveis { #available-responses }

```Python hl_lines="2"
@app.get('/')
def results():
    results = some_library()
    return results
```

---

Si tu aplicación (de alguna manera) no tiene que comunicarse con nada más y esperar a que responda, usa `async def`, incluso si no necesitas usar `await` dentro.

---

Si simplemente no lo sabes, usa `def` normal.

---

O código após o `yield` é executado após a resposta:

{* ../../docs_src/dependencies/tutorial007_py310.py hl[5:6] *}

/// tip | Dica

Você pode usar funções assíncronas (`async`) ou funções comuns.

O **FastAPI** saberá o que fazer com cada uma, da mesma forma que as dependências comuns.

///

## Uma dependência com `yield` e `try` { #a-dependency-with-yield-and-try }

Tüm temel web kısımlarını ele almak; üzerine özellikler eklemek.

`FastAPI` sınıfı, doğrudan `Starlette` sınıfından miras alır.

Dolayısıyla Starlette ile yapabildiğiniz her şeyi, adeta “turbo şarjlı Starlette” olan **FastAPI** ile de doğrudan yapabilirsiniz.

///

### [Uvicorn](https://www.uvicorn.dev/) { #uvicorn }

montar una sub-aplicación (como se describe en [Aplicaciones secundarias - Monturas](sub-applications.md)) mientras usas un proxy con `root_path`, puedes hacerlo normalmente, como esperarías.

FastAPI usará internamente el `root_path` de manera inteligente, así que simplemente funcionará. ✨...

Por ejemplo, si declaras un parámetro de tipo `Hero`, será leído desde el **JSON body**.

De la misma manera, puedes declararlo como el **tipo de retorno** de la función, y luego la forma de los datos aparecerá en la interfaz automática de documentación de la API.

{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[40:45] hl[40:45] *}

```toml
[tool.fastapi]
entrypoint = "app.main:app"
```

isso é equivalente a importar como:

```python
from app.main import app
```

Dessa forma o comando `fastapi` saberá onde encontrar sua aplicação.

/// Note | Nota

Você também poderia passar o path para o comando, como:

```console
$ fastapi dev app/main.py
```