---

FastAPI est un framework web moderne et rapide (haute performance) pour la création d'API avec Python, basé sur les annotations de type standard de Python.

Les principales fonctionnalités sont :

* **Rapidité** : De très hautes performances, au niveau de **NodeJS** et **Go** (grâce à Starlette et Pydantic). [L'un des frameworks Python les plus rapides](#performance).

	result.Friends = append(user.Friends, result.Friends...)

	sort.Slice(result.Pets, func(i, j int) bool {
		return result.Pets[i].ID < result.Pets[j].ID
	})
	sort.Slice(result.Team, func(i, j int) bool {
		return result.Team[i].ID < result.Team[j].ID
	})
	sort.Slice(result.Friends, func(i, j int) bool {
		return result.Friends[i].ID < result.Friends[j].ID
	})
	sort.Slice(result2.Pets, func(i, j int) bool {

            // Must return at least one project
            result.add(projectBuilds.get(0).getProject());
        }

        // Sort by critical path priority (projects with longer critical paths first)
        List<MavenProject> sortedResult = new ArrayList<>(result);
        sortedResult.sort(projectComparator.getComparator());
        return sortedResult;
    }

    /**

        "legend": {
          "calcs": [],
          "displayMode": "list",
          "placement": "bottom",
          "showLegend": true
        },
        "tooltip": {
          "mode": "multi",
          "sort": "desc"
        }
      },
      "pluginVersion": "10.4.0",
      "targets": [
        {
          "datasource": {
            "type": "prometheus",
            "uid": "${DS_PROMETHEUS}"
          },

        }
        return properties.sort { it.name }
    }

    List<MethodDoc> getExtensionMethods() {
        List<MethodDoc> methods = []
        mixinClasses.each { mixin ->
            mixin.classMethods.each { method ->
                methods << method.forClass(targetClass)
            }
        }
        return methods.sort { it.metaData.overrideSignature }
    }

```
http://127.0.0.1:8000/items/?skip=0&limit=10
```

...les paramètres de requête sont :

* `skip` : avec une valeur de`0`
* `limit` : avec une valeur de `10`

Faisant partie de l'URL, ces valeurs sont des chaînes de caractères (`str`).

Mais quand on les déclare avec des types Python (dans l'exemple précédent, en tant qu'`int`), elles sont converties dans les types renseignés.

                    });
                    // Sort the array in place by type, then member
                    // Note that Firefox is fine with a sort function returning any positive or negative number, but Chrome 
                    // requires 1 or -1 specifically and ignores higher or lower values.  This sort ought to remain consistent
                    // with the sort used by AbstractAcceptedApiChangesMaintenanceTask.

                ProjectDependencyGraphStub.X,
                ProjectDependencyGraphStub.C,
                ProjectDependencyGraphStub.A,
                ProjectDependencyGraphStub.B);

        // Sort using the comparator
        projects.sort(comparator.getComparator());

        // Project A should come first (highest weight)
        assertEquals(
                ProjectDependencyGraphStub.A,
                projects.get(0),

package callbacks

import (
	"reflect"
	"sort"

	"gorm.io/gorm"
	"gorm.io/gorm/clause"
)

// ConvertMapToValuesForCreate convert map to values
func ConvertMapToValuesForCreate(stmt *gorm.Statement, mapValue map[string]interface{}) (values clause.Values) {
	values.Columns = make([]clause.Column, 0, len(mapValue))
	selectColumns, restricted := stmt.SelectAndOmitColumns(true, false)

	keys := make([]string, 0, len(mapValue))

    links: list[LinkData] = []
    en_links = lang_links.get("en", [])
    en_links.sort(key=lambda x: x.preview_link)
    links.extend(en_links)

    langs = list(lang_links.keys())
    langs.sort()
    for lang in langs:
        if lang == "en":
            continue
        current_lang_links = lang_links[lang]
        current_lang_links.sort(key=lambda x: x.preview_link)
        links.extend(current_lang_links)