¿Lo notaste? un string usando `value.startswith()` puede recibir una tupla, y comprobará cada valor en la tupla:

{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[16:19] hl[17] *}

#### Un ítem aleatorio { #a-random-item }

Con `data.items()` obtenemos un <dfn title="Algo que podemos iterar con un for loop, como una list, set, etc.">objeto iterable</dfn> con tuplas que contienen la clave y el valor para cada elemento del diccionario.

    AnyUrl: str,
}


def generate_encoders_by_class_tuples(
    type_encoder_map: dict[Any, Callable[[Any], Any]],
) -> dict[Callable[[Any], Any], tuple[Any, ...]]:
    encoders_by_class_tuples: dict[Callable[[Any], Any], tuple[Any, ...]] = defaultdict(
        tuple
    )
    for type_, encoder in type_encoder_map.items():
        encoders_by_class_tuples[encoder] += (type_,)
    return encoders_by_class_tuples

І все ж редактор знає, що це `str`, і надає підтримку для цього.

#### Tuple and Set { #tuple-and-set }

Ви повинні зробити те ж саме, щоб оголосити `tuple` і `set`:

{* ../../docs_src/python_types/tutorial007_py310.py hl[1] *}

Це означає:

* Змінна `items_t` — це `tuple` з 3 елементами: `int`, ще `int`, та `str`.
* Змінна `items_s` — це `set`, і кожен його елемент має тип `bytes`.

        // When
        Type3Message type3 = new Type3Message(createMockContext(), type2, null, password, "DOMAIN", "user", "WORKSTATION",
                NtlmFlags.NTLMSSP_NEGOTIATE_NTLM);

        // Then
        assertNotNull(type3.getLMResponse());
        assertNotNull(type3.getNTResponse());
        assertTrue(type3.getLMResponse().length > 0);
        assertTrue(type3.getNTResponse().length > 0);
    }

    @Test

    *,
    route: routing.APIRoute,
    operation_ids: set[str],
    model_name_map: ModelNameMap,
    field_mapping: dict[
        tuple[ModelField, Literal["validation", "serialization"]], dict[str, Any]
    ],
    separate_input_output_schemas: bool = True,
) -> tuple[dict[str, Any], dict[str, Any], dict[str, Any]]:
    path = {}
    security_schemes: dict[str, Any] = {}
    definitions: dict[str, Any] = {}

    return "alice", required_scopes.scopes


def get_data():
    return [1, 2, 3]


def get_data_override():
    return [3, 4, 5]


@app.get("/user")
def read_user(
    user_data: tuple[str, list[str]] = Security(get_user, scopes=["foo", "bar"]),
    data: list[int] = Depends(get_data),
):
    return {"user": user_data[0], "scopes": user_data[1], "data": data}


client = TestClient(app)

沒有型別時，幾乎不可能做到這點。

請注意，變數 `item` 是清單 `items` 中的一個元素。

即便如此，編輯器仍然知道它是 `str`，並提供相應的支援。

#### Tuple 與 Set { #tuple-and-set }

你也可以用相同方式來宣告 `tuple` 與 `set`：

{* ../../docs_src/python_types/tutorial007_py310.py hl[1] *}

這代表：

* 變數 `items_t` 是一個有 3 個項目的 `tuple`，分別是 `int`、`int` 和 `str`。
* 變數 `items_s` 是一個 `set`，而其中每個項目都是 `bytes` 型別。

#### Dict { #dict }

#### 使用 `value.startswith()` 的字串 { #string-with-value-startswith }

你注意到了嗎？字串的 `value.startswith()` 可以接收一個 tuple，並逐一檢查 tuple 中的每個值：

{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[16:19] hl[17] *}

#### 隨機項目 { #a-random-item }

透過 `data.items()` 我們會得到一個包含每個字典項目鍵值對 tuple 的 <dfn title="可以用 for 迴圈遍歷的東西，例如 list、set 等等。">iterable object</dfn>。

我們用 `list(data.items())` 把這個可疊代物件轉成正式的 `list`。

Et pourtant, l'éditeur sait que c'est un `str` et fournit le support approprié.

#### Tuple et Set { #tuple-and-set }

Vous feriez la même chose pour déclarer des `tuple` et des `set` :

{* ../../docs_src/python_types/tutorial007_py310.py hl[1] *}

Cela signifie :

* La variable `items_t` est un `tuple` avec 3 éléments, un `int`, un autre `int`, et un `str`.

        response=response,
        dependency_cache=dependency_cache,
    )


def _validate_value_with_model_field(
    *, field: ModelField, value: Any, values: dict[str, Any], loc: tuple[str, ...]
) -> tuple[Any, list[Any]]:
    if value is None:
        if field.field_info.is_required():
            return None, [get_missing_field_error(loc=loc)]
        else:
            return deepcopy(field.default), []