def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}
```

<details markdown="1">
<summary>Tàbí lò <code>async def</code>...</summary>

Tí kóòdù rẹ̀ bá ń lò `async` / `await`, lò `async def`:

```Python hl_lines="9  14"
from typing import Union

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def read_root():
    return {"Hello": "World"}

  //       "key": "runlevel",
  //       "operator": "NotIn",
  //       "values": [
  //         "0",
  //         "1"
  //       ]
  //     }
  //   ]
  // }
  //
  // If instead you want to only run the webhook on any objects whose
  // namespace is associated with the "environment" of "prod" or "staging";
  // you will set the selector as follows:
  // "namespaceSelector": {
  //   "matchExpressions": [

Es spielt keine Rolle. **FastAPI** weiß, was zu tun ist.

/// note | "Hinweis"

Wenn Ihnen das nichts sagt, lesen Sie den [Async: *„In Eile?“*](../../async.md#in-eile){.internal-link target=_blank}-Abschnitt über `async` und `await` in der Dokumentation.

///

## Integriert in OpenAPI

Alle Requestdeklarationen, -validierungen und -anforderungen Ihrer Abhängigkeiten (und Unterabhängigkeiten) werden in dasselbe OpenAPI-Schema integriert.

/// tip | "Tipp"

Beachten Sie, dass wir, da wir Standard-`open()` verwenden, welches `async` und `await` nicht unterstützt, hier die Pfadoperation mit normalen `def` deklarieren.

///

### `FileResponse`

Streamt eine Datei asynchron als Response.

///

### 🔃 `def` 🆚 `async def`

📥 👥 ⚙️ 🇸🇲 📟 🔘 *➡ 🛠️ 🔢* & 🔗, &, 🔄, ⚫️ 🔜 🚶 & 🔗 ⏮️ 🔢 💽.

👈 💪 ⚠ 🚚 "⌛".

✋️ 🇸🇲 🚫 ✔️ 🔗 ⚙️ `await` 🔗, 🔜 ⏮️ 🕳 💖:

```Python
user = await db.query(User).first()
```

...& ↩️ 👥 ⚙️:

```Python
user = db.query(User).first()
```

⤴️ 👥 🔜 📣 *➡ 🛠️ 🔢* & 🔗 🍵 `async def`, ⏮️ 😐 `def`,:

      futures.add(
          executor.submit(
              new Callable<@Nullable Void>() {
                @Override
                public @Nullable Void call() throws Exception {
                  barrier.await();
                  Integer first = network.nodes().iterator().next();
                  for (Integer node : network.nodes()) {
                    Set<Integer> unused = network.successors(node);
                  }

    protected Map<String, String> propertyMap = new HashMap<>();

    protected Map<String, String> childUrlRuleMap = new LinkedHashMap<>();

    protected String defaultEncoding;

    // If you want to follow a html spec, use 512.
    protected int preloadSizeForCharset = 2048;

    protected Pattern invalidUrlPattern = Pattern.compile("^\\s*javascript:|" //
            + "^\\s*mailto:|" //
            + "^\\s*irc:|" //

      futures.add(
          executor.submit(
              new Callable<@Nullable Void>() {
                @Override
                public @Nullable Void call() throws Exception {
                  barrier.await();
                  Integer first = graph.nodes().iterator().next();
                  for (Integer node : graph.nodes()) {
                    Set<Integer> unused = graph.successors(node);
                  }

 * data into it using methods like {@link Hasher#putBytes(byte[])}, and finally ask for the {@code
 * HashCode} when finished using {@link Hasher#hash}. (See an {@linkplain #newHasher example} of
 * this.)
 *
 * <p>If all you want to hash is a single byte array, string or {@code long} value, there are
 * convenient shortcut methods defined directly on {@link HashFunction} to make this easier.
 *

  /**
   * Returns a "Java hash code" for this {@code HashCode} instance; this is well-defined (so, for
   * example, you can safely put {@code HashCode} instances into a {@code HashSet}) but is otherwise
   * probably not what you want to use.
   */
  @Override
  public final int hashCode() {
    // If we have at least 4 bytes (32 bits), just take the first 4 bytes. Since this is