Python Academy · Lección

Métodos de instancia y self

Escriba métodos que operen sobre los datos propios del objeto.

Métodos de instancia y self es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Python Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Python Academy incluye 4 lecciones en total.

Introducción

Los métodos de instancia operan sobre los datos de un objeto específico y usan self para acceder a sus atributos y modificarlos.

Definición de métodos de instancia

def method(self): dentro de una clase es un método de instancia. Recibe el objeto como primer argumento (self).

class Circle:
    def __init__(self, r): self.r = r
    def area(self):
        import math
        return math.pi * self.r**2
print(Circle(5).area())

Llamada a métodos

obj.method() es una forma abreviada de ClassName.method(obj). Python pasa obj como self automáticamente.

class Dog:
    def __init__(self, name): self.name = name
    def bark(self): print(f'{self.name} says Woof!')
Dog('Rex').bark()

Métodos que devuelven self

Devolver self permite encadenar métodos: builder.set_name('x').set_age(3).build().

class Builder:
    def __init__(self): self.data = {}
    def set(self, k, v):
        self.data[k] = v
        return self
    def build(self): return self.data
result = Builder().set('x',1).set('y',2).build()
print(result)

Métodos privados (por convención)

Anteponer _ indica «uso interno». Anteponer __ activa el name mangling: _ClassName__method.

class Account:
    def __init__(self, bal): self._bal = bal
    def _validate(self, amount): return amount > 0
    def deposit(self, amount):
        if self._validate(amount):
            self._bal += amount
a = Account(100)
a.deposit(50)
print(a._bal)

Propiedades como métodos

@property convierte un método en un atributo legible. No se necesitan paréntesis al acceder a él.

class Circle:
    def __init__(self, r): self.r = r
    @property
    def diameter(self): return self.r * 2
c = Circle(5)
print(c.diameter)  # no ()

Modificación del estado

Los métodos que modifican los atributos de self cambian el estado del objeto. Diseñe métodos con una intención clara: consulta o comando.

class Stack:
    def __init__(self): self.items = []
    def push(self, x): self.items.append(x)
    def pop(self): return self.items.pop()
    def peek(self): return self.items[-1]
s = Stack()
s.push(1); s.push(2)
print(s.pop(), s.peek())

Comparación de objetos

De forma predeterminada, == compara la identidad. Implemente __eq__ para comparar por valor.

class Point:
    def __init__(self, x, y): self.x,self.y=x,y
    def __eq__(self, other): return self.x==other.x and self.y==other.y
print(Point(1,2)==Point(1,2))

Protocolo de iteración

Implemente __iter__ y __next__ para hacer que una clase sea iterable y pueda usarse en bucles for.

class Countdown:
    def __init__(self, n): self.n = n
    def __iter__(self): return self
    def __next__(self):
        if self.n <= 0: raise StopIteration
        self.n -= 1; return self.n + 1
print(list(Countdown(3)))

Protocolo de gestor de contexto

Implemente __enter__ y __exit__ para poder usar una clase en instrucciones with.

class Timer:
    def __enter__(self):
        import time
        self.start = time.time()
        return self
    def __exit__(self, *args):
        import time
        print(f'elapsed: {time.time()-self.start:.3f}s')
with Timer(): pass

Método frente a función

Al acceder a Dog.bark mediante la clase, es una función simple. Mediante una instancia, d.bark es un método ligado: self ya está rellenado.

class Dog:
    def bark(self): print('woof')
print(type(Dog.bark))
print(type(Dog().bark))

Comprobación rápida

¿Qué es el encadenamiento de métodos y qué debe devolver un método para permitirlo?

Repaso

Métodos de instancia: def m(self). Llámelos como obj.m(). Devuelva self para encadenarlos. __eq__/__iter__/__enter__/__exit__ implementan protocolos. El prefijo _ indica uso interno.

Continúe

¡Excelente! Continúe con la siguiente lección para profundizar sus conocimientos.

Preguntas frecuentes

¿La lección «Métodos de instancia y self» es gratis?

Sí — el texto completo de «Métodos de instancia y self» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Python Academy, actualiza a CoddyKit PRO. El curso de Python Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Métodos de instancia y self»?

Escriba métodos que operen sobre los datos propios del objeto. Practicas Python Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Python Academy?

No se requiere experiencia previa. Python Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Métodos de instancia y self»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Python Academy?

Sí. Cada lección de Python Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Clases y el método __init__
Atributos de instancia frente a atributos de clase
Métodos de instancia y self
Métodos mágicos: __str__ y __repr__

← Volver a Python Academy