Las clases son el pilar de la programación orientada a objetos . OOP está muy preocupado con la organización del código, la reutilización y la encapsulación.
Primero, un descargo de responsabilidad: OOP está parcialmente en contraste con la programación funcional , que es un paradigma diferente que se usa mucho en Python. No todos los que programan en Python (o seguramente la mayoría de los idiomas) usan OOP. Puede hacer mucho en Java 8 que no está muy orientado a objetos. Si no quieres usar OOP, entonces no lo hagas. Si solo está escribiendo scripts únicos para procesar datos que nunca volverá a usar, entonces siga escribiendo como está.
Sin embargo, hay muchas razones para usar OOP.
Algunas razones:
Organización: OOP define formas bien conocidas y estándar de describir y definir datos y procedimientos en código. Tanto los datos como el procedimiento pueden almacenarse en diferentes niveles de definición (en diferentes clases), y existen formas estándar de hablar sobre estas definiciones. Es decir, si usa OOP de manera estándar, le ayudará a usted mismo y a otros a comprender, editar y usar su código. Además, en lugar de utilizar un mecanismo de almacenamiento de datos complejo y arbitrario (dictados de dictados o listas o dictados o listas de dictados de conjuntos, o lo que sea), puede nombrar piezas de estructuras de datos y consultarlas convenientemente.
Estado: OOP lo ayuda a definir y realizar un seguimiento del estado. Por ejemplo, en un ejemplo clásico, si está creando un programa que procesa estudiantes (por ejemplo, un programa de calificaciones), puede mantener toda la información que necesita sobre ellos en un solo lugar (nombre, edad, sexo, nivel de grado, cursos, calificaciones, maestros, compañeros, dieta, necesidades especiales, etc.), y estos datos se conservan mientras el objeto esté vivo y sea fácilmente accesible.
Encapsulación : con la encapsulación, el procedimiento y los datos se almacenan juntos. Los métodos (un término OOP para funciones) se definen junto con los datos sobre los que operan y producen. En un lenguaje como Java que permite el control de acceso , o en Python, dependiendo de cómo describa su API pública, esto significa que los métodos y los datos se pueden ocultar al usuario. Lo que esto significa es que si necesita o desea cambiar el código, puede hacer lo que quiera para la implementación del código, pero mantener las API públicas igual.
Herencia : la herencia le permite definir datos y procedimientos en un lugar (en una clase), y luego anular o ampliar esa funcionalidad más adelante. Por ejemplo, en Python, a menudo veo personas creando subclases de la dictclase para agregar funcionalidades adicionales. Un cambio común es anular el método que arroja una excepción cuando se solicita una clave de un diccionario que no existe para dar un valor predeterminado basado en una clave desconocida. Esto le permite extender su propio código ahora o más tarde, permitir que otros extiendan su código y le permite extender el código de otras personas.
Reutilización: todas estas razones y otras permiten una mayor reutilización del código. El código orientado a objetos le permite escribir código sólido (probado) una vez y luego reutilizarlo una y otra vez. Si necesita modificar algo para su caso de uso específico, puede heredar de una clase existente y sobrescribir el comportamiento existente. Si necesita cambiar algo, puede cambiarlo todo mientras mantiene las firmas de métodos públicos existentes, y nadie es más sabio (con suerte).
Nuevamente, hay varias razones para no usar OOP, y no es necesario. Pero afortunadamente con un lenguaje como Python, puede usar solo un poco o mucho, depende de usted.
Un ejemplo del caso de uso del estudiante (no hay garantía en la calidad del código, solo un ejemplo):
Orientado a objetos
class Student(object):
def __init__(self, name, age, gender, level, grades=None):
self.name = name
self.age = age
self.gender = gender
self.level = level
self.grades = grades or {}
def setGrade(self, course, grade):
self.grades[course] = grade
def getGrade(self, course):
return self.grades[course]
def getGPA(self):
return sum(self.grades.values())/len(self.grades)
# Define some students
john = Student("John", 12, "male", 6, {"math":3.3})
jane = Student("Jane", 12, "female", 6, {"math":3.5})
# Now we can get to the grades easily
print(john.getGPA())
print(jane.getGPA())
Dict estándar
def calculateGPA(gradeDict):
return sum(gradeDict.values())/len(gradeDict)
students = {}
# We can set the keys to variables so we might minimize typos
name, age, gender, level, grades = "name", "age", "gender", "level", "grades"
john, jane = "john", "jane"
math = "math"
students[john] = {}
students[john][age] = 12
students[john][gender] = "male"
students[john][level] = 6
students[john][grades] = {math:3.3}
students[jane] = {}
students[jane][age] = 12
students[jane][gender] = "female"
students[jane][level] = 6
students[jane][grades] = {math:3.5}
# At this point, we need to remember who the students are and where the grades are stored. Not a huge deal, but avoided by OOP.
print(calculateGPA(students[john][grades]))
print(calculateGPA(students[jane][grades]))