Did you notice? a string using `value.startswith()` can take a tuple, and it will check each value in the tuple:

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

#### A Random Item { #a-random-item }

With `data.items()` we get an <abbr title="Something we can iterate on with a for loop, like a list, set, etc.">iterable object</abbr> with tuples containing the key and value for each dictionary item.

Notice that the variable `item` is one of the elements in the list `items`.

And still, the editor knows it is a `str`, and provides support for that.

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

You would do the same to declare `tuple`s and `set`s:

//// tab | Python 3.9+

```Python hl_lines="1"
{!> ../../docs_src/python_types/tutorial007_py39.py!}
```

////

//// tab | Python 3.8+

        TestRule rule2 = new TestRule("rule2", true);
        TestRule rule3 = new TestRule("rule3", false);
        TestRule rule4 = new TestRule("rule4", true);

        ruleManager.addRule(rule1);
        ruleManager.addRule(rule2);
        ruleManager.addRule(rule3);
        ruleManager.addRule(rule4);

        List<Rule> rules = ruleManager.getRules();
        assertEquals(4, rules.size());

    private set

  // These properties are guarded by `this`. They are typically only accessed by the thread executing
  // the call, but they may be accessed by other threads for duplex requests.

  /** True if this call still has a request body open. */
  private var requestBodyOpen = false

  /** True if this call still has a response body open. */
  private var responseBodyOpen = false

{* ../../docs_src/body_nested_models/tutorial002.py hl[1] *}

### Declare a `list` with a type parameter { #declare-a-list-with-a-type-parameter }

To declare types that have type parameters (internal types), like `list`, `dict`, `tuple`:

* If you are in a Python version lower than 3.9, import their equivalent version from the `typing` module
* Pass the internal type(s) as "type parameters" using square brackets: `[` and `]`

In Python 3.9 it would be:

Parametreler bağlantının bir parçası oldukları için doğal olarak string olarak değerlendirilirler.

Fakat, Python tipleri ile tanımlandıkları zaman (yukarıdaki örnekte `int` oldukları gibi), parametreler o tiplere dönüştürülür ve o tipler çerçevesinde doğrulanırlar.

Yol parametreleri için geçerli olan her türlü işlem aynı şekilde sorgu parametreleri için de geçerlidir:

* Editör desteği (şüphesiz)

        } else if (bodyHasUnknownEncoding(request.headers)) {
          logger.log("--> END ${request.method} (encoded body omitted)")
        } else if (requestBody.isDuplex()) {
          logger.log("--> END ${request.method} (duplex request body omitted)")
        } else if (requestBody.isOneShot()) {
          logger.log("--> END ${request.method} (one-shot body omitted)")
        } else {
          var buffer = Buffer()

It is equivalent to `set(["name", "description"])`.

///

#### Using `list`s instead of `set`s { #using-lists-instead-of-sets }

If you forget to use a `set` and use a `list` or `tuple` instead, FastAPI will still convert it to a `set` and it will work correctly:

{* ../../docs_src/response_model/tutorial006_py310.py hl[29,35] *}

## Recap { #recap }

* <a href="https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/" target="_blank"><code>pydantic-extra-types</code></a> - Pydantic ile birlikte kullanılabilecek ek tipler için.

Starlette tarafında kullanılan:

* <a href="https://www.python-httpx.org" target="_blank"><code>httpx</code></a> - Eğer `TestClient` yapısını kullanacaksanız gereklidir.

    assertThat(response.body.string()).isEqualTo("Hello response!")
    applicationLogs
      .assertLogEqual("--> POST $url")
      .assertLogEqual("--> END POST (duplex request body omitted)")
      .assertLogMatch(Regex("""<-- 200 $url \(\d+ms\)"""))
      .assertLogEqual("content-length: 15")
      .assertLogEqual("")
      .assertLogEqual("Hello response!")