Introduction

La bibliothèque attrs de Python change la donne pour les développeurs qui cherchent à simplifier la création de classes et à réduire le code passe-partout. Cette bibliothèque jouit même de la confiance de la NASA.
Créé par Hynek Schlawack en 2015, attrs est rapidement devenu un outil préféré parmi les développeurs Python pour sa capacité à générer automatiquement des méthodes spéciales et à fournir une manière propre et déclarative de définir des classes.
les classes de données sont une sorte de sous-ensemble d'attrs.

Pourquoi les attrs sont utiles :

• Réduit le code passe-partout
• Améliore la lisibilité et la maintenabilité du code
• Fournit des fonctionnalités puissantes pour la validation et la conversion des données
• Améliore les performances grâce à des implémentations optimisées

2. Premiers pas avec les attributs

Installation:
Pour commencer avec attrs, vous pouvez l'installer en utilisant pip :

pip install attrs

Utilisation de base :
Voici un exemple simple d'utilisation d'attrs pour définir une classe :

import attr

@attr.s
class Person:
    name = attr.ib()
    age = attr.ib()

# Creating an instance
person = Person("Alice", 30)
print(person)  # Person(name='Alice', age=30)

3. Caractéristiques principales des attributs

un. Génération automatique de méthodes :

attrs génère automatiquement les méthodes init, repr et eq pour vos classes :

@attr.s
class Book:
    title = attr.ib()
    author = attr.ib()
    year = attr.ib()

book1 = Book("1984", "George Orwell", 1949)
book2 = Book("1984", "George Orwell", 1949)

print(book1)  # Book(title='1984', author='George Orwell', year=1949)
print(book1 == book2)  # True

b. Définition d'attribut avec types et valeurs par défaut :

import attr
from typing import List

@attr.s
class Library:
    name = attr.ib(type=str)
    books = attr.ib(type=List[str], default=attr.Factory(list))
    capacity = attr.ib(type=int, default=1000)

library = Library("City Library")
print(library)  # Library(name='City Library', books=[], capacity=1000)

c. Validateurs et convertisseurs :

import attr

def must_be_positive(instance, attribute, value):
    if value 




  
  
  4. Utilisation avancée



  
  
  un. Personnalisation du comportement des attributs :




import attr

@attr.s
class User:
    username = attr.ib()
    _password = attr.ib(repr=False)  # Exclude from repr

    @property
    def password(self):
        return self._password

    @password.setter
    def password(self, value):
        self._password = hash(value)  # Simple hashing for demonstration

user = User("alice", "secret123")
print(user)  # User(username='alice')





  
  
  b. Instances et emplacements gelés :




@attr.s(frozen=True) # slots=True is the default
class Point:
    x = attr.ib()
    y = attr.ib()

point = Point(1, 2)
try:
    point.x = 3  # This will raise an AttributeError
except AttributeError as e:
    print(e)  # can't set attribute





  
  
  c. Fonctions d'usine et traitement post-init :




import attr
import uuid

@attr.s
class Order:
    id = attr.ib(factory=uuid.uuid4)
    items = attr.ib(factory=list)
    total = attr.ib(init=False)

    def __attrs_post_init__(self):
        self.total = sum(item.price for item in self.items)

@attr.s
class Item:
    name = attr.ib()
    price = attr.ib(type=float)

order = Order(items=[Item("Book", 10.99), Item("Pen", 1.99)])
print(order)  # Order(id=UUID('...'), items=[Item(name='Book', price=10.99), Item(name='Pen', price=1.99)], total=12.98)





  
  
  5. Meilleures pratiques et pièges courants



  
  
  Meilleures pratiques :

• Utilisez des annotations de type pour une meilleure lisibilité du code et une prise en charge de l'IDE
• Exploiter les validateurs pour l'intégrité des données
• Utiliser des classes gelées pour les objets immuables
• Profitez de la génération automatique de méthodes pour réduire la duplication de code

Pièges courants :

• Oublier d'utiliser le décorateur @attr.s sur la classe
• Utilisation excessive de validateurs complexes qui pourraient être des méthodes distinctes
• Ne pas prendre en compte l'impact sur les performances d'une utilisation intensive des fonctions d'usine

6. attrs vs autres bibliothèques

attrs et dataclasses sont plus rapides que pydantic¹.

Comparaison avec les classes de données :

• attrs est plus riche en fonctionnalités et plus flexible
• les classes de données sont intégrées à Python 3.7, ce qui les rend plus accessibles
• attrs a de meilleures performances dans la plupart des cas
• les classes de données sont liées à la version Python, tandis que les attrs en tant que bibliothèque externe peuvent être utilisés avec n'importe quelle version de Python.

Comparaison avec pydantic :

• pydantic se concentre sur la validation des données et la gestion des paramètres
• attrs est plus polyvalent et s'intègre mieux aux bases de code existantes
• pydantic a une sérialisation JSON intégrée, tandis que attrs nécessite des bibliothèques supplémentaires

Quand choisir les attributs :

• Pour les hiérarchies de classes complexes avec des comportements personnalisés
• Lorsque vous avez besoin d'un contrôle précis sur les définitions d'attributs
• Pour les projets qui nécessitent une compatibilité Python 2 (bien que moins pertinent maintenant)

7. Performances et applications du monde réel

Performance:
attrs offre généralement de meilleures performances que les classes écrites manuellement ou d'autres bibliothèques en raison de ses implémentations optimisées.

Exemple concret :

from attr import define, Factory
from typing import List, Optional

@define
class Customer:
    id: int
    name: str
    email: str
    orders: List['Order'] = Factory(list)

@define
class Order:
    id: int
    customer_id: int
    total: float
    items: List['OrderItem'] = Factory(list)

@define
class OrderItem:
    id: int
    order_id: int
    product_id: int
    quantity: int
    price: float

@define
class Product:
    id: int
    name: str
    price: float
    description: Optional[str] = None

# Usage
customer = Customer(1, "Alice", "[email protected]")
product = Product(1, "Book", 29.99, "A great book")
order_item = OrderItem(1, 1, 1, 2, product.price)
order = Order(1, customer.id, 59.98, [order_item])
customer.orders.append(order)

print(customer)

8. Conclusion et appel à l'action

attrs est une bibliothèque puissante qui simplifie les définitions de classes Python tout en fournissant des fonctionnalités robustes pour la validation et la manipulation des données. Sa capacité à réduire le code passe-partout, à améliorer la lisibilité et à améliorer les performances en fait un outil inestimable pour les développeurs Python.

Ressources communautaires :

• Dépôt GitHub : https://github.com/python-attrs/attrs
• Documentation : https://www.attrs.org/
• Page PyPI : https://pypi.org/project/attrs/

Essayez attrs dans votre prochain projet et découvrez ses avantages par vous-même. Partagez vos expériences avec la communauté et contribuez à son développement continu. Bon codage !

1. https://stefan.sofa-rockers.org/2020/05/29/attrs-dataclasses-pydantic/ ↩