}

    /**
     * If the argument type at the specified position is a number, converts the argument to match the type.
     *
     * @param paramTypes
     *            array of parameter types
     * @param args
     *            array of arguments
     * @param index
     *            index of the argument to operate on
     * @return {@literal true} if the argument was converted to match the type
     */

///

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

### `Union` in Python 3.10

In diesem Beispiel übergeben wir dem Argument `response_model` den Wert `Union[PlaneItem, CarItem]`.

Da wir es als **Wert einem Argument überreichen**, statt es als **Typannotation** zu verwenden, müssen wir `Union` verwenden, selbst in Python 3.10.

Übergeben Sie der Funktion `*` als ersten Parameter.

	// Broadcast without memory operand.
	VADDPD.BCST X3, X2, K1, X1       // ERROR "illegal broadcast without memory argument"
	VADDPD.BCST X3, X2, K1, X1       // ERROR "illegal broadcast without memory argument"
	VADDPD.BCST X3, X2, K1, X1       // ERROR "illegal broadcast without memory argument"
	// CLWB instructions:
	CLWB BX                          // ERROR "invalid instruction"
	// CLDEMOTE instructions:

     * <li>If <code>type</code> is an array, the actual class of its elements is returned.</li>
     * <li>Otherwise, <code>null</code> is returned.</li>
     * </ul>
     *
     * @param type
     *            the type to analyze
     * @param map
     *            the map that contains the type variables and type arguments

 *       typically because the type forbids nullable type arguments: For example, {@code
 *       ImmutableList.get} returns {@code E}, but that value is never {@code null}. (Accordingly,
 *       {@code ImmutableList} is declared to forbid {@code ImmutableList<@Nullable String>}.)
 *   <li>methods whose return type is a type variable but which can return {@code null} regardless
 *       of the type argument supplied by the user of the class: For example, {@code

 *       typically because the type forbids nullable type arguments: For example, {@code
 *       ImmutableList.get} returns {@code E}, but that value is never {@code null}. (Accordingly,
 *       {@code ImmutableList} is declared to forbid {@code ImmutableList<@Nullable String>}.)
 *   <li>methods whose return type is a type variable but which can return {@code null} regardless
 *       of the type argument supplied by the user of the class: For example, {@code

from unicorn import UnicornMiddleware

app = FastAPI()

app.add_middleware(UnicornMiddleware, some_config="rainbow")
```

`app.add_middleware()` receives a middleware class as the first argument and any additional arguments to be passed to the middleware.

## Integrated middlewares { #integrated-middlewares }

**FastAPI** includes several middlewares for common use cases, we'll see next how to use them.

f1 := apply[[]int]             // type argument for S explicitly provided, type argument for E inferred
f2 := apply[[]string, string]  // both type arguments explicitly provided

var bytes []byte
r := apply(bytes, func(byte) byte { … })  // both type arguments inferred from the function arguments
</pre>

<p>

from unicorn import UnicornMiddleware

app = FastAPI()

app.add_middleware(UnicornMiddleware, some_config="rainbow")
```

`app.add_middleware()` empfängt eine Middleware-Klasse als erstes Argument und dann alle weiteren Argumente, die an die Middleware übergeben werden sollen.

## Integrierte Middleware

**FastAPI** enthält mehrere Middlewares für gängige Anwendungsfälle. Wir werden als Nächstes sehen, wie man sie verwendet.