PlusPedia wird derzeit technisch modernisiert. Aktuell laufen Wartungsarbeiten. Für etwaige Unannehmlichkeiten bitten wir um Entschuldigung; es sind aber alle Artikel zugänglich und Sie können PlusPedia genauso nutzen wie immer.
Neue User bitte dringend diese Hinweise lesen:
Anmeldung - E-Mail-Adresse Neue Benutzer benötigen ab sofort eine gültige Email-Adresse. Wenn keine Email ankommt, meldet Euch bitte unter NewU25@PlusPedia.de.
Hinweis zur Passwortsicherheit:
Bitte nutzen Sie Ihr PlusPedia-Passwort nur bei PlusPedia.
Wenn Sie Ihr PlusPedia-Passwort andernorts nutzen, ändern Sie es bitte DORT bis unsere Modernisierung abgeschlossen ist.
Überall wo es sensibel, sollte man generell immer unterschiedliche Passworte verwenden! Das gilt hier und im gesamten Internet.
Aus Gründen der Sicherheit (PlusPedia hatte bis 24.07.2025 kein SSL | https://)
Bei PlusPedia sind Sie sicher: – Wir verarbeiten keine personenbezogenen Daten, erlauben umfassend anonyme Mitarbeit und erfüllen die Datenschutz-Grundverordnung (DSGVO) vollumfänglich. Es haftet der Vorsitzende des Trägervereins.
PlusPedia blüht wieder auf als freundliches deutsches Lexikon.
Wir haben auf die neue Version 1.43.3 aktualisiert.
Wir haben SSL aktiviert.
Hier geht es zu den aktuellen Aktuelle Ereignissen
Programmieren für Anfänger in Python/Objektorientierung: Unterschied zwischen den Versionen
Init |
Navi bitte nicht irgendwohin klatschen |
||
| (8 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt) | |||
| Zeile 1: | Zeile 1: | ||
In Python ist ja "alles" ein Objekt im Sinne der [[Objektorientierte Programmierung|objektorientierten Programmierung]] (oop). | |||
== Allgemein == | == Allgemein == | ||
| Zeile 9: | Zeile 8: | ||
Folgende Dinge sind wichtig: | Folgende Dinge sind wichtig: | ||
jede Klasse sollte eine __init__ - Methode haben, in dieser sollten die Attribute initialisiert werden | * jede Klasse sollte eine __init__ - Methode haben, in dieser sollten die Attribute initialisiert werden | ||
jede Methode sollte mit (self, [eventuell weitere Parameter]) beginnen (Außer ihr wollt explizit statische Funktionen - eher selten) | * jede Methode sollte mit (self, [eventuell weitere Parameter]) beginnen (Außer ihr wollt explizit statische Funktionen - eher selten) | ||
ein Objekt wird erzeugt: student = CStudent("Vorname", "Nachname"); | * ein Objekt wird erzeugt: student = CStudent("Vorname", "Nachname"); | ||
beliebter_fehler_student = CStudent; # Dies funktioniert zwar - aber dann bekommt ihr einige Fehlermeldungen wahrscheinlich. In diesem Fall habt ihr kein Objekt von CStudent erzeugt sondern habt eine Referenz auf die Klasse CStudent erzeugt. das heißt: student = beliebter_fehler_student(...) müsste funktionieren. Kann sehr praktisch sein. Aber ist in dem Fall nicht das, was ihr wollt. | beliebter_fehler_student = CStudent; # Dies funktioniert zwar - aber dann bekommt ihr einige Fehlermeldungen wahrscheinlich. In diesem Fall habt ihr kein Objekt von CStudent erzeugt sondern habt eine Referenz auf die * Klasse CStudent erzeugt. das heißt: student = beliebter_fehler_student(...) müsste funktionieren. Kann sehr praktisch sein. Aber ist in dem Fall nicht das, was ihr wollt. | ||
Und jetzt der Quelltext: | Und jetzt der Quelltext: | ||
| Zeile 44: | Zeile 44: | ||
=== Erste Gefahr === | === Erste Gefahr === | ||
=== | Was man machen kann ist folgendes: | ||
<poem> | |||
def immatrikulieren(self, s_matrikel_nr): #begin | |||
self.s_matrikel_nr = s_matrikel_nr; | |||
#enddef | |||
Man kann in Methoden einem Objekt neue Attribute geben. | |||
Ich halte das für sehr fraglich: | |||
Ich hätte die folgende Ausgabe so programmiert: | |||
for student in list_students: # do begin | |||
print(student.wie_heisst_du()); | |||
if (student.s_matrikel_nr is not None): print(student.s_matrikel_nr); | |||
pass; #endfor | |||
doch bevor die Methode immatrikulieren nicht aufgerufen wurde gibt es das Attribut s_matrikel_nr nicht. | |||
so würde ich es NICHT programmieren (so etwas gehört eigentlich verboten): | |||
---- | |||
class CStudent: | |||
i_anzahl_der_studenten = 0; | |||
def __init__(self, s_vorname, s_nachname): #begin | |||
self.s_vorname = s_vorname; | |||
self.s_nachname = s_nachname; | |||
#enddef __init__ | |||
def immatrikulieren(self, s_matrikel_nr): #begin | |||
self.s_matrikel_nr = s_matrikel_nr; | |||
#enddef | |||
def wie_heisst_du(self): #begin | |||
return self.s_nachname+", "+self.s_vorname + " " + self.s_nachname | |||
#enddef wie_heisst_du | |||
pass; #end class CStudent | |||
list_students = [] | |||
student_claudia_mit_c = CStudent("Claudia", "Mit C"); | |||
list_students.append(student_claudia_mit_c); | |||
student_klaudia_mit_k = CStudent("Klaudia", "Mit K"); | |||
list_students.append(student_klaudia_mit_k); | |||
student_anton = CStudent("James", "Bond"); | |||
list_students.append(student_anton); | |||
for student in list_students: # do begin | |||
print(student.wie_heisst_du()); | |||
if (student.s_matrikel_nr is not None): print(student.s_matrikel_nr); | |||
pass; #endfor | |||
---- | ---- | ||
So finde ich es richtig: | |||
class CStudent: | |||
i_anzahl_der_studenten = 0; | |||
def __init__(self, s_vorname, s_nachname): #begin | |||
self.s_vorname = s_vorname; | |||
self.s_nachname = s_nachname; | |||
self.s_matrikel_nr = None; | |||
#enddef __init__ | |||
def immatrikulieren(self, s_matrikel_nr): #begin | |||
self.s_matrikel_nr = s_matrikel_nr; | |||
#enddef | |||
def wie_heisst_du(self): #begin | |||
return self.s_nachname+", "+self.s_vorname + " " + self.s_nachname | |||
#enddef wie_heisst_du | |||
pass; #end class CStudent | |||
list_students = [] | |||
student_claudia_mit_c = CStudent("Claudia", "Mit C"); | |||
list_students.append(student_claudia_mit_c); | |||
student_klaudia_mit_k = CStudent("Klaudia", "Mit K"); | |||
list_students.append(student_klaudia_mit_k); | |||
student_anton = CStudent("James", "Bond"); | |||
list_students.append(student_anton); | |||
for student in list_students: # do begin | |||
print(student.wie_heisst_du()); | |||
if (student.s_matrikel_nr is not None): print(student.s_matrikel_nr); | |||
pass; #endfor | |||
</poem> | |||
Mein Tipp: Definiert alle Variablen im __init__-Block, die ihr verwenden wollt. | |||
=== Schweinereien === | |||
==== Erste Schweinerei ==== | |||
<poem> | |||
class CStudent: | |||
i_anzahl_der_studenten = 0; | |||
def __init__(self, s_vorname, s_nachname): #begin | |||
self.s_vorname = s_vorname; | |||
self.s_nachname = s_nachname; | |||
self.s_matrikel_nr = None; | |||
#enddef __init__ | |||
pass; #end class CStudent | |||
student_anton = CStudent("James", "Bond"); | |||
student_anton.Freundin = "Pünktchen"; | |||
print (student_anton.Freundin); | |||
Das ist gültiger Python-Code. | |||
Und hier fängt es an Kriminell zu werden. | |||
Wir können unserem Objekt Attribute ausdenken. | |||
Das mag praktisch erscheinen - | |||
aber ich halte dies für hochgradig gefährlich. | |||
Stellt euch so was vor: | |||
def brave_funktion(student): | |||
student.lange_nase = True; | |||
polizei.untersuchung(student): | |||
student.zeig_mal_deine_ganze_attribute(); | |||
# oh eine lange_nase also | |||
</poem> | |||
==== Zweite Schweinerei ==== | |||
<poem> | |||
"__" - bietet einen relativ guten Schutz zur Geheimhaltung. | |||
Aber folgender Code funktioniert: | |||
class CStudent: | |||
i_anzahl_der_studenten = 0; | |||
__private_variable = "geheim"; | |||
def __init__(self, s_vorname, s_nachname): #begin | |||
self.s_vorname = s_vorname; | |||
self.s_nachname = s_nachname; | |||
self.s_matrikel_nr = None; | |||
self.__private_variable = "geheim"; | |||
#enddef __init__ | |||
def tell_me_secret(self): #return string #begin | |||
print(self.__private_variable); | |||
pass; #enddef | |||
pass; #end class CStudent | |||
student_boese = CStudent("Gold", "Finger"); | |||
# print (student_boese.__private_variable); - Das geht nicht | |||
student_boese.__private_variable = "Aber Hallo"; | |||
print (student_boese.__private_variable); | |||
student_boese.tell_me_secret() | |||
>>> ================================ RESTART ================================ | |||
>>> | |||
Aber Hallo | |||
geheim | |||
dass man so was nicht machen sollte - ist klar: | |||
student_boese.__private_variable = "Aber Hallo"; | |||
Aber dass es Python erlaubt ist fraglich. | |||
In diesem Fall hat man nämlich zwei Variablen mit eigentlich demselben Namen. | |||
</poem> | |||
== Siehe auch == | |||
{{Navigationsleiste Programmieren für Anfäger in Python}} | |||
== Weblinks == | |||
== Literatur == | |||
== Einzelnachweise == | |||
<references/> | |||
{{Vorlage:PPA-Opal}} | {{Vorlage:PPA-Opal}} | ||
Aktuelle Version vom 9. September 2025, 11:48 Uhr
In Python ist ja "alles" ein Objekt im Sinne der objektorientierten Programmierung (oop).
Allgemein
Mit diesem Programm könnt ihr die funktionsweise der oop sehen.
Zudem wie man mehrere Objekte in einer Liste verwalten kann.
In diesem Fall habe ich auf setter und getter funktionen verzichtet.
Folgende Dinge sind wichtig:
- jede Klasse sollte eine __init__ - Methode haben, in dieser sollten die Attribute initialisiert werden
- jede Methode sollte mit (self, [eventuell weitere Parameter]) beginnen (Außer ihr wollt explizit statische Funktionen - eher selten)
- ein Objekt wird erzeugt: student = CStudent("Vorname", "Nachname");
beliebter_fehler_student = CStudent; # Dies funktioniert zwar - aber dann bekommt ihr einige Fehlermeldungen wahrscheinlich. In diesem Fall habt ihr kein Objekt von CStudent erzeugt sondern habt eine Referenz auf die * Klasse CStudent erzeugt. das heißt: student = beliebter_fehler_student(...) müsste funktionieren. Kann sehr praktisch sein. Aber ist in dem Fall nicht das, was ihr wollt.
Und jetzt der Quelltext:
class CStudent:
i_anzahl_der_studenten = 0;
def __init__(self, s_vorname, s_nachname): #begin
self.s_vorname = s_vorname;
self.s_nachname = s_nachname;
#enddef __init__
def wie_heisst_du(self): #begin
return self.s_nachname+", "+self.s_vorname + " " + self.s_nachname
#enddef wie_heisst_du
pass; #end class CStudent
list_students = []
student_claudia_mit_c = CStudent("Claudia", "Mit C");
list_students.append(student_claudia_mit_c);
student_klaudia_mit_k = CStudent("Klaudia", "Mit K");
list_students.append(student_klaudia_mit_k);
student_anton = CStudent("James", "Bond");
list_students.append(student_anton);
for student in list_students: # do begin
print(student.wie_heisst_du());
pass; #endfor
Gefahren
Erste Gefahr
Was man machen kann ist folgendes:
def immatrikulieren(self, s_matrikel_nr): #begin
self.s_matrikel_nr = s_matrikel_nr;
#enddef
Man kann in Methoden einem Objekt neue Attribute geben.
Ich halte das für sehr fraglich:
Ich hätte die folgende Ausgabe so programmiert:
for student in list_students: # do begin
print(student.wie_heisst_du());
if (student.s_matrikel_nr is not None): print(student.s_matrikel_nr);
pass; #endfor
doch bevor die Methode immatrikulieren nicht aufgerufen wurde gibt es das Attribut s_matrikel_nr nicht.
so würde ich es NICHT programmieren (so etwas gehört eigentlich verboten):
class CStudent:
i_anzahl_der_studenten = 0;
def __init__(self, s_vorname, s_nachname): #begin
self.s_vorname = s_vorname;
self.s_nachname = s_nachname;
#enddef __init__
def immatrikulieren(self, s_matrikel_nr): #begin
self.s_matrikel_nr = s_matrikel_nr;
#enddef
def wie_heisst_du(self): #begin
return self.s_nachname+", "+self.s_vorname + " " + self.s_nachname
#enddef wie_heisst_du
pass; #end class CStudent
list_students = []
student_claudia_mit_c = CStudent("Claudia", "Mit C");
list_students.append(student_claudia_mit_c);
student_klaudia_mit_k = CStudent("Klaudia", "Mit K");
list_students.append(student_klaudia_mit_k);
student_anton = CStudent("James", "Bond");
list_students.append(student_anton);
for student in list_students: # do begin
print(student.wie_heisst_du());
if (student.s_matrikel_nr is not None): print(student.s_matrikel_nr);
pass; #endfor
So finde ich es richtig:
class CStudent:
i_anzahl_der_studenten = 0;
def __init__(self, s_vorname, s_nachname): #begin
self.s_vorname = s_vorname;
self.s_nachname = s_nachname;
self.s_matrikel_nr = None;
#enddef __init__
def immatrikulieren(self, s_matrikel_nr): #begin
self.s_matrikel_nr = s_matrikel_nr;
#enddef
def wie_heisst_du(self): #begin
return self.s_nachname+", "+self.s_vorname + " " + self.s_nachname
#enddef wie_heisst_du
pass; #end class CStudent
list_students = []
student_claudia_mit_c = CStudent("Claudia", "Mit C");
list_students.append(student_claudia_mit_c);
student_klaudia_mit_k = CStudent("Klaudia", "Mit K");
list_students.append(student_klaudia_mit_k);
student_anton = CStudent("James", "Bond");
list_students.append(student_anton);
for student in list_students: # do begin
print(student.wie_heisst_du());
if (student.s_matrikel_nr is not None): print(student.s_matrikel_nr);
pass; #endfor
Mein Tipp: Definiert alle Variablen im __init__-Block, die ihr verwenden wollt.
Schweinereien
Erste Schweinerei
class CStudent:
i_anzahl_der_studenten = 0;
def __init__(self, s_vorname, s_nachname): #begin
self.s_vorname = s_vorname;
self.s_nachname = s_nachname;
self.s_matrikel_nr = None;
#enddef __init__
pass; #end class CStudent
student_anton = CStudent("James", "Bond");
student_anton.Freundin = "Pünktchen";
print (student_anton.Freundin);
Das ist gültiger Python-Code.
Und hier fängt es an Kriminell zu werden.
Wir können unserem Objekt Attribute ausdenken.
Das mag praktisch erscheinen -
aber ich halte dies für hochgradig gefährlich.
Stellt euch so was vor:
def brave_funktion(student):
student.lange_nase = True;
polizei.untersuchung(student):
student.zeig_mal_deine_ganze_attribute();
# oh eine lange_nase also
Zweite Schweinerei
"__" - bietet einen relativ guten Schutz zur Geheimhaltung.
Aber folgender Code funktioniert:
class CStudent:
i_anzahl_der_studenten = 0;
__private_variable = "geheim";
def __init__(self, s_vorname, s_nachname): #begin
self.s_vorname = s_vorname;
self.s_nachname = s_nachname;
self.s_matrikel_nr = None;
self.__private_variable = "geheim";
#enddef __init__
def tell_me_secret(self): #return string #begin
print(self.__private_variable);
pass; #enddef
pass; #end class CStudent
student_boese = CStudent("Gold", "Finger");
- print (student_boese.__private_variable); - Das geht nicht
student_boese.__private_variable = "Aber Hallo";
print (student_boese.__private_variable);
student_boese.tell_me_secret()
>>> ================================ RESTART ================================
>>>
Aber Hallo
geheim
dass man so was nicht machen sollte - ist klar:
student_boese.__private_variable = "Aber Hallo";
Aber dass es Python erlaubt ist fraglich.
In diesem Fall hat man nämlich zwei Variablen mit eigentlich demselben Namen.
Siehe auch
Weblinks
Literatur
Einzelnachweise
Andere Lexika
Wikipedia kennt dieses Lemma (Programmieren für Anfänger in Python/Objektorientierung) vermutlich nicht.