Décorateurs Property Avancés

Fait partie de la section Programmation orientée objet du Journey Python de Coddy. Leçon 31 sur 64.

Les décorateurs de propriétés avancés offrent un contrôle plus sophistiqué de l’accès aux attributs, notamment les propriétés calculées, les deleters et la gestion complète des propriétés.

Voici un exemple de propriétés calculées qui dérivent des valeurs à partir d'autres attributs :

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    @property
    def area(self):
        return self.width * self.height
    
    @property
    def perimeter(self):
        return 2 * (self.width + self.height)

Utilisez les propriétés calculées comme des attributs ordinaires :

rect = Rectangle(5, 3)
print(rect.area)      # 15 - calculé automatiquement
print(rect.perimeter) # 16 - calculé automatiquement

Créez une propriété avec un getter, un setter et un deleter :

class Temperature:
    def __init__(self):
        self._temp = 0
    
    @property
    def temperature(self):
        return self._temp
    
    @temperature.setter
    def temperature(self, value):
        if value < -273.15:
            raise ValueError("Temperature below absolute zero!")
        self._temp = value
    
    @temperature.deleter
    def temperature(self):
        print("Resetting temperature to 0")
        self._temp = 0

Utilisez la fonctionnalité complète de la propriété :

temp = Temperature()

Utilisez le setter avec validation :

temp.temperature = 25
print(temp.temperature)  # 25

# temp.temperature = -300  # Lèverait une ValueError

Utilisez le suppresseur :

del temp.temperature
print(temp.temperature)  # 0

Créez un exemple plus complexe avec un score de jeu :

class Player:
    def __init__(self, name):
        self.name = name
        self._score = 0
        self._level = 1
    
    @property
    def score(self):
        return self._score
    
    @score.setter
    def score(self, value):
        if value >= 0:
            self._score = value
            self._level = (value // 1000) + 1
        else:
            raise ValueError("Score cannot be negative")
    
    @score.deleter
    def score(self):
        print(f"Resetting {self.name}'s progress")
        self._score = 0
        self._level = 1
    
    @property
    def level(self):
        return self._level

player = Player("Alice")
player.score = 2500
print(f"Score: {player.score}, Level: {player.level}")  # Score : 2500, Niveau : 3

del player.score
print(f"Score: {player.score}, Level: {player.level}")  # Score : 0, Niveau : 1

Sortie :

15
16
25
Resetting temperature to 0
0
Score: 2500, Level: 3
Resetting Alice's progress
Score: 0, Level: 1

Point clé : Les décorateurs de propriétés avancés permettent des propriétés calculées (calculées à partir d’autres données), la suppression de propriétés avec @property.deleter, ainsi qu’un contrôle total de l’accès, de la modification et de la suppression des attributs. Cela crée des interfaces intuitives tout en maintenant une validation stricte des données et l’encapsulation.

Défi

Moyen

Dans ce défi, vous allez implémenter une classe Rectangle avec un encapsulation correcte et une validation des propriétés.

rectangle.py - Il s’agit du fichier que vous devez modifier, contenant des commentaires TODO pour vous guider dans votre implémentation
driver.py - Contient de nombreux scénarios de test (ne pas modifier)

Implémentez des attributs privés pour _width et _height
Créez des propriétés pour width et height avec validation (elles doivent être positives)
- Levez les exceptions ValueError avec les messages appropriés, comme indiqué dans les TODO
- Important : Vérifiez si la valeur est inférieure ou égale à 0, puis levez l’erreur (cela garantit un comportement cohérent)
Implémentez des propriétés en lecture seule pour area et perimeter
Créez une propriété dimensions avec les fonctionnalités d’accesseur, de mutateur et de suppresseur, comme décrit dans les TODO
- Important : Dans le mutateur, utilisez la syntaxe de décomposition de tuple : width, height = dimensions

Essayez vous-même

from rectangle import Rectangle

# Gestionnaire de cas de test
test_case = input()

# Test de fonctionnalité de base
if test_case == "default_test":
    rect = Rectangle(5, 3)
    print(f"Width: {rect.width}, Height: {rect.height}")
    print(f"Area: {rect.area}, Perimeter: {rect.perimeter}")
    
    # Test the dimensions property
    print(f"Dimensions: {rect.dimensions}")
    rect.dimensions = (10, 8)
    print(f"New area: {rect.area}")
    
    # Test de validation
    try:
        rect.width = -2
    except ValueError as e:
        print(f"Validation error: {e}")
    
    # Test du deleter
    del rect.dimensions
    print(f"After reset: {rect.dimensions}")

# Test avec des valeurs nulles
elif test_case == "zero_values":
    try:
        rect = Rectangle(0, 5)
    except ValueError as e:
        print(f"Error creating rectangle: {e}")
    
    try:
        rect = Rectangle(5, 0)
    except ValueError as e:
        print(f"Error creating rectangle: {e}")

# Test avec des valeurs négatives
elif test_case == "negative_values":
    rect = Rectangle(5, 3)
    original_dimensions = rect.dimensions
    
    try:
        rect.dimensions = (5, -3)
    except ValueError as e:
        print(f"Error setting dimensions: {e}")
    
    print(f"Dimensions after failed update: {rect.dimensions}")
    print(f"Original dimensions preserved: {rect.dimensions == original_dimensions}")

# Test avec de grandes valeurs
elif test_case == "large_values":
    rect = Rectangle(1000000, 2000000)
    print(f"Large rectangle area: {rect.area}")
    print(f"Large rectangle perimeter: {rect.perimeter}")

# Test avec des valeurs à virgule flottante
elif test_case == "float_values":
    rect = Rectangle(3.5, 2.75)
    print(f"Dimensions: {rect.dimensions}")
    print(f"Area: {rect.area}")
    print(f"Perimeter: {rect.perimeter}")
    
    rect.dimensions = (1.1, 2.2)
    print(f"New area with float dimensions: {rect.area}")

# Test avec des erreurs de type
elif test_case == "type_errors":
    try:
        rect = Rectangle("5", 3)
    except Exception as e:
        print(f"Type error during creation: {type(e).__name__}: {e}")
    
    rect = Rectangle(5, 3)
    try:
        rect.dimensions = 10  # Pas un tuple
    except Exception as e:
        print(f"Type error setting dimensions: {type(e).__name__}: {e}")

# Test de plusieurs opérations sur les propriétés
elif test_case == "property_operations":
    rect = Rectangle(5, 10)
    print(f"Initial - Width: {rect.width}, Height: {rect.height}, Area: {rect.area}")
    
    rect.width = 8
    print(f"After width change - Width: {rect.width}, Area: {rect.area}")
    
    rect.height = 6
    print(f"After height change - Height: {rect.height}, Area: {rect.area}")
    
    rect.dimensions = (12, 9)
    print(f"After dimensions change - Dimensions: {rect.dimensions}, Area: {rect.area}")
    
    del rect.dimensions
    print(f"After reset - Dimensions: {rect.dimensions}, Area: {rect.area}")

# Test des cas limites de validation des propriétés
elif test_case == "validation_edge_cases":
    rect = Rectangle(5, 3)
    
    try:
        rect.width = 0
    except ValueError as e:
        print(f"Zero width error: {e}")
    
    # Une très petite valeur positive devrait être acceptée
    rect.height = 0.0001
    print(f"Small height accepted: {rect.height}")
    print(f"Area with small height: {rect.area}")

# Test avec plusieurs rectangles
elif test_case == "multiple_rectangles":
    rect1 = Rectangle(5, 3)
    rect2 = Rectangle(10, 2)
    rect3 = Rectangle(4, 4)
    
    print(f"Rectangle 1 - Area: {rect1.area}, Perimeter: {rect1.perimeter}")
    print(f"Rectangle 2 - Area: {rect2.area}, Perimeter: {rect2.perimeter}")
    print(f"Rectangle 3 - Area: {rect3.area}, Perimeter: {rect3.perimeter}")
    
    # Modifier chaque rectangle
    rect1.width = 7
    rect2.height = 5
    rect3.dimensions = (6, 6)
    
    print(f"After modifications:")
    print(f"Rectangle 1 - Dimensions: {rect1.dimensions}")
    print(f"Rectangle 2 - Dimensions: {rect2.dimensions}")
    print(f"Rectangle 3 - Dimensions: {rect3.dimensions}")

# Test de performance avec de nombreuses opérations
elif test_case == "performance_test":
    rect = Rectangle(5, 5)
    
    # Effectuer de nombreuses opérations sur les propriétés
    for i in range(1000):
        rect.width = i % 10 + 1  # Valeurs 1-10
        rect.height = i % 5 + 1  # Valeurs 1-5
        area = rect.area  # Accéder à la propriété calculée
        perimeter = rect.perimeter  # Accéder à la propriété calculée
        dims = rect.dimensions  # Accéder au getter de la propriété
    
    print(f"Final state after 1000 operations:")
    print(f"Width: {rect.width}, Height: {rect.height}")
    print(f"Area: {rect.area}, Perimeter: {rect.perimeter}")