Introdução

A biblioteca attrs do Python é uma virada de jogo para desenvolvedores que buscam simplificar a criação de classes e reduzir o código clichê. Esta biblioteca tem a confiança até da NASA.
Criado por Hynek Schlawack em 2015, o attrs rapidamente se tornou uma ferramenta favorita entre os desenvolvedores Python por sua capacidade de gerar automaticamente métodos especiais e fornecer uma maneira limpa e declarativa de definir classes.
dataclasses é uma espécie de subconjunto de atributos.

Por que os atributos são úteis:

• Reduz o código padrão
• Melhora a legibilidade e manutenção do código
• Fornece recursos poderosos para validação e conversão de dados
• Melhora o desempenho por meio de implementações otimizadas

2. Primeiros passos com atributos

Instalação:
Para começar com attrs, você pode instalá-lo usando pip:

pip install attrs

Uso básico:
Aqui está um exemplo simples de como usar atributos para definir uma 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. Principais recursos de atributos

um. Geração automática de método:

attrs gera automaticamente os métodos init, repr e eq para suas 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. Definição de atributos com tipos e valores padrão:

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. Validadores e conversores:

import attr

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




  
  
  4. Uso avançado



  
  
  um. Personalizando o comportamento do atributo:




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. Instâncias e slots congelados:




@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. Funções de fábrica e processamento pós-inicialização:




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. Melhores práticas e armadilhas comuns



  
  
  Melhores práticas:

• Use anotações de tipo para melhor legibilidade do código e suporte IDE
• Aproveite validadores para integridade de dados
• Use classes congeladas para objetos imutáveis
• Aproveite a geração automática de métodos para reduzir a duplicação de código

Armadilhas comuns:

• Esquecendo de usar o decorador @attr.s na aula
• Uso excessivo de validadores complexos que poderiam ser métodos separados
• Não considerando o impacto no desempenho do uso extensivo de funções de fábrica

6. attrs vs outras bibliotecas

attrs e dataclasses são mais rápidos que pydantic¹.

Comparação com classes de dados:

• attrs é mais rico em recursos e flexível
• dataclasses são incorporadas ao Python 3.7, tornando-as mais acessíveis
• attrs tem melhor desempenho na maioria dos casos
• dataclasses estão vinculadas à versão Python, enquanto attrs como uma biblioteca externa pode ser usada com qualquer versão Python.

Comparação com pydantic:

• pydantic está focado na validação de dados e gerenciamento de configurações
• attrs é de uso mais geral e se integra melhor às bases de código existentes
• pydantic possui serialização JSON integrada, enquanto attrs requer bibliotecas adicionais

Quando escolher atributos:

• Para hierarquias de classes complexas com comportamentos personalizados
• Quando você precisa de controle refinado sobre definições de atributos
• Para projetos que exigem compatibilidade com Python 2 (embora menos relevante agora)

7. Desempenho e aplicações do mundo real

Desempenho:
attrs geralmente oferece melhor desempenho do que classes escritas manualmente ou outras bibliotecas devido às suas implementações otimizadas.

Exemplo do mundo real:

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. Conclusão e apelo à ação

attrs é uma biblioteca poderosa que simplifica as definições de classe Python ao mesmo tempo que fornece recursos robustos para validação e manipulação de dados. Sua capacidade de reduzir código clichê, melhorar a legibilidade e melhorar o desempenho o torna uma ferramenta inestimável para desenvolvedores Python.

Recursos da comunidade:

• Repositório GitHub: https://github.com/python-attrs/attrs
• Documentação: https://www.attrs.org/
• Página PyPI: https://pypi.org/project/attrs/

Experimente o Attrs em seu próximo projeto e experimente seus benefícios em primeira mão. Compartilhe suas experiências com a comunidade e contribua para seu desenvolvimento contínuo. Boa codificação!

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