Try/Except und shelve

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Bl3nder
User
Beiträge: 139
Registriert: Freitag 3. Januar 2020, 17:07

Ich habe zu den oben genannten Themen Fragen.


Ich bin per Zufall auf die Bibliothek shelve gestossen ( bin noch anfänger) wenn Ich das richtig verstanden habe -> wenn ICh diese Benutzte ( Information damit "verpacke") sind diese sicherer weil damit 3 weitere Datein erzeugt werden und die Festplatte meine Gespeicherten Daten so wiederherstellen kann ICh verstehe jedoch nicht ganz wann es sinnvoll ist diese zu verwenden:

1.)Bsp1 Configdatein hier macht es aus meiner Sicht Sinn da es meistens kleine Datein sind -> bei der es wichtig sein kann die Einstellungen für ein Programm nie zu verlieren.

2.)Würde es auch Sinnmachen große mengen Messdaten darin zupacken damit diese extra sicher sind ?



Try & Except:
Macht es Sinn sein Skript wie folgt aus zu bauen:

Code: Alles auswählen

import shutil
from tkinter import messagebox
import sys
from os import listdir,makedirs
from pathlib import Path

# Festlegung der Pfade
PFAD_ZUR_NAS = Path(r"E:\NAS_Dummy")
PFAD_ZUR_EXTERNEN_FESTPLATTE = Path(r"E:\Externefestplatte_Dummy")
PFAD_ZUR_FERTIGDATEN = Path(r"C:\Users\Marcel\Desktop\Fertigdaten_Dummy")


# ---------------------------------------------------Programm Anfang-----------------------------------------------------

def ordner_erstellen(nas,externefestplatte,fertigdaten):
    """Hier werden die Oberordner erzeugt"""

    try:
        nas_Monate_Ordner=nas.joinpath("Monate")
        nas_Jahre_Ordner=nas.joinpath("Jahre")
        externefestplatte_Monate_Ordner=externefestplatte.joinpath("Monate")
        externefestplatte_Jahre_Ordner=externefestplatte.joinpath("Jahre")
        if not nas_Monate_Ordner.exists():
            makedirs(nas_Monate_Ordner)
        if not nas_Jahre_Ordner.exists():
            makedirs(nas_Jahre_Ordner)
        if not externefestplatte_Monate_Ordner.exists():
            makedirs(externefestplatte_Monate_Ordner)
        if not externefestplatte_Jahre_Ordner.exists():
            makedirs(externefestplatte_Jahre_Ordner)

#---------------------------Unterordner--------------------------------------------------------------------------------
        ordner_jahr_gefunden =[file for file in listdir(fertigdaten) if file.endswith('_01.wrt')]
        ordner_die_hinzugefuegt_werden=[]
        for file in ordner_jahr_gefunden:
            d=str(file).split("_")
            del d[0],d[1]
            ordner_die_hinzugefuegt_werden.append(d)
        while len(ordner_die_hinzugefuegt_werden)>0:
            for jahr in ordner_die_hinzugefuegt_werden[0]:
                if not nas_Jahre_Ordner.joinpath(jahr).exists():
                    makedirs(nas_Jahre_Ordner.joinpath(jahr))
            for jahr in ordner_die_hinzugefuegt_werden[0]:
                if not externefestplatte_Jahre_Ordner.joinpath(jahr).exists():
                    makedirs(externefestplatte_Jahre_Ordner.joinpath(jahr))
            del ordner_die_hinzugefuegt_werden[0]


    except FileNotFoundError:
        if externefestplatte.exists():
            externefestplatte_Monate_Ordner = externefestplatte.joinpath("Monate")
            externefestplatte_Jahre_Ordner = externefestplatte.joinpath("Jahre")
            if not externefestplatte_Monate_Ordner.exists():
                makedirs(externefestplatte_Monate_Ordner)
            if not externefestplatte_Jahre_Ordner.exists():
                makedirs(externefestplatte_Jahre_Ordner)
            

        elif nas.exists():
            nas_Monate_Ordner=nas.joinpath("Monate")
            nas_Jahre_Ordner=nas.joinpath("Jahre")
            if not nas_Monate_Ordner.exists():
                makedirs(nas_Monate_Ordner)
            if not nas_Jahre_Ordner.exists():
                makedirs(nas_Jahre_Ordner)






def ermittelt_fehlende_Daten(nas, externefestplatte, fertigdaten):
    """Hier wird geprüft ob einer der drei Pfade nicht vorhanden ist sollte das so sein wird eine exeption geschmissen wo
    dann geprüft wird ob der Ordner Fertigdaten vorhanden ist wenn ja wird geprüft ob die nas oder externefestplatte fehlt
    und die entgegengesetzt operation trotzdem ausgeführt wenn Fertigdaten fehlt wird das Programm beendet."""
    fehlende_fertigdaten_auf_nas = []
    fehlende_fertigdaten_auf_externefestplatte = []
    try:
        verfuegbarere_fertigdatein = listdir(fertigdaten)
        verfuegbarere_fertigdatein_in_nas = listdir(nas)
        verfuegbarere_fertigdatein_in_externefestplatte = listdir(externefestplatte)
        for i in verfuegbarere_fertigdatein:
            if i not in verfuegbarere_fertigdatein_in_nas:
                fehlende_fertigdaten_auf_nas.append(i)
            if i not in verfuegbarere_fertigdatein_in_externefestplatte:
                fehlende_fertigdaten_auf_externefestplatte.append(i)
        return fehlende_fertigdaten_auf_nas, fehlende_fertigdaten_auf_externefestplatte
    except FileNotFoundError:
        if fertigdaten.exists():
            if nas.exists():
                verfuegbarere_fertigdatein = listdir(fertigdaten)
                verfuegbarere_fertigdatein_in_nas = listdir(nas)
                for file in verfuegbarere_fertigdatein:
                    if file not in verfuegbarere_fertigdatein_in_nas:
                        fehlende_fertigdaten_auf_nas.append(file)
                return (fehlende_fertigdaten_auf_nas, None)
            elif externefestplatte.exists():
                verfuegbarere_fertigdatein = listdir(fertigdaten)
                verfuegbarere_fertigdatein_in_externefestplatte = listdir(externefestplatte)
                for file in verfuegbarere_fertigdatein:
                    if file not in verfuegbarere_fertigdatein_in_externefestplatte:
                        fehlende_fertigdaten_auf_externefestplatte.append(file)
                return (None, fehlende_fertigdaten_auf_externefestplatte)
        else:
            sys.exit(-1)  # Fertigdatenordner nicht vorhanden


def main():
    ordner_erstellen(PFAD_ZUR_NAS,PFAD_ZUR_EXTERNEN_FESTPLATTE,PFAD_ZUR_FERTIGDATEN)
    fehlenden_daten_nas, fehlenenden_daten_externefestplatte = ermittelt_fehlende_Daten(PFAD_ZUR_NAS,PFAD_ZUR_EXTERNEN_FESTPLATTE,PFAD_ZUR_FERTIGDATEN)


if __name__ == "__main__":
    main()

Ich bin mir da momentan nicht ganz sichere meine Gedanken sind folgende:

Wenn Ich einmal gucke ob die Pfade vorhanden sind müsste es doch reichen -> da das Programm ja in wenigen Sekunden durchlaufen ist.

Beim Programmieren denke mich nur dann was passiert wenn genau in der Sekunde -> wo der Sprung zu nächsten Funktion geschickt zum Beispiel die Externefestplatte abgemacht wird -> das führt zu einem Fehler der dann wenn ICh nur einmal mit Try/Except arbeite nicht abgefangen wird .

Ich würde gerne eure Meinungen dazu hören.

Danke im vorraus!
Eine Vision ohne Aktion bleibe eine Illusion
Benutzeravatar
noisefloor
User
Beiträge: 4194
Registriert: Mittwoch 17. Oktober 2007, 21:40
Wohnort: WW
Kontaktdaten:

Hallo,
Ich bin per Zufall auf die Bibliothek shelve gestossen ( bin noch anfänger) wenn Ich das richtig verstanden habe -> ...
Nee, hast du völlig falsch verstanden: Das shelve-Modul stellte eine (einfache) Schlüssel-Werte Datenbank bereit, wobei die Werte beliebige Python-Objekte sein dürfen. Das war's. shelve schreibt eine Datei und nicht drei und auch mit (besserer) Sicherheit hat das so rein gar nichts zu tun.

Wo hast du die Info mit dem 3-fach her? Wenn du dich auf den Satz "By default, version 3 pickles are used to serialize values." aus der Doku beziehst: das heißt, dass shelve das pickle-Protokoll Version 3 (es gibt insgesamt z.Zt. 5) verwendet, nicht das drei Dateien angelegt werden.

Gruß, noisefloor
Bl3nder
User
Beiträge: 139
Registriert: Freitag 3. Januar 2020, 17:07

Ich danke fdir für die schnelle Antwort als Ich mit shelve herumgespielt habe waren danach 3 Datein erzeugt worden [bak,dat,dir] Ich habe dann gedacht mal angenommen 1 Datei ist gelöscht worden oder weg das die Festplatte mithilfe der anderen die Daten dann wieder herstellen kann ,also benutzt man das ehr bei Tabellen wie :

Kunde Nummer
Dennis 1
Thomas 2
...

? Also al eine Art zuweisung nur wo ist dann der Vorteil das so zu machen das kann Ich doch auch mit einem Dictonary und das in eine txt Datei speichern ?
Eine Vision ohne Aktion bleibe eine Illusion
Benutzeravatar
/me
User
Beiträge: 3561
Registriert: Donnerstag 25. Juni 2009, 14:40
Wohnort: Bonn

Bl3nder hat geschrieben: Donnerstag 12. November 2020, 19:34 das kann Ich doch auch mit einem Dictonary und das in eine txt Datei speichern ?
Du musst es dann aber beim Einlesen selber wieder in ein Dictionary überführen. Ich mag ja JSON als Speicherformat und auch dafür gibt es in der Standardbibliothek von Python ein Modul : json
Benutzeravatar
__blackjack__
User
Beiträge: 14053
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

@Bl3nder: Wie viele Dateien erstellt werden ist nicht so wirklich festgelegt weil `shelve` verschiedene ”backends” verwenden kann.

Wie noisefloor schon schrieb: das ist einfach eine Schlüssel/Wert-Datenbank. Die `pickle` für die Werte verwendet. Womit man sich dann auch gleich die Probleme von `pickle` einhandelt. Es gibt kaum einen Grund das zu benutzen.

Was meinst Du mit Dictionary in einer Textdatei speichern? Das geht ja nicht wirklich beziehungsweise macht man das ja nicht. Man kann das als JSON serialisieren. Und ist dann auf auf die Datentypen angewiesen die sich als JSON serialisieren lassen, beziehungsweise müsste selbst Code schreiben um auch andere Objekte zu (de)serialisieren.

Oder man könnte ein Dictionary mit `pickle` serialisieren, das ist dann aber keine Textdatei. Und man hat die Probleme/Einschränkungen von `pickle`. Im Gegensatz zu `shelve` kann man nicht auf einzelne Schlüssel zugreifen, weder lesend, noch schreibend, sondern muss immer die komplette Datenstruktur (de)serialisieren.
“Vir, intelligence has nothing to do with politics!” — Londo Mollari
Bl3nder
User
Beiträge: 139
Registriert: Freitag 3. Januar 2020, 17:07

Ich danke euch für eure Erklärungen bezüglich shelve .

Wie steht ihr zu meiner zweiten Fragen ( das ist das erstemal das Ich mich mit Try/Except beschäftige).
Eine Vision ohne Aktion bleibe eine Illusion
Sirius3
User
Beiträge: 18274
Registriert: Sonntag 21. Oktober 2012, 17:20

@Bl3nder: was bei Deinem Code zuerst auffällt ist, dass alles doppelt ist. Der Code im try-Block wurde zum Großteil auch in den except-Block kopiert. Und was Du für NAS machst, machst Du identisch mit Externer Fesplatte.
Warum verwendest Du Funktionen aus os, wenn die Path benutzt?
Das was Du da mit `del` machst, ist äußerst undurchsichtig. Warum werden da Pfade, die 01.wrt heißen angelegt? Oder soll das das del verhindern? Wie gesagt, extrem undurchsichtig.

Code: Alles auswählen

def make_year_month(path, fertigdaten):
    if path.exists():
        (path / "Monate").mkdir(exist_ok=True)
        path_year = path / "Jahre"
        path_year.mkdir(exist_ok=True)
        for file in fertigdaten.glob('*_01.wrt'):
            year = file.name.split("_")[1]
            (path_year / year).mkdir(exist_ok=True)

def ordner_erstellen(nas, externefestplatte, fertigdaten):
    """Hier werden die Oberordner erzeugt"""
    make_year_month(nas, fertigdaten)
    make_year_month(externefestplatte, fertigdaten)
Ein sys.exit darf es nur in main geben. Die Exception würde man daher auch dort abfangen.
`i` ist ein ganz schlechter Name für einen Dateinamen.

Code: Alles auswählen

def ermittelt_fehlende_Daten(nas, externefestplatte, fertigdaten):
    fehlende_fertigdaten_auf_nas = []
    fehlende_fertigdaten_auf_externefestplatte = []
    for file in ferigdaten.iterdir():
        if not (nas / file.name).exists():
            fehlende_fertigdaten_auf_nas.append(file.name)
        if not (externefestplatte / file.name).exists():
            fehlende_fertigdaten_auf_externefestplatte.append(file.name)
    return fehlende_fertigdaten_auf_nas, fehlende_fertigdaten_auf_externefestplatte
Bl3nder
User
Beiträge: 139
Registriert: Freitag 3. Januar 2020, 17:07

@Sirius

Meine Logik ist wie folgt:

Ich habe es so verstanden das man den Code der eigentlich ausgeführt werden soll in den try Teil packt -> Ich versuche als erstes bzw prüfe ob die Ordner aus der NAS und der Externenfestplatte vorhanden sind sind Sie das -> liegt es nahe das die Externefestplatte eventuell gar nicht angeschlossen ist daher kann ich den Prozess doch abfangen und den Code dann trotzdem für die Nas ausführen und umgekehrt halt auch Nas nicht vorhanden -> externefestplatte schon.

Mit den Try/Except beziehe Ich mich ja auch auf meine Frage weiter oben mal angenommen die Ordner sind erstellt und das Programm springt nachher zu einer Funktion wo es darum geht die Datei zu verschieben würde ICh meiner Logik nach das wieder verwenden: Das es doch theoretisch ein das in der Sekunde wieder was geändert wurde ?


Meine Logik (schematische darstellung):


def func1():
try:code
except

def func2()
try:code
except


def main()
func1()
func2()
.
.
.

main()



Oder macht man das folgender Maßen:


def main()
try:
func1()
func2()

except

main()
????

""Warum verwendest Du Funktionen aus os, wenn die Path benutzt?""

Die Frage verstehe Ich nicht ganz ich nehme das was Ich kenne und weiß wie es funktioniert Ich weiß das es auch eine OS.path funktion gibt aber Ich mag es lieber mit Pathlib zu arbeiten?


Das was Du da mit `del` machst, ist äußerst undurchsichtig. Warum werden da Pfade, die 01.wrt heißen angelegt? Oder soll das das del verhindern? Wie gesagt, extrem undurchsichtig.


Ich habe folgendes Problem:
in Fertigdaten sind Datein die heißen Fertigdaten_2020_01.wrt ...... diese liste ich auf mit listdir -> Ich benötigte jedoch eigentlich nur immer die _01.wrt Datei weil Ich daraus das Jahr
haben möchte ->2020 oder wenn 2 Datein die so heißen dort vorhanden sind bsp 2021 bedeutet Ich habe eine Liste [Fertigdaten,2020,01.wrt ,Fertigdaten,2021,01.wrt ] hier lösche ICh Fertigdaten und 01.wrt raus damit Ich nur noch 2020,2021 habe so nun gibt es aber ein Fehler Ich kann keine 2 Einträge als Pfad übergeben -> deswegen nehme ICh immer den ersten eintrag und wenn der Ordner erzeugt ist lösche ICh den Eintrag und das durchläuft eine Schleife ....


Langsam glaube Ich einfach das Programmieren sein zu lassen ICh hab nun so viele gelesen recheriert und leider ist es immer alles falsch das Problem ist einfach was Ich habe in dem BUch was Ich habe gibt es eine Lektion try/ exept zum Beispiel dann verstehe Ich halbwegs wie man sowas anwendet aber ICh kann das nicht implemtieren in meine Projekt nur so ist der ganze Code den Ich gemacht habe wieder für die Tonne.... Dabei bin ich schon zurück gegangen mit den schwierigkeits Grad....

Und die andere Frage wieso darf Ich nur mein Programm in meiner main schleife verlassen und nicht in der Funktion wenn dort so wie ich es programmiert habe der Fehler aufgetreten ist ?
Eine Vision ohne Aktion bleibe eine Illusion
Sirius3
User
Beiträge: 18274
Registriert: Sonntag 21. Oktober 2012, 17:20

Du findest pathlib besser, benutzt aber trotzdem os? Das verstehe ich wiederum nicht. Wen man ein Modul verwendet, dann liest man am besten erst mal die Dokumentation, damit man weiß, was man damit alles machen kann.
Wenn man in irgendeiner Funktion sys.exit aufruft, dann ist sie nicht allgemein verwendbar, dann kann man nicht nachverfolgen, wie der Programmablauf ist, Fehler meldet man per Exception zum Aufrufenden hoch, bis man sinnvoll den Fehler verarbeiten kann.

Du denkst einfach zu kompliziert. Statt alles in einem Stück zu programmieren, schreibe einfache Funktionen, die genau eine Sache machen und teste die und probiere aus.
Zum Beispiel hast Du den String "Fertigdaten_2020_01.wrt". Da kannst Du natürlich am _ splitten, und hast eine Liste ["Fertigdaten", "2020", "01.wrt"] und dann kann man natürlich den ersten und letzen Eintrag löschen, um nur noch den zweiten zu haben, aber viel logischer ist es doch, einfach den zweiten Eintrag zu nehmen. Beim Programmieren ist es ganz normal, alles fünf mal in die Tonne zu treten, wie bei jedem anderen Handwerk auch.
Sirius3
User
Beiträge: 18274
Registriert: Sonntag 21. Oktober 2012, 17:20

Du findest pathlib besser, benutzt aber trotzdem os? Das verstehe ich wiederum nicht. Wen man ein Modul verwendet, dann liest man am besten erst mal die Dokumentation, damit man weiß, was man damit alles machen kann.
Wenn man in irgendeiner Funktion sys.exit aufruft, dann ist sie nicht allgemein verwendbar, dann kann man nicht nachverfolgen, wie der Programmablauf ist, Fehler meldet man per Exception zum Aufrufenden hoch, bis man sinnvoll den Fehler verarbeiten kann.

Du denkst einfach zu kompliziert. Statt alles in einem Stück zu programmieren, schreibe einfache Funktionen, die genau eine Sache machen und teste die und probiere aus.
Zum Beispiel hast Du den String "Fertigdaten_2020_01.wrt". Da kannst Du natürlich am _ splitten, und hast eine Liste ["Fertigdaten", "2020", "01.wrt"] und dann kann man natürlich den ersten und letzen Eintrag löschen, um nur noch den zweiten zu haben, aber viel logischer ist es doch, einfach den zweiten Eintrag zu nehmen. Beim Programmieren ist es ganz normal, alles fünf mal in die Tonne zu treten, wie bei jedem anderen Handwerk auch.
Bl3nder
User
Beiträge: 139
Registriert: Freitag 3. Januar 2020, 17:07

Jetzt verstehe Ich was du meinst ja um die Sachen mir auf zu listen ja Ich habe mir da ehrlich gesagt kein großen kopf gemacht das Ich wusste das es mit os geht.


Ja Nur in meinem Kopf habe ICh halt eine Vorstellung und damit es übersichtlich bleibt versuche Ich das immer alles in eine Funktion zu pressen -> Ich werde mich nachher mal dran setzten und das ein bisschen aufteilen.


Wie müsste Ich es den dann programmieren ? -> Also den Try Except block in der main function

so in der Art:

def Funktion1:
if Pfad vorhanden:

else:raise FileNotFoundError




def main():
try:Funktion1 <- hier ist es mir nicht ganz bewusst wie fange Ich nun die Exception nur für Funktion 1 ab und wenn ICh noch weitere Funktionen habe benötigen die jedes
mal einen eigenen Try/Excep "Baum"?

exception FileNotFoundError:
anderer Code()






main()
Eine Vision ohne Aktion bleibe eine Illusion
Sirius3
User
Beiträge: 18274
Registriert: Sonntag 21. Oktober 2012, 17:20

Welche Fehler können auftreten und welches Ergebnis soll dann rauskommen?
Bl3nder
User
Beiträge: 139
Registriert: Freitag 3. Januar 2020, 17:07

Naja als Ich würde sagen das 2 Fehler auftreten können :

Das die Datei nicht gefunden werden kann -> da der Pfad nicht vorhanden ist
Und das die Datei schon im Ordner sich befindet.


Naja mein Gedanke ist eigentlich:

Versuch die Daten auf beide Medien zu schreiben ->NAS,Externefestplatte

Wenn eins der beiden nicht vorhanden ist Exception Prüfe ob man es wenigstens auf eines der beiden schreiben kann.

Nur Ich bin mir halt unsicher ob man das vor jeder Funktion machen sollte.

So in etwa:

Code: Alles auswählen

def funktion1():
    pass

def funktion2():
    pass




def main():
    funktion1()
    funktion2()





if __name__ == "__main__":
    try:
        main()
    except:pass
        

Nur hier hätte ich das problem das ich nicht verstehe wie Ich genau die Exception zuordne.

Als Beispiel in Funktion1 würde ICh Daten von A->B schreiben und das klappt nicht nicht würde er einen Fehler "werfen" in dem Fall möchte ICh aber trotzdem das das andere Versucht wird ?Nur Ich kann mir nicht vorstellen das man mehrere Exception hat mit FilenotFound ???

Ich danke dir schonmal
Eine Vision ohne Aktion bleibe eine Illusion
Sirius3
User
Beiträge: 18274
Registriert: Sonntag 21. Oktober 2012, 17:20

Die zwei Fehler "Das die Datei nicht gefunden werden kann -> da der Pfad nicht vorhanden ist" und "Und das die Datei schon im Ordner sich befindet." sehe ich in Deinem Code gar nicht. Da werden nur ein paar Verzeichnisse erzeugt und ein paar Dateien gesucht.

Jetzt sollen angeblich Dateien kopiert werden. Das ist eine ganz neue Funktionalität.
Also in Pseudo-Code:

Code: Alles auswählen

for datei in alle_quell_dateien:
    for ziel in [ziel1, ziel2]:
        try:
            kopiere(datei, ziel)
        except Fehler:
            print(f"{datei} konnte nicht kopiert werden, ist aber egal")
Bl3nder
User
Beiträge: 139
Registriert: Freitag 3. Januar 2020, 17:07

Ok wir reden gerade ein bisschen aneinander vorbei ich habe verstanden Ich soll dir sagen "" Welche Fehler können auftreten und welches Ergebnis soll dann rauskommen?""

Das du mir zeigst wo Ich das nun einfügen soll da der Code von dir oben mir aussieht als ob man ihn in eine Funktion packen könnte was ich ja nicht sollte da -> es so ja nicht an die übergeordnete Funktion weiter gegeben wird ???



Und leider verstehe Ich auch den code nicht ganz :

for datei in alle_quell_dateien:
for ziel in [ziel1, ziel2]:
try:
kopiere(datei, ziel)
except Fehler:
print(f"{datei} konnte nicht kopiert werden, ist aber egal")

Und kann man eventuell direkt fragen ob datei,ziel1 oder datei,ziel2 den Fehler geworfen hat? Oder sehe Ich das komplett falsch?


Desweiteren so wie Ich es verstanden habe:

Es tritt ein Fehler aus -> und wenn man kein Try/Except benutzt "hängt" sich das Programm auf weil es nicht weiß was es machen soll.

Wenn Ich den Fehler abfange wird mein Code danach weiterausgeführt.

Nur dann wären wir doch bei meinen Ursprungsgedanken oder nicht ->

Mal angenommen Ich sage list.dir (in einer anderen Funktion)-> und er findet pfad nicht wirft die Bibliothek einen Fehler also muss ICh das doch in jeder Funktion berücksichtigen oder nicht ???Dann hätte Ich doch wieder in jeder Funktion try/except
Eine Vision ohne Aktion bleibe eine Illusion
Sirius3
User
Beiträge: 18274
Registriert: Sonntag 21. Oktober 2012, 17:20

Ja, dann bist Du bei Deinem Ursprungsgedanke. Deshalb habe ich ja gefragt, was Du eigentlich machen willst.
Du mußt den Fehler dort Abfangen wo es sinnvoll ist, und wenn es sinnvoll ist, beim Kopieren jeder Datei gleich den Fehler abzufangen, dann ist das so.
Bl3nder
User
Beiträge: 139
Registriert: Freitag 3. Januar 2020, 17:07

Ich habe jetzt nochmal alles überarbeitet:

Und stelle es mir in etwa so vor:

Code: Alles auswählen

from pathlib import Path
import shutil
import time
import os

# Festlegung der Pfade
PFAD_ZUR_NAS = Path(r"E:\NAS_Dummy")
PFAD_ZUR_EXTERNEN_FESTPLATTE = Path(r"E:\Externefestplatte_Dummy")
PFAD_ZUR_FERTIGDATEN = Path(r"C:\Users\Marcel\Desktop\Fertigdaten_Dummy")



def prueft_ob_ober_Ordner_struktur_vorhanden_ist(pfad_Medium,pfad_fertigdaten):
    """Hier wird geprüft ob die Pfade bestehen und die Ordner erzeugt"""
    try:
        if pfad_Medium.exists():
            (pfad_Medium/"Jahre").mkdir(exist_ok=True)
            (pfad_Medium/"Monate").mkdir(exist_ok=True)
            for file in pfad_fertigdaten.glob('*_01.wrt'):
                jahr = file.name.split("_")[1]
                (pfad_Medium/"Jahre"/jahr).mkdir(exist_ok=True)
                (pfad_Medium / "Monate" / jahr).mkdir(exist_ok=True)
    except FileNotFoundError:
        print("Pfad nicht vorhanden!")

def prueft_ob_daten_aus_fertigdaten_vorhanden_sind_in_Medium(pfad_medium,pfad_fertigdaten):
    fehlende_fertigdaten_auf_Medium = []
    try:
        for file in pfad_fertigdaten.iterdir():
            if not (pfad_medium / file.name).exists():
                if file.name not in("Fertigdaten.wrt","Fertigdaten_konsistenz.wrt",".fertig.wrt"):
                    fehlende_fertigdaten_auf_Medium.append(file.name)
        return fehlende_fertigdaten_auf_Medium
    except FileNotFoundError:
        print("Pfad nicht vorhanden!")

def fehlende_monats_daten_in_medium_kopieren(fehlende_daten,pfad_Medium,pfad_fertigdaten):
    try:
        for file in fehlende_daten:
            datei_monat_jahr_ordner=file.split("_")[1]                     #In dem Ordner Monate werden die Datein nochmal in Jahre unterteilt hier wird in diesem Ordner das Jahr zugeteilt
            shutil.copy(pfad_fertigdaten/file,pfad_Medium/"Monate"/datei_monat_jahr_ordner)
    except FileNotFoundError:
        print("Pfad nicht vorhanden!")
        
    


def  fehlende_jahres_daten_in_medium_kopieren(pfad_medium,pfad_fertigdaten):
    try:
        if (pfad_fertigdaten/".fertig.wrt").exists():
            jahre=str((time.localtime(os.path.getmtime(pfad_fertigdaten/".fertig.wrt")).tm_year)-1)
            if not (pfad_medium/"Jahre"/jahre).exists():
                (pfad_medium/"Jahre"/jahre).mkdir(exist_ok=True)
                shutil.copy(pfad_fertigdaten/".fertig.wrt",pfad_medium /"Jahre"/jahre)
            else: shutil.copy(pfad_fertigdaten/".fertig.wrt",pfad_medium/"Jahre"/jahre)
    except FileNotFoundError:
        print("Pfad nicht vorhanden!")

def auf_differenz_zwischen_beiden_Medien_pruefen(pfad_nas,pfad_externefestplatte):
    """Noch in Arbeit"""
    alle_daten_nas=[]
    alle_daten_externefestplatte=[]
    for f in (pfad_nas/"Monate").iterdir():
        for d in (pfad_nas/"Monate"/f).iterdir():
            alle_daten_nas.append(d)

    for f in (pfad_externefestplatte/"Monate").iterdir():
        for d in (pfad_externefestplatte/"Monate"/f).iterdir():
            alle_daten_externefestplatte.append(d)

    if len(alle_daten_nas) == len(alle_daten_externefestplatte):
        print("alles gleich")

def main():
    prueft_ob_ober_Ordner_struktur_vorhanden_ist(PFAD_ZUR_NAS,PFAD_ZUR_FERTIGDATEN)
    prueft_ob_ober_Ordner_struktur_vorhanden_ist(PFAD_ZUR_EXTERNEN_FESTPLATTE, PFAD_ZUR_FERTIGDATEN)
    fehlende_fertigdaten_auf_nas =prueft_ob_daten_aus_fertigdaten_vorhanden_sind_in_Medium(PFAD_ZUR_NAS,PFAD_ZUR_FERTIGDATEN)
    fehlende_fertigdaten_auf_externefestplatte=prueft_ob_daten_aus_fertigdaten_vorhanden_sind_in_Medium(PFAD_ZUR_EXTERNEN_FESTPLATTE,PFAD_ZUR_FERTIGDATEN)
    fehlende_monats_daten_in_medium_kopieren(fehlende_fertigdaten_auf_nas,PFAD_ZUR_NAS,PFAD_ZUR_FERTIGDATEN)
    fehlende_monats_daten_in_medium_kopieren(fehlende_fertigdaten_auf_externefestplatte, PFAD_ZUR_EXTERNEN_FESTPLATTE, PFAD_ZUR_FERTIGDATEN)
    fehlende_jahres_daten_in_medium_kopieren(PFAD_ZUR_NAS,PFAD_ZUR_FERTIGDATEN)
    #auf_differenz_zwischen_beiden_Medien_pruefen(PFAD_ZUR_NAS,PFAD_ZUR_EXTERNEN_FESTPLATTE)



if __name__=="__main__":
    main()

Das Programm funktioniert bis auf die differenz Prüfung am ende wunderbar ( die ist allerdings auch noch in arbeit):

Ich habe nun folgendes ich möchte die exception in der funktion haben -> da Ich mir dadurch erhoffe das Ich dann zum Beispiel den Anwender sagen kann welcher Pfad nicht vorhanden ist oder welche Datei und nicht nur eine allgemeine Meldung Pfad ist nicht vorhanden etc.... Kann mir dabei nochmal jemand auf die Sprünge helfen?

Und ob es so sinnvoll ist wie ich es gemacht habe?


Anmerkung die exist_ok nehme ich später raus mir geht es mehr darum eine allgemeine Aussage zu erhalten :)
Eine Vision ohne Aktion bleibe eine Illusion
Bl3nder
User
Beiträge: 139
Registriert: Freitag 3. Januar 2020, 17:07

Ich habe es nochmal überarbeitet kann mir jemand sagen ob es so richtig ist :



Code: Alles auswählen

from pathlib import Path
import tkinter
from tkinter import messagebox
import shutil
import time
import os

# Festlegung der Pfade
PFAD_ZUR_NAS = Path(r"E:\NAS_Dummy")
PFAD_ZUR_EXTERNEN_FESTPLATTE = Path(r"E:\Externefestplatte_Dummy")
PFAD_ZUR_FERTIGDATEN = Path(r"C:\Users\Marcel\Desktop\Fertigdaten_Dummy")


#Pfade für Testzwecke
#PFAD_ZUR_FERTIGDATEN = Path(r"C:\Users\Marcel\Desktop\Test")
#PFAD_ZUR_NAS = Path(r"C:\Users\Marcel\Desktop\Test")
#PFAD_ZUR_EXTERNEN_FESTPLATTE = Path(r"C:\Users\Marcel\Desktop\Test")




def informationsfenster(Ausgabe):
    root = tkinter.Tk()
    root.withdraw()
    root.after(10000, lambda: root.destroy())
    messagebox.showinfo("Information",Ausgabe)


def prueft_ob_ober_Ordner_struktur_vorhanden_ist(pfad_Medium,pfad_fertigdaten):
    """Hier wird geprüft ob die Pfade bestehen und die Ordner erzeugt"""

    if pfad_Medium.exists():
        (pfad_Medium/"Jahre").mkdir(exist_ok=True)
        (pfad_Medium/"Monate").mkdir(exist_ok=True)
        for file in pfad_fertigdaten.glob('*_01.wrt'):
            jahr = file.name.split("_")[1]
            (pfad_Medium/"Jahre"/jahr).mkdir(exist_ok=True)
            (pfad_Medium / "Monate" / jahr).mkdir(exist_ok=True)


def prueft_ob_daten_aus_fertigdaten_vorhanden_sind_in_Medium(pfad_medium,pfad_fertigdaten):
    fehlende_fertigdaten_auf_Medium = []
    try:
        for file in pfad_fertigdaten.iterdir ():
            if not (pfad_medium / file.name).exists ():
                if file.name not in ("Fertigdaten.wrt", "Fertigdaten_konsistenz.wrt", ".fertig.wrt"):
                    fehlende_fertigdaten_auf_Medium.append (file.name)
        return fehlende_fertigdaten_auf_Medium
    except FileNotFoundError:
        print("Der Pfad zu den Fertigdaten kann nicht gefunden werden",pfad_fertigdaten)


def fehlende_monats_daten_in_medium_kopieren(fehlende_daten,pfad_Medium,pfad_fertigdaten):
    try:
        for file in fehlende_daten:
            datei_monat_jahr_ordner = file.split ("_") [1]  # In dem Ordner Monate werden die Datein nochmal in Jahre unterteilt hier wird in diesem Ordner das Jahr zugeteilt
            shutil.copy (pfad_fertigdaten / file, pfad_Medium / "Monate" / datei_monat_jahr_ordner)
    except TypeError:
        print("None ist nicht iterable,!",pfad_fertigdaten,"scheint nicht verfügbar zu sein")#check if exist
    except FileNotFoundError:
        print ("Der angegebende Pfad kann nicht gefunden werden", pfad_Medium)





def  fehlende_jahres_daten_in_medium_kopieren(pfad_medium,pfad_fertigdaten):
    if (pfad_fertigdaten / ".fertig.wrt").exists ():
        jahre = str ((time.localtime (os.path.getmtime (pfad_fertigdaten / ".fertig.wrt")).tm_year) - 1)
        try:
            if not (pfad_medium / "Jahre" / jahre).exists ():
                (pfad_medium / "Jahre" / jahre).mkdir (exist_ok = True)
            shutil.copy (pfad_fertigdaten / ".fertig.wrt", pfad_medium / "Jahre" / jahre)
        except FileNotFoundError:
            print("Der Angegebende Pfad kann nicht gefunden werden",pfad_medium)



def differenz_monate_zwischen_beiden_medien_pruefen(pfad_nas,pfad_externefestplatte):

    alle_daten_nas=[]
    alle_daten_externefestplatte=[]
    daten_von_nas_auf_externefestplatte=[]
    daten_von_externefestplatte_auf_nas =[]

    try:
        for ordner in (pfad_nas).iterdir():
            for file in (pfad_nas/ordner).iterdir():
                alle_daten_nas.append(file.name)
    except FileNotFoundError:
        print("Der angegebende Pfad kann nicht gefunden werden",pfad_nas)




    try:
        for ordner in (pfad_externefestplatte).iterdir():
            for file in (pfad_externefestplatte/ordner).iterdir():
                alle_daten_externefestplatte.append(file.name)
    except FileNotFoundError:
        print ("Der angegebende Pfad kann nicht gefunden werden", pfad_externefestplatte)


    if alle_daten_nas != alle_daten_externefestplatte:
        print("Ausgleich eingeleitet")
        for file in alle_daten_nas:
            if file not in alle_daten_externefestplatte:
                daten_von_nas_auf_externefestplatte.append(file)
                print("Auf der Externenfestplatte fehlt die Datei",file)
        for file in alle_daten_externefestplatte:
            if file not in alle_daten_nas:
                daten_von_externefestplatte_auf_nas.append(file)
                print("Auf der NAS fehlt die Datei", file)

        if len(daten_von_nas_auf_externefestplatte) >0:
            for file in daten_von_nas_auf_externefestplatte:
                ordner_name=file.split("_")[1]
                try:
                    if not (pfad_externefestplatte/ordner_name).exists():
                        (pfad_externefestplatte / ordner_name).mkdir(exist_ok=True)
                    shutil.copy(pfad_nas/ordner_name/file,pfad_externefestplatte/ordner_name)
                    print(file,"wurde auf die Externefestplatte kopiert")
                except FileNotFoundError:
                    print("Einer der angegebenden Pfade scheint nicht zu existieren",PFAD_ZUR_EXTERNEN_FESTPLATTE,PFAD_ZUR_NAS,"dadurch kann der Abgleich zwischen Ihnen nicht statt finden")
        if len(daten_von_externefestplatte_auf_nas)>0:
            for file in daten_von_externefestplatte_auf_nas:
                ordner_name=file.split("_")[1]
                try:
                    if not (pfad_nas/ordner_name).exists():
                        (pfad_nas/ordner_name).mkdir(exist_ok=True)
                    shutil.copy(pfad_externefestplatte/ordner_name/file,pfad_nas/ordner_name)
                    print(file,"wurde auf die Nas kopiert")
                except FileNotFoundError:
                    print("Einer der angegebenden Pfade scheint nicht zu existieren",PFAD_ZUR_EXTERNEN_FESTPLATTE,PFAD_ZUR_NAS,"dadurch kann der Abgleich zwischen Ihnen nicht statt finden")
    else:informationsfenster("Der Datenbestand ist auf beiden Medien gleich!")







    """Hier werden nur die Ordner aufgelistet die auch eine Datei beinhalten"""
def differenz_jahre_zwischen_beiden_medien_pruefen(pfad_nas, pfad_externefestplatte):
    alle_daten_nas = {}
    alle_daten_externefestplatte = {}

    """Hier werden nur die Ordner aufgelistet die auch eine Datei beinhalten"""

    try:
        for ordner in (pfad_nas).iterdir ():
            for file in (pfad_nas / ordner).iterdir ():
                ordner_name = file.parts [3]
                datei_name = file.parts [4]
                alle_daten_nas [ordner_name] = datei_name
    except FileNotFoundError:
        print("Der angegebende Pfad existiert nicht",pfad_nas)
    try:
        for ordner in (pfad_externefestplatte).iterdir ():
            for file in (pfad_externefestplatte / ordner).iterdir ():
                ordner_name = file.parts [3]
                datei_name = file.parts [4]
                alle_daten_externefestplatte [ordner_name] = datei_name
    except FileNotFoundError:
        print("Der angegebende Pfad existiert nicht",pfad_externefestplatte)

    if alle_daten_nas != alle_daten_externefestplatte:
        print("nicht gleich")
        # if len(alle_daten_nas)>len(alle_daten_externefestplatte):
        for jahr_ordner in alle_daten_nas.keys ():
            try:
                if not (pfad_externefestplatte / jahr_ordner / ".fertig.wrt").exists ():
                    (pfad_externefestplatte / jahr_ordner).mkdir (exist_ok = True)
                shutil.copy (pfad_nas / jahr_ordner / ".fertig.wrt", pfad_externefestplatte / jahr_ordner)
            except FileNotFoundError:
                print ("Einer der angegebenden Pfade scheint nicht zu existieren", PFAD_ZUR_EXTERNEN_FESTPLATTE,
                       PFAD_ZUR_NAS, "dadurch kann der Abgleich zwischen Ihnen nicht statt finden")
        # if len(alle_daten_externefestplatte) > len(alle_daten_nas):
        for jahr_ordner in alle_daten_externefestplatte.keys ():
            try:
                if not (pfad_nas / jahr_ordner / ".fertig.wrt").exists ():
                    (pfad_nas / jahr_ordner).mkdir (exist_ok = True)
                shutil.copy (pfad_externefestplatte / jahr_ordner / ".fertig.wrt", pfad_nas / jahr_ordner)
            except FileNotFoundError:
                print ("Einer der angegebenden Pfade scheint nicht zu existieren", PFAD_ZUR_EXTERNEN_FESTPLATTE,
                       PFAD_ZUR_NAS, "dadurch kann der Abgleich zwischen Ihnen nicht statt finden")
    else:
        print ("sind gleich!")




def main():
    prueft_ob_ober_Ordner_struktur_vorhanden_ist(PFAD_ZUR_NAS,PFAD_ZUR_FERTIGDATEN)
    prueft_ob_ober_Ordner_struktur_vorhanden_ist(PFAD_ZUR_EXTERNEN_FESTPLATTE, PFAD_ZUR_FERTIGDATEN)
    fehlende_fertigdaten_auf_nas =prueft_ob_daten_aus_fertigdaten_vorhanden_sind_in_Medium(PFAD_ZUR_NAS,PFAD_ZUR_FERTIGDATEN)
    fehlende_fertigdaten_auf_externefestplatte=prueft_ob_daten_aus_fertigdaten_vorhanden_sind_in_Medium(PFAD_ZUR_EXTERNEN_FESTPLATTE,PFAD_ZUR_FERTIGDATEN)
    fehlende_monats_daten_in_medium_kopieren(fehlende_fertigdaten_auf_nas,PFAD_ZUR_NAS,PFAD_ZUR_FERTIGDATEN)
    fehlende_monats_daten_in_medium_kopieren(fehlende_fertigdaten_auf_externefestplatte, PFAD_ZUR_EXTERNEN_FESTPLATTE, PFAD_ZUR_FERTIGDATEN)
    fehlende_jahres_daten_in_medium_kopieren(PFAD_ZUR_NAS,PFAD_ZUR_FERTIGDATEN)
    differenz_monate_zwischen_beiden_medien_pruefen(PFAD_ZUR_NAS / "Monate", PFAD_ZUR_EXTERNEN_FESTPLATTE / "Monate")#Für Monate
    differenz_jahre_zwischen_beiden_medien_pruefen(PFAD_ZUR_NAS/"Jahre",PFAD_ZUR_EXTERNEN_FESTPLATTE/"Jahre")#Für Jahre


if __name__=="__main__":
    main()


Hauptfehlerquelle ist bei das die Pfade nicht vorhanden sein können Ich habe deswegen die Test Pfade oben -> und habe einen der richtigen pfade gegen Testpfade ersetzt und dann immer wieder das skript durchlaufen lassen und an den Stellen wo es zu einem Fehler gekommen wäre ein try/except eingefügt.?


Ich danke euch .
Eine Vision ohne Aktion bleibe eine Illusion
Sirius3
User
Beiträge: 18274
Registriert: Sonntag 21. Oktober 2012, 17:20

Deine Leerzeichensetzung entspricht nicht der Konvention, das erschwert das Lesen des Codes ungemein. Vor der öffnenden Klammer eines Funktionsaufrufs kommt kein Leerzeichen, dagegen um Operationen wie / oder = immer. Etliche Klammernpaare sind zu viel.

Es ist eine seltsame Ordnung, dass Dateien erst nach Monat und dann nach Jahr einsortiert werden. Hat das irgendeinen tieferen Sinn?

`prueft_ob_daten_aus_fertigdaten_vorhanden_sind_in_Medium` liefert im Fehlerfall None zurück, das führt an einer ganz anderen Stelle zu einem Folgefehler, den Du dann nochmals behandeln mußt. Deine Fehlerbehandlung ist daher falsch, weil Du den selben Fehler zweimal behandelst, anstatt die Fehlerbehandlung dort zu machen, wo Du es nur einmal machen müßtest.

Code: Alles auswählen

def prueft_ob_daten_aus_fertigdaten_vorhanden_sind_in_Medium(pfad_medium, pfad_fertigdaten):
    fehlende_fertigdaten_auf_Medium = []
    for file in pfad_fertigdaten.iterdir():
        if file.name not in ("Fertigdaten.wrt", "Fertigdaten_konsistenz.wrt", ".fertig.wrt"):
            if not (pfad_medium / file.name).exists():
                fehlende_fertigdaten_auf_Medium.append(file.name)
    return fehlende_fertigdaten_auf_Medium


def fehlende_monats_daten_in_medium_kopieren(fehlende_daten, pfad_medium, pfad_fertigdaten):
    try:
        for filename in fehlende_daten:
            datei_monat_jahr_ordner = filename.split("_")[1]
            # In dem Ordner Monate werden die Datein nochmal in Jahre unterteilt
            # hier wird in diesem Ordner das Jahr zugeteilt
            shutil.copy (pfad_fertigdaten / file, pfad_Medium / "Monate" / datei_monat_jahr_ordner)
    except FileNotFoundError:
        print("Der angegebende Pfad kann nicht gefunden werden", pfad_medium)


def main():
    try:
        fehlende_fertigdaten_auf_nas = prueft_ob_daten_aus_fertigdaten_vorhanden_sind_in_Medium(PFAD_ZUR_NAS,PFAD_ZUR_FERTIGDATEN)
    except FileNotFoundError:
        print("Der Pfad zu den Fertigdaten kann nicht gefunden werden", PFAD_ZUR_FERTIGDATEN)
    else:
        fehlende_monats_daten_in_medium_kopieren(fehlende_fertigdaten_auf_nas, PFAD_ZUR_NAS, PFAD_ZUR_FERTIGDATEN)
Dass das Jahr über das Änderungsdatum einer Datei ermittelt wird, ist nicht gerade sehr robust. Gibt es da nichts besseres? Warum benutzt Du schon wieder was aus os, obwohl Du doch eigentlich Pathlib benutzt?

In `differenz_monate_zwischen_beiden_medien_pruefen` definierst Du leere Listen weit vor der Zeile, wo sie wirklich gebraucht werden. Das macht den Code unübersichtlich. Die Funktion ist auch wieder zu lang, weil zu viel doppelt kopierter Code vorkommt. Wenn einer der Ziele gar nicht vorhanden ist, denkt das Programm, dass es alle Dateien kopieren muß und liefert dann entsprechend lange Listen von Dateinamen und es wiederholt sich sinnlos die selbe Meldungen, dass etwas nicht kopiert werden kann.

In `differenz_jahre_zwischen_beiden_medien_pruefen` benutzt Du absolute Indizes, die zu schwer auffindbaren Fehlern führen, falls sich mal was am Zielort ändert.
Bl3nder
User
Beiträge: 139
Registriert: Freitag 3. Januar 2020, 17:07

Deine Leerzeichensetzung entspricht nicht der Konvention, das erschwert das Lesen des Codes ungemein. Vor der öffnenden Klammer eines Funktionsaufrufs kommt kein Leerzeichen, dagegen um Operationen wie / oder = immer. Etliche Klammernpaare sind zu viel. -> Versuch Ich mich nächstes mal dran zu halten war mir nicht bekannt.

gemeinte wäre also :

def zur_veranschaulichung(test):
test += 1
zur_veranschaulichung(test)


Es ist eine seltsame Ordnung, dass Dateien erst nach Monat und dann nach Jahr einsortiert werden. Hat das irgendeinen tieferen Sinn?

Das ist vorgegeben durch meine Software die auf dem Rechner läuft :Es werden über das Jahr Dateien erzeugt 2020_01 ..... und aus den wird einmal im Jahr eine Datei erzeugt die einfach nur .fertig.wrt heißt daher auch das Problem wieso Ich die Methode mit dem "erstellungs/bearbeitung" Datum genommen habe wie gesagt -> Ich kann die Datei auch nicht einfach umbennen da ICh nicht weiß was das für Folgen in dem anderen Programm hätte.



In `differenz_monate_zwischen_beiden_medien_pruefen` definierst Du leere Listen weit vor der Zeile, wo sie wirklich gebraucht werden. Das macht den Code unübersichtlich. Die Funktion ist auch wieder zu lang, weil zu viel doppelt kopierter Code vorkommt. Wenn einer der Ziele gar nicht vorhanden ist, denkt das Programm, dass es alle Dateien kopieren muß und liefert dann entsprechend lange Listen von Dateinamen und es wiederholt sich sinnlos die selbe Meldungen, dass etwas nicht kopiert werden kann.

Hab Ich mir fast gedacht das das angemerkt wird dazu habe Ich eine allgemeine Frage:

Ich könnte wie du schon richtig festgestellt hast den Code halbieren ( Ich könnte die Funktion von aussen zweimal aufrufen mit jeweils unterschiedlichen Parametern [Pfaden] welchen unterschied macht den das genau ( ist es nur für andere Leute dann leichter den Code zu lesen)? Weil am Ende bleibt es sich doch gleich oder nicht ?

Um dein Beispiel abschließend zu verstehen sieht meine main funktion dann in etwa so aus [ es geht dort nur um ja oder nein bitte damit ich es versteh ]

Code: Alles auswählen

    try:fehlende_fertigdaten_auf_nas =prueft_ob_daten_aus_fertigdaten_vorhanden_sind_in_Medium(PFAD_ZUR_NAS,PFAD_ZUR_FERTIGDATEN)
    except FileNotFoundError:
        print("ok")
    else:
        fehlende_monats_daten_in_medium_kopieren (fehlende_fertigdaten_auf_nas, PFAD_ZUR_NAS, PFAD_ZUR_FERTIGDATEN)
        
    try:
        fehlende_fertigdaten_auf_externefestplatte=prueft_ob_daten_aus_fertigdaten_vorhanden_sind_in_Medium(PFAD_ZUR_EXTERNEN_FESTPLATTE,PFAD_ZUR_FERTIGDATEN)
    except FileNotFoundError:
        print("ok")
    else:
        fehlende_monats_daten_in_medium_kopieren (fehlende_fertigdaten_auf_externefestplatte,PFAD_ZUR_EXTERNEN_FESTPLATTE, PFAD_ZUR_FERTIGDATEN)

Warum benutzt Du schon wieder was aus os, obwohl Du doch eigentlich Pathlib benutzt?

Das hatten wir ja beim letzten mal ist es auch verboten sich Sachen aus unterschiedlichen Bibliotheken zu benutzen ( Konvention) dann wusste Ich das auch nicht wie gesagt Ich benutze das als erstes was Ich kenne ... Wenn Ich nach einem Problem google kommt auch als Lösungsvorschlag os.path.getmtime(path) wieso sollte Ich das dann nicht benutzen



In `differenz_jahre_zwischen_beiden_medien_pruefen` benutzt Du absolute Indizes, die zu schwer auffindbaren Fehlern führen, falls sich mal was am Zielort ändert.

Ja wie gesagt absolute Indizes sind doch leichter zu verwenden oder nicht sollte Ich die Ordner sonst alle suchen lassen ? glob ....



Zurück zum allgemeinen meiner Frage den da ging es ja ob die richtige benutzung von try/except:
Ich bekomme langsam das Gefühl das es dafür keine Konvention gibt ( du benutztes zum Teil in der main als auch in der funktion -> Ich sehe schon so das so wie du es benutzt hast das natürlich seinen Sinn macht nur verstehe Ich dadurch nun wieder null kannst du mir einfach nur klar zu sagen wo Ich es benutzen soll main oder funktion alles ander verwirrt mich leider nur.Ich brauche für mich ein Leitfaden den Ich dann Schritt für Schritt ab arbeiten kann:

Ich habe auch noch ein Verständnis Problem:

In meinem Buch steht als Beispiel um zu erklären wie Try / except arbeitet:

Hier wird in der Funktion geprüft warum machen die das dann wieder hier so wenn I

Code: Alles auswählen

def get (name):
    try:
        return open(name)
    except FileNotFoundError:
        return 

Hier wird in der Funktion geprüft warum machen die das dann wieder hier so wenn folgendes auch machen könnte:

Code: Alles auswählen

def main():
    try:
        get(name = "Ausgedachter Pfad")
    except FileNotFoundError:
        return None
... Ich bekomme es nicht in meinem Kopf



In einer anderen Gruppe wurde mir dann zu dem Thema gesagt:
try ist zum abfangen bestimmter Fehler und man sollte es nur an bestimmten Stellen benutzen / Hier im Forum hat blackjack dazu mal geschrieben man sollte so wenig Code wie möglich in den try block schreiben -> In meinem Fall will Ich halt das die ganze Funktion abgebrochen wird daher habe Ich sie so benutzt wie ICh es nun mal gemacht habe .. Meine Frage an dieser Stelle habe ich es wirklich wieder so falsch benutzt ?!

Ich meine was ist an

Code: Alles auswählen

    try:
        for file in pfad_fertigdaten.iterdir ():
            if not (pfad_medium / file.name).exists ():
                if file.name not in ("Fertigdaten.wrt", "Fertigdaten_konsistenz.wrt", ".fertig.wrt"):
                    fehlende_fertigdaten_auf_Medium.append (file.name)
        return fehlende_fertigdaten_auf_Medium
    except FileNotFoundError:
        print("Der Pfad zu den Fertigdaten kann nicht gefunden werden",pfad_fertigdaten)
so schlimm und falsch -> es gibt doch extra FileNotFoundError wieso sollte Ich das dann nicht einfach benutzen oder wieso sollte man es überhaupt benutzen -> Ich könnte vorher auch einfach prüfen ob die Pfade existieren oder nicht und jeweils den Code ausführen -> sollte Ich Try/except nur dann verwenden wenn Ich eine Lösung für ein Problem habe ?!

Ich könnte ja sonst in dem o.g Fall auch einfach sagen:

Code: Alles auswählen

from pathlib import Path
def get (name):
    
    if not Path(name).exists():
        print("Der Pfad",name,"existiert nicht!")

def main():
    try:
        get(name = "Ausgedachter Pfad")
    except FileNotFoundError:
        return None



Ich danke dir trotzdem jedes mal für deine Mühe und das du trotz meiner Unfähigkeit und Dummheit mir dennoch hilfst.
Eine Vision ohne Aktion bleibe eine Illusion
Antworten