El decorador @property en Python: sus casos de uso, ventajas y sintaxis

? Conoce Propiedades

¡Bienvenidos! En este artículo, aprenderá a trabajar con el @propertydecorador en Python.

Aprender√°s:

  • Las ventajas de trabajar con propiedades en Python.
  • Los conceptos b√°sicos de las funciones de decorador: qu√© son y c√≥mo se relacionan con @property.
  • C√≥mo puede usar @property para definir captadores, definidores y eliminadores.

1ÔłŹ‚É£ Ventajas de las propiedades en Python

Comencemos con un poco de contexto. ¬ŅPor qu√© usar√≠as propiedades en Python?

Las propiedades pueden considerarse la forma "Pythonic" de trabajar con atributos porque:

  • La sintaxis utilizada para definir propiedades es muy concisa y legible.
  • Puede acceder a los atributos de instancia exactamente como si fueran atributos p√ļblicos mientras utiliza la "magia" de los intermediarios (captadores y definidores) para validar nuevos valores y evitar acceder o modificar los datos directamente.
  • Al usar @property, puede "reutilizar" el nombre de una propiedad para evitar crear nuevos nombres para los captadores, definidores y eliminadores.

Estas ventajas hacen que las propiedades sean una herramienta realmente increíble para ayudarlo a escribir código más conciso y legible. ?

2ÔłŹ‚É£ Introducci√≥n a los decoradores

Una funci√≥n decoradora es b√°sicamente una funci√≥n que agrega nueva funcionalidad a una funci√≥n que se pasa como argumento. ¬ŅUsar una funci√≥n decoradora es como agregar chispas de chocolate a un helado ?. Nos permite agregar una nueva funcionalidad a una funci√≥n existente sin modificarla.

En el siguiente ejemplo, puede ver cómo se ve una función decoradora típica en Python:

def decorator(f): def new_function(): print("Extra Functionality") f() return new_function @decorator def initial_function(): print("Initial Functionality") initial_function()

Analicemos estos elementos en detalle:

  • Primero encontramos la funci√≥n decoradora def decorator(f)(los sprinkles ‚ú®) que toma una funci√≥n fcomo argumento.
def decorator(f): def new_function(): print("Extra Functionality") f() return new_function
  • Esta funci√≥n decorador tiene una funci√≥n anidada, new_function. Observe c√≥mo fse llama dentro new_functionpara lograr la misma funcionalidad mientras agrega una nueva funcionalidad antes de la llamada a la funci√≥n (tambi√©n podr√≠amos agregar una nueva funcionalidad despu√©s de la llamada a la funci√≥n).
  • La funci√≥n decoradora en s√≠ misma devuelve la funci√≥n anidada new_function.
  • Luego (abajo), encontramos la funci√≥n que se decorar√° (¬Ņel helado?) initial_function. Observe la sintaxis muy peculiar ( @decorator) sobre el encabezado de la funci√≥n.
@decorator def initial_function(): print("Initial Functionality") initial_function()

Si ejecutamos el código, vemos esta salida:

Extra Functionality Initial Functionality

Observe c√≥mo se ejecuta la funci√≥n decoradora incluso si solo estamos llamando initial_function(). ¬ŅEsta es la magia de agregar @decorator ?.

?Nota: En general, escribiríamos @, reemplazando el nombre de la función decoradora después del símbolo @.

S√© que puede estar preguntando: ¬Ņc√≥mo se relaciona esto con @property? @Property es un decorador integrado para la funci√≥n property () en Python. Se utiliza para dar una funcionalidad "especial" a ciertos m√©todos para que act√ļen como captadores, definidores o eliminadores cuando definimos propiedades en una clase.

Ahora que est√° familiarizado con los decoradores, ¬°veamos un escenario real del uso de @property!

? Escenario del mundo real: @property

Digamos que esta clase es parte de su programa. Est√° modelando una casa con una Houseclase (por el momento, la clase solo tiene definido un atributo de instancia de precio ):

class House: def __init__(self, price): self.price = price

Este atributo de instancia es p√ļblico porque su nombre no tiene un gui√≥n bajo al principio. Dado que el atributo es p√ļblico actualmente, es muy probable que usted y otros desarrolladores de su equipo hayan accedido y modificado el atributo directamente en otras partes del programa utilizando la notaci√≥n de puntos, como esta:

# Access value obj.price # Modify value obj.price = 40000

? Consejo: obj representa una variable que hace referencia a una instancia de House.

Hasta ahora todo est√° funcionando muy bien, ¬Ņverdad? Pero digamos que se le pide que haga que este atributo est√© protegido (no p√ļblico) y valide el nuevo valor antes de asignarlo . Espec√≠ficamente, debe verificar si el valor es un valor flotante positivo. ¬ŅC√≥mo lo har√≠as t√ļ? Veamos.

Cambiar su código

En este punto, si decide agregar getters y setters, probablemente usted y su equipo entrar√°n en p√°nico. Esto se debe a que cada l√≠nea de c√≥digo que accede o modifica el valor del atributo tendr√° que modificarse para llamar al getter o al setter, respectivamente. De lo contrario, el c√≥digo se romper√° ‚ö†ÔłŹ.

# Changed from obj.price obj.get_price() # Changed from obj.price = 40000 obj.set_price(40000)

Pero ... ¬°Las propiedades vienen al rescate! Con @property, usted y su equipo no necesitar√°n modificar ninguna de esas l√≠neas porque podr√°n agregar getters y setters "detr√°s de escena" sin afectar la sintaxis que us√≥ para acceder o modificar el atributo cuando era p√ļblico.

Impresionante, ¬Ņverdad?  

? @property: Sintaxis y lógica

Si decide usarlo @property, su clase se ver√° como el siguiente ejemplo:

class House: def __init__(self, price): self._price = price @property def price(self): return self._price @price.setter def price(self, new_price): if new_price > 0 and isinstance(new_price, float): self._price = new_price else: print("Please enter a valid price") @price.deleter def price(self): del self._price

Específicamente, puede definir tres métodos para una propiedad:

  • Un captador : para acceder al valor del atributo.
  • Un setter : para establecer el valor del atributo.
  • Un eliminador : para eliminar el atributo de instancia.

El precio ahora est√° "protegido"

Please note that the price attribute is now considered "protected" because we added a leading underscore to its name in self._price:

self._price = price

In Python, by convention, when you add a leading underscore to a name, you are telling other developers that it should not be accessed or modified directly outside of the class. It should only be accessed through intermediaries (getters and setters) if they are available.

? Getter

Here we have the getter method:

@property def price(self): return self._price

Notice the syntax:

  • @property - Used to indicate that we are going to define a property. Notice how this immediately improves readability because we can clearly see the purpose of this method.
  • def price(self) - The header. Notice how the getter is named exactly like the property that we are defining: price. This is the name that we will use to access and modify the attribute outside of the class. The method only takes one formal parameter, self, which is a reference to the instance.
  • return self._price - This line is exactly what you would expect in a regular getter. The value of the protected attribute is returned.

Here is an example of the use of the getter method:

>>> house = House(50000.0) # Create instance >>> house.price # Access value 50000.0

Notice how we access the price attribute as if it were a public attribute. We are not changing the syntax at all, but we are actually using the getter as an intermediary to avoid accessing the data directly.

? Setter

Now we have the setter method:

@price.setter def price(self, new_price): if new_price > 0 and isinstance(new_price, float): self._price = new_price else: print("Please enter a valid price")

Notice the syntax:

  • @price.setter - Used to indicate that this is the setter method for the price property. Notice that we are not using @property.setter, we are using @price.setter. The name of the property is included before .setter.
  • def price(self, new_price): - The header and the list of parameters. Notice how the name of the property is used as the name of the setter. We also have a second formal parameter (new_price), which is the new value that will be assigned to the price attribute (if it is valid).
  • Finally, we have the body of the setter where we validate the argument to check if it is a positive float and then, if the argument is valid, we update the value of the attribute. If the value is not valid, a descriptive message is printed. You can choose how to handle invalid values according the needs of your program.

This is an example of the use of the setter method with @property:

>>> house = House(50000.0) # Create instance >>> house.price = 45000.0 # Update value >>> house.price # Access value 45000.0

Notice how we are not changing the syntax, but now we are using an intermediary (the setter) to validate the argument before assigning it. The new value (45000.0) is passed as an argument to the setter :

house.price = 45000.0

If we try to assign an invalid value, we see the descriptive message. We can also check that the value was not updated:

>>> house = House(50000.0) >>> house.price = -50 Please enter a valid price >>> house.price 50000.0

? Tip: This proves that the setter method is working as an intermediary. It is being called "behind the scenes" when we try to update the value, so the descriptive message is displayed when the value is not valid.

? Deleter

Finally, we have the deleter method:

@price.deleter def price(self): del self._price

Notice the syntax:

  • @price.deleter - Used to indicate that this is the deleter method for the price property. Notice that this line is very similar to @price.setter, but now we are defining the deleter method, so we write @price.deleter.
  • def price(self): - The header. This method only has one formal parameter defined, self.
  • del self._price - The body, where we delete the instance attribute.

? Tip: Notice that the name of the property is "reused" for all three methods.

This is an example of the use of the deleter method with @property:

# Create instance >>> house = House(50000.0) # The instance attribute exists >>> house.price 50000.0 # Delete the instance attribute >>> del house.price # The instance attribute doesn't exist >>> house.price Traceback (most recent call last): File "", line 1, in  house.price File "", line 8, in price return self._price AttributeError: 'House' object has no attribute '_price'

The instance attribute was deleted successfully ?. When we try to access it again, an error is thrown because the attribute doesn't exist anymore.

? Some final Tips

You don't necessarily have to define all three methods for every property. You can define read-only properties by only including a getter method. You could also choose to define a getter and setter without a deleter.

If you think that an attribute should only be set when the instance is created or that it should only be modified internally within the class, you can omit the setter.

You can choose which methods to include depending on the context that you are working with.

? In Summary

  • You can define properties with the @property syntax, which is more compact and readable.
  • @property can be considered the "pythonic" way of defining getters, setters, and deleters.
  • By defining properties, you can change the internal implementation of a class without affecting the program, so you can add getters, setters, and deleters that act as intermediaries "behind the scenes" to avoid accessing or modifying the data directly.

I really hope you liked my article and found it helpful. To learn more about Properties and Object Oriented Programming in Python, check out my online course, which includes 6+ hours of video lectures, coding exercises, and mini projects.