02

Datenkapsel/schlange.py

@@ -1,6 +1,6 @@
-class Schlange(object):
+class Schlange(object):                        #Klasse Schlange definiert
-    def __init__(self):
+    def __init__(self):                        #init => Konstruktor
-        self.liste = []
+        self.__liste = []                      #__Liste => Unterstriche ein Hinweis das der nutzer dies nicht dierekt verwenden soll/ direkter zugriff wird verhindert
         self.anzahl = 0
 
     def istLeer(self):
@@ -10,26 +10,26 @@ class Schlange(object):
             return False
 
     def mitLetztem(self, element):
-        self.liste = self.liste + [element]
+        self.__liste = self.__liste + [element]
         self.anzahl = self.anzahl + 1
 
     def ohneErstes(self):
         if not self.istLeer():
-            self.liste = self.liste[1:]
+            self.__liste = self.__liste[1:]          #1: => bis zum letzten Element von eins bis Ende
             self.anzahl = self.anzahl - 1
 
     def erstes(self):
         if self.istLeer():
             return None
         else:
-            return self.liste[0]
+            return self.__liste[0]
 
     def anzahlElemente(self):
         return self.anzahl
 
     def getSchlange(self):
-        return self.liste
+        return self.__liste
 
     def setSchlange(self, liste):
-        self.liste = liste
+        self.__liste = liste
-        self.anzahl = len(self.liste)
+        self.anzahl = len(self.__liste)

Datenkapsel/starten_schlange.py

@@ -1,4 +1,6 @@
-from schlange import Schlange
+from schlange import Schlange     #von der Klasse wird abgerufen
-s = Schlange()
+s = Schlange()                    # s=> das Objekt (s wird erzeugt) wird der Klasse Schlange zugewiesen ()=>keine Parameter werden übergeben
-s.liste = s.liste + [3]
+# s.__liste = s.__liste + [3]           #liste wird mit der 3 gefüllt / der wert des atributs wird verändert
-print(s.istLeer())
+s.mitLetztem(3)                   # das Objekt ruft eine Methode auf
+print(s.istLeer())                # liste wird ausgegeben
+                                  

README copy.md

@@ -1,2 +0,0 @@
-# Objektorientierung
-

README.md

@@ -1,2 +1,9 @@
 # Objektorientierung
-
+## 18.09
+verkettete Liste und liniare Liste in der Klasse besprovhen und erklärt
+## 21.09
+Aufgabe von Itslearning bearbeitet und in der Datei liste.py zu finden, inform von #anhenungen an die einzelnen zeilen.
+## 25.09
+An den Aufgaben von istlearning weiter gearbeitet und einiges ausprobiert.
+## 02.10
+Heute habe ich mich an die Aufgaben gesetzt und die neu hinzugefügten Code zeile versuch schlüssig zu erklären.

liniare_verkettete_Listen/knoten.py

@@ -0,0 +1,6 @@
+class Knoten:
+    def __init__(self, data):              # next wird nicht in die Klammer gesetzut da es in Zeile 4 die Defenition None erhält
+        self.data = data
+        self.next = None
+
+        

liniare_verkettete_Listen/liste.py

@@ -0,0 +1,108 @@
+from knoten import Knoten                                       # von der Klasse Knoten wird der knoten abgerufen
+class Liste:                                                    # class wird erstellt und mit leben ("Liste") gefüllt
+
+    def __init__(self):                                         # __init__ der Konstruktor und wird mit dem Parameter self gefüllt 
+        self.head = None                                        # die Methode head erhält die definition Nne wodurch das Ende der Kette beschrieben wird
+
+    def ausgebenListe(self):                                    # Methode wird erstellt
+
+        aktueller_knoten = self.head                            #aktueller_knoten wird auf self.head gesetzt
+
+        while aktueller_knoten is not None:                     # unter der Bedingung das aktueller_knoten einen wert hat...
+
+            print(aktueller_knoten.daten)                       # befehl wird erteilt , dass der aktuelle_knoten.daten also die neuzugeschriebenen werte ausgegeben werden
+
+            aktueller_knoten = aktueller_knoten.nachfolger      # daraufhin wird der nachfolger von aktueller_knoten der neue aktuelle_knoten die werte somit also überschrieben
+#aufgabe2
+           
+    def append(self,daten):
+        aktueller_knoten = Knoten(daten)                 # Objekt erzeugt mit `daten` drin 
+
+        if self.head == None: 
+            self.head = aktueller_knoten                     # aktuelller knoten wird als "link" in head gespeichert und schafft eine verbindung nwird zum neuen head
+
+        else:
+            letzter_Knoten = self.head
+                                                              # letzter Knoten wird gesucht, vom head
+            while letzter_Knoten.nachfolger is not None:      # wird die liste durchgegangen und der nachfolger ist None ist dies das letzte Atribut
+                letzter_Knoten = letzter_Knoten.nachfolger
+
+            letzter_Knoten.nachfolger = aktueller_knoten 
+
+ #Element in die Kette einfügen
+    def einfuegen_bei(self, index, daten):                   #definiert das in den kommenden Zeilen ein neues Element eingeführt werden soll
+
+           neuer_Knoten = Knoten(daten)                      # neues Elemen wird mit einewm Objekt gefüllt
+
+           if index == 0:                                    #wenn index Null dann....
+
+                neuer_Knoten.nachfolger = self.head          #die daten des neuen Knoten werden als link auf head gesetzt und somit zeigt head auf den neuen knoten
+                self.head = neuer_Knoten                     #  
+
+                return                                       #beendet die Methode nur wenn der if Befehl eingetreten ist
+
+           aktueller_knoten = self.head                      # 
+           zaehler = 0                                       #
+           while aktueller_knoten is not None and zaehler < index - 1: #
+                aktueller_knoten = aktueller_knoten.nachfolger   # 
+                zaehler += 1
+
+           if aktueller_knoten is None:
+                print ("index out of range")
+                return
+
+           neuer_Knoten.nachfolger = aktueller_knoten.nachfolger            
+           aktueller_knoten.nachfolger = neuer_Knoten   
+
+
+### Sucht nach dem ersten Vorkommen des Werts und löscht es ####
+    def loeschen(self,suchwert):
+        aktueller_knoten = self.head
+        vorheriger_knoten = None
+
+        if aktueller_knoten is None:                                 
+           print("Liste ist leer löschen nicht möglich")  
+           return                                                          
+
+        if aktueller_knoten.daten ==  suchwert:                      
+             self.head = aktueller_knoten.nachfolger
+             return
+
+        while aktueller_knoten is not None and aktueller_knoten.daten != suchwert:
+             vorheriger_knoten = aktueller_knoten           # merken zum Löschen
+             aktueller_knoten = aktueller_knoten.nachfolger
+
+        if aktueller_knoten is None:
+             print(f"Wert {suchwert} wurde nicht gefunden")
+             return
+
+        vorheriger_knoten.nachfolger = aktueller_knoten.nachfolger          
+
+
+    def loeschen_anStelle(self,index):                         # Element wird an bestimmter stelle gelöscht
+
+         if self.head is None:
+              print("Liste ist leer")
+              return
+         
+         if index == 0:
+              self.head = self.head.nachfolger
+              return
+         
+         aktueller_knoten = self.head
+
+         for i in range(index-1):
+            if aktueller_knoten.nachfolger is None:
+                 print(f"Index {index} existiert nicht")
+                 return
+            aktueller_knoten = aktueller_knoten.nachfolger  
+         
+         if aktueller_knoten.nachfolger is None:
+            print("Existiert nicht")
+            return
+        
+         aktueller_knoten.nachfolger = aktueller_knoten.nachfolger.nachfolger
+
+                 
+                     
+         

liniare_verkettete_Listen/starten.py

@@ -0,0 +1,9 @@
+from knoten import Knoten
+
+knoten1 = Knoten(33)
+knoten2 = Knoten(66)
+knoten1.next = knoten2
+
+print(knoten1.next.data)
+print(knoten2.data)
+