POO. Atributos II
Modelos de programación
Una de las tareas que con más frecuencia debemos realizar al trabajar con objetos es dar valor a los atributos y modificar esos valores. En la entrada anterior en la que comparamos funciones con métodos ya estuvimos trabajando sobre ello, así como en la entrada referida a los atributos. Ahora nos vamos a centrar en esta cuestión de forma específica.
Caben tres posibilidades para modificar el valor de un atributo:
- Modificarlo directamente
- Modificarlo mediante un método específico
- O modificarlo de forma incremental, también mediante un método
Partiremos de una clase simple, en cuyos objetos no se tiene pensado modificar el contenidos de los atributos, para ir mostrando las tres opciones enunciadas antes.
class coche:
def __init__(self,marca,modelo,anno):
self.marca=marca
self.modelo=modelo
self.anno=anno
def descripcion(self):
coche_descripcion= f"Mi coche es un {self.marca} {self.modelo} de {self.anno}"
return coche_descripcion
mi_coche=coche("Seat","Toledo",1996)
texto=mi_coche.descripcion()
print(texto)
La única novedad que presenta este script es que el método descripcion(self) devuelve return una cadena f que describe el objeto, por lo que su uso debe asociarse a una variable texto Por lo demás, presenta un funcionamiento de sobre conocido.
Para explicar las implicaciones de la modificación de atributo, deberemos incluir en la definición de atributos uno que no figure como parámetro, por ejemplo, el valor del cuentakilómetros, así como un método para mostrar el cuentakilómetros actual del vehículo. Esto modifica la definición de la clase como sigue:
class coche:
def __init__(self,marca,modelo,anno):
self.marca=marca
self.modelo=modelo
self.anno=anno
self.cuentakilometros=0
def descripcion(self):
coche_descripcion= f"Mi coche es un {self.marca} {self.modelo} de {self.anno}"
return coche_descripcion
def cuentaK(self):
print(f"El cuentakilómetros de mi coche marca {self.cuentakilometros} kilómetros")
Procedamos ahora a introducir/modificar el valor inicial del parámetro cuentakilometros directamente en la definición del objeto mi_coche
mi_coche=coche("Seat","Toledo",1996)
mi_coche.cuentakilometros = 1200
texto=mi_coche.descripcion()
print(texto)
mi_coche.cuentaK()
Una vez definido el objeto mi_coche=coche("Seat","Toledo",1996) establecemos el valor del atributo no definido como parámetro (y en consecuencia no establecido ya como valor en la definición del objeto) mediante la expresión basada en la sintaxis del punto mi_coche.cuentakilometros = 1200. Posteriormente llamaremos a este método de forma directa mi_coche.cuentaK() ya que originalmente no cuenta con la instrucción return.
La segunda opción consiste en modificar el atributo mediante un método específico, el siguiente...
def cuentaK(self, km_actuales):
self.cuentakilometros = km_actuales
print(f"El cuentakilómetros de mi coche marca {self.cuentakilometros} kilómetros")
... que asocia el valor dado al atributo km_actuales al parámetro cuentakilometros que después se imprime por pantalla mediante print(): mi_coche.cuentaK(1200)
Finalmente veamos cómo se concreta el método que permite incrementar el valor del parámetro, añadiéndolo como método nuevo.
class coche:
def __init__(self,marca,modelo,anno):
self.marca=marca
self.modelo=modelo
self.anno=anno
self.cuentakilometros=0
def descripcion(self):
coche_descripcion= f"Mi coche es un {self.marca} {self.modelo} de {self.anno}"
return coche_descripcion
def cuentaK(self,kilometraje):
self.cuentakilometros =kilometraje
def leer_cuentaK(self):
print(f"Este coche ha recorrido {self.cuentakilometros} Km")
def incrementarKm(self,km):
self.cuentakilometros += km
Observa que he eliminado la instrucción print() del método cuentaK() primitivo y he creado un método específico de escritura de los Km que lleva recorridos el coche leer_cuentaK(). De este modo diferenciamos ambos procesos: dar valor al atributo cuentakilometros y escribir el resultado. El objetivo es reutilizar este método cuando incrementemos los kilómetros, que es lo que hacemos con el método incrementarKm()
Este es el método que nos permite incrementar los kilómetros inicialmente establecidos mediante el método cuentaK(). Observa que incrementarKm() tiene dos parámetros: el obligatorio self y km, que serán los km que incrementemos cada vez que usemos el método. La instrucción de este método consiste en añadir km al dato que contiene el atributo cuentakilometros.
Desde el lado de la creación de un objeto asociado a la variable mi_coche...
mi_coche=coche("Seat","Toledo",1996)
texto=mi_coche.descripcion()
print(texto)
mi_coche.cuentaK(1200)
mi_coche.leer_cuentaK()
mi_coche.incrementarKm(100)
mi_coche.leer_cuentaK()
... podemos apreciar los cuatro métodos de la clase, incluyendo el uso repetido del método leer_cuentaK(): primero para informar de los km del cuentakilómetros y después para informar del resultante tras el incremento.
Te dejo a continuación el código de estos script:
