Prüfen ob Datei vorhanden dann umbenennen

[DirtyBlaze]

Hallo zusammen,

mein Problem besteht aktuell in dem unten aufgeführten Stück Programmcode. Ich möchte prüfen ob es eine PDF-Datei mit demselben Namen bereits in einem anderen Ordner gibt. Wenn dies der Fall ist soll ein Zähler alle Dateien, die denselben Namen in dem Ordner enthalten, zählen. Am Ende soll die PDF-Datei als "Name_Zähler.pdf" oder wenn nicht vorhanden nur mit "Name.pdf" angelegt werden.

Hier habe ich auch schon gute Ansätze gefunden: viewtopic.php?t=17337
Aber ich habe hier wohl einfach einen Denkfehler/Blockade.
Die Fehlermeldung ist entweder: Datei schon vorhanden oder ich bekomme überhaupt keine Fehlermeldung.

Code: Alles auswählen

 
 
 	files = os.listdir(aa) 
        #Jeden Wert in Files prüfen
        for file in files:
            #Nur Name von file betrachten und nicht die Endung
            [Name, Ext] = os.path.splitext(file)
            counter = 0
            #Solange line2 (Quelldateiname) in  Name (Zieldateiname) dann counter +1
            while str(line2) in Name:
                    counter = counter +1
            #Datei aus dem Quellpfad nehmen und in den Zielpfad (aa + line2 +_+counter+ pdf) (Pfad+ Dateianme + _ +Anzahl + Endung)schreiben
            os.rename(a+dat,aa+str(line2)+"_"+str(counter)+".pdf")
            
 	

Alternative:

Code: Alles auswählen

	files = os.listdir(aa) 
        counter = 0
        for file in files:
            [Name, Ext] = os.path.splitext(file)
            
            if Name in line2:
                os.rename(a+dat,aa+str(line2)+"_"+str(counter)+".pdf")
                counter = counter + 1
            else:
                os.rename(a+dat,aa+str(line2)+".pdf")

[Jankie]

Anmerkungen:
benutze statt dem os Modul besser das pathlib Modul
Variablennamen sollten aussagekräftig sein und dem Leser vermitteln, wofür die Varaible steht. Da ist "a" oder "aa" nicht wirklich zielführend.
Variablen werden laut Konvention klein_mit_unterstrich geschrieben.
Statt Strings mit + zusammenzusetzen benutzt man f-Strings.
Die eckigen Klammern um "Name, Ext" gehören da nicht hin.
line2 kommt aus dem nirgendwo.


Ich habe hier mal was zusammengebastelt:

Man kann ein Dateinamen angeben, wenn dieser vorhanden ist, wird der Dateiname mit einem Unterstrich und einer fortlaufenden Zahl zurückgegeben.
Also angenommen du hast die Datei "test.pdf" und gibst nun als Dateinamen "test" an, dann gibt das Programm "test_1.pdf" zurück, inkl. des gesamten Pfades. Das prüft also nur den Namen und gibt dir einen neuen Namen zurück, das mit dem abspeichern müsstest du noch übernehmen.

Code: Alles auswählen

import pathlib

PATH = pathlib.Path(r"C:\Users\xxx\Desktop")
FILE_SUFFIX = ".pdf"


def check_if_filename_exists_and_increment_filename(desired_filename):
    if desired_filename in  [filename.stem for filename in PATH.glob(f"*{FILE_SUFFIX}")]:
        for i in range(1,10000):
            new_filename = f"{desired_filename}_{i}"
            if not pathlib.Path(PATH / new_filename).with_suffix(FILE_SUFFIX).exists():
                return pathlib.Path(PATH / new_filename).with_suffix(FILE_SUFFIX)
    else:
        return pathlib.Path(PATH / desired_filename).with_suffix(FILE_SUFFIX)

def main():
    desired_filename = input("Gib den gewünschten Dateinamen ohne Endung an: ")
    filename = check_if_filename_exists_and_increment_filename(desired_filename)
    print(filename)

if __name__ == "__main__":
    main()

[Sirius3]

@DirtyBlaze: Deine Codes funktionieren überhaupt nicht. Im ersten ist `line2` nicht definiert, und wenn es das wäre, dann wäre die while-Schleife eine Endlosschleife, weil sich line2 innerhalb des Schleifenblocks nicht ändert. Was a und dat ist, wird auch nicht klar.

@Jankie: warum gehst Du alle Dateien durch, wenn Du nur ein bestimmtes suchst?

Code: Alles auswählen

TARGET_PATH = Path('.../ziel')
source_filename = Path('.../irgendwas.pdf')
filenames = list(TARGET_PATH.glob(f"{source_filename.stem}*.pdf"))

Jetzt kannst Du die Liste nach der größten Nummer durchsuchen und läufst nicht in Gefahr, dass die Funktion bei mehr als 10000 Dateien einfach None zurückliefert.

[Jankie]

So in etwa?

Code: Alles auswählen

import pathlib

TARGET_PATH = pathlib.Path(r"C:\Users\xx\Desktop")
FILE_SUFFIX = ".pdf"

def increment_filename_if_file_already_exists(target_filename):
    files_with_similar_name = list(TARGET_PATH.glob(f"{target_filename.stem.rsplit('_')[0]}*{FILE_SUFFIX}"))
    if target_filename in files_with_similar_name:
            filename, increment_number = sorted(files_with_similar_name)[-1].stem.rsplit("_", 1)
            new_filename = f"{filename}_{int(increment_number)+1}"
            if not pathlib.Path(TARGET_PATH / new_filename).with_suffix(FILE_SUFFIX).exists():
                return pathlib.Path(TARGET_PATH / new_filename).with_suffix(FILE_SUFFIX)
    else:
        return pathlib.Path(TARGET_PATH / target_filename).with_suffix(FILE_SUFFIX)

def main():
    target_filename = pathlib.Path(TARGET_PATH / input("Gib den gewünschten Dateinamen ohne Endung an: ")).with_suffix(FILE_SUFFIX)
    new_filename = increment_filename_if_file_already_exists(target_filename)
    print(new_filename)

if __name__ == "__main__":
    main()

[Sirius3]

Jetzt hast Du noch das Problem, dass bei Deiner Sortierung die Datei bild_9.pdf größer ist als bild_73.pdf

[Jankie]

Ich hoffe jetzt hab ich an alles gedacht und habe das so richtig gemacht, in dem ich ein key bei Zeile 9 in sorted() mit übergebe.

Code: Alles auswählen

import pathlib

TARGET_PATH = pathlib.Path(r"C:\Users\xxx\Desktop")
FILE_SUFFIX = ".pdf"

def increment_filename_if_file_already_exists(target_filename):
    files_with_similar_name = list(TARGET_PATH.glob(f"{target_filename.stem.rsplit('_')[0]}*{FILE_SUFFIX}"))
    if target_filename in files_with_similar_name:
            filename, increment_number = sorted(files_with_similar_name, key = lambda x: int(x.rsplit("_", 1)[1]))[-1].stem.rsplit("_", 1)
            new_filename = f"{filename}_{int(increment_number)+1}"
            if not pathlib.Path(TARGET_PATH / new_filename).with_suffix(FILE_SUFFIX).exists():
                return pathlib.Path(TARGET_PATH / new_filename).with_suffix(FILE_SUFFIX)
    else:
        return pathlib.Path(TARGET_PATH / target_filename).with_suffix(FILE_SUFFIX)

def main():
    target_filename = pathlib.Path(TARGET_PATH / input("Gib den gewünschten Dateinamen ohne Endung an: ")).with_suffix(FILE_SUFFIX)
    new_filename = increment_filename_if_file_already_exists(target_filename)
    print(new_filename)

if __name__ == "__main__":
    main()

[Sirius3]

@Jankie: eingerückt wird immer mit 4 Leerzeichen pro Ebene, nicht mal 4 und mal 8. Die exists-Abfrage ist überflüssig, da du ja den Dateinamen so konstruiert hast, dass er nicht existiert. Würde er existieren würde die Funktion None zurückliefern, was ein Programmierfehler ist.
sorted aufzurufen, nur um die größte Zahl zu erhalten, ist unnötig kompliziert.
Was passiert, wenn da keine Zahl im Namen ist?

[Jankie]

Die größte Zahl ohne sorted zu bekommen fällt mir schwer, hast du an sowas gedacht?

Code: Alles auswählen

import pathlib

TARGET_PATH = pathlib.Path(r"C:\Users\xxx\Desktop")
FILE_SUFFIX = ".pdf"

def increment_filename_if_file_already_exists(target_filename):
    files_with_similar_name = list(TARGET_PATH.glob(f"{target_filename.stem.rsplit('_')[0]}*{FILE_SUFFIX}"))
    if target_filename in files_with_similar_name:
        increment_number = max([int(filename.stem.rsplit("_", 1)[-1]) for filename in files_with_similar_name if filename.stem.rsplit("_", 1)[-1].isdigit()])
        new_filename = f"{target_filename.stem}_{int(increment_number)+1}"
        return pathlib.Path(TARGET_PATH / new_filename).with_suffix(FILE_SUFFIX)
    else:
        return pathlib.Path(TARGET_PATH / target_filename).with_suffix(FILE_SUFFIX)

def main():
    target_filename = pathlib.Path(TARGET_PATH / input("Gib den gewünschten Dateinamen ohne Endung an: ")).with_suffix(FILE_SUFFIX)
    new_filename = increment_filename_if_file_already_exists(target_filename)
    print(new_filename)

if __name__ == "__main__":
    main()

[Sirius3]

Der Fall, dass keine Datei mit Zahl abliegt ist noch nicht berücksichtigt.
Du hast viel doppelten Code.

Code: Alles auswählen

import pathlib

TARGET_PATH = pathlib.Path(r"C:\Users\xxx\Desktop")
FILE_SUFFIX = ".pdf"

def increment_filename_if_file_already_exists(target_filename):
    files_with_similar_name = list(TARGET_PATH.glob(f"{target_filename.stem.rsplit('_')[0]}*{FILE_SUFFIX}"))
    if target_filename in files_with_similar_name:
        suffixes = (filename.stem.rsplit("_", 1)[-1] for filename in files_with_similar_name)
        try:
            increment_number = max(int(s) for s in suffixes if s.isdigit())
        except ValueError:
            increment_number = 0
        new_filename = f"{target_filename.stem}_{increment_number+1}"
    else:
        new_filename = target_filename
    return pathlib.Path(TARGET_PATH / new_filename).with_suffix(FILE_SUFFIX)

def main():
    filename_stem = input("Gib den gewünschten Dateinamen ohne Endung an: ")
    target_filename = pathlib.Path(TARGET_PATH / filename_stem).with_suffix(FILE_SUFFIX)
    new_filename = increment_filename_if_file_already_exists(target_filename)
    print(new_filename)

if __name__ == "__main__":
    main()

[snafu]

Ich hätte folgenden Ansatz:

Code: Alles auswählen

def get_new_filename(name):
    path = pathlib.Path(name)
    if not path.exists():
        return path
    pattern = f"{path.stem}_[0-9]*{path.suffix}"
    next_number = 1
    for candidate in path.parent.glob(pattern):
        name, number = candidate.stem.rsplit("_", 1)
        if name == path.stem and number.isdigit():
            next_number = max(int(number), next_number) + 1
    return path.parent / f"{path.stem}_{next_number}{path.suffix}"

Die Dateiendung wird hierbei direkt mit dem Namen übergeben. Kommt auch damit klar, wenn ähnliche Namen existieren, z.B. "spam.txt" und "spammer.txt".

List Comprehensions waren mir hierfür zu kompliziert, daher die Lösung über den wiederholten Aufruf der max()-Funktion. Alternativ kann man natürlich auch eine Liste mit den Zahlen bauen und diese an max() übergeben.

[snafu]

Das Ermitteln der nächsten Zahl war nicht robust, da es nur zufällig so klappte, wenn man sich auf die Reihenfolge der bisherigen Dateinamen verlassen konnte. Hier nochmal überarbeitet:

Code: Alles auswählen

import pathlib

def get_new_filename(name):
    path = pathlib.Path(name)
    if not path.exists():
        return path
    pattern = f"{path.stem}_[0-9]*{path.suffix}"
    highest_number = 0
    for candidate in path.parent.glob(pattern):
        name, number = candidate.stem.rsplit("_", 1)
        if name == path.stem and number.isdigit():
            highest_number = max(int(number), highest_number)
    filename = f"{path.stem}_{highest_number + 1}{path.suffix}"
    return path.parent / filename

def main():
    for name in ("spam.txt", "spammer.txt"):
        for _ in range(3):
            path = get_new_filename(name)
            print(path)
            path.touch()
    for path in pathlib.Path().glob("spam*.txt"):
        path.unlink()

if __name__ == "__main__":
    main()

ACHTUNG: Es werden beim Ausführen von main() kurzzeitig Dateinamen angelegt und anschließend wieder gelöscht. Am besten nur in einem Test-Verzeichnis ausführen. Die Funktion get_new_filename() selbst legt jedoch nichts im Dateisystem an, sondern ermittelt nur einen "freien" Dateinamen.

[Jankie]

Hallo zusammen,

ich hatte noch zwei Ideen. Die würden im Gegensatz zu den ersten Varianten aber dann auch die fehlenden Zwischenräume füllen, also wenn "test.pdf" eingegeben wird und "test.pdf", "test_1.pdf", "test_3.pdf" existieren, würde "test_2.pdf" zurückgegeben werden:

Die erste Idee war mit einer while Schleife zu testen, ob die angegebene Datei existiert, wenn ja, soll um 1 erhöht werden.

Code: Alles auswählen

import pathlib

TARGET_PATH = pathlib.Path(r"C:\Users\xxx\Desktop\TEST")
FILE_SUFFIX = ".pdf"

def increment_filename_if_file_already_exists(target_filename):
    counter = 1
    while target_filename.exists():
        new_filename = pathlib.Path(TARGET_PATH /f"{target_filename.stem.rsplit('_',1)[0]}_{counter}").with_suffix(FILE_SUFFIX)
        counter += 1
    return new_filename

def main():
    filename_stem = input("Gib den gewünschten Dateinamen ohne Endung an: ")
    target_filename = pathlib.Path(TARGET_PATH / filename_stem).with_suffix(FILE_SUFFIX)
    new_filename = increment_filename_if_file_already_exists(target_filename)
    print(new_filename)

if __name__ == "__main__":
    main()

Die Idee funktioniert soweit ich das beurteilen kann.

Die zweite Idee war ein rekursiver Aufruf, da mache ich aber anscheinend irgendetwas falsch oder ich habe das ganze Thema mit der Rekursion noch nicht wirklich verstanden.

Code: Alles auswählen

def increment_filename_if_file_already_exists(target_filename, counter = 0):
    if target_filename.exists():
        new_filename = pathlib.Path(TARGET_PATH /f"{target_filename.stem.rsplit('_',1)[0]}_{counter+1}").with_suffix(FILE_SUFFIX)
        increment_filename_if_file_already_exists(new_filename, counter + 1)
    else:
        return target_filename

Wenn ich vor dem "return target_filename" ein "print(target_filename)" hinschreibe, zeigt er mir den Pfad komplett an. Wenn ich den Wert allerdings per return zurückgebe, zeigt er mir in der main() bei "print(new_filename)" nur None an. Habe das Programm mal Schrittweise debuggt und da ist mir aufgefallen, dass nach dem return sich die Funktion nochmal mehrmals selbst aufruft. Warum ist das so? Wo ist mein Denkfehler? Wie würde man sowas rekursiv lösen?


#edit:

Habe den Fehler glaube ich gelöst bekommen.

Code: Alles auswählen

def increment_filename_if_file_already_exists(target_filename, counter = 0):
    if target_filename.exists():
        new_filename = pathlib.Path(TARGET_PATH /f"{target_filename.stem.rsplit('_',1)[0]}_{counter+1}").with_suffix(FILE_SUFFIX)
        return increment_filename_if_file_already_exists(new_filename, counter + 1)
    else:
        return target_filename

[snafu]

Grundsätzlich möglich, allerdings sollte man möglichst sparsam mit Operationen auf dem Dateisystem sein, da diese zu einem Performance-Killer werden können. Insofern würde ich den Weg über glob() mit einschränkendem Pattern und Verarbeitung innerhalb der Programmlogik bevorzugen. Funktionieren tut aber beides und der exist()-Ansatz erfordert natürlich weniger Hirnschmalz, wodurch auch die Gefahr von Fehlern bei der Implementierung verringert wird.

[DirtyBlaze]

Vielen Dank für die ganze Hilfestellungen.
Ich möchte meine gesammelten PDF-Rechnungen in meine Kundennummer umbenennen um diese nachher weiter in verschiedene Ordner wie zum Beispiel "Rechnung Telekom, Strom etc." zu sortieren.
Mein Code funktioniert sofern jede Kundennummer maximal 2 Mal vorkommt. Sobald eine Kundennummer mehr als zwei mal vorkommt, wird immer das zweite Dokument(_1) verwendet und in _2,_3 etc umbenannt und in den Ziel-Ordner kopiert.
PS: Bin kein Programmierer und nehme jede Kritik und Verbesserungsvorschläge gerne an.(Sofern ich diese auch nach dem Doku lesen verstanden habe)

Code: Alles auswählen

import re
import os
import shutil
import pathlib


# Dateien aus einem Ordner in ein Array einlesen
SOURCE_PATH = "C:\\Users\\Test\\Desktop\\Sortieren\\"
TARGET_PATH = "C:\\Users\\Test\\Desktop\\Sortiert\\"
SOURCE_PATH_LIST = os.listdir(SOURCE_PATH)


for dat in SOURCE_PATH_LIST:
    with pdfplumber.open(SOURCE_PATH + dat) as pdf2:
        # pages gibt die Seite an die gelesen werden soll 0 = 1
        page = pdf2.pages[0]
        text = page.extract_text()
        pdf2.close()
        # print(text)

        Reg_KundenNr = re.compile(r"(Kundennummer)")
        Reg_KundenNr1 = re.compile(r"\d{8}")

#Sucht in jeder Zeile der PDF nach dem String "KundenNr1" und danach wir die "Zahl" in eine Variable geschrieben
        for line in text.split('\n'):
            if Reg_KundenNr.findall(line):
                FILENAME_PDF = Reg_KundenNr1.findall(line)
            
#In diesem Abschnitt wird geprüft ob des eine Datei mit dem Namen "FILENAME_PDF" im Zielpfad schon gibt. Wenn es die Datei noch nicht #gibt, wird diese erstellt. Wenn es die Datei schon gibt, wird ein Zähler hochgezählt und die Datei "FILENAME_PDF"+'_'+Zähler  im Ziel-Ordner #erstellt.
        if FILENAME_PDF[0] is not 0:
            TARGET_PATH_LIST = os.listdir(TARGET_PATH)
            if os.path.exists(TARGET_PATH + FILENAME_PDF[0] + ".pdf"):
                counter = 0

                for TARGET_PATH_LIST_LIST in TARGET_PATH_LIST:
                    if FILENAME_PDF[0] in TARGET_PATH_LIST_LIST:
                        counter = counter + 1
                    if counter > 0:
                        print("Mit Zähler" + SOURCE_PATH + dat + "Wird zu" + FILENAME_PDF[0] +"_"+ str(counter))
                        shutil.copyfile(SOURCE_PATH + dat, TARGET_PATH + FILENAME_PDF[0] + "_" + str(counter) + ".pdf")

            else:
                print(SOURCE_PATH + dat)
                shutil.copyfile(SOURCE_PATH + dat, TARGET_PATH + FILENAME_PDF[0] + ".pdf")

[Sirius3]

Nur Konstanten schreibt man komplett gross, und das bis auf SOURCE_PATH und TARGET_PATH gibt es keine Konstanten.
Alle Variablen schreibt man dagegen komplett klein.
Benutze keine kryptischen Abkürzungen. `dat` verbindet man mit data, aber auf keinen Fall mit Dateiname, da der Rest der Variablen auch englisch benannt sind.
Der with-Block sorgt schon dafür, dass pdf2 ordentlich wieder geschlossen wird, das close ist also überflüssig, wenn der with-Block auch nur die wirklich relevanten Zeilen umfasst. Um einen fixen String in einer Zeile zu suchen, sind reguläre Ausdrücke nicht gemacht, ein findall um überhaupt die Existenz zu prüfen, ist auch verwirrend, benutze einfach `in`.
FILENAME_PDF ist nicht nur falsch geschrieben, weil es keine Konstante ist, sondern auch, weil es gar kein Dateiname ist, und erst recht keine PDF-Datei. Es ist eine Liste mit Strings zu je 8 Ziffern. Und acht Ziffern können niemals identisch 0 sein. is ist hier auch der falsche Vergleich, Gleichheit prüft man mit ==, Ungleichheit mit !=.

Pfade stückelt man nicht mit + zusammen, sondern benutzt pathlib.Path, wie die ganzen Beiträge hier im Thread auch vormachen. Dazu brauch ich ja nichts mehr schreiben, lies das doch mal durch, wende es an und wenn Du Fragen hast, stelle konkrete Fragen.

[Nufnus]

Pfade stückelt man nicht mit + zusammen, sondern benutzt pathlib.Path

Würde mich gerne kurz mit einer Zwischenfrage dazu schummeln.
Spricht was dagegen stattdessen os.path zu benutzen? Habe ich bisher.
Ist Pathlib vielleicht mächtiger oder ist os.path eigentlich Python 2? Oder ist es einfach egal?

[__blackjack__]

@Nufnus: Wenn es nicht besser als `os.path` wäre, hätten die Python-Entwickler das Modul nicht in die Standardbibliothek aufgenommen.

[Nufnus]

Okay danke, dann ist es also bestimmt mächtiger, wenn es nachträglich aufgenommen wurde.
Weil zur Standardbibliothek gehört os.path doch eigentlich auch.

[__blackjack__]

@Nufnus: Mächtiger nicht, das benutzt ja auch nur `os.path` & Co aber halt eine ordentliche, durchdachte API statt einfach nur die C-Funktionen in Python bereitgestellt. `os.path` war/ist halt so ziemlich das einfachste was man machen kann/konnte um schnell die Funktionalität zur Verfügung zu stellen die es in C in der C-Standardbibliothek oder im POSIX-Standard gibt.

[Nufnus]

Alles klar, danke! Jetzt verstehe ich den Unterschied