### Valores de retorno

E elas também podem ou não retornar valores, eles não serão utilizados.

Então, você pode reutilizar uma dependência comum (que retorna um valor) que já seja utilizada em outro lugar, e mesmo que o valor não seja utilizado, a dependência será executada:

//// tab | Python 3.9+

```Python hl_lines="11  16"
{!> ../../docs_src/dependencies/tutorial006_an_py39.py!}
```

////

//// tab | Python 3.8+

E você também pode definir uma lista (`list`) de valores padrão caso nenhum seja informado:

```Python hl_lines="9"
{!../../docs_src/query_params_str_validations/tutorial012.py!}
```

Se você for até:

```
http://localhost:8000/items/
```

O valor padrão de `q` será: `["foo", "bar"]` e sua resposta será:

```JSON
{
  "q": [
    "foo",
    "bar"
  ]
}
```

Mesmo embora a especificação principal para web assíncrono em Python (ASGI) foi desenvolvida no Django, para adicionar suporte para WebSockets.

Esse tipo de assincronicidade é o que fez NodeJS popular (embora NodeJS não seja paralelo) e que essa seja a força do Go como uma linguagem de programa.

E esse é o mesmo nível de performance que você tem com o **FastAPI**.

///

```Python hl_lines="13"
{!> ../../docs_src/dependencies/tutorial005.py!}
```

////

Vamos focar nos parâmetros declarados:

* Mesmo que essa função seja uma dependência ("injetável") por si mesma, ela também declara uma outra dependência (ela "depende" de outra coisa).
    * Ela depende do `query_extractor`, e atribui o valor retornado pela função ao parâmetro `q`.

* Outros...

Darei exemplos mais concretos nos próximos capítulos.

## Reinicializações

Semelhante a garantir que seu aplicativo seja executado na inicialização, você provavelmente também deseja garantir que ele seja **reiniciado** após falhas.

### Nós cometemos erros

Nós, como humanos, cometemos **erros** o tempo todo. O software quase *sempre* tem **bugs** escondidos em lugares diferentes. 🐛

```Python hl_lines="1  15"
{!../../docs_src/debugging/tutorial001.py!}
```

### Sobre `__name__ == "__main__"`

O objetivo principal de `__name__ == "__main__"` é ter algum código que seja executado quando seu arquivo for chamado com:

<div class="termy">

```console
$ python myapp.py
```

</div>

mas não é chamado quando outro arquivo o importa, como em:

```Python

/// tip | "Dica"

Utilize a versão com `Annotated` se possível.

///

```Python hl_lines="15  20"
{!> ../../docs_src/dependencies/tutorial001.py!}
```

////

Ainda que `Depends` seja utilizado nos parâmetros da função da mesma forma que `Body`, `Query`, etc, `Depends` funciona de uma forma um pouco diferente.

Você fornece um único parâmetro para `Depends`.

Esse parâmetro deve ser algo como uma função.

Se você precisa de algo fácil de integrar com o FastAPI, mas que seja mais robusto, suportado por Redis, PostgreSQL ou outros, verifique o <a href="https://github.com/encode/broadcaster" class="external-link" target="_blank">encode/broadcaster</a>.

///

## Mais informações

/// info | "informação"



///

	Um token "bearer" não é a única opção.

	Mas é a melhor no nosso caso.

	E talvez seja a melhor para a maioria dos casos, a não ser que você seja um especialista em OAuth2 e saiba exatamente o porquê de existir outras opções que se adequam melhor às suas necessidades.

	Nesse caso, **FastAPI** também fornece as ferramentas para construir.

```Python hl_lines="13  15  22  25"
{!../../docs_src/background_tasks/tutorial002.py!}
```

Neste exemplo, as mensagens serão gravadas no arquivo `log.txt` _após_ o envio da resposta.

Se houver uma consulta na solicitação, ela será gravada no log em uma tarefa em segundo plano.