Dictionnaires et tuples

1. Définition

Un p-uplet nommé est une sous-classe immuable de tuple, qui permet d'accéder aux éléments par un nom (attribut) en plus de l'index. Cela améliore la lisibilité du code par rapport aux tuples classiques.

2. Création d'un namedtuple

• Import depuis le module collections :

  from collections import namedtuple
  

• Définition d'un type nommé :

  Point = namedtuple('Point', ['x', 'y'])
  

• Instanciation :

  p = Point(10, 20)
  

3. Accès aux éléments

• Par index : p[0] → 10
• Par nom : p.x → 10

4. Propriétés importantes

5. Exemple complet

from collections import namedtuple

Personne = namedtuple('Personne', ['nom', 'age', 'ville'])
p1 = Personne('Alice', 30, 'Paris')

print(p1.nom)          # Alice
print(p1[1])           # 30
print(p1._fields)      # ('nom', 'age', 'ville')

# Conversion en dict
d = p1._asdict()
print(d)               # {'nom': 'Alice', 'age': 30, 'ville': 'Paris'}

# Remplacement d'un champ
p2 = p1._replace(age=31)
print(p2)              # Personne(nom='Alice', age=31, ville='Paris')

6. Avantages et limites

1. Définition

Un dictionnaire est une structure de données mutable qui stocke des paires clé : valeur. Les clés doivent être immuables et uniques.

2. Création de dictionnaires

• Littéral :

  d = {'nom': 'Alice', 'age': 30}
  

• Avec constructeur :

  d = dict(nom='Alice', age=30)
  

3. Accès et modification

• Accès : d['nom'] → 'Alice'
• Modification : d['age'] = 31
• Ajout : d['ville'] = 'Paris'
• Suppression : del d['age']

4. Méthodes clés

5. Parcours d’un dictionnaire

for clé, valeur in d.items():
    print(f"{clé} : {valeur}")

6. Dictionnaires imbriqués

Les valeurs peuvent être des dictionnaires eux-mêmes, permettant des structures complexes.

d = {
    'Alice': {'age': 30, 'ville': 'Paris'},
    'Bob': {'age': 25, 'ville': 'Lyon'}
}

7. Exemple complet

d = {'nom': 'Alice', 'age': 30}
print(d['nom'])          # Alice

d['age'] = 31           # Modification
d['ville'] = 'Paris'    # Ajout

print(d.get('pays', 'France'))  # France (valeur par défaut)

for k, v in d.items():
    print(k, v)

1. Utilisation de namedtuple pour des données immuables

• Modéliser des entités simples (ex : coordonnées, personnes, points)
• Garantir l’intégrité des données (pas de modification accidentelle)
• Faciliter la conversion en dictionnaire pour sérialisation

2. Utilisation de dictionnaires pour des données dynamiques

• Stocker des configurations modifiables
• Manipuler des données avec des clés variables
• Construire des structures imbriquées complexes

3. Conversion entre namedtuple et dictionnaire

• namedtuple._asdict() → dictionnaire
• namedtuple(**dictionnaire) → namedtuple (via unpacking)

4. Astuces et pièges

• Les clés de dictionnaire doivent être immuables (ex : pas de listes)
• Namedtuple ne supporte pas les champs avec des noms réservés (ex : class)
• Pour des structures plus complexes, envisager dataclasses (Python 3.7+)

1. Exemple : coordonnées géographiques

from collections import namedtuple

Coord = namedtuple('Coord', ['latitude', 'longitude'])
paris = Coord(48.8566, 2.3522)
print(paris.latitude)  # 48.8566

2. Exemple : dictionnaire imbriqué pour un annuaire

annuaire = {
    'Alice': {'tel': '0123456789', 'email': 'alice@example.com'},
    'Bob': {'tel': '0987654321', 'email': 'bob@example.com'}
}

print(annuaire['Alice']['email'])  # alice@example.com

3. Exemple : mise à jour partielle d’un namedtuple

p = Coord(48.8566, 2.3522)
p2 = p._replace(latitude=50.0)
print(p2)  # Coord(latitude=50.0, longitude=2.3522)

À retenir :
Un namedtuple est un tuple immuable avec des noms de champs pour un accès clair, tandis qu’un dictionnaire est une structure mutable clé-valeur, plus flexible mais moins performante. Choisir selon le besoin de mutabilité et la lisibilité.