},
}

func TestString(t *testing.T) {
	for i, test := range stringTests {
		s := test.ETag.String()
		if s != test.String {
			t.Fatalf("Test %d: got %s - want %s", i, s, test.String)
		}
	}
}

var equalTests = []struct {
	A     string
	B     string
	Equal bool
}{
	{A: "3b83ef96387f14655fc854ddc3c6bd57", B: "3b83ef96387f14655fc854ddc3c6bd57", Equal: true},   // 0

## `async` 和 `await` { #async-and-await }

現代 Python 版本提供一種非常直觀的方式定義非同步程式碼。這使得它看起來就像正常的「順序」程式碼，並在適當的時機替你「等待」。

當某個操作需要等待才能回傳結果，並且支援這些新的 Python 特性時，你可以像這樣編寫程式碼：

```Python
burgers = await get_burgers(2)
```

這裡的關鍵是 `await`。它告訴 Python 必須等待 ⏸ `get_burgers(2)` 完成它的工作 🕙， 然後將結果儲存在 `burgers` 中。如此，Python 就可以在此期間去處理其他事情 🔀 ⏯ （例如接收另一個請求）。

要讓 `await` 運作，它必須位於支持非同步功能的函式內。為此，只需使用 `async def` 宣告函式：

# 并发 async / await { #concurrency-and-async-await }

有关路径操作函数的 `async def` 语法以及异步代码、并发和并行的一些背景知识。

## 赶时间吗？ { #in-a-hurry }

<abbr title="too long; didn't read - 太长；没看"><strong>TL;DR:</strong></abbr>

如果你正在使用第三方库，它们会告诉你使用 `await` 关键字来调用它们，就像这样：

```Python
results = await some_library()
```

然后，通过 `async def` 声明你的 *路径操作函数*：

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

///

次に、アプリを渡して `AsyncClient` を作成し、`await` を使って非同期リクエストを送信できます。

{* ../../docs_src/async_tests/app_a_py310/test_main.py hl[9:12] *}

これは次と同等です:

```Python
response = client.get('/')
```

...これまでは `TestClient` でリクエストを送っていました。

/// tip | 豆知識

新しい `AsyncClient` では async/await を使っている点に注意してください。リクエストは非同期です。

///

/// warning | 注意

/// note | 技术细节

您也可以使用 `from starlette.websockets import WebSocket`。

**FastAPI** 直接提供了相同的 `WebSocket`，只是为了方便开发人员。但它直接来自 Starlette。

///

## 等待消息并发送消息 { #await-for-messages-and-send-messages }

在您的 WebSocket 路由中，您可以使用 `await` 等待消息并发送消息。

{* ../../docs_src/websockets_/tutorial001_py310.py hl[48:52] *}

您可以接收和发送二进制、文本和 JSON 数据。

## 尝试一下 { #try-it }

将代码放在 `main.py`，然后运行你的应用程序：

		Queries can be inclusive or exclusive of the upper and lower bounds.
		If you want to find documents whose content_length fields have values
		between 1000 and 10000, inclusive, you can enter:
		<pre>content_length:[1000 TO 10000]</pre>
		If you want to exclude the upper and lower bounds, use "{}".
	</dd>
	<dt>Boost</dt>
	<dd>

        for (int t = 0; t < numThreads; t++) {
            final int threadId = t;
            executor.submit(() -> {
                try {
                    startLatch.await();
                    for (int i = 0; i < eventsPerThread; i++) {
                        helper.offer(new LogNotificationEvent(i, "ERROR", "org.test", "t" + threadId + "-" + i, null));

# 동시성과 async / await { #concurrency-and-async-await }

*경로 처리 함수*에서의 `async def` 문법에 대한 세부사항과 비동기 코드, 동시성 및 병렬성에 대한 배경

## 바쁘신가요? { #in-a-hurry }

<abbr title="too long; didn't read - 너무 길어서 읽지 않음"><strong>TL;DR:</strong></abbr>

다음과 같이 `await`를 사용해 호출하라고 안내하는 제3자 라이브러리를 사용하는 경우:

```Python
results = await some_library()
```

다음처럼 *경로 처리 함수*를 `async def`를 사용해 선언하십시오:

```Python hl_lines="2"
@app.get('/')

This means that you can send only the data that you want to update, leaving the rest intact.

/// note

`PATCH` is less commonly used and known than `PUT`.

And many teams use only `PUT`, even for partial updates.

You are **free** to use them however you want, **FastAPI** doesn't impose any restrictions.

But this guide shows you, more or less, how they are intended to be used.

* `read(size)`: Lê `size` (`int`) bytes/caracteres do arquivo.
* `seek(offset)`: Vai para o byte na posição `offset` (`int`) no arquivo.
    * Por exemplo, `await myfile.seek(0)` irá para o início do arquivo.
    * Isso é especialmente útil se você executar `await myfile.read()` uma vez e precisar ler o conteúdo novamente.
* `close()`: Fecha o arquivo.

Como todos esses métodos são métodos `assíncronos`, você precisa "aguardar" por eles.