Home » Analytics » Comment écrire des data classes Python efficaces et performantes

Comment écrire des data classes Python efficaces et performantes

Par

Écrire des data classes Python efficaces permet de réduire le boilerplate, d’économiser de la mémoire et d’améliorer la robustesse du code. Grâce aux paramètres comme frozen, slots ou default_factory, vous contrôlez mieux votre code. Découvrez comment choisir et exploiter ces options.

3 principaux points à retenir.

  • Utilisez frozen avec slots pour des objets immuables, hashables, et économes en mémoire.
  • Personnalisez l’égalité et l’initialisation via field(compare=False) et __post_init__ pour gagner en précision et sécurité.
  • Évitez les pièges des valeurs par défaut mutables en optant pour default_factory et préparez vos objets comme de vrais contrats fiables.

Pourquoi rendre une data class immuable et hashable

Rendre une data class immuable avec @dataclass(frozen=True) est une approche stratégique qui présente de nombreux avantages. En définissant vos data classes comme immuables, vous les rendez automatiquement hashables. Pourquoi est-ce si important ? Parce que cela vous permet d’utiliser ces instances comme clés dans des dictionnaires ou dans des ensembles (sets) sans risque de conflit ou d’erreur. Une erreur courante lors de l’utilisation des objets mutables comme clés est que, si un objet change d’état, cela peut invalider la clé et causer des incohérences dans votre application.

Imaginez un système de cache où vous stockez des résultats de calculs coûteux. Si vous utilisez une instance mutable comme clé, et qu’un de ses attributs est modifié, vous pourriez perdre l’accès au cache associé à cette clé, entraînant des recalculs non désirés. En rendant vos data classes immuables, vous évitez de telles situations de bugs liés à la modification d’état involontaire.

Voici un exemple minimal montrant l’utilisation de frozen=True :

from dataclasses import dataclass

@dataclass(frozen=True)
class CacheKey:
    user_id: int
    resource_type: str
    timestamp: int

cache = {}
key = CacheKey(user_id=42, resource_type="profile", timestamp=1698345600)
cache[key] = {"data": "expensive_computation_result"}
Découvrez égalementQuels patterns analytiques maîtriser en data science ?

Dans cet exemple, nous avons créé une classe CacheKey avec des attributs immuables, ce qui nous permet de les utiliser comme clés dans un dictionnaire. Ce comportement est crucial pour optimiser le stockage et la récupération d’informations dans des architectures logicielles, comme les systèmes de cache ou les bases de données temporaires.

Un autre aspect à considérer est l’impact sur la performance. Avec des instances immuables, Python peut optimiser la gestion de la mémoire. Les objets immuables peuvent également être partagés en toute sécurité entre plusieurs parties du code, ce qui réduit la duplication de données et améliore l’efficacité globale de votre application. Que diriez-vous d’en savoir plus sur cette capacité d’immunité et ses implications ? Consultez cet article intéressant.

Comment optimiser la mémoire avec slots dans les data classes



Lorsque vous créez des milliers d'objets en Python, chaque octet compte. C'est ici que l'option slots=True dans les data classes entre en jeu. En supprimant le __dict__ d'instance, cette option permet d'adopter une méthode de stockage plus compacte et efficace. En effet, au lieu d'utiliser un dictionnaire pour conserver les attributs, les slots recourent à un tableau de taille fixe, ce qui permet d'économiser de la mémoire et de rendre l'accès aux attributs plus rapide.



Examinons un exemple simple pour illustrer cette différence. D'abord, prenons une data class sans l'utilisation de slots :



from dataclasses import dataclass

@dataclass
class Measurement:
    sensor_id: int
    temperature: float
    humidity: float



Découvrez égalementComment la data analytics révolutionne-t-elle la sécurité en entrepôt ?
Maintenant, voici la même classe, mais avec l’option slots=True :


from dataclasses import dataclass

@dataclass(slots=True)
class MeasurementWithSlots:
    sensor_id: int
    temperature: float
    humidity: float



La différence de performance devient flagrante lorsqu'on instancie des milliers d’objets. Par exemple, créer une liste de 1 000 000 objets Measurement va consommer disproportionnellement plus de mémoire que la liste de MeasurementWithSlots. Un test effectué a montré que les instances sans slots consomment jusqu'à 50% de mémoire en plus que celles avec.


Cependant, cette optimisation vient avec des limitations. Les data classes utilisant slots ne supportent pas les attributs dynamiques. Autrement dit, une fois la classe définie, vous ne pouvez pas ajouter d'attributs supplémentaires. Cela limite la flexibilité de certains scénarios, mais c'est un compromis acceptable pour de nombreuses applications.






Avantages
Inconvénients






Economie de mémoire significative
Pas d'attributs dynamiques




Accès plus rapide aux attributs
Limité à un nombre fixe d'attributs




Simplicité de gestion de grandes quantités d'objets
Usage principal pour des structures de données simples






En somme, si votre projet nécessite de manipuler un grand nombre d'instances légères, envisager les slots peut faire toute la différence.


Découvrez égalementComment Docker simplifie-t-il la reproductibilité en data science ?


Peut-on exclure certains champs des comparaisons et initialisations


Vous vous êtes déjà demandé pourquoi deux objets en Python peuvent être jugés égaux même s’ils comportent des attributs différents ? C’est là que le paramètre field(compare=False) entre en scène. En excluant certains champs des comparaisons d’égalité, comme les métadonnées ou les timestamps, vous évitez des inégalités factices. Cela devient particulièrement pertinent lorsque vous manipulez des données sensibles où seule une partie des attributs doit influencer l’égalité.


Pour mieux comprendre, prenons un exemple concret :


from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class User:
    user_id: int
    email: str
    last_login: datetime = field(compare=False)
    login_count: int = field(compare=False, default=0)

user1 = User(1, "alice@example.com", datetime.now(), 5)
user2 = User(1, "alice@example.com", datetime.now(), 10)
print(user1 == user2)  # Cela affiche True



Dans cet exemple, même si last_login et login_count diffèrent entre user1 et user2, les deux objets sont considérés comme égaux. Cela est dû au fait que leurs ID et emails, qui sont pertinents, sont identiques. Exclure des attributs d’une comparaison peut vous faire gagner du temps en évitant des erreurs d’égalité lorsque vous comparez des objets qui ne devraient pas, par exemple, différer en fonction de données non essentielles.


Découvrez égalementComment automatiser le nettoyage de données avec Python efficacement ?
Il est aussi intéressant d’évoquer le paramètre init=False. Ce dernier vous permet de ne pas exposer un champ à l’init, ce qui est crucial pour maintenir la cohérence et la propreté de vos objets. En l’utilisant, vous vous assurez qu’un champ, bien qu’indispensable, ne soit pas accessible directement lors de la création d’une instance. Imaginez que vous calculiez un champ basé sur d’autres attributs de l’objet ; le rendre non initialisable garantit que sa valeur est toujours correcte et dépendante des autres attributs.


Pensez-y la prochaine fois que vous créez des data classes. En jouant intelligemment avec ces paramètres, vous vous assurez que vos objets demeurent en accord avec la logique de votre application, évitant ainsi des comportements imprévus. Pour en savoir plus, vous pouvez consulter cette discussion sur l’utilisation des data classes.


Comment gérer les valeurs par défaut mutables proprement


Vous avez probablement déjà rencontré le piège des valeurs par défaut mutables en Python. Par exemple, utiliser une liste ou un dictionnaire comme valeur par défaut dans une signature de fonction ou dans une classe peut mener à des comportements étranges. Imaginez que vous ayez une classe de panier d’achats où chaque instance est censée avoir son propre ensemble d’articles. En utilisant une liste comme valeur par défaut, tous les paniers risquent de partager la même liste. Chaque ajout ou suppression dans un panier affectera donc tous les autres. Résultat : des bugs difficiles à détecter.


Voici un exemple typique du problème :


class ShoppingCart:
    def __init__(self, items=[]):
        self.items = items


Découvrez égalementQuels sont les meilleurs outils Python pour vos pipelines ETL ?
Avec cette définition, si vous créez deux instances de ShoppingCart, chaque panier partagera la même liste d’items. Cela peut sembler anodin, mais les conséquences peuvent rapidement devenir chaotiques :


cart1 = ShoppingCart()
cart1.items.append("laptop")
print(cart1.items)  # ['laptop']
cart2 = ShoppingCart()
print(cart2.items)  # ['laptop'] - Oups !


Pour éviter ce type de désastre, Python offre une solution élégante : default_factory. Ce paramètre permet de spécifier une fonction qui sera appelée pour créer une valeur par défaut distincte pour chaque instance. Voici comment ça fonctionne :


from dataclasses import dataclass, field

@dataclass
class ShoppingCart:
    items: list = field(default_factory=list)


Avec ce code, chaque fois que vous instanciez ShoppingCart, une nouvelle liste est créée :


cart1 = ShoppingCart()
cart1.items.append("laptop")
print(cart1.items)  # ['laptop']
cart2 = ShoppingCart()
print(cart2.items)  # [] - Correct !


Les valeurs par défaut sont bien isolées, ce qui réduit le risque de comportements inattendus. De la même manière, vous pouvez utiliser default_factory pour les dictionnaires ou d’autres types mutables. Cela permet de garantir que chaque instance dispose de ses propres données sans interférences indésirables.


Pour finir, lorsque vous définissez des champs dans vos data classes, réfléchissez toujours aux valeurs par défaut que vous choisissez. Si elles sont de type mutable, utilisez default_factory pour éviter d’introduire de la complexité inutile dans votre code. Cela vous permettra d’écrire un code plus propre et moins sujet à erreurs.


Quand utiliser __post_init__ dans vos data classes




Dans vos data classes Python, la méthode __post_init__ est cruciale. Elle s’utilise pour exécuter un code juste après l’init auto-généré. Pourquoi est-ce important ? Parce que vous pouvez effectuer des calculs dérivés, valider des données ou nettoyer des valeurs, sans encombrer l'initialisation de vos objets.
 


Prenons l'exemple d'un rectangle. Vous voulez calculer sa surface après avoir défini sa largeur et sa hauteur. Voici comment vous pouvez le faire :



from dataclasses import dataclass, field

@dataclass
class Rectangle:
    width: float
    height: float
    area: float = field(init=False)

    def __post_init__(self):
        self.area = self.width * self.height
        if self.width <= 0 or self.height <= 0:
            raise ValueError("Les dimensions doivent être positives")    



Dans cet exemple, area est un champ dérivé qui n'est pas initialisé via le constructeur par défaut grâce à init=False. Cela signifie qu’il n’apparaît pas dans l’init auto-généré. La méthode __post_init__ est exécutée juste après la création de l'objet, permettant de calculer la surface et de valider les dimensions.


L'intérêt de dissocier les champs initiaux et calculés est de rendre les objets plus lisibles et maintenables. Cela prévient l'éparpillement des logiques d'initialisation et de validation. Si vous deviez modifier la logique de calcul, vous savez exactement où aller sans fouiller dans le constructeur. En pouvant vérifier des préconditions dans __post_init__, vous renforcez la sécurité et l'intégrité de vos données.


Pour des exemples plus complexes et d'autres usages, vous pouvez consulter cette discussion sur StackOverflow.




Comment ces techniques rendent-elles votre code Python plus efficace au quotidien


Maîtriser les data classes Python, c’est plus qu’une question de syntaxe : c’est une démarche pragmatique pour écrire moins de code, plus fiable, et plus performant. En combinant immutabilité avec frozen, optimisation mémoire avec slots, personnalisation des comparaisons, gestion fine des valeurs par défaut, et post-initialisation, vous réduisez bugs et gaspillage de ressources. Ces pratiques vous donnent un coup d’avance, que ce soit pour construire un cache solide, gérer de gros volumes d’objets, ou contrôler l’état de vos données. Bref, un gain de temps et de tranquillité pour coder mieux, plus vite et durablement.


FAQ






Qu'est-ce qu'une data class en Python ?




      Une data class est une classe Python simplifiée créée avec le décorateur @dataclass. Elle génère automatiquement des méthodes comme __init__, __repr__, et __eq__, facilitant la gestion des objets portant principalement des données.      








Pourquoi utiliser frozen=True dans une data class ?




      frozen=True rend la data class immuable, ce qui la rend hashable. Cela permet d’utiliser ses instances comme clés dans des dictionnaires ou dans des sets, tout en évitant les modifications imprévues d’état.      








À quoi sert l’option slots=True ?




      slots=True élimine le dictionnaire d'attributs par instance, réduisant la mémoire consommée et accélérant l'accès aux attributs. C'est idéal pour gérer de nombreux objets légers, au prix d’une moindre flexibilité (pas d’ajout dynamique d’attributs).      








Comment éviter les problèmes avec des valeurs par défaut mutables ?




      Utilisez default_factory dans la déclaration des champs pour créer une nouvelle instance d’un objet mutable (liste, dict, set) à chaque fois, afin d’éviter le partage involontaire du même objet mutable entre plusieurs instances.      








Quand utiliser __post_init__ dans une data class ?




      __post_init__ est utilisé pour exécuter du code après l'initialisation automatique des champs. Il permet de calculer des valeurs dérivées, valider ou nettoyer les données d’entrée, et assurer la cohérence avant l’utilisation de l’objet.      








 


 


A propos de l'auteur


Franck Scandolera est consultant et formateur expert en Analytics, Data, Automatisation et IA. Avec des années d’expérience à intégrer des solutions Python dans des workflows métier complexes, il accompagne les entreprises pour tirer le meilleur de leurs données et de leurs outils. Responsable de l’agence webAnalyste et de 'Formations Analytics', il intervient partout en France, Suisse et Belgique, partageant son savoir-faire technique et stratégique sur la qualité et la performance des modules Python.
Retour en haut
Vizyz