nom = {"clé": valeur, ...}
note = {"nom": "Ada", "age": 36}
# créer avec des paires clé: valeur
vide = {} # créer un dictionnaire vide
Les { } servent uniquement à fabriquer le dictionnaire. Chaque paire s'écrit clé: valeur.
{ } Les accolades : le dictionnaire
Le hashmap, le dictionnaire, l'objet (presque) : trois mots pour la même idée. Les accolades fabriquent la structure clé/valeur. Mais pour lire ou écrire dedans, on n'utilise pas { } : on entre avec des crochets [ ] et la clé.
Créer
Lire · Écrire
dico["clé"] / dico["clé"] = valeur
note["nom"] # LIRE par clé -> "Ada"
note["age"] = 37 # ÉCRIRE : modifier
note["ville"] = "Lyon" # ÉCRIRE : ajouter une clé
note.get("taille", 0) # LIRE prudent (0 si absente)
On entre dans le dictionnaire avec des crochets [ ] et la clé - jamais avec des accolades.
( ) Les parenthèses : la fonction
Les parenthèses servent deux fois pour une fonction : à la définition (on annonce les paramètres) et à l'appel (on déclenche le travail). Pas de parenthèses à l'appel = la fonction ne s'exécute pas.
Créer (définir)
def nom(parametres):
def aire(largeur, hauteur):
return largeur * hauteur
# def + ( ) = créer la fonction
Les parenthèses après le nom listent les paramètres que la fonction attend. Vides () = aucun paramètre.
Utiliser (appeler)
nom(arguments)
aire(3, 5) # APPELER -> 15
resultat = aire(3, 5) # garder le résultat
aire # SANS ( ) : pas appelée !
Les ( ) à l'appel déclenchent l'exécution. Le nom seul, sans parenthèses, ne lance rien : il désigne juste la fonction.
[ ] Les crochets : le tableau et l'accès
Le crochet a deux métiers. Il crée des listes (tableaux). Et il sert de porte d'accès : par position dans une liste, et par clé dans un dictionnaire. C'est le même symbole qui ouvre la liste et le hashmap.
Créer (une liste)
nom = [valeur, valeur, ...]
mesures = [21.5, 22.0, 19.8]
# créer une liste (tableau)
vide = [] # créer une liste vide
Entre crochets, une suite de valeurs séparées par des virgules forme une liste ordonnée.
Lire · Écrire (accès)
liste[position] / dico["clé"]
mesures[0] # LIRE par position -> 21.5
mesures[0] = 99.9 # ÉCRIRE une case
mesures.append(23) # ÉCRIRE : ajouter au bout
note["nom"] # LIRE un dict par clé
note["age"] = 37 # ÉCRIRE un dict
Même symbole, deux usages : liste par numéro de position (qui commence à 0), dictionnaire par clé.
En un coup d'œil
Trois symboles, trois rôles. Un truc à retenir : { } fabrique, ( ) exécute, [ ] accède.
| Symbole | Ce qu'il CRÉE | Ce qu'il LIT / ÉCRIT |
|---|---|---|
| { } | un dictionnaire (hashmap) note = {"nom": "Ada"} |
rien : on entre avec [ ] |
| ( ) | une fonction (def) def aire(l, h): |
appelle / exécute aire(3, 5) |
| [ ] | une liste (tableau) mesures = [21.5, 22.0] |
lit/écrit une case mesures[0] · note["nom"] |
Les pièges fréquents
Trois confusions classiques entre les symboles.
Oublier les ( ) pour appeler
aire # la fonction, PAS appelée
aire() # là elle s'exécute
Sans parenthèses, la fonction ne tourne pas. C'est l'oubli numéro un : on attend un résultat qui n'arrive jamais.
{ } vide = dict, mais { 1, 2 } = set
vide = {} # dictionnaire vide
x = {1, 2} # ensemble (set), pas un dict !
x = {"a": 1} # dictionnaire (il y a un :)
Des accolades avec des : = dictionnaire. Sans : = ensemble. Le deux-points fait toute la différence.
Créer avec [ ] vs accéder avec [ ]
mesures = [21.5, 22.0] # CRÉER une liste
mesures[0] # ACCÉDER à une case
Le même crochet sert à fabriquer la liste (avec des virgules) et à entrer dedans (avec une position). Deux rôles, ne pas les confondre.