Klassen sind die Säule der objektorientierten Programmierung . OOP befasst sich stark mit der Organisation, Wiederverwendbarkeit und Kapselung von Code.
Erstens ein Haftungsausschluss: OOP steht teilweise im Gegensatz zu Functional Programming , einem anderen Paradigma, das in Python häufig verwendet wird. Nicht jeder, der in Python (oder sicherlich in den meisten Sprachen) programmiert, verwendet OOP. In Java 8 können Sie viel tun, was nicht sehr objektorientiert ist. Wenn Sie OOP nicht verwenden möchten, tun Sie dies nicht. Wenn Sie nur einmalige Skripte schreiben, um Daten zu verarbeiten, die Sie nie wieder verwenden werden, schreiben Sie weiter so, wie Sie sind.
Es gibt jedoch viele Gründe, OOP zu verwenden.
Einige Gründe:
Organisation: OOP definiert bekannte und standardmäßige Methoden zur Beschreibung und Definition von Daten und Prozeduren im Code. Sowohl Daten als auch Prozeduren können auf verschiedenen Definitionsebenen (in verschiedenen Klassen) gespeichert werden, und es gibt Standardmethoden, um über diese Definitionen zu sprechen. Das heißt, wenn Sie OOP auf standardmäßige Weise verwenden, hilft dies Ihrem späteren Selbst und anderen, Ihren Code zu verstehen, zu bearbeiten und zu verwenden. Anstatt einen komplexen, willkürlichen Datenspeicherungsmechanismus zu verwenden (Diktate von Diktaten oder Listen oder Diktate oder Listen von Diktaten von Mengen oder was auch immer), können Sie auch Teile von Datenstrukturen benennen und bequem darauf verweisen.
Status: Mit OOP können Sie den Status definieren und verfolgen. Wenn Sie beispielsweise in einem klassischen Beispiel ein Programm erstellen, das Schüler verarbeitet (z. B. ein Notenprogramm), können Sie alle Informationen, die Sie über sie benötigen, an einem Ort aufbewahren (Name, Alter, Geschlecht, Klassenstufe, Kurse, Noten, Lehrer, Gleichaltrige, Ernährung, besondere Bedürfnisse usw.), und diese Daten bleiben erhalten, solange das Objekt lebt und leicht zugänglich ist.
Kapselung : Bei der Kapselung werden Prozedur und Daten zusammen gespeichert. Methoden (ein OOP-Begriff für Funktionen) werden direkt neben den Daten definiert, mit denen sie arbeiten und die sie erzeugen. In einer Sprache wie Java, die Zugriffskontrolle ermöglicht , oder in Python, je nachdem, wie Sie Ihre öffentliche API beschreiben, bedeutet dies, dass Methoden und Daten vor dem Benutzer verborgen werden können. Dies bedeutet, dass Sie, wenn Sie Code benötigen oder ändern möchten, alles tun können, um den Code zu implementieren, aber die öffentlichen APIs gleich lassen.
Vererbung : Mit Vererbung können Sie Daten und Prozeduren an einem Ort (in einer Klasse) definieren und diese Funktionalität später überschreiben oder erweitern. In Python sehe ich beispielsweise häufig Leute, die Unterklassen der dictKlasse erstellen , um zusätzliche Funktionen hinzuzufügen. Eine häufige Änderung besteht darin, die Methode zu überschreiben, die eine Ausnahme auslöst, wenn ein Schlüssel aus einem nicht vorhandenen Wörterbuch angefordert wird, um einen Standardwert basierend auf einem unbekannten Schlüssel anzugeben. Auf diese Weise können Sie Ihren eigenen Code jetzt oder später erweitern, anderen erlauben, Ihren Code zu erweitern, und Sie können den Code anderer Personen erweitern.
Wiederverwendbarkeit: Alle diese und andere Gründe ermöglichen eine bessere Wiederverwendbarkeit von Code. Mit objektorientiertem Code können Sie festen (getesteten) Code einmal schreiben und dann immer wieder verwenden. Wenn Sie etwas für Ihren speziellen Anwendungsfall optimieren müssen, können Sie von einer vorhandenen Klasse erben und das vorhandene Verhalten überschreiben. Wenn Sie etwas ändern müssen, können Sie alles ändern, während Sie die vorhandenen öffentlichen Methodensignaturen beibehalten, und niemand ist (hoffentlich) klüger.
Auch hier gibt es mehrere Gründe, OOP nicht zu verwenden, und Sie müssen es nicht. Aber zum Glück können Sie mit einer Sprache wie Python nur ein bisschen oder viel verwenden, es liegt an Ihnen.
Ein Beispiel für den Anwendungsfall eines Schülers (keine Garantie für die Codequalität, nur ein Beispiel):
Objektorientierte
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())
Standard Dikt
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]))