* `skip`: with a value of `0`
* `limit`: with a value of `10`

As they are part of the URL, they are "naturally" strings.

But when you declare them with Python types (in the example above, as `int`), they are converted to that type and validated against it.

All the same process that applied for path parameters also applies for query parameters:

* Editor support (obviously)

* `frozenset`:
    * In requests and responses, treated the same as a `set`:
        * In requests, a list will be read, eliminating duplicates and converting it to a `set`.
        * In responses, the `set` will be converted to a `list`.
        * The generated schema will specify that the `set` values are unique (using JSON Schema's `uniqueItems`).
* `bytes`:
    * Standard Python `bytes`.
    * In requests and responses will be treated as `str`.

 * lookups.
 *
 * <p>During construction, names are normalized in two ways:
 *
 * <ol>
 *   <li>ASCII uppercase characters are converted to lowercase.
 *   <li>Unicode dot separators other than the ASCII period ({@code '.'}) are converted to the ASCII
 *       period.
 * </ol>
 *
 * <p>The normalized values will be returned from {@link #toString()} and {@link #parts()}, and will

///

## Dataclasses in `response_model`

You can also use `dataclasses` in the `response_model` parameter:

{* ../../docs_src/dataclasses/tutorial002.py hl[1,7:13,19] *}

The dataclass will be automatically converted to a Pydantic dataclass.

This way, its schema will show up in the API docs user interface:

<img src="/img/tutorial/dataclasses/image01.png">

## Dataclasses in Nested Data Structures

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"bytes"
	"context"
	"fmt"
	"testing"
)

// Test if various paths work as expected when converted to UNC form
func TestUNCPaths(t *testing.T) {
	testCases := []struct {
		objName string
		pass    bool
	}{
		{"/abcdef", true},
		{"/a/b/c/d/e/f/g", true},
		{string(bytes.Repeat([]byte("界"), 85)), true},

But if you return a `Response` directly (or any subclass, like `JSONResponse`), the data won't be automatically converted (even if you declare a `response_model`), and the documentation won't be automatically generated (for example, including the specific "media type", in the HTTP header `Content-Type` as part of the generated OpenAPI).

    # o sourceCodeLineSeparator: (NotRequired - Default no setting)
    #  The line separator setting for source code of generated classes.
    #   LF   -> converted to LF
    #   CRLF -> converted to CRLF
    #   (no setting) -> no convert (template default is CRLF)
    #
    #; sourceCodeLineSeparator = LF
    # - - - - - - - - - -/

        "price": 42.0,
        "tax": 3.2
    },
    "user": {
        "username": "dave",
        "full_name": "Dave Grohl"
    },
    "importance": 5
}
```

Mais uma vez, ele converterá os tipos de dados, validar, documentar, etc.

## Múltiplos parâmetros de corpo e consulta

{"item_id":3}
```

/// check | Revisa

Observa que el valor que recibió (y devolvió) tu función es `3`, como un Python `int`, y no un string `"3"`.

Entonces, con esa declaración de tipos **FastAPI** te da <abbr title="convertir el string que viene de un HTTP request a datos de Python">"parsing"</abbr> automático del request.

///

## Validación de datos

ECL0091=Illegal URL({0})
ECL0094=IllegalArgumentException occurred when value({7}) of class {5}[{6}] is set to {2}[{3}] field({4}) of class({0})[{1}]. Target class is ({8})[{9}].
ECL0097=Value({1}) of property({0}) can not be converted. because {2}.
ECL0098=Exception occurred when value({7}) of class{5}[{6}] is set to {2}[{3}] property({4}) of class({0})[{1}]. Target class is ({8})[{9}].
ECL0099=Field({1}) of class({0}) is not a static field.