En Python, "todo es un objeto" significa que cualquier entidad manipulada (números, texto, funciones, clases, módulos) es una instancia de alguna clase. Cada objeto tiene:
id()
type()
object
type
class Fruta: def __init__(self, nombre, color, sabor): self.nombre = nombre self.color = color self.sabor = sabor def madurar(self): print(f"{self.nombre} está madurando y se vuelve más dulce.") def mostrar_info(self): print(f"Esta fruta es una {self.nombre}, es de color {self.color} y tiene un sabor {self.sabor}.")
()
__init__()
manzana_roja = Fruta("Manzana", "Roja", "Dulce") platano_verde = Fruta("Plátano", "Verde", "Insípido") naranja_valencia = Fruta("Naranja", "Naranja", "Cítrico")
Son variables que almacenan datos asociados a una clase y es compartida por todas las instancias/objetos de esa clase.
Se accede a ellos usando la notación de punto (.) después del objeto objeto.atributo o de la clase objeto.atributo.
.
objeto.atributo
En Python puedes modificar el atributo de una clase o de una instancia de esa clase, pero tienen efectos distintos.
class Automovil: llantas = 4 def __init__(self, marca): self.marca = marca def info(self): print(f"Este {self.marca} tiene {self.llantas} llantas.")
Aquí llantas es un atributo de clase, mientras que marca es un atributo de la instancia de esa clase.
llantas
marca
>>> auto1 = Automovil('Ford') >>> auto2 = Automovil('Nissan')
>>> Automovil.llantas 4 >>> auto1.llantas 4 >>> auto2.llantas 4
>>> auto1.marca 'Ford' >>> auto2.marca 'Nissan' >>> Automovil.marca Traceback (most recent call last): File "<pyshell#27>", line 1, in <module> Automovil.marca AttributeError: type object 'Automovil' has no attribute 'marca'
Son variables que almacenan datos asociados a un objeto. Representan las características o propiedades de esa instancia en particular.
Se accede a ellos usando la notación de punto (.) después del objeto: objeto.atributo. Ejemplo:
.nombre
.color
.sabor
print(manzana_roja.nombre) # Imprime Manzana print(platano_verde.color) # Imprime Verde print(naranja_valencia) # Imprime Cítrico
madurar()
mostrar_info()
>>> manzana_roja.madurar() Manzana está madurando y se vuelve más dulce >>> naranja_valencia.mostrar_info() Esta fruta es una Naranja, es de color Naranja y tiene un sabor Cítrico.
self
En Python, self es una convención utilizada para referirse a la instancia del objeto dentro de una clase. Aunque puedes usar cualquier otro nombre, self es la práctica estándar y altamente recomendada, ya que mejora la legibilidad del código y facilita la comprensión por parte de otros programadores.
La herencia permite que una clase (subclase o hija) herede atributos y métodos de otra clase (superclase o padre). Esto promueve la reutilización de código y la organización jerárquica.
class Animal: def __init__(self, nombre): self.nombre = nombre def hablar(self): print("Sonido genérico de animal") class Perro(Animal): def hablar(self): print("Guau!")
mi_perro = Perro("Chocorol") # Imprime: Guau! mi_perro.hablar() #Imprime: Chocorol. Accede a un atributo de la clase padre print(mi_perro.nombre) animal_generico = Animal("Polito") #Imprime: Sonido genérico de animal animal_generico.hablar()
class Motor: def encender(self): print("Motor encendido") class Coche: def __init__(self, marca, modelo): self.marca = marca self.modelo = modelo self._motor = Motor() def arrancar(self): self._motor.encender() print("El coche ha arrancado.") def conducir(self): print("Conduciendo el coche.")
self._motor
Coche()
mi_coche = Coche("Toyota", "Corolla") mi_coche.arrancar() mi_coche.conducir()
_
__
class MiClase: def __init__(self): self.publico = 3.1416 self._semi_privado = 1234 self.__muy_privado = "313373" def imprime(self): print( self.publico, self._semi_privado, self.__muy_privado ) objeto = MiClase()
>>> objeto.imprime() 3.1416 1234 313373
>>> objeto.publico 3.1416 >>> objeto._semi_privado 1234 >>> objeto.__muy_privado Traceback ...
.__muy_privado
>>> objeto._MiClase__muy_privado '313373'
class Gato: def hacer_sonido(self): print("Prrrrrr") class Luna(Gato): def hacer_sonido(self): print("Miauuu") class Cucho(Gato): def hacer_sonido(self): print("Mrma mra mra mauuu")
>>> gato1 = Gato() >>> gato1.hacer_sonido() Prrrrrr >>> gato2 = Luna() >>> gato2.hacer_sonido() Miauuu >>> gato3 = Cucho() >>> gato3.hacer_sonido() Mrma mra mra mauuu
La recolección de basura en Python es un proceso automático que libera la memoria que ya no está en uso por el programa. Python utiliza principalmente dos técnicas:
Conteo de referencias: Cada objeto tiene un contador que rastrea cuántas referencias apuntan a él. Cuando este contador llega a cero, el objeto se libera inmediatamente.
Recolector cíclico: El conteo de referencias no maneja correctamente las referencias circulares (cuando dos o más objetos se referencian entre sí, impidiendo que su contador llegue a cero). El recolector cíclico detecta y libera estos ciclos.
La introspección permite examinar objetos en tiempo de ejecución. Funciones clave:
type(objeto)
dir(objeto)
id(objeto)
hasattr(objeto, 'nombre')
callable(objeto)
inspect
Ejemplo: dir([1, 2]) muestra los métodos de una lista.
dir([1, 2])
**La abstracción**: ocultar la complejidad de la implementación interna de un objeto y exponer solo una interfaz simplificada para interactuar con él. Se logra principalmente mediante clases y métodos.