Atributos. Modificar valores
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. En ésta nos vamos a centrar en esta cuestión específicamente.
Caben tres posibilidades u opciones 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=marcaself.modelo=modeloself.anno=annodef descripcion(self):coche_descripcion= f"Mi coche es un {self.marca} {self.modelo} de {self.anno}"return coche_descripcionmi_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=marcaself.modelo=modeloself.anno=annoself.cuentakilometros=0def descripcion(self):coche_descripcion= f"Mi coche es un {self.marca} {self.modelo} de {self.anno}"return coche_descripciondef 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 = 1200texto=mi_coche.descripcion()print(texto)mi_coche.cuentaK()
Una vez definido el objeto mi_coche (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 la instrucción 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 independizamos 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 el uso de 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:
No hay comentarios:
Publicar un comentario
Comenta esta entrada