Encapsulación
Explore conceptos avanzados de la programación orientada a objetos.
Encapsulación es una lección gratuita de Python For Kids en CoddyKit. Esta es la lección 4 de 5. 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 For Kids, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Python For Kids incluye 5 lecciones en total.
Encapsulamiento
¡Le damos la bienvenida de nuevo a la lección de programación orientada a objetos (POO)! Hoy aprenderemos sobre el encapsulamiento en Python, un concepto clave que ayuda a proteger los datos y métodos dentro de las clases.
¿Qué es el encapsulamiento?
El encapsulamiento es el concepto de agrupar los datos (atributos) y los métodos (funciones) que operan sobre esos datos dentro de una sola unidad, conocida como clase. También restringe el acceso directo a algunos componentes de un objeto, lo que significa que la representación interna del objeto queda oculta para el exterior.
- Ocultación de datos: Protección del estado interno de un objeto frente a interferencias no deseadas.
- Control de acceso: Definición de cómo se puede acceder a los datos y métodos o modificarlos.
El encapsulamiento garantiza que los objetos controlen sus propios datos y expongan solo lo necesario.
Modificadores de acceso
En Python, el encapsulamiento se implementa mediante modificadores de acceso para controlar la visibilidad de los miembros de una clase (atributos y métodos). Hay tres tipos de modificadores de acceso:
- Público: Accesible desde cualquier lugar.
- Protegido: Accesible dentro de la clase y sus subclases.
- Privado: Accesible únicamente dentro de la propia clase.
Veamos cómo utilizar estos modificadores de acceso en Python.
Atributos y métodos públicos
Los miembros públicos son accesibles desde fuera de la clase. De forma predeterminada, todos los atributos y métodos son públicos, a menos que se especifique lo contrario.
Ejemplo:
# Defines the Person class with public attributes and methods
class Person:
def __init__(self, name, age):
self.name = name # Public attribute
self.age = age # Public attribute
def greet(self):
print("Hello, my name is " + self.name + "!") # Public method
# Creates an object of the Person class
person1 = Person("Alice", 30)
# Accesses public attributes and methods
print(person1.name) # Output: Alice
person1.greet() # Output: Hello, my name is Alice!
Atributos y métodos protegidos
Los miembros protegidos se indican mediante un prefijo de un solo guion bajo (_). Son accesibles dentro de la clase y sus subclases, pero no deberían consultarse directamente desde fuera de la clase.
Ejemplo:
# Defines the Employee class with protected attributes and methods
class Employee:
def __init__(self, name, salary):
self._name = name # Protected attribute
self._salary = salary # Protected attribute
def _increase_salary(self, amount):
self._salary += amount # Protected method
print(self._name + "'s new salary is " + str(self._salary))
# Creates an object of the Employee class
employee1 = Employee("Bob", 50000)
# Accesses protected attributes and methods (not recommended)
print(employee1._name) # Output: Bob
employee1._increase_salary(5000) # Output: Bob's new salary is 55000
Atributos y métodos privados
Los miembros privados se indican mediante un prefijo de dos guiones bajos (__). Solo son accesibles dentro de la propia clase y no se puede acceder a ellos directamente desde fuera de la clase.
Ejemplo:
# Defines the BankAccount class with private attributes and methods
class BankAccount:
def __init__(self, owner, balance):
self.__owner = owner # Private attribute
self.__balance = balance # Private attribute
def deposit(self, amount):
self.__balance += amount # Modifies private attribute
print("Deposited:", amount)
self.__show_balance()
def __show_balance(self):
print("Current Balance:", self.__balance) # Private method
# Creates an object of the BankAccount class
account1 = BankAccount("Charlie", 1000)
# Attempts to access private attributes and methods (will cause errors)
# print(account1.__owner) # AttributeError
# account1.__show_balance() # AttributeError
# Uses public methods to interact with private attributes
account1.deposit(500) # Output:
# Deposited: 500
# Current Balance: 1500
¿Por qué utilizar encapsulamiento?
El encapsulamiento ofrece varias ventajas:
- Control: Permite controlar cómo se accede a los datos o cómo se modifican.
- Seguridad: Protege el estado interno de un objeto frente a cambios no deseados.
- Mantenibilidad: Facilita el mantenimiento del código y reduce la probabilidad de errores.
El encapsulamiento ayuda a crear aplicaciones sólidas y seguras.
Ejemplo de encapsulación: clase Car
Vamos a crear una clase Car que utilice la encapsulación para proteger sus atributos y métodos.
Código:
# Defines the Car class with encapsulated attributes and methods
class Car:
def __init__(self, make, model, year):
self.make = make # Public attribute
self.model = model # Public attribute
self.__year = year # Private attribute
def get_year(self):
return self.__year # Public method to access private attribute
def set_year(self, year):
if year > 0:
self.__year = year # Public method to modify private attribute
print("Year updated to", self.__year)
else:
print("Invalid year!")
def __display_info(self):
print(self.make, self.model, self.__year) # Private method
def show_info(self):
self.__display_info() # Public method that calls a private method
# Creates an object of the Car class
car1 = Car("Tesla", "Model S", 2020)
# Accesses public attributes and methods
print(car1.make) # Output: Tesla
print(car1.get_year()) # Output: 2020
# Modifies the private attribute using a public method
car1.set_year(2021) # Output: Year updated to 2021
# Calls a public method that interacts with a private method
car1.show_info() # Output: Tesla Model S 2021
# Attempts to access private attributes and methods directly (will cause errors)
# print(car1.__year) # AttributeError
# car1.__display_info() # AttributeError
# Defines the Student class with encapsulated attributes
class Student:
def __init__(self, name, grade):
self.name = name # Public attribute
self.__grade = grade # Private attribute
def get_grade(self):
return self.__grade # Public method to access private attribute
def set_grade(self, grade):
if 0 <= grade <= 100:
self.__grade = grade # Updates the grade
else:
print("Invalid grade!")
# Creates an object of the Student class
student1 = Student("Diana", 85)
# Accesses and modifies the grade using public methods
print(student1.get_grade()) # Output: 85
student1.set_grade(90)
print(student1.get_grade()) # Output: 90
# Attempts to access the private attribute directly (will cause an error)
# print(student1.__grade) # AttributeError
¡Excelente trabajo!
Ha aprendido a utilizar la encapsulación en Python para proteger sus datos y métodos dentro de las clases. La encapsulación le ayuda a controlar el acceso a los datos de sus objetos, lo que hace que sus programas sean más seguros y fáciles de mantener. ¡Siga practicando mediante el diseño de clases con los modificadores de acceso adecuados para mejorar sus habilidades de programación!
Preguntas frecuentes
¿La lección «Encapsulación» es gratis?
Sí — el texto completo de «Encapsulación» 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 For Kids, actualiza a CoddyKit PRO. El curso de Python For Kids incluye 5 lecciones en total.
¿Qué aprenderé en «Encapsulación»?
Explore conceptos avanzados de la programación orientada a objetos. Practicas Python For Kids 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 For Kids?
No se requiere experiencia previa. Python For Kids 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 4 de 5.
¿Cuánto tiempo toma la lección «Encapsulación»?
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 For Kids?
Sí. Cada lección de Python For Kids 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
- Introducción a la programación orientada a objetos
- Creación de clases y objetos
- Herencia
- Encapsulación
- Polimorfismo