Python Academy · Leçon

typing.NamedTuple

Ajouter des annotations de type aux tuples nommés

Leçon 4 sur 413 étapes

typing.NamedTuple est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Une alternative typée

La classe de base typing.NamedTuple est une manière moderne, fondée sur les classes, de définir des tuples nommés. Elle ajoute des annotations de type et se lit comme une classe ordinaire, ce que la plupart des éditeurs et des vérificateurs de types comprennent mieux que la forme fabriquée.

Syntaxe fondée sur une classe

Créez une sous-classe de NamedTuple et déclarez chaque champ avec une annotation de type. Le résultat reste un véritable tuple.

from typing import NamedTuple

class Point(NamedTuple):
    x: int
    y: int

p = Point(1, 2)
print(p)

Même comportement qu'un tuple

Tout ce qui fonctionnait avec la version fabriquée fonctionne toujours : accès par nom, accès par index, déballage et immuabilité.

from typing import NamedTuple

class Point(NamedTuple):
    x: int
    y: int

p = Point(1, 2)
print(p.x, p[1])
x, y = p
print(x, y)

Valeurs par défaut intégrées

Donnez une valeur par défaut à un champ en lui affectant simplement une valeur dans le corps de la classe. Les champs avec une valeur par défaut doivent venir après ceux qui n'en ont pas.

from typing import NamedTuple

class Point(NamedTuple):
    x: int
    y: int
    z: int = 0

print(Point(1, 2))
print(Point(1, 2, 9))

Ajouter des méthodes

Puisqu'il s'agit d'une classe, vous pouvez ajouter de véritables méthodes. C'est une possibilité que la fabrique collections.namedtuple ne permet pas proprement.

from typing import NamedTuple

class Point(NamedTuple):
    x: int
    y: int

    def distance_sq(self):
        return self.x ** 2 + self.y ** 2

print(Point(3, 4).distance_sq())

Les propriétés aussi

Vous pouvez également définir des propriétés calculées qui déduisent des valeurs à partir des champs.

from typing import NamedTuple

class Rectangle(NamedTuple):
    width: int
    height: int

    @property
    def area(self):
        return self.width * self.height

print(Rectangle(3, 4).area)

Les méthodes auxiliaires sont conservées

Les méthodes auxiliaires familières des tuples sont toujours disponibles : _replace(), _asdict() et _fields fonctionnent de la même manière.

from typing import NamedTuple

class Point(NamedTuple):
    x: int
    y: int

p = Point(1, 2)
print(p._asdict())
print(p._replace(x=9))

Les annotations de type documentent l'intention

Les annotations ne sont pas imposées lors de l'exécution, mais elles documentent les types attendus et permettent à des outils comme mypy de détecter les erreurs avant l'exécution du programme.

from typing import NamedTuple

class Employee(NamedTuple):
    name: str
    salary: float
    active: bool = True

e = Employee('Alice', 5000.0)
print(e)

NamedTuple ou classe de données

Pour choisir entre les deux :

NamedTuple : immuable, semblable à un tuple, prend en charge l'indexation et le déballage.
classe de données : mutable par défaut (ou figée), sans indexation, avec davantage d'options de configuration.
Choisissez NamedTuple lorsque le comportement d'un tuple est important ; choisissez une classe de données pour des enregistrements plus riches.

Imbrication et composition

Les tuples nommés se composent très bien. Un champ peut être un autre tuple nommé, ce qui permet de construire des données structurées et immuables.

from typing import NamedTuple

class Point(NamedTuple):
    x: int
    y: int

class Line(NamedTuple):
    start: Point
    end: Point

line = Line(Point(0, 0), Point(3, 4))
print(line.end.y)

Comme types de retour de fonction

Annotez une fonction pour qu'elle renvoie votre NamedTuple afin que les éditeurs connaissent les types des champs du résultat. L'annotation documente la structure de l'enregistrement renvoyé.

from typing import NamedTuple

class Stats(NamedTuple):
    minimum: int
    maximum: int

def analyze(nums) -> Stats:
    return Stats(min(nums), max(nums))

r = analyze([5, 2, 8])
print(r.minimum, r.maximum)

Vérification rapide

Quel est l'avantage de typing.NamedTuple par rapport à la fabrique collections.namedtuple ?

Réponds-y dans la leçon interactive

Récapitulatif

Vous avez appris à ajouter des annotations de type aux tuples nommés.

Créez une sous-classe de typing.NamedTuple avec des champs annotés.
Définissez les valeurs par défaut directement ; ajoutez des méthodes et des propriétés.
Les méthodes auxiliaires _replace, _asdict et _fields fonctionnent toujours.
Préférez cette approche à la fabrique pour sa lisibilité et ses outils.

Gratuit pour commencer

Apprends Python avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 76
Leçons: 320

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « typing.NamedTuple » est-elle gratuite ?

Oui — le texte complet de « typing.NamedTuple » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « typing.NamedTuple » ?

Ajouter des annotations de type aux tuples nommés Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « typing.NamedTuple » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Python Academy