.jpeg)
En Python, el parámetro `self` se usa en los métodos de una clase para hacer referencia a la instancia actual del objeto.
Cada vez que se llama a un método de una instancia de una clase, Python pasa automáticamente la instancia como primer argumento. El nombre convencional para este argumento es self, aunque puedes llamarlo de otra manera (aunque no se recomienda porque es una convención establecida).
Veamos un ejemplo:
class Persona:
def __init__(self, nombre, edad):
self.nombre = nombre # `self.nombre` es un atributo de la instancia
self.edad = edad # `self.edad` también es un atributo de la instancia
def saludar(self):
print(f"Hola, mi nombre es {self.nombre} y tengo {self.edad} años.")
# Crear una instancia de la clase
p1 = Persona("Carlos", 30)
# Llamar al método saludar
p1.saludar()
- self.nombre = nombre: Guarda el valor del parámetro nombre en el atributo nombre de la instancia.
- def saludar(self): El método recibe self, lo que le permite acceder a los atributos nombre y edad de la instancia p1.
- Cuando se llama a p1.saludar(), Python en realidad ejecuta Persona.saludar(p1), pasando la instancia p1 como primer argumento.
self es obligatorio en métodos de instancia porque permite acceder a los atributos y otros métodos de la instancia. Si se omite, se generará un error:
class Prueba:
def mensaje():
print("Este método no tiene self.")
p = Prueba()
p.mensaje() # TypeError: mensaje() takes 0 positional arguments but 1 was given
Aquí, Python intenta pasar la instancia p automáticamente, pero como el método mensaje() no tiene self, se genera un error.
El parámetro self también se usa en métodos especiales como __str__, __repr__, __eq__, etc.:
class Auto:
def __init__(self, marca):
self.marca = marca
def __str__(self):
return f"Auto de marca {self.marca}"
a = Auto("Toyota")
print(a) # Auto de marca Toyota
En Python, un constructor es un método especial que se ejecuta automáticamente cuando se crea una nueva instancia de una clase. Se define con el método __init__.
__init__ es el constructor de una clase en Python. Se usa para inicializar los atributos del objeto cuando se crea una instancia.
class Persona:
def __init__(self, nombre, edad):
self.nombre = nombre # Atributo de la instancia
self.edad = edad # Atributo de la instancia
def presentarse(self):
print(f"Hola, soy {self.nombre} y tengo {self.edad} años.")
# Crear una instancia
p1 = Persona("Carlos", 30)
# Llamar a un método
p1.presentarse()
- __init__ recibe self, que es la instancia del objeto.
- self.nombre = nombre almacena el valor en el objeto.
- Cuando se crea una instancia con Persona("Carlos", 30), Python ejecuta automáticamente __init__, asignando "Carlos" a self.nombre y 30 a self.edad.
Se pueden definir valores predeterminados en los parámetros del constructor:
class Coche:
def __init__(self, marca="Toyota", modelo="Corolla"):
self.marca = marca
self.modelo = modelo
c1 = Coche() # Usa los valores por defecto
c2 = Coche("Ford", "Focus") # Pasa valores específicos
print(c1.marca, c1.modelo) # Toyota Corolla
print(c2.marca, c2.modelo) # Ford Focus
También es posible definir un constructor sin argumentos (además de `self`):
class Ejemplo:
def __init__(self):
print("Se ha creado una nueva instancia.")
obj = Ejemplo() # Se imprimirá el mensaje
El constructor puede contener lógica para validar datos o modificar valores antes de asignarlos:
class Usuario:
def __init__(self, nombre, edad):
self.nombre = nombre
self.edad = max(0, edad) # Evita edades negativas
u1 = Usuario("Ana", -5)
print(u1.edad) # 0
Para poder utilizar objetos debemos definir una variable de referencia y luego instanciar dicho objeto, como vimos anteriormente:
c1 = Coche() # Usa los valores por defecto
c2 = Coche("Ford", "Focus") # Pasa valores específicos
Una vez definido un objeto podemos interactuar con él invocando sus atributos (lo cual no es recomendado porque rompemos el principio del encapsulamiento) públicos e interactuando con sus métodos:
c1.marca = "Ford"
c1.modelo = ”Fiesta”
