这也是我们在接下来将看到的。

在下面的例子中，你将接受任意键为 `int` 类型并且值为 `float` 类型的 `dict`：

{* ../../docs_src/body_nested_models/tutorial009_py310.py hl[7] *}

/// tip | 提示

请记住 JSON 仅支持将 `str` 作为键。

但是 Pydantic 具有自动转换数据的功能。

这意味着，即使你的 API 客户端只能将字符串作为键发送，只要这些字符串内容仅包含整数，Pydantic 就会对其进行转换并校验。

然后你接收的名为 `weights` 的 `dict` 实际上将具有 `int` 类型的键和 `float` 类型的值。

///

## 总结 { #recap }

from fastapi import FastAPI
from fastapi.responses import JSONResponse
from fastapi.testclient import TestClient
from pydantic import BaseModel


class Item(BaseModel):
    name: str
    price: float


app = FastAPI()


@app.get("/default")
def get_default() -> Item:
    return Item(name="widget", price=9.99)


@app.get("/explicit", response_class=JSONResponse)
def get_explicit() -> Item:

    print "* ${change.summary}\n"
}
}
for (changeType in changelogsByVersionByTypeByArea[version].keySet()) { %>
[[${ changeType }-${ unqualifiedVersion }]]
[float]
=== ${ TYPE_LABELS.getOrDefault(changeType, 'No mapping for TYPE_LABELS[' + changeType + ']') }
<% for (team in changelogsByVersionByTypeByArea[version][changeType].keySet()) {
    print "\n${team}::\n";

				}
			}
			if authZInit {
				setGlobalAuthZPlugin(polplugin.New(authZPluginCfg))
			}
		}

		if !openidInit || !ldapInit || !authNInit || !authZInit {
			retryInterval := time.Duration(r.Float64() * float64(3*time.Second))
			if !openidInit {
				logger.Info("Waiting for OpenID to be initialized.. (retrying in %s)", retryInterval)
			}
			if !ldapInit {

    List<Float> floats = Arrays.asList(0.0f, 1.0f, 2.0f);
    List<Long> longs = Arrays.asList(0L, 1L, 2L);
    List<Double> doubles = Arrays.asList(0.0, 1.0, 2.0);

    assertThat(Doubles.toArray(bytes)).isEqualTo(array);
    assertThat(Doubles.toArray(shorts)).isEqualTo(array);
    assertThat(Doubles.toArray(ints)).isEqualTo(array);
    assertThat(Doubles.toArray(floats)).isEqualTo(array);

    List<Float> floats = Arrays.asList(0.0f, 1.0f, 2.0f);
    List<Long> longs = Arrays.asList(0L, 1L, 2L);
    List<Double> doubles = Arrays.asList(0.0, 1.0, 2.0);

    assertThat(Longs.toArray(bytes)).isEqualTo(array);
    assertThat(Longs.toArray(shorts)).isEqualTo(array);
    assertThat(Longs.toArray(ints)).isEqualTo(array);
    assertThat(Longs.toArray(floats)).isEqualTo(array);

    List<Float> floats = Arrays.asList(0.0f, 1.0f, 2.0f);
    List<Long> longs = Arrays.asList(0L, 1L, 2L);
    List<Double> doubles = Arrays.asList(0.0, 1.0, 2.0);

    assertThat(Shorts.toArray(bytes)).isEqualTo(array);
    assertThat(Shorts.toArray(shorts)).isEqualTo(array);
    assertThat(Shorts.toArray(ints)).isEqualTo(array);
    assertThat(Shorts.toArray(floats)).isEqualTo(array);

        assertTrue(infinityOpt.isPresent());
        assertTrue(Double.isInfinite(infinityOpt.get()));

        OptionalEntity<Float> negInfinityOpt = OptionalUtil.ofNullable(Float.NEGATIVE_INFINITY);
        assertTrue(negInfinityOpt.isPresent());
        assertTrue(Float.isInfinite(negInfinityOpt.get()));

        // Test with very large strings
        StringBuilder largeString = new StringBuilder();

{
  "fess_config.elevate_word" : {
    "aliases" : { },
    "mappings" : {
      "elevate_word" : {
        "properties" : {
          "boost" : {
            "type" : "float"
          },
          "createdBy" : {
            "type" : "keyword"
          },
          "createdTime" : {
            "type" : "long"
          },
          "permissions" : {
            "type" : "keyword"
          },
          "reading" : {

            final Pair<String, Float> pair = new Pair<>();
            final String[] values = s.split(":");
            if (values.length == 1) {
                pair.setFirst(values[0].trim());
                pair.setSecond(1.0f);
            } else if (values.length > 1) {
                pair.setFirst(values[0]);
                pair.setSecond(Float.parseFloat(values[1]));
            } else {