import java.io.IOException;
import java.io.InputStream;
import java.util.Random;
import org.jspecify.annotations.NullUnmarked;

/**
 * A byte source for testing that has configurable behavior.
 *
 * @author Colin Decker
 */
@NullUnmarked
public final class TestByteSource extends ByteSource implements TestStreamSupplier {

  private final byte[] bytes;
  private final ImmutableSet<TestOption> options;

{* ../../docs_src/cookie_params/tutorial001_an_py310.py hl[9] *}

/// note | Technische Details

`Cookie` ist eine „Schwester“-Klasse von `Path` und `Query`. Sie erbt auch von derselben gemeinsamen `Param`-Klasse.

Aber denken Sie daran, dass, wenn Sie `Query`, `Path`, `Cookie` und andere von `fastapi` importieren, diese tatsächlich Funktionen sind, die spezielle Klassen zurückgeben.

///

/// info | Info

  public void testPutDuplicateValue() {
    List<Entry<K, V>> entries = copyToList(multimap().entries());

    for (Entry<K, V> entry : entries) {
      resetContainer();

      K k = entry.getKey();
      V v = entry.getValue();

      List<V> values = multimap().get(k);
      List<V> expectedValues = copyToList(values);

      assertTrue(multimap().put(k, v));
      expectedValues.add(v);

import com.google.errorprone.annotations.Immutable;
import java.io.Serializable;
import java.util.zip.Checksum;

/**
 * {@link HashFunction} adapter for {@link Checksum} instances.
 *
 * @author Colin Decker
 */
@Immutable
final class ChecksumHashFunction extends AbstractHashFunction implements Serializable {
  private final ImmutableSupplier<? extends Checksum> checksumSupplier;
  private final int bits;

Ich finde, `Union[SomeType, None]` ist expliziter in dem, was es bedeutet.

Es geht nur um Wörter und Namen. Aber diese Wörter können beeinflussen, wie Sie und Ihr Team über den Code denken.

Als Beispiel nehmen wir diese Funktion:

```python
from typing import Optional


def say_hi(name: Optional[str]):
    print(f"Hey {name}!")
```

                headersNode = new ObjectNode(jsonNodeFactory);
            }

            for (Map.Entry<String, String> entry : headers.entrySet()) {
                headersNode.set(entry.getKey(), TextNode.valueOf(entry.getValue()));
            }
            doNodeValue.set("headers", headersNode);
        }
    }

    private boolean shouldApplyHeaders(ObjectNode doNodeValue) {

    }
  }

  @Override
  final Iterator<E> elementIterator() {
    return new Itr<E>() {
      @Override
      @ParametricNullness
      E result(int entryIndex) {
        return backingMap.getKey(entryIndex);
      }
    };
  }

  @Override
  final Iterator<Entry<E>> entryIterator() {
    return new Itr<Entry<E>>() {
      @Override
      Entry<E> result(int entryIndex) {

      Map<K, V> map, ObjectOutputStream stream) throws IOException {
    stream.writeInt(map.size());
    for (Map.Entry<K, V> entry : map.entrySet()) {
      stream.writeObject(entry.getKey());
      stream.writeObject(entry.getValue());
    }
  }

  /**
   * Populates a map by reading an input stream, as part of deserialization. See {@link #writeMap}
   * for the data format.
   */

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import org.jspecify.annotations.NullUnmarked;

/**
 * A char source for testing that has configurable options.
 *
 * @author Colin Decker
 */
@NullUnmarked
public class TestCharSource extends CharSource implements TestStreamSupplier {

  private final TestByteSource byteSource;

  public TestCharSource(String content, TestOption... options) {

Ein Beispiel aus der offiziellen Pydantic Dokumentation:

{* ../../docs_src/python_types/tutorial011_py310.py *}

/// info | Info

Um mehr über [Pydantic zu erfahren, schauen Sie sich dessen Dokumentation an](https://docs.pydantic.dev/).

///

**FastAPI** basiert vollständig auf Pydantic.