andie39‘s Fragen Thread

[andie39]

Es gibt immer wieder Dinge die nicht klar sind auch in der remove Funktion die funktioniert und einen Film hinzugefügt. Hier stolpere ich über die Stelle an der in die Datei geschrieben wird.

Hintergrund: Ich dachte es gibt gff einen Befehl zum entfernen den ich nicht kenne also habe ich Google bemüht. Dabei stellte ich fest, dass es das wohl nicht gibt und man es überschreibt.

Ich GLAUBE das meiste zu verstehen bis eben zum
write:

Dieser Code ist es ja:

Code: Alles auswählen

def remove_movie():
    with open("movies.csv", "r") as file:
        lines = file.readlines()
    with open("movies.csv", "w") as file:
        eingabe = input("Welchen Film möchten Sie enternen?")
        for element in lines:
            if element != eingabe + ("\n"):
                file.write(element)

Nehmen wir an die folgenden Filme sind schon drin:

Alien, Predator, Terminator

Jeder hat dann ja eine Indexposition 1,2,3 und die Liste kann iteriert werden.

Ich lese die Funktion so:

Datei wird geöffnet und der Inhalt der Zeilen als Liste in lines gepackt.

Jetzt wird die Datei zum schreiben geöffnet,
eine Abfrage nach einem Film der hinzugefügt werden soll gemacht, dieser als Variabel eingabe gespeichert.

Nun für jeden Wert in lines geprüft ob der eingegebene Wert ungleich ist und wenn das true ist wird der Wert in die Datei geschrieben.

Beispiel: Eingabe ist: Rambo:

Es wird geprüft: Ist Rambo ungleich Alien?
Wenn true: Schreibe Alien in die Datei
Dann: Ist Predator ungleich Rambo
Wenn true: Schreibe Predator in die Datei


Wäre Rambo schon drin, wäre die Frage: Ist Rambo
ungleich Rambo false und es würde nicht in die Datei geschrieben.


Was mich stutzig macht ist:
w für write überschreibt eine Datei. a statt w fügt etwas hinzu.

Ich hätte eigentlich also erwartet, dass hier mit w folgendes geschehen wäre:

Alien wird reingeschrieben da true, dann wird Predator geprüft ist auch ungleich der Eingabe und würde nun Alien überschreiben.

Am Ende wäre nur Terminator in der Liste.
Aber alle drei Filme sind noch drin.

Warum überschreibt w. nicht die vorherigen Werte?

[__blackjack__]

@andie39: Ich glaube ein Problem was das ganze an der Stelle verkompliziert ist das Dateiobjekt und dass das einen Zustand hat und da Tests mit ``in``, das darüber iterieren, und das lesen mit `read()` alle den Zustand ändern und das deshalb Einfluss auf folgende Tests/Operationen hat. Diese Operationen laufen aber ”geräuschlos” ab, liefern aber nicht mehr unbedingt das Ergebnis das man erwartet, wenn man sich über diesen inneren Zustand nicht im klaren ist.

Also zum Beispiel das nach einem `read()` sozusagen nichts mehr in dem Dateiobjekt ist, weil die aktuelle Leseposition, die in dem Dateiobjekt verwaltet wird, dann am Ende der Datei steht:

Code: Alles auswählen

In [151]: file = open("movies.csv")                                             

In [152]: file.read()                                                           
Out[152]: 'Love actually\nDie Hard\nThe Grinch\nSpiderman - Homecoming\n'

In [153]: file.read()  # Wir sind am Ende, total am Ende:
Out[153]: ''

In [154]: "Die Hard\n" in file  # ist in der Datei enthalten, aber:
Out[154]: False

In [155]: file = open("movies.csv")  # Funktioniert bei einer neu geöffneten Datei:

In [156]: "Die Hard\n" in file                                                  
Out[156]: True

In [157]: file.read()  # liefert nicht mehr den gesamten Dateiinhalt:
Out[157]: 'The Grinch\nSpiderman - Homecoming\n'

Hätte man in [156] nach etwas gesucht was *nicht* in der Datei enthalten gewesen wäre, hätte das letzte `read()` eine leere Zeichenkette geliefert.

Hier mal eine mögliche Implementierung von der API die ich vorgeschlagen hatte:

Code: Alles auswählen

def validate_movie(movie):
    if "\n" in movie:
        raise ValueError(f"illegal newline in {movie!r}")
    return movie


def load_movies(filename):
    with open(filename, "r", encoding="utf-8") as file:
        return [line.rstrip() for line in file]


def save_movies(filename, movies):
    with open(filename, "w", encoding="utf-8") as file:
        file.writelines(f"{validate_movie(movie)}\n" for movie in movies)


def add_movie(filename, movie):
    validate_movie(movie)
    
    movies = load_movies(filename)
    if movie in movies:
        return False

    movies.append(movie)
    save_movies(filename, movies)
    return True

[__blackjack__]

@andie39: Der Dateimodus "w" wirkt beim *öffnen* der Datei. Die Datei wird geöffnet und geleert und die aktuelle Position ist am Anfang der Datei. Das wars. Ab da arbeitet man dann ganz normal mit der geöffneten leeren Datei.

Bei "a" wird die Datei geöffnet und die aktuelle Position ganz ans Ende gesetzt. So das der erste Schreibvorgang nicht am Anfang der Datei erfolgt, sondern am Ende, also die Datei um weitere Bytes erweitert, ohne dass sich an den Daten die schon da waren, etwas ändert.

Das `write()` macht in beiden Fällen genau das gleiche. Das schreibt die Daten an die aktuelle Position und bewegt diese um die Anzahl der geschriebenen Bytes weiter, so das der nächste Schreibvorgang hinter die Daten vom letzten Schreibvorgang schreibt.

[andie39]

Ach so.
Ich dachte erst wenn man reinschreibt wird ûberschrieben. Das erklärt das natürlich.

Die Suche per IN, in der gesamten Datei war ja eh nicht zielführend. Wie Sirius ja als Beispiel ES und EScape Room genannt hat.

Zum read() Befehl:

Ach so, wenn man ein weiteres Mal direkt hinter dem read ein erneutes macht ist die Position am Ende. Und kann nicht mehr durchlaufen?
Man muss dann die Datei erst erneut öffnen?

[andie39]

Du warst ja schon nah dran

In der Schleife über alle Zeilen, prüft man jetzt jede Zeile ob sie der Eingabe entspricht. Wird ein Treffer gefunden, gibt es die entsprechende Meldung und die Schleife wird abgebrochen.
Der for - else Zweig wird nur ausgeführt, wenn es kein "break" in der Schleife ausgelöst wurde, also der Titel noch nicht vorhanden ist.
Dann - und nur dann öffnest du die Datei zum (a)nhängen.

Code: Alles auswählen

def add_movie():
    with open ("movies.csv", "r") as file:
        lines =  file.readlines()
    eingabe = input("Geben Sie einen Filmtitel ein:")
    for element in lines:
        if eingabe == element:
            print(f"Der Titel {eingabe} ist bereits in der Datenbank")
            break
    else:
        print(f"Der Titel {eingabe} wird neu in die Datenbank eingefügt")
        with open("movies.csv", "a") as file:
            file.write(eingabe + "\n")

Hallo,

habe mal getestet, deni Code funktioniert auch nicht.
er fügt zwar neue Filme hinzu, aber wenn es den Film schon gibt, dann fügt er den Film trotzden nochmal hnizu.
Ich dachte erstm es liegt daran,dass dein els: nicht auf der gleichen Höhe eingerückt ist, wie das if, aber wenn ich das ändere, wird es nehrfach hinzugefügt.

Ich dachte auch immer das if und else immer in der gleichen Höhe der Einrückung seni müssen?!

[__deets__]

Es gibt auch bei for ein else. Und bei try/except.

[Sirius3]

Das Problem hatten wir ja jetzt schon sehr oft: gelesene Zeilen haben immer das Zeileende-Zeichen als letztes Zeichen, `eingabe` hat das aber nicht, so dass der Vergleich `eingabe == element` immer fehlschlägt.

Nicht nur auf `if` kann ein `else` folgen, sondern auch auf `for`, `while` oder `try/except`.
Aber es ist wirklich wichtig, Funktionen zu schreiben, die nur eine Sache machen, und die Richtig. Dann hast Du deutlich weniger Probleme, den Ablauf einer Funktion zu verstehen.

[andie39]

Ich habe es gelöst, element so nuss es sein;

if eingabe == element.strip("\n"):

\n muss entfernt werden beim Vergleich

Nachtrag: Hatte ich vor dem Post von Sirius gepostet


Ach dann macht das mit dem else Sinn.
wenn es direkt im Block nit if gleich ist, dann wird er ja immer wenn eingabe und element ungleich sind den Film hinzufügen.

Hier prüft die for Schleife jetzt nur ob der Film vorhanden ist, erst wenn die for Schleife komplett false ist wird else durchgeführt und der Film hnizugefügt.

[rogerb]

habe mal getestet, deni Code funktioniert auch nicht.

Genau, das hatte ich gestern so spät nicht mehr getestet. Du hast die Lösung ja gefunden.
Ich würde auch eigentlich das csv-Modul oder das json-Modul dafür verwenden. Dann ist die Gefahr geringer, in solche Fehler zu laufen.

[andie39]

Danke für eure Geduld ich GLAUBE jetzt hab ich es begriffen.
Man muss schon genau schauen was wo eingerückt ist und was passiert.

Ja das mit dem Modul wurde schon erwähnt mir geht es hier nur um eine Übung passend zu meinem Onlinekurs.

Erst wenn ich merke ich kann es, was dauern kann, wie man ja hier sieht mache ich weiter.

Dieses Programm ist nur dafür da. Hauptsächlich auch weil hier noch das dictionary kommt, wenn es darum geht einzufügen, ob ein Film verliehen ist oder nicht

[andie39]

So, ich habe nun die Funktion zum suchen eines Films in der Datenbank geschrieben und die halbwegs die Funktion einen Film als Verliehen oder Verfügbar zu markieren:
Hier die Funktion zur Suche:

Code: Alles auswählen

def find_movie():
    with open ("movies.csv", "r") as file:
        lines = file.readlines()
        eingabe = input("Welchen Film suchen Sie?")
        for element in lines:
            if eingabe == element.strip("\n"):
                print(f"{eingabe}, ist in der Datenbank vorhanden.")
                break
        
        else:
            print(f"{eingabe} ist in der Datenbank NICHT vorhanden.")
       

Und hier einen Film als verliehen und verfügbar zu markieren:

Code: Alles auswählen

def mark_lend():
    with open ("movies.csv", "r") as file:
        lines = file.readlines()
        movies_marked = {}
        eingabe = input("Welcher Film soll als verliehen markiert werden?")
        for element in lines:
            if eingabe == element.strip("\n"):
                movies_marked[element] = "Verliehen"
            else:
                movies_marked[element] = "Verfügbar"
 
 

Aber das ist erzeugt nur ein Dictionary welches den eingegebenen Film als verliehen und die anderen als verfügbar kennzeichnet.
Er müsste dann noch in die movies.csv schreiben und dort diese Informationen setzen und natürlich auch die, die noch als verliehen dort sind, dürfen nicht einfach überschrieben werden.

Je mehr ich mir das so ansehe und dazu google stelle ich fest:

So aufwendig sollte das in der Realität niemals sein.
das CSV Modul von Anfang an würde vieles erleichtern, wie auch hier ja schon geschrieben wurde.

Und auch _blackjack_ hat Recht:
Die Funktionen sollten einfacher gehalten werden.


Allerdings ging es mir ja auch darum, gelerntes zu probieren.
Nachdem Filme hinzufügen, Filme entfernen und Filme suchen im nachhinein nicht so ein Problem sind, da diese ja nur eine einfache Liste sind, wird es mit der Zusatz ob die verliehen oder verfügbar sind etwas schwieriger.

Abgesehen vom CSV Modul etc.

Wenn man es so programmieren würde wie ich es gerade versuche, ohne Module etc:

Wie würdet ihr es machen?
Die Funktion die,die Filme kennzeichnet so schreiben, dass diese ein dictionary erzeugt,
wie oben, aber erst noch prüft ob hier einige bereits den Wert "verliehen" haben und diese dann entsprechend überspringen?
Dieses dictonary dann in eine neue Datei schreiben die man aufrufen und prüfen kann?

Das wäre so mein Gedanke, wie seht ihr das?

[__blackjack__]

@andie39: Du könntest eine extra Datei erstellen wo die verliehenen Filme entweder extra gespeichert werden, oder das Programm so schreiben, dass die verliehenen Filme sozusagen verschoben werden, also wenn Film X verliehen wird, dann aus der movies-Datei entfernen und zur lent-movies-Datei hinzufügen und wenn der Film zurück kommt, das ganze wieder umgekehrt.

Oder Du speicherst die Information zu jedem Film dazu, beispielsweise das Filme die da sind, als erstes Zeichen vor dem Titel ein "+" haben und alle die verliehen sind ein "-".

In beiden Fällen würde ich dann wieder dafür plädieren, dass es eine Lese- und eine Schreibfunktion gibt und diese beiden Funktionen die *einzigen* sind, die etwas von "+", "-", und "\n" wissen. Liefern und als Argument erwarten würden diese beiden Funktionen dann Listen aus Tupeln (Filmtitel, Wahrheitswert), wobei der Wahrheitswert, also `True` oder `False` aussagt ob der Film verfügbar oder verliehen ist. Wobei es auch gerne ein `collection.namedtuple()`-Typ sein darf, der diese beiden Informationen zusammenfasst.

[andie39]

Hmm….
gute Frage wie ich das am besten machen sollte.

Ich habe mir aber mal deine Beispiele hier genauer angesehen:

Code: Alles auswählen

def validate_movie(movie):
    if "\n" in movie:
        raise ValueError(f"illegal newline in {movie!r}")
    return movie


def load_movies(filename):
    with open(filename, "r", encoding="utf-8") as file:
        return [line.rstrip() for line in file]


def save_movies(filename, movies):
    with open(filename, "w", encoding="utf-8") as file:
        file.writelines(f"{validate_movie(movie)}\n" for movie in movies)


def add_movie(filename, movie):
    validate_movie(movie)
    
    movies = load_movies(filename)
    if movie in movies:
        return False

    movies.append(movie)
    save_movies(filename, movies)
    return True

Sieht sinnvoll aus, kleinere Funktionen werden in andere mit eingebaut so das man die auch nicht immer neu schreiben muss.

Sehr clever.

Aber ich habe ich eine Frage zu einer Funktion :


Load und safe öffnen und schreiben ja nur.
Load erstellt eine Liste die wird als movies später definiert und dort ein Film in die Liste hinzugefügt um dann die neue Liste Zeile für Zeile damit save dort eben die einzelnen Filme wieder in die Datei reinschreibt das macht soweit Sinn aber hier, dieser Teil der add Funktion:

Code: Alles auswählen

movies = load_movies(filename)
    if movie in movies:
        return False

    movies.append(movie)
    save_movies(filename, movies)
    return True

Ich weiss das man einen Rückgabewert entsprechend false oder true nach Bool definieren kann, aber was macht das genau?
Was bringt die Rückgabe false?
Lässt es das Programm dann hier stoppen, so dass die Funktion nicht weiter ausgeführt wird? Was hier ja das hinzufügen des Films und die Datei neu schreiben wäre?

Und wenn ja, wäre die Rückgabe true am Ende der Funktion dann nicht überflüssig da die Funkt dort sowieso endet?

[__blackjack__]

@andie39: Die Funktion selbst macht mit dem Rückgabewert nichts, aber der Aufrufer kann daran feststellen ob der Aufruf geklappt hat, oder ob es den Film schon gab. In den Funktionen ist ja keine Benutzerinteraktion enthalten. Der Code der das aufruft, möchte dem Benutzer vielleicht gerne mitteilen ob das hinzufügen erfolgreich war oder nicht. Wenn einen das nicht interessiert, kann man das ignorieren.

[andie39]

@andie39: Die Funktion selbst macht mit dem Rückgabewert nichts, aber der Aufrufer kann daran feststellen ob der Aufruf geklappt hat, oder ob es den Film schon gab. In den Funktionen ist ja keine Benutzerinteraktion enthalten. Der Code der das aufruft, möchte dem Benutzer vielleicht gerne mitteilen ob das hinzufügen erfolgreich war oder nicht. Wenn einen das nicht interessiert, kann man das ignorieren.

Ok, aber dann wäre doch ein print Befehl eher nötig, der mitteilt ob es den Film gibt oder nicht?
Du benutzt es ja auch bei der load_movies, aber das würde doch auch ohne gehen oder nicht?
Also so:

Code: Alles auswählen

def load_movies(filename):
    with open(filename, "r", encoding="utf-8") as file:
        [line.rstrip() for line in file]
       

Muss doch nicht extra das return hin?


Desweiteren bei der add_movie dann:

Code: Alles auswählen

def add_movie(filename, movie):
    validate_movie(movie)
    
    movies = load_movies(filename)
    if movie in movies:
        return False

    movies.append(movie)
    save_movies(filename, movies)

Würde jetzt nicht der Film so oder so hinzugefügt werden, auch wenn der schon verfügbar ist?
Denn movies.append(movie) ist ja nicht im if block untergebracht sondern würde doch nach der if Anweisung so oder so ausgeführt werden, da nicht eingerückt oder nicht?

[__blackjack__]

@andie39: Doch `load_movies()` braucht ein ``return``, was sollte den sonst zurückgegeben werden? Ohne explizites ``return`` wird in dem ``with``-Block eine Liste erstellt, und die wird dann einfach verworfen, weil nichts damit gemacht wird. Und dann läuft die Funktion weiter hinter den ``with``-Block. Da steht nichts mehr, also ist der Ablauf der Funktion da zuende und es wird zum Aufrufer zurückgekehrt und implizit `None` zurückgegeben.

``return`` heisst zu deutsch sowohl „kehre zurück“ (zum Aufrufer) als auch „gib zurück“ (an den Aufrufer) und kehrt zum Aufrufer zurück. Nicht irgendwann sondern *sofort*. Wenn der Film in der Liste enthalten ist, wird ``return False`` ausgeführt, was die Funktion sofort an der Stelle beendet.

Es kann sein, dass trotzdem zwischen dem tatsächlichen zurückkehren, und bevor der Programmablauf beim Aufrufer weiter geht, noch etwas passiert was *in* der Funktion steht oder veranlasst wurde, nämlich wenn das ``return`` nicht nur die Funktion, sondern auch ``with``-Blöcke, oder ``try``-Blöcke mit einem ``finally``-Block verlässt. Ersteres ist in `load_movies()` der Fall wo das verlassen des ``with``-Blocks Code auslöst der die Datei schliesst. ``try``/``finally`` ist vielleicht ein Vorgriff auf Ausnahmebehandlung, wo ich jetzt nicht weiss ob Du das schon als Thema hattest.

[andie39]

Es wird doch etwas mit der Liste gemacht zumindest in der add_movies:

def load_movies(filename):
with open(filename, "r", encoding="utf-8") as file:
[line.rstrip() for line in file]

Hier wird ja eine Liste erstellt und diese liste bekommt doch in der add_movies gleich die Variable movies zugewiesen hier:

def add_movie(filename, movie):
validate_movie(movie)

movies = load_movies(filename)

——————

Ach return beendet auch eine Funktion?
Ich dachte das die nur etwas zurück gibt.

Beispiel man hat eine Berechnung laufen:

a +b- c = result
return(result)

Das dies dann eben zurückgegeben wird.

Hier aber wird die Liste ja so oder so erstellt. Das heißt return beendet immer die Funktion und lässt den Rest nicht weiterlaufen außer durch einen Zusatz wie try etc?

[__blackjack__]

@andie39: In der `load_movies()` wird nichts mit der Liste gemacht. Insbesondere wird die nicht an den Aufrufer, also zum Beispiel `add_movie()` zurückgegeben. Das die den Rückgabewert von `load_movies()` an einen Namen bindet hat innerhalb der `load_movie()`-Funktion keinen Einfluss auf irgend etwas. Wenn `load_movies()`, beziehungsweise ganz allgemein eine Funktion nicht explizit etwas zurück gibt und der Programmfluss am Ende der Funktion ankommt, dann wird implizit der Wert `None` zurück gegeben. Du kannst Dir am Ende *jeder* Funktion (und Methode) ein unsichtbares ``return None`` vorstellen. Wenn das nicht so gelöst wäre, müsste die Sprache/Laufzeitumgebung irgendwie zwischen Funktionen/Methoden die etwas zurückgeben und welchen die das nicht tun unterscheiden, und das bei jedem Aufruf testen und gegebenenfalls eine Fehlermeldung/Ausnahme auslösen. Hätten die Python-Entwickler so machen können, haben sie aber nicht.

Und ja, ``return`` beendet, wenn es ausgeführt wird, die Funktion.

[andie39]

Danke.

Ok also wenn irgendwo retund in einer Funktion ausgeführt wird stoppt diese.
Das erklärt das.

Das mit dem return bei load_movies im Zusammenhang mit add_movies verstehe ich nicht…….
Doch jetzt schon das return gibt die Liste zurück.

Ich dachte nur weil:

[line.rstrip() for line in file]

Die eckigen Klammern erzeugen ja eine Liste.
Return gibt die zurück.

Ich dachte das auch ohne return die Funktion
aufgrund der letzten Zeile:
[line.rstrip() for line in file]

Eine Liste erzeugt und an die Funktion bindet.

Aber ja es ist ja wie bei meinem Beispiel einer berechnung bei der ja das result zurückgegeben werden soll.
Das resultat ist ja hier die Liste.

[andie39]

Ich habe hier in den letzten Tagen einiges gelernt auch Dinge die ich falsch angenommen hatte:

1. Die else Ausführung bei einer for/while Schleife und dahingehend im Zusammenhang mit break

2. Den return Befehl besser verstanden und das dieser eine Funktion beendet mit einigen try/except Ausnahmen.

3. Zukünftig die Arbeit mit bestehenden Modulen

4. Am wichtigsten aber wohl:
Funktionen so klein wie möglich halten und nur das rein was die wirklich machen sollen und dann weitere mit anderen Funktionen zusammen konstruieren.


Danke allen!!