As aulas são o pilar da programação orientada a objetos . OOP está muito preocupado com a organização do código, reutilização e encapsulamento.
Primeiro, um aviso: OOP contrasta parcialmente com a Programação Funcional , que é um paradigma diferente usado muito no Python. Nem todo mundo que programa em Python (ou certamente a maioria das linguagens) usa OOP. Você pode fazer muito no Java 8 que não é muito orientado a objetos. Se você não quiser usar o OOP, não o faça. Se você estiver apenas escrevendo scripts únicos para processar dados que nunca mais usará, continue escrevendo do jeito que está.
No entanto, existem várias razões para usar o OOP.
Algumas razões:
Organização: OOP define maneiras conhecidas e padrão de descrever e definir dados e procedimentos no código. Os dados e o procedimento podem ser armazenados em diferentes níveis de definição (em diferentes classes), e existem maneiras padrão de falar sobre essas definições. Ou seja, se você usar o OOP de maneira padrão, ele ajudará você e outras pessoas a entender, editar e usar seu código. Além disso, em vez de usar um mecanismo complexo e arbitrário de armazenamento de dados (dictos de dictos ou listas ou dictos ou listas de dictos de conjuntos ou qualquer outra coisa), você pode nomear partes das estruturas de dados e consultá-las convenientemente.
Estado: OOP ajuda a definir e acompanhar o estado. Por exemplo, em um exemplo clássico, se você estiver criando um programa que processa alunos (por exemplo, um programa de notas), você pode manter todas as informações necessárias sobre eles em um único local (nome, idade, sexo, nível da série, cursos, notas, professores, colegas, dieta, necessidades especiais etc.), e esses dados persistem enquanto o objeto estiver vivo e forem facilmente acessíveis.
Encapsulamento : com o encapsulamento, o procedimento e os dados são armazenados juntos. Os métodos (um termo OOP para funções) são definidos ao lado dos dados em que operam e produzem. Em uma linguagem como Java, que permite controle de acesso , ou em Python, dependendo de como você descreve sua API pública, isso significa que métodos e dados podem ser ocultados do usuário. O que isso significa é que, se você precisar ou quiser alterar o código, poderá fazer o que quiser com a implementação do código, mas manter as APIs públicas iguais.
Herança : a herança permite definir dados e procedimentos em um local (em uma classe) e, em seguida, substituir ou estender essa funcionalidade posteriormente. Por exemplo, no Python, muitas vezes vejo pessoas criando subclasses da dictclasse para adicionar funcionalidades adicionais. Uma alteração comum está substituindo o método que lança uma exceção quando uma chave é solicitada de um dicionário que não existe para fornecer um valor padrão com base em uma chave desconhecida. Isso permite que você estenda seu próprio código agora ou mais tarde, permita que outras pessoas estendam seu código e que você estenda o código de outras pessoas.
Reutilização: todos esses motivos e outros permitem maior reutilização do código. O código orientado a objetos permite que você escreva um código sólido (testado) uma vez e depois reutilize repetidamente. Se você precisar ajustar algo para o seu caso de uso específico, poderá herdar de uma classe existente e substituir o comportamento existente. Se você precisar alterar alguma coisa, poderá alterar tudo enquanto mantém as assinaturas de método público existentes, e ninguém é o mais sábio (espero).
Novamente, existem vários motivos para não usar o OOP, e você não precisa. Mas, felizmente, com uma linguagem como Python, você pode usar um pouco ou muito, depende de você.
Um exemplo do caso de uso do aluno (sem garantia de qualidade do código, apenas um exemplo):
Orientado a Objeto
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())
Ditado padrão
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]))