cases section below.

To access a struct, union, or enum type directly, prefix it with
struct_, union_, or enum_, as in C.struct_stat. The size of any C type
T is available as C.sizeof_T, as in C.sizeof_struct_stat. These
special prefixes means that there is no way to directly reference a C
identifier that starts with "struct_", "union_", "enum_", or
"sizeof_", such as a function named "struct_function".

///

{* ../../docs_src/extra_models/tutorial003_py310.py hl[1,14:15,18:20,33] *}

### `Union` в Python 3.10

```

////

#### Using `Union` or `Optional` { #using-union-or-optional }

If you are using a Python version below 3.10, here's a tip from my very **subjective** point of view:

* 🚨 Avoid using `Optional[SomeType]`
* Instead ✨ **use `Union[SomeType, None]`** ✨.

* `dict`

Hetzelfde als bij Python 3.8, uit de `typing`-module:

* `Union`
* `Optional` (hetzelfde als bij Python 3.8)
* ...en anderen.

In Python 3.10 kun je , als alternatief voor de generieke `Union` en `Optional`, de <abbr title='ook wel "bitwise or operator" genoemd, maar die betekenis is hier niet relevant'>verticale lijn (`|`)</abbr> gebruiken om unions van typen te voorzien, dat is veel beter en eenvoudiger.

////

```

////

#### Uso de `Union` u `Optional`

Si estás usando una versión de Python inferior a 3.10, aquí tienes un consejo desde mi punto de vista muy **subjetivo**:

* 🚨 Evita usar `Optional[SomeType]`
* En su lugar ✨ **usa `Union[SomeType, None]`** ✨.

```

////

#### Utilizando `Union` ou `Optional`

Se você está utilizando uma versão do Python abaixo da 3.10, aqui vai uma dica do meu ponto de vista bem **subjetivo**:

* 🚨 Evite utilizar `Optional[SomeType]`
* No lugar, ✨ **use `Union[SomeType, None]`** ✨.

  }

  /**
   * Returns a new range set consisting of the union of this range set and {@code other}.
   *
   * <p>This is essentially the same as {@code TreeRangeSet.create(this).addAll(other)} except it
   * returns an {@code ImmutableRangeSet}.
   *
   * @since 21.0
   */
  public ImmutableRangeSet<C> union(RangeSet<C> other) {
    return unionOf(Iterables.concat(asRanges(), other.asRanges()));
  }

  /**

#### <abbr title="Union – Verbund, Einheit‚ Vereinigung: Eines von Mehreren">Union</abbr>

Sie können deklarieren, dass eine Variable einer von **verschiedenen Typen** sein kann, zum Beispiel ein `int` oder ein `str`.

In Python 3.6 und höher (inklusive Python 3.10) können Sie den `Union`-Typ von `typing` verwenden und die möglichen Typen innerhalb der eckigen Klammern auflisten.

    assertMinSize(union(emptySet(), emptySet()), 0);
    assertMinSize(union(setSize(2), setSize(3)), 3);
    assertMinSize(union(setSize(3), setSize(2)), 3);
    assertMinSize(union(setSizeRange(10, 20), setSizeRange(11, 12)), 11);
    assertMinSize(union(setSizeRange(11, 12), setSizeRange(10, 20)), 11);
  }

  public void testUnion_maxSize() {
    assertMaxSize(union(emptySet(), emptySet()), 0);

```Python
q: str
```

вместо:

```Python
q: Union[str, None] = None
```

Но у нас query-параметр определён как `Query`. Например:

//// tab | Annotated

```Python
q: Annotated[Union[str, None], Query(min_length=3)] = None
```

////

//// tab | без Annotated

```Python
q: Union[str, None] = Query(default=None, min_length=3)
```

////