Verzeichnis/Dateiliste als tex-Datei ausgeben

Du hast eine Idee für ein Projekt?
Benutzeravatar
BlackJack
Moderator
Beiträge: 32710
Registriert: Dienstag 25. Januar 2005, 23:29
Wohnort: Berlin
Kontaktdaten:

Re: Verzeichnis/Dateiliste als tex-Datei ausgeben

Beitragvon BlackJack » Freitag 7. Juli 2017, 09:58

@Melewo: Ein paar Anmerkungen zu Deinem Programm (ist etwas lang geworden — nicht erschrecken :-)).

Das Modul lässt sich nicht importieren ohne dass das Programm los läuft und `instanz` ist eine globale Variable. Ersteres verhindert das man das Modul in einer Python-Shell importieren und einzelne Funktionen oder Klassen testen oder in anderen Modulen verwenden kann. Auch Werkzeuge die Informationen per ”introspection” aus dem Modul ziehen, wie Sphinx, das Dokumentationswerkzeug welches viele Python-Projekte verwenden und mit dem auch die Python-Dokumentation erstellt wird, funktionieren nur wenn man Module importieren kann. Ebenso Testwerkzeuge für Unit- und Doctests.

`instanz` ist kein guter Name, denn der ist so generisch das er für wirklich *jeden* Wert in Python geeignet ist. Mich persönlich stört auch, dass es eine falsche Übersetzung für „instance“ ist. Oder wäre, wenn man sich nicht der ”Dummheit” der Masse beugt. :-)

Die Aufteilung des Codes in `Dateisuche` würde ich als falsch ansehen. Ein Objekt sollte nach Ablauf der `__init__()` in einem benutzbaren Zustand sein. Bei `Dateisuche` *muss* man zwingend die `layout()`-Methode aufrufen, wenn man das aber immer zwingend machen muss, dann stellt sich die Frage warum man den Benutzer der Klasse dazu zwingt. Ein guter Grund für eine Zweiteilung ist das die `__init__()` zum Aufrufer zurückkehren sollte, damit der gegebenfalls noch etwas mit dem Objekt machen kann, wenn er möchte. Also in diesem Fall bevor die GUI-Hauptschleife läuft. Aber nach der `__init__()` der Klasse die das Hauptfenster stellt, sollte das Hauptfenster auch komplett sein, soweit es diese Klasse angeht. Das heisst so ziemlich alles aus der `layout()`-Methode sollte im Zuge von `__init__()` passieren. Da die `layout()`-Methode dann nur noch den Aufruf der GUI-Hauptschleife enthält, wäre dafür der Name `mainloop()` passender. Und man könnte sich diese Methode ganz sparen wenn man die Klasse die das Hauptfenster repräsentiert von `Tk` erben lässt, was ja allgemein das Hauptfenster ist und diese Methode bereits besitzt.

Das die `StrinVar`-Objekte mit dem Wert '1' initialisiert werden damit *keine* Auswahl bei den Radiobuttons angezeigt wird ist irreführend, denn wenn der Benutzer *nichts* auswählt, dann werden ja die Werte 'alphabetisch' und 'py' verwendet. Warum wird das dem Benutzer nicht angezeigt? Wenn in der GUI kein Radiobutton ausgewählt ist, dann würde ich als Benutzer ”unsortiert” und Dateien mit beliebiger Endung erwarten.

Hinter `set_auswahl` würde man eine „setter“-Methode erwarten, aber kein `StringVar`-Objekt. Zudem ist das eine Mischung aus Englisch und Deutsch innerhalb eines Namens. `vondate` und `bisdate` ebenfalls, und ohne Trennung zwischen den beiden Namen. Insgesamt sollte man bei *einer* Sprache bleiben um Verwirrungen zu vermeiden. `auswahl` ist auch zu generisch weil der Name nicht verrät *was* da ausgewählt wird — das Sortierkriterium.

`durchlaufe` klingt auch eher nach einer Tätigkeit und kaum jemand würde den Startpfad für die Suche hinter dem Namen vermuten.

`frame_li` und `frame_re` enthalten Abkürzungen und das für ”Ortsangaben” in der GUI die so nicht unbedingt sein müssen. Man könnte sich später auch entscheiden die anders darzustellen, zum Beispiel über- statt nebeneinander, dann stimmen die Namen nicht mehr. Man könnte beide auch einfach nur `frame` nennen, wenn man sie nicht ”auf Vorrat” am Anfang definieren würde, sondern erst wenn man sie benötigt. Oder man verwendet Namen die den Inhalt beschreiben wie `result_frame` und `controls_frame` oder etwas in der Art.

Bei `scrollbr` fehlt ein 'a' — und jetzt sag bitte nicht das das kein Versehen war, sondern das Du diesen einen Konsonanten absichtlich weggelassen hast. ;-)

`drei_buttons` und `sechs_buttons`? Da werden keine `Button`\s dran gebunden und die `drei_*` stimmt noch nicht einmal, denn das Wörterbuch hat vier Einträge. Ausser in der allerneuesten Python 3-Version ist ein Wörterbuch auch keine gute Idee weil die Werte dort keine feste Reihenfolge haben. Die Reihenfolge der Radiobuttons kann also bei jedem Programmstart anders sein. Eine Liste mit Tupeln wäre hier eine sinnvollere Wahl.

`key2` und `wert2` muss auch nicht sein, da kann man `key` und `wert` für schreiben. Nach welchem Kriterium wird entschieden welchen Namen man in Deutsch und welchen in Englisch verwendet? Und wonach ob man Zahlen oder Buchstaben anhängt (`radioba`/`radiobb`)?

`radioba.bind()` und `radiobb.bind()` beziehen sich jeweils nur auf den *letzten* der erzeugten Radiobuttons, das macht keinen Sinn.

Das Erzeugen der Radiobuttons passiert in zwei fast identischen Code-Blöcken. Code- und Datenwiederholung vermeidet man als Programmierer. Programme werden dadurch schwieriger zu warten und damit fehleranfälliger, denn wenn man etwas ändert, muss immer daran denken es in allen Kopien zu ändern und aufpassen das man es überall wirklich gleich ändert.

`uebernehme_auswahl()` sollte nicht lokal definiert werden. Die Funktion ist noch nicht einmal komplett ein Closure weil auf die Hälfte der Werte ”direkt” zugegriffen wird und auf die andere über `self`. Letztlich ist die Funktion aber auch komplett überflüssig, denn warum im Hintergrund Werte übernehmen, wenn man das auch erst dann machen kann wenn man sie *braucht*. Also `von` und `bis` auch an das Objekt binden, und die ganzen redundanten Attribute loswerden und in der `main()` erst alle Werte aus der GUI auslesen.

Der Name `main()` für eine Methode die nicht das Hauptprogramm enthält ist falsch.

Die `suche_files()` ist in gewisser Weise mit der GUI vermischt, denn sie bekommt nahezu ungeprüfte Nutzereingaben. Sie sollte Datumsobjekte bekommen und nicht vom Benutzer eingegebene Zeichenketten. Die Eingabe entgegen zu nehmen zu prüfen und zu konvertieren ist Aufgabe der GUI. Die Daten werden auch ständig aufs neue konvertiert für jeden Vergleich.

Beim Anzeigen des Ergebnisses ist der Name `dateien` falsch weil der nur an einen Dateinamen gebunden wird. Letztlich ist es auch nicht besonders effizient die Namen alle einzeln in das `Text`-Widget zu schreiben und es ist auch ziemlich verwirrend das die in umgekehrter Reihenfolge ausgegeben werden. Ich habe mich zuerst sehr gewundert warum `suche_files()` immer alles `reverse` sortiert bis ich das gesehen habe. Damit rechnet niemand und die Programmlogik sollte nichts über solche Details wissen müssen. Die Funktion formatiert auch die Ergebnisse als Zeichenketten — im Grunde ebenfalls Aufgabe der GUI.

Für die Sortierkriterien würde ich Konstanten für die Zeichenketten einführen, oder noch besser ein `enum.Enum` erstellen.

Das `file_dict` ist ein Fehler wenn nach Zeit sortiert wird, denn Du bildest dort Zeiten auf Dateinamen ab. Das funktioniert nur wenn alle Dateien garantiert unterschiedliche Zeiten haben, was so ganz und gar nicht garantiert ist. Es gibt ``touch`` oder Dateisysteme mit einer relativ niedrigen Zeitauflösung was die Metadaten angeht, da kann man ganz locker viele Dateien mit der gleichen Zeit haben. Es ist auch verwirrend das in manchen Fällen in diesem Wörterbuch Zeiten auf Namen abgebildet werden und in anderen Namen auf Zeiten. Die Ergebniswerte sollten immer die gleiche Reihenfolge haben.

`verzeichnisse` wird nur an *einen* Verzeichnispfad gebunden. Genau so falsch ist `dateinamen` in der inneren Schleife und später `filetimes`.

Es wird (zu) oft `os.path.join()` mit den gleichen Werten gemacht. Also sowohl der Code dafür als auch die tatsächliche Ausführung. Das macht man einmal am Anfang und gut ist.

Das filtern nach Anfangs-/Endzeit ist komisch gelöst. Erstens passiert es nur wenn nicht nach Name sortiert wird. Warum dann nicht? Nichts in der GUI deutet auf diese Einschränkung hin und ich finde das sehr überraschend. Dann müssen entweder beide Endpunkte eingegeben worden sein. Wird nur einer eingegeben, bleibt das Ergebnis einfach leer‽ Auch etwas unerwartet für meinen Geschmack. Man kann doch auch nur eine Grenze setzen wollen und das macht doch auch total Sinn nur nach Dateien zu suchen die älter als X sind oder jünger als Y.

Wenn man das generell für alle Sortierkriterien macht, dann bleibt in den ganzen ``if``/``elif``-Zweigen nur noch das ermitteln von `zeitpunkt` und es unterscheiden sich nur der Test auf die Sortierkonstante und die Funktion die zum ermitteln der Zeit verwendet wird. Das kann man ohne das ``if``/``elif``/… lösen mit einem Wörterbuch das die Sortierkonstanten auf die Funktionen abbildet. Schon hat man nur noch eine Stelle im Code wo Datei + Zeit zur Ergebnisliste hinzugefügt wird.

Anstelle von einer Zahl oder einer Zeichenkette wären Datums-/Zeitangaben besser als `datetime.datetime` repräsentiert. Die kann man auch vergleichen, die `repr()`-Ausgabe ist lesbarer, und man kann die `format()`-Methode verwenden.

So als zwischenergebnis lande ich erst einmal hier (kaum getestet):
  1. import os
  2. from datetime import datetime as DateTime
  3. from tkinter import (
  4.     Tk, Frame, Label, Button, Text, Scrollbar, Radiobutton, Entry,
  5.     StringVar, END, LEFT, RIGHT, Y, W
  6. )
  7. #
  8. # TODO Maybe use `enum.Enum`.
  9. #
  10. SORT_BY_NAME = 'name'
  11. SORT_BY_CREATION_TIME = 'creation_time'
  12. SORT_BY_CHANGE_TIME = 'change_time'
  13. SORT_BY_ACCESS_TIME = 'access_time'
  14. SORT_BY_TIME = [SORT_BY_CREATION_TIME, SORT_BY_CHANGE_TIME, SORT_BY_ACCESS_TIME]
  15.  
  16. SORT_BY_TO_GET_TIME_FUNC = {
  17.     SORT_BY_NAME: os.path.getctime,
  18.     SORT_BY_CREATION_TIME: os.path.getctime,
  19.     SORT_BY_CHANGE_TIME: os.path.getmtime,
  20.     SORT_BY_ACCESS_TIME: os.path.getatime,
  21. }
  22.  
  23. DATE_FORMAT = '%d.%m.%Y'
  24.  
  25.  
  26. def search_files(start_path, sort_by, filename_extension, start_date, end_date):
  27.     #
  28.     # TODO Own class for the result tuples or at least a
  29.     #      `collections.namedtuple`.
  30.     #
  31.     os.stat_float_times(False)
  32.  
  33.     result = list()
  34.     for path, _, filenames in os.walk(start_path):
  35.         for filename in filenames:
  36.             full_path = os.path.join(path, filename)
  37.             if os.path.splitext(filename)[1] == filename_extension:
  38.                 file_time = DateTime.fromtimestamp(
  39.                     SORT_BY_TO_GET_TIME_FUNC[sort_by](full_path)
  40.                 )
  41.                 if (
  42.                     (not start_date or start_date < file_time)
  43.                     and (not end_date or file_time <= end_date)
  44.                 ):
  45.                     result.append((full_path, file_time))
  46.  
  47.     if sort_by == SORT_BY_NAME:
  48.         result.sort(key=lambda x: x[0].lower())
  49.     elif sort_by in SORT_BY_TIME:
  50.         result.sort(key=lambda x: x[1])
  51.     else:
  52.         raise ValueError('unknown sort criterion {0!r}'.format(sort_by))
  53.  
  54.     return result
  55.  
  56.  
  57. class Dateisuche(Tk):
  58.  
  59.     def __init__(self):
  60.         Tk.__init__(self)
  61.         self.title('Dateisuche')
  62.         self['bg'] = 'gray50'
  63.  
  64.         self.sort_criterion = StringVar(value=SORT_BY_NAME)
  65.         self.filename_extension = StringVar(value='.py')
  66.         self.start_path = '.'
  67.         #
  68.         # Linker Frame.
  69.         #
  70.         frame = Frame(self, bg='gray50', padx=2)
  71.         self.result_text = Text(frame, width=92, height=38)
  72.         self.result_text.pack(pady=0, padx=2)
  73.         scrollbar = Scrollbar(frame)
  74.         scrollbar.config(command=self.result_text.yview)
  75.         scrollbar.pack(side=RIGHT, fill=Y)
  76.         self.result_text.config(yscrollcommand=scrollbar.set)
  77.         frame.pack(side=LEFT)
  78.         #
  79.         # Rechter Frame.
  80.         #
  81.         self.background_color = '#6f6352'
  82.         self.font_name = 'cambria'
  83.         frame = Frame(self, bg=self.background_color, padx=2)
  84.  
  85.         self._create_radiobuttons(
  86.             frame,
  87.             'Auswahl Sortierung',
  88.             self.sort_criterion,
  89.             [
  90.                 ('Alphabetisch', SORT_BY_NAME),
  91.                 ('Datei angelegt', SORT_BY_CREATION_TIME),
  92.                 ('Letzte Änderung', SORT_BY_CHANGE_TIME),
  93.                 ('Letzter Zugriff', SORT_BY_ACCESS_TIME),
  94.             ],
  95.         )
  96.         self._create_radiobuttons(
  97.             frame,
  98.             'Auswahl Endung',
  99.             self.filename_extension,
  100.             [
  101.                 ('doc', '.doc'),
  102.                 ('docx', '.docx'),
  103.                 ('htm', '.htm'),
  104.                 ('html', '.html'),
  105.                 ('pdf', '.pdf'),
  106.                 ('py', '.py'),
  107.             ],
  108.         )
  109.  
  110.         self._create_headline(frame, 'Auswahl Zeitraum')
  111.         options = dict(
  112.             bg=self.background_color,
  113.             font=(self.font_name, 10),
  114.             fg='#ffce58',
  115.             justify=LEFT,
  116.         )
  117.         Label(
  118.             frame, text='Beispiel: 28.06.2017\n\nVon:', **options
  119.         ).pack(padx=10, anchor=W)
  120.         self.start_date_entry = Entry(frame)
  121.         self.start_date_entry.pack(padx=10, anchor=W)
  122.  
  123.         Label(frame, text='Bis:', **options).pack(padx=10, anchor=W)
  124.         self.end_date_entry = Entry(frame)
  125.         self.end_date_entry.pack(padx=10, anchor=W)
  126.  
  127.         search_button = Button(
  128.             frame,
  129.             text='Suche',
  130.             font=(self.font_name, 10, 'bold'),
  131.             padx=18,
  132.             command=self.do_search,
  133.         )
  134.         search_button.pack(pady=18)
  135.  
  136.         frame.pack(side=LEFT, fill=Y)
  137.  
  138.     def _create_headline(self, parent, text):
  139.         Label(
  140.             parent,
  141.             text=text,
  142.             fg='#ffe9b3',
  143.             bg=self.background_color,
  144.             font=(self.font_name, 11),
  145.             justify=LEFT,
  146.         ).pack(padx=10, pady=12, anchor=W)
  147.  
  148.     def _create_radiobuttons(self, parent, headline_text, variable, choices):
  149.         self._create_headline(parent, headline_text)
  150.         for text, value in choices:
  151.             Radiobutton(
  152.                 parent,
  153.                 text=text,
  154.                 fg='#ffce58',
  155.                 bg=self.background_color,
  156.                 selectcolor='#606060',
  157.                 activebackground=self.background_color,
  158.                 variable=variable,
  159.                 value=value,
  160.             ).pack(padx=8, anchor=W)
  161.  
  162.     def do_search(self):
  163.         try:
  164.             start_date = DateTime.strptime(
  165.                 self.start_date_entry.get(), DATE_FORMAT
  166.             )
  167.         except ValueError:
  168.             start_date = None
  169.  
  170.         try:
  171.             end_date = DateTime.strptime(self.end_date_entry.get(), DATE_FORMAT)
  172.         except ValueError:
  173.             end_date = None
  174.  
  175.         paths = search_files(
  176.             self.start_path,
  177.             self.sort_criterion.get(),
  178.             self.filename_extension.get(),
  179.             start_date,
  180.             end_date,
  181.         )
  182.         self.result_text.delete(1.0, END)
  183.         self.result_text.insert(
  184.             1.0, '\n'.join(map('{0[0]} - {0[1]:%d.%m.%Y}'.format, paths))
  185.         )
  186.         self.result_text.insert(END, '\n')
  187.  
  188.  
  189. def main():
  190.     Dateisuche().mainloop()
  191.  
  192.  
  193. if __name__ == '__main__':
  194.     main()
“XML combines all the inefficiency of text-based formats with most of the unreadability of binary formats :-)” — Oren Tirosh, c.l.p, 2002
Melewo
User
Beiträge: 167
Registriert: Mittwoch 3. Mai 2017, 16:30

Re: Verzeichnis/Dateiliste als tex-Datei ausgeben

Beitragvon Melewo » Freitag 7. Juli 2017, 11:05

Ja, das ist reichlich viel, gehe jetzt nur auf einige Punkte ein und den Rest muss ich erst verarbeiten.

BlackJack hat geschrieben:Das heisst so ziemlich alles aus der `layout()`-Methode sollte im Zuge von `__init__()` passieren.

Gerade in dieser Beziehung hatte ich mir die Bemerkungen von Sirius3 zu Herzen genommen und auf alles was nicht unbedingt zu sein brauchte, unter __init__ verzichtet. Jedenfalls hatte ich es so aufgefassst.

Sirius3 hat geschrieben:Die ganzen GUI-Elemente an Attribute zu binden, ist unnötig. Eigentlich braucht man bei TK außer ein paar IntVar/StrVar-Objekten fast nichts mehr nach der Initialisierung.

viewtopic.php?f=9&t=40640

Dann:
BlackJack hat geschrieben:Das die `StrinVar`-Objekte mit dem Wert '1' initialisiert werden damit *keine* Auswahl bei den Radiobuttons angezeigt wird ist irreführend, denn wenn der Benutzer *nichts* auswählt, dann werden ja die Werte 'alphabetisch' und 'py' verwendet. Warum wird das dem Benutzer nicht angezeigt?

Die werden bei mir richtig angezeigt, vorher wurden alle mit Punkt angezeigt, jetzt nur noch die ausgewählten, deshalb hatte ich doch nach einer Lösung gesucht und die bei Stack Overflow gefunden.

BlackJack hat geschrieben:Bei `scrollbr` fehlt ein 'a' — und jetzt sag bitte nicht das das kein Versehen war, sondern das Du diesen einen Konsonanten absichtlich weggelassen hast.

Beim ersten Script mit der Animation hatte ich das so geschrieben, bei dem hatte ich den Code nur kopiert und nun sehe ich es.

BlackJack hat geschrieben:Das Erzeugen der Radiobuttons passiert in zwei fast identischen Code-Blöcken.

Sind zwischenzeitlich nicht mehr und die unteren wurden ersetzt für eine Mehrfachauswahl mit Checkbuttons für Endungen.

Das ist der Stand von gestern Abend/heute Morgen und außer das a bei scrollbar habe ich jetzt nichts mehr verändert, weil ich mir erst noch einmal alles durchlesen und anschauen möchte, was Du geschrieben und geändert hast.

  1. from tkinter import Tk, Frame, Label, Button, Text, Scrollbar, Radiobutton, \
  2.                     Checkbutton, Entry, StringVar, IntVar, END
  3. from tkinter.filedialog import asksaveasfile
  4. import os
  5. import time
  6.  
  7. # Wandelt Datum 00.00.0000 in Timestamp
  8. def wandle_datum(data):
  9.     return int(time.mktime(time.strptime(data, "%d.%m.%Y")))
  10.  
  11. # Wandelt Timestamp in Datum 00.00.0000
  12. def wandle_zeitformat(filetimes):
  13.     return time.strftime("%d.%m.%Y", time.localtime(filetimes))
  14.  
  15. # Formatierung für Listeneintrag, wobei .\\ entfernt wird.
  16. def formatiere_string(files, zeitformat):
  17.     return "{0:s} - ({1:s})".format(os.path.relpath(files), zeitformat)
  18.  
  19. # Die eigentliche Sortier- und Suchfunktion
  20. def suche_files(durchlaufe, suche, auswahl, endungsliste, vondate, bisdate):
  21.     os.stat_float_times(False)
  22.     file_dict = {}
  23.     suchliste = []
  24.     rueckgabe = []
  25.  
  26.     # Suche in Dateien und zähle Zeilen mit Treffern
  27.     def zaehle_treffer(file, gesucht, zeit):
  28.         treffer = 0
  29.         with open(file, "r") as datei:
  30.             for zeile in datei:
  31.                 if gesucht in zeile:
  32.                     treffer += 1
  33.  
  34.         if treffer > 0:
  35.             # Einfügen mit Anzahl Treffer - Pfad/Dateiname (Datum) in Liste
  36.             suchliste.append("{0:s} - {1:s} - ({2:s})".format(
  37.                 str(treffer), os.path.relpath(file), wandle_zeitformat(zeit)))  
  38.  
  39.     for verzeichnisse, unterordner, dateien in os.walk(durchlaufe):
  40.         for dateinamen in dateien:
  41.             extension = os.path.splitext(dateinamen)[1]
  42.             if extension in endungsliste:
  43.                 pfad = os.path.join(verzeichnisse, dateinamen)
  44.                
  45.                 # Ohne Sucheingabe: Pfad/Dateiname als Schlüssel
  46.                 if auswahl == "alphabetisch":
  47.                     zeitpunkt = os.path.getctime(pfad)
  48.                     if suche == False:
  49.                         file_dict[pfad] = zeitpunkt
  50.                     else:
  51.                         zaehle_treffer(pfad, suche, zeitpunkt)
  52.                 elif auswahl == "angelegt":
  53.                     zeitpunkt = os.path.getctime(pfad)
  54.                 elif auswahl == "aenderung":
  55.                     zeitpunkt = os.path.getmtime(pfad)
  56.                 elif auswahl == "aufgerufen":
  57.                     zeitpunkt = os.path.getatime(pfad)
  58.                    
  59.                 # Ohne Sucheingabe: Timestamp als Schlüssel
  60.                 if (auswahl == "angelegt" or auswahl == "aenderung"
  61.                         or auswahl == "aufgerufen"):
  62.                     if vondate == False or bisdate == False:
  63.                         if suche == False:
  64.                             file_dict[zeitpunkt] = pfad
  65.                         else:
  66.                             zaehle_treffer(pfad, suche, zeitpunkt)
  67.                     elif vondate != False and bisdate != False:
  68.                         # Verglichen werden die einzelnen Timestamps
  69.                         if (zeitpunkt >= wandle_datum(vondate) and
  70.                             zeitpunkt <= wandle_datum(bisdate)):
  71.                             if suche == False:
  72.                                 file_dict[zeitpunkt] = pfad
  73.                             else:
  74.                                 zaehle_treffer(pfad, suche, zeitpunkt)                            
  75.  
  76.     # Nur ausführen, falls ein Suchbegriff übergegeben wurde.
  77.     if suche != False:
  78.         rueckgabe = sorted(suchliste, reverse = True)
  79.  
  80.     # Reihenfolge im Schleifenkopf: files und filetimes
  81.     elif auswahl == "alphabetisch":
  82.         sortiert = sorted(file_dict.items(), key = lambda i: i[0].lower())
  83.  
  84.         for files, filetimes in sortiert:
  85.             zeitformat = wandle_zeitformat(filetimes)
  86.             rueckgabe.append(formatiere_string(files, zeitformat))
  87.  
  88.     # Reihenfolge im Schleifenkopf: filetimes und files
  89.     elif (auswahl == "angelegt" or auswahl == "aenderung"
  90.             or auswahl == "aufgerufen"):
  91.         sortiert = sorted(file_dict.items(), reverse = True)
  92.  
  93.         for filetimes, files in sortiert:
  94.             zeitformat = wandle_zeitformat(filetimes)
  95.             rueckgabe.append(formatiere_string(files, zeitformat))
  96.  
  97.     return rueckgabe
  98.  
  99. class Dateisuche:
  100.  
  101.     def __init__(self):
  102.         self.fenster = Tk()
  103.         self.durchlaufe = "."            # Startet Durchlauf oder Suche bei "."
  104.         self.endungslis = []             # Liste mit ausgewählten Dateiendungen
  105.         self.sortierung = StringVar(value="1")
  106.         self.textfeld = None
  107.         self.suche_in = None
  108.         self.warnung  = None
  109.         self.von = None
  110.         self.bis = None
  111.         self.auswahl_buttons = {
  112.             "Alphabetisch" : "alphabetisch",
  113.             "Datei angelegt"  : "angelegt",
  114.             "Letzte Änderung" : "aenderung",
  115.             "Letzter Zugriff" : "aufgerufen"
  116.         }
  117.         self.endungen = {
  118.             "doc" : 0,
  119.             "docx": 0,
  120.             "pdf" : 0,
  121.             "txt *" : 0,
  122.             "htm *" : 0,
  123.             "html *": 0,
  124.             "py *"  : 0,
  125.             "pyw *" : 0,
  126.             "php *" : 0
  127.         }
  128.  
  129.     def main(self):
  130.         hinweise = ""
  131.         # Ein Suchbegriff braucht nicht unbedingt gesetzt zu sein.
  132.         suche_nach = self.suche_in.get()
  133.  
  134.         if suche_nach is None or suche_nach == "":
  135.             suche_nach = False
  136.             hinweise += "Ein Suchbegriff wurde nicht eingegeben.\n"
  137.         elif len(suche_nach) < 3:
  138.             suche_nach = False
  139.             hinweise += "Der eingegebene Suchbegriff war zu kurz.\n"
  140.         else:
  141.             hinweise += "Suchbegriff: {0:s}\n".format(suche_nach)
  142.  
  143.         # Sortierungsmethode auf alphabetische oder zeitliche Auswahl pruefen.
  144.         sortmethode = self.sortierung.get()
  145.         sortmethode = ("alphabetisch" if sortmethode == "1" else sortmethode)
  146.  
  147.         # Nur für Ausgabe der Hinweise
  148.         if suche_nach == False:
  149.             hinweise += "Sortierungsmethode: {0:s} \n".format(sortmethode)
  150.         else:
  151.             hinweise += "Sortierungsmethode: Anzahl Zeilen mit Treffern.\n"
  152.  
  153.         # Endungsliste leeren, damit bereits ausgwählte Endungen nicht bei
  154.         # jedem weiteren Klick erneut hinzugefügt werden.
  155.         self.endungslis = []
  156.         # Auswahl von Dateiendungen pruefen und notfalls abbrechen.
  157.         for key, value in self.endungen.items():
  158.             status = value.get()
  159.             if status != False:
  160.                 endung = ".{0:s}".format(key.replace(" *", ""))
  161.                 self.endungslis.append(endung)
  162.  
  163.         if not self.endungslis:
  164.             self.warnung = True
  165.             warnhinweis  = "Es wurde keine Endung ausgewählt!\n"
  166.         else:
  167.             self.warnung = False
  168.             hinweise += "Ausgewählte Endungen: {}\n".format(self.endungslis)
  169.  
  170.         # Auf Auswahl eines Zeitraums pruefen.
  171.         vondate = self.von.get()
  172.         bisdate = self.bis.get()
  173.  
  174.         if vondate is None or vondate == "":
  175.             vondate = False
  176.             vondato = "?"
  177.         else:
  178.             vondato = vondate
  179.         if bisdate is None or bisdate == "":
  180.             bisdate = False
  181.             bisdato = "?"
  182.         else:
  183.             bisdato = bisdate
  184.         # Nur für Ausgabe der Hinweise
  185.         hinweise += "Zeitraum: {0:s} - {0:s}\n".format(vondato, bisdato)
  186.  
  187.         # Aufruf der Sortier- und Suchfunktion
  188.         if self.warnung == False:
  189.             gefunden = suche_files(self.durchlaufe, suche_nach, sortmethode,
  190.                        self.endungslis, vondate, bisdate)
  191.  
  192.         # Ausgabe der Hinweise
  193.         self.textfeld.delete(1.0, END)
  194.         if self.warnung == True:
  195.             self.textfeld.insert(1.0, "{0:s}\n".format(warnhinweis))
  196.         else:
  197.             self.textfeld.insert(1.0, "{0:s}\n".format(hinweise))
  198.             # Die von suche_files() zurückgegebene Liste am Ende einfügen.
  199.             for dateien in gefunden:
  200.                 self.textfeld.insert(END, "{0:s}\n".format(dateien))
  201.  
  202.     def speichere_suchergebnis(self):
  203.         datei = asksaveasfile(mode = "a",
  204.                               filetypes = [("Text Datei", "*.txt")])
  205.         if datei is not None:
  206.             datei.write(self.textfeld.get("1.0", END))
  207.             datei.close()
  208.             self.textfeld.delete("1.0", END)
  209.             self.textfeld.insert(END, "Gespeichert!")
  210.            
  211.     def layout(self):
  212.         self.fenster.title("Dateisuche")
  213.         self.fenster.geometry("980x740")
  214.         self.fenster["bg"] = "#808080"
  215.  
  216.         # Aufteilung in linken und rechten Frame
  217.         frame_li = Frame(self.fenster, bg = "#808080", padx = 2, pady = 4)
  218.         frame_re = Frame(self.fenster, bg = "#6f6352", padx = 2, pady = 4)
  219.  
  220.         # Linker Frame:
  221.         # Textfeld für Hinweise, Meldungen und Ergebnisse
  222.         self.textfeld = Text(
  223.                         frame_li, pady = 8, padx = 8, width = 98, height = 46)
  224.         scrollbar = Scrollbar(frame_li)
  225.         scrollbar.config(command = self.textfeld.yview)
  226.         self.textfeld.config(yscrollcommand = scrollbar.set)
  227.  
  228.         frame_li.pack(side = "left")
  229.         scrollbar.pack(side = "right", fill = "y")
  230.         self.textfeld.pack(pady = 0, padx = 2)
  231.  
  232.         # Rechter Frame:
  233.         # Suche in mit * gekennzeichneten Dateien
  234.         frame_re.pack(side = "right", fill = "y")
  235.         Label(
  236.             frame_re,
  237.             text = "Suche in *",
  238.             bg = "#6f6352",
  239.             font = ("cambria", 11),
  240.             fg = "#ffe9b3",
  241.             justify = "left").pack(padx = 10, pady = 12, anchor = "w")
  242.         self.suche_in = Entry(frame_re)
  243.         self.suche_in.pack(padx = 10, anchor = "w")
  244.  
  245.         # Auswahl Sortierungsmethode
  246.         Label(
  247.             frame_re,
  248.             text = "Auswahl Sortierung",
  249.             bg = "#6f6352",
  250.             font = ("cambria", 11),
  251.             fg = "#ffe9b3",
  252.             justify = "left").pack(padx = 10, pady = 12, anchor = "w")
  253.         # Sortierungsmethode alphabetisch oder nach zeitlichen Vorgaben
  254.         for key, wert in self.auswahl_buttons.items():
  255.             Radiobutton(
  256.                 frame_re, text = key,
  257.                 bg = "#6f6352",
  258.                 fg = "#ffce58",
  259.                 selectcolor = "#606060",
  260.                 activebackground = "#6f6352",
  261.                 variable = self.sortierung,
  262.                 value = wert).pack(padx = 8, anchor = "w")
  263.  
  264.         # Auswahl von Dateiendungen
  265.         Label(
  266.             frame_re,
  267.             text = "Auswahl Endung",
  268.             bg = "#6f6352",
  269.             font = ("cambria", 11),
  270.             fg = "#ffe9b3",
  271.             justify = "left").pack(padx = 10, pady = 12, anchor = "w")
  272.         # Auswahl von Dateinamenserweiterungen
  273.         for key in self.endungen:
  274.             self.endungen[key] = IntVar()
  275.             check_endung = Checkbutton(
  276.                 frame_re,
  277.                 text = key,
  278.                 bg = "#6f6352",
  279.                 fg = "#ffce58",
  280.                 selectcolor = "#606060",
  281.                 activebackground = "#6f6352",
  282.                 variable=self.endungen[key])
  283.             check_endung.pack(padx = 8, anchor = "w")
  284.  
  285.         # Auswahl eines Zeitraums
  286.         Label(
  287.             frame_re,
  288.             text = "Auswahl Zeitraum",
  289.             bg = "#6f6352",
  290.             font = ("cambria", 11),
  291.             fg = "#ffe9b3",
  292.             justify = "left").pack(padx = 10, pady = 12, anchor = "w")
  293.         Label(
  294.             frame_re,
  295.             text = "Beispiel: 28.06.2017\n\nVon:",
  296.             font = ("cambria", 10),
  297.             fg = "#ffce58",
  298.             bg = "#6f6352",
  299.             justify = "left").pack(padx = 10, anchor = "w")
  300.         self.von = Entry(frame_re)
  301.         self.von.pack(padx = 10, anchor = "w")
  302.         Label(
  303.             frame_re,
  304.             text = "Bis:",
  305.             bg = "#6f6352",
  306.             font = ("cambria", 10),
  307.             fg = "#ffce58",
  308.             justify = "left").pack(padx = 10, anchor = "w")
  309.         self.bis = Entry(frame_re)
  310.         self.bis.pack(padx = 10, anchor = "w")
  311.  
  312.         # Durchlauf mit Sortierung oder Suche starten
  313.         Button(
  314.             frame_re,
  315.             text = "Suche",
  316.             font = ("cambria", 10, "bold"), padx = 20,
  317.             command = self.main).pack(side = "top", pady = 10)
  318.         # Speichern unter ...
  319.         Button(
  320.             frame_re,
  321.             text = "Speichern",
  322.             font = ("cambria", 10, "bold"), padx = 8,
  323.             command = self.speichere_suchergebnis).pack(side = "top")
  324.  
  325.         self.fenster.mainloop()
  326.  
  327. if __name__ == "__main__":
  328.     instanz = Dateisuche()
  329.     instanz.layout()
Benutzeravatar
BlackJack
Moderator
Beiträge: 32710
Registriert: Dienstag 25. Januar 2005, 23:29
Wohnort: Berlin
Kontaktdaten:

Re: Verzeichnis/Dateiliste als tex-Datei ausgeben

Beitragvon BlackJack » Freitag 7. Juli 2017, 14:36

Sirius3 hat im anderen Thema gesagt das nicht alles an das Objekt gebunden werden muss, nicht das es nicht in der `__init__()` passieren sollte.

Zum `StringVar`-Wert '1': Mir ist schon klar was Du da gemacht hast, aber ich bin der Meinung das ist falsch. Denn wenn Du die (oder im neuen das eine) auf '1' setzt dann wird beim starten der GUI *kein* Radiobutton ausgewählt dargestellt. Aber wenn man selber nichts auswählt und auf die Suchen-Fläche klickt, dann wird ja sortiert: alphabetisch. Und darum sollte das auch beim Start des Programm ausgewählt sein, damit der Benutzer das *sieht* das das passiert. Und als die Endungen noch Radiobuttons waren, galt das auch für *.py als Endung — danach wurde gesucht wenn man nichts ausgewählt hat, aber es wurde nicht in der GUI angezeigt.

Jetzt im neuen könntest Du Dir Zeile 145 sparen wenn da nicht mit '1' sondern mit 'alphabetisch' initialisiert werden würde, und der Benutzer würde von Anfang sehen nach was sortiert wird wenn er selber nichts anderes auswählt.
“XML combines all the inefficiency of text-based formats with most of the unreadability of binary formats :-)” — Oren Tirosh, c.l.p, 2002
Melewo
User
Beiträge: 167
Registriert: Mittwoch 3. Mai 2017, 16:30

Re: Verzeichnis/Dateiliste als tex-Datei ausgeben

Beitragvon Melewo » Freitag 7. Juli 2017, 16:01

Ich bin ja noch nicht fertig, werde in den nächsten Tagen noch einmal alles durchgehen und schauen, was sich noch verbessern lässt. Erkenne z.B. keinen zeitlichen Unterschied zwischen getctime und getatime, so dass minimal meine Bezeichnung falsch ist oder vom System abhängig.

Augenblicklich ist es noch so, dass das Script nach dem Start noch nichts ausgibt, also nur ein leeres Textfeld und minimal eine Endung ausgewählt werden muss. Wird der Button ohne Auswahl einer Endung betätigt, wird die Funktion in Zeile 189 nicht aufgerufen und stattdessen in Zeile 195 nur der Hinweis "Es wurde keine Endung ausgewählt!" aus Zeile 165 ins Textfeld geschrieben. Wurde mindestens eine Endung ausgewählt, so ist alles andere optional.
Melewo
User
Beiträge: 167
Registriert: Mittwoch 3. Mai 2017, 16:30

Re: Verzeichnis/Dateiliste als tex-Datei ausgeben

Beitragvon Melewo » Montag 10. Juli 2017, 19:05

BlackJack hat geschrieben:`frame_li` und `frame_re` enthalten Abkürzungen und das für ”Ortsangaben” in der GUI die so nicht unbedingt sein müssen. Man könnte sich später auch entscheiden die anders darzustellen, zum Beispiel über- statt nebeneinander, dann stimmen die Namen nicht mehr.

Na ja, doch das kann sich eigentlich derjenige umgestalten oder umbenennen, den mein Design nicht passt. Mir gefällt die Aufteilung so wie sie ist, sonst hätte ich das Fenster anders gestaltet.

BlackJack hat geschrieben:Letztlich ist es auch nicht besonders effizient die Namen alle einzeln in das `Text`-Widget zu schreiben

Diesen Punkt habe ich noch geändert, hielt ich es selbst nicht für eine gute Lösung, musste nur erst einmal schauen, wie das besser geschrieben werden könnte und wusste es bis vor wenigen Tagen noch nicht besser. Ich denke, dass es nun besser ist.

Was ich noch geändert habe, wenn ein Suchbegriff mit Umlauten eingegeben wurde, wurden nur Treffer in mit UTF-8 Kodierung gespeicherten Seiten gefunden. nun findet die Treffer in UTF-8 und ISO-Seiten.

Für einen Test das Script in mein htdocs-Verzeichnis auf dem Rechner abgelegt. Windows 10 erzählte mir unter Eigenschaften, dass dieses Verzeichnis 71.378 Dateien in 6.410 Ordner enthalten würde. Gut, die wenigsten davon dürften die Endung *.htm haben, doch ein paar Tausend könnten es auch sein. Jedenfalls um diese 6.410 Ordner zu durchqueren und in allen Dateien mit der Endung *.htm nach dem Suchwort "description" zu suchen, hat die Suche etwa 80 Sekunden benötigt und ich denke, damit kann ich gut leben.

Eigentlich bin ich nun so wie die ist und läuft fürs Erste zufrieden. Einzig, die hätte mir bei der Gelegenheit nicht nur die Seiten mit den meisten Treffern oben listen können, sondern auch die Gesamtzahl der Seiten mit Treffern anzeigen können. Doch darüber mache ich mir vielleicht später noch einmal Gedanken, das kann ja nicht mehr so ein großes Problem sein.

  1. from tkinter import Tk, Frame, Label, Button, Text, Scrollbar, Radiobutton, \
  2.                     Checkbutton, Entry, StringVar, IntVar, END
  3. from tkinter.filedialog import asksaveasfile
  4. import time
  5. import os
  6.  
  7. # Wandelt Datum 00.00.0000 in Timestamp
  8. def wandle_datum(data):
  9.     return int(time.mktime(time.strptime(data, "%d.%m.%Y")))
  10.  
  11. # Wandelt Timestamp in Datum 00.00.0000
  12. def wandle_zeitformat(filetimes):
  13.     return time.strftime("%d.%m.%Y", time.localtime(filetimes))
  14.  
  15. # Formatierung für Listeneintrag, wobei .\\ entfernt wird.
  16. def formatiere_string(files, zeitformat):
  17.     return "{0:s} - ({1:s})".format(os.path.relpath(files), zeitformat)
  18.  
  19. # Umwandlung, falls UTF-8 und ISO-kodierte Dateien mit einem Umlaute
  20. # enthaltenen Suchbegriff durchsucht werden.
  21. def wandle_umlaute(data):
  22.     umlaute = {
  23.         "\\xc4": "Ä",
  24.         "\\xd6": "Ö",
  25.         "\\xdc": "Ü",
  26.         "\\xe4": "ä",
  27.         "\\xf6": "ö",
  28.         "\\xfc": "ü",
  29.         "\\xdf": "ß"
  30.     }
  31.     for umlaut in umlaute:
  32.         data = data.replace(umlaut, umlaute[umlaut])
  33.     return data.lower()
  34.  
  35. # Die eigentliche Sortier- und Suchfunktion
  36. def suche_files(durchlaufe, suche, auswahl, endungsliste, vondate, bisdate):
  37.     os.stat_float_times(False)
  38.     file_dict = {}
  39.     suchliste = []
  40.     rueckgabe = []
  41.  
  42.     # Suche in Dateien und zähle Zeilen mit Treffern
  43.     def zaehle_treffer(file, gesucht, zeit):
  44.         treffer = 0
  45.         with open(file, "r", encoding="utf-8",
  46.                   errors="backslashreplace") as datei:
  47.             for zeile in datei:
  48.                 if gesucht.lower() in wandle_umlaute(zeile):
  49.                     treffer += 1
  50.  
  51.         if treffer > 0:
  52.             # Einfügen mit Anzahl Treffer - Pfad/Dateiname (Datum) in Liste
  53.             suchliste.append("{0:s} - {1:s} - ({2:s})".format(
  54.                 str(treffer), os.path.relpath(file), wandle_zeitformat(zeit)))
  55.  
  56.     for verzeichnisse, unterordner, dateien in os.walk(durchlaufe):
  57.         for dateinamen in dateien:
  58.             extension = os.path.splitext(dateinamen)[1]
  59.             if extension in endungsliste:
  60.                 pfad = os.path.join(verzeichnisse, dateinamen)
  61.  
  62.                 # Ohne Sucheingabe: Pfad/Dateiname als Schlüssel
  63.                 if auswahl == "alphabetisch":
  64.                     zeitpunkt = os.path.getctime(pfad)
  65.                     if suche == False:
  66.                         file_dict[pfad] = zeitpunkt
  67.                     else:
  68.                         zaehle_treffer(pfad, suche, zeitpunkt)
  69.                 elif auswahl == "angelegt":
  70.                     zeitpunkt = os.path.getctime(pfad)
  71.                 elif auswahl == "aenderung":
  72.                     zeitpunkt = os.path.getmtime(pfad)
  73.                 elif auswahl == "aufgerufen":
  74.                     zeitpunkt = os.path.getatime(pfad)
  75.  
  76.                 # Ohne Sucheingabe: Timestamp als Schlüssel
  77.                 if (auswahl == "angelegt" or auswahl == "aenderung"
  78.                         or auswahl == "aufgerufen"):
  79.                     if vondate == False or bisdate == False:
  80.                         if suche == False:
  81.                             file_dict[zeitpunkt] = pfad
  82.                         else:
  83.                             zaehle_treffer(pfad, suche, zeitpunkt)
  84.                     elif vondate != False and bisdate != False:
  85.                         # Verglichen werden die einzelnen Timestamps
  86.                         if (zeitpunkt >= wandle_datum(vondate) and
  87.                             zeitpunkt <= wandle_datum(bisdate)):
  88.                             if suche == False:
  89.                                 file_dict[zeitpunkt] = pfad
  90.                             else:
  91.                                 zaehle_treffer(pfad, suche, zeitpunkt)
  92.  
  93.     # Nur ausführen, falls ein Suchbegriff übergegeben wurde.
  94.     if suche != False:
  95.         rueckgabe = sorted(suchliste, reverse = True)
  96.  
  97.     # Reihenfolge im Schleifenkopf: files und filetimes
  98.     elif auswahl == "alphabetisch":
  99.         sortiert = sorted(file_dict.items(), key = lambda i: i[0].lower())
  100.  
  101.         for files, filetimes in sortiert:
  102.             zeitformat = wandle_zeitformat(filetimes)
  103.             rueckgabe.append(formatiere_string(files, zeitformat))
  104.  
  105.     # Reihenfolge im Schleifenkopf: filetimes und files
  106.     elif (auswahl == "angelegt" or auswahl == "aenderung"
  107.             or auswahl == "aufgerufen"):
  108.         sortiert = sorted(file_dict.items(), reverse = True)
  109.  
  110.         for filetimes, files in sortiert:
  111.             zeitformat = wandle_zeitformat(filetimes)
  112.             rueckgabe.append(formatiere_string(files, zeitformat))
  113.  
  114.     return rueckgabe
  115.  
  116. class Dateisuche:
  117.  
  118.     def __init__(self):
  119.         self.fenster = Tk()
  120.         self.durchlaufe = "."            # Startet Durchlauf oder Suche bei "."
  121.         self.endungslis = []             # Liste mit ausgewählten Dateiendungen
  122.         self.sortierung = StringVar(value="1")
  123.         self.textfeld = None
  124.         self.suche_in = None
  125.         self.warnung  = None
  126.         self.von = None
  127.         self.bis = None
  128.         self.auswahl_buttons = {
  129.             "Alphabetisch": "alphabetisch",
  130.             "Datei angelegt" : "angelegt",
  131.             "Letzte Änderung": "aenderung",
  132.             "Letzter Zugriff": "aufgerufen"
  133.         }
  134.         self.endungen = {
  135.             "doc" : 0,
  136.             "docx": 0,
  137.             "pdf" : 0,
  138.             "txt *" : 0,
  139.             "htm *" : 0,
  140.             "html *": 0,
  141.             "py *"  : 0,
  142.             "pyw *" : 0,
  143.             "php *" : 0
  144.         }
  145.  
  146.     # Daten von der Eingabe und für Ausgabe prüfen
  147.     def pruefe_daten(self):
  148.         hinweise = ""
  149.         # Ein Suchbegriff braucht nicht unbedingt gesetzt zu sein.
  150.         suche_nach = self.suche_in.get()
  151.  
  152.         if suche_nach is None or suche_nach == "":
  153.             suche_nach = False
  154.             hinweise += "Ein Suchbegriff wurde nicht eingegeben.\n"
  155.         elif len(suche_nach) < 3:
  156.             suche_nach = False
  157.             hinweise += "Der eingegebene Suchbegriff war zu kurz.\n"
  158.         else:
  159.             hinweise += "Suchbegriff: {0:s}\n".format(suche_nach)
  160.  
  161.         # Sortierungsmethode auf alphabetische oder zeitliche Auswahl pruefen.
  162.         sortmethode = self.sortierung.get()
  163.         sortmethode = ("alphabetisch" if sortmethode == "1" else sortmethode)
  164.  
  165.         # Nur für Ausgabe der Hinweise
  166.         if suche_nach == False:
  167.             hinweise += "Sortierungsmethode: {0:s} \n".format(sortmethode)
  168.         else:
  169.             hinweise += "Sortierungsmethode: Anzahl Zeilen mit Treffern.\n"
  170.  
  171.         # Endungsliste leeren, damit bereits ausgwählte Endungen nicht bei
  172.         # jedem weiteren Klick erneut hinzugefügt werden.
  173.         self.endungslis = []
  174.         # Auswahl von Dateiendungen pruefen und notfalls abbrechen.
  175.         for key, value in self.endungen.items():
  176.             status = value.get()
  177.             if status != False:
  178.                 endung = ".{0:s}".format(key.replace(" *", ""))
  179.                 self.endungslis.append(endung)
  180.  
  181.         if not self.endungslis:
  182.             self.warnung = True
  183.             warnhinweis  = "Es wurde keine Endung ausgewählt!\n"
  184.         else:
  185.             self.warnung = False
  186.             hinweise += "Ausgewählte Endungen: {}\n".format(self.endungslis)
  187.  
  188.         # Auf Auswahl eines Zeitraums pruefen.
  189.         vondate = self.von.get()
  190.         bisdate = self.bis.get()
  191.  
  192.         if vondate is None or vondate == "":
  193.             vondate = False
  194.             vondato = "?"
  195.         else:
  196.             vondato = vondate
  197.         if bisdate is None or bisdate == "":
  198.             bisdate = False
  199.             bisdato = "?"
  200.         else:
  201.             bisdato = bisdate
  202.         # Nur für Ausgabe der Hinweise
  203.         hinweise += "Zeitraum: {0:s} - {0:s}\n".format(vondato, bisdato)
  204.  
  205.         # Aufruf der Sortier- und Suchfunktion
  206.         if self.warnung == False:
  207.             gefunden = suche_files(self.durchlaufe, suche_nach, sortmethode,
  208.                        self.endungslis, vondate, bisdate)
  209.  
  210.         # Ausgabe der Hinweise
  211.         self.textfeld.delete(1.0, END)
  212.         if self.warnung == True:
  213.             self.textfeld.insert(1.0, "{0:s}\n".format(warnhinweis))
  214.         elif gefunden:
  215.             self.textfeld.insert(1.0, "{0:s}\n".format(hinweise))
  216.             # Die von suche_files() zurückgegebene Liste am Ende einfügen.
  217.             self.textfeld.insert(END, "\n".join(map(str, gefunden)))
  218.         else:
  219.             hinweise += "\nEin Fehler trat auf oder " \
  220.                         "es wurden keine Dateien gefunden!"
  221.             self.textfeld.insert(1.0, "{0:s}\n".format(hinweise))
  222.  
  223.     def speichere_suchergebnis(self):
  224.         datei = asksaveasfile(mode = "a",
  225.                               filetypes = [("Text Datei", "*.txt")])
  226.         if datei is not None:
  227.             datei.write(self.textfeld.get(1.0, END))
  228.             datei.close()
  229.             self.textfeld.delete(1.0, END)
  230.             self.textfeld.insert(END, "Gespeichert!")
  231.  
  232.     def layout(self):
  233.         self.fenster.title("Meine-Suche")
  234.         self.fenster.geometry("980x740")
  235.         self.fenster["bg"] = "#808080"
  236.  
  237.         # Aufteilung in linken und rechten Frame
  238.         frame_li = Frame(self.fenster, bg = "#808080", padx = 2, pady = 4)
  239.         frame_re = Frame(self.fenster, bg = "#6f6352", padx = 2, pady = 4)
  240.  
  241.         # Linker Frame:
  242.         # Textfeld für Hinweise, Meldungen und Ergebnisse
  243.         self.textfeld = Text(
  244.                         frame_li, pady = 8, padx = 8, width = 98, height = 46)
  245.         scrollbar = Scrollbar(frame_li)
  246.         scrollbar.config(command = self.textfeld.yview)
  247.         self.textfeld.config(yscrollcommand = scrollbar.set)
  248.         frame_li.pack(side = "left")
  249.         scrollbar.pack(side = "right", fill = "y")
  250.         self.textfeld.pack(pady = 0, padx = 2)
  251.  
  252.         # Rechter Frame:
  253.         # Suche in mit * gekennzeichneten Dateien
  254.         frame_re.pack(side = "right", fill = "y")
  255.         Label(
  256.             frame_re,
  257.             text = "Suche in *",
  258.             bg = "#6f6352",
  259.             fg = "#ffe9b3",
  260.             font = ("cambria", 11),
  261.             justify = "left").pack(padx = 10, pady = 12, anchor = "w")
  262.         self.suche_in = Entry(frame_re)
  263.         self.suche_in.pack(padx = 10, anchor = "w")
  264.         # Auswahl Sortierungsmethode
  265.         Label(
  266.             frame_re,
  267.             text = "Auswahl Sortierung",
  268.             bg = "#6f6352",
  269.             fg = "#ffe9b3",
  270.             font = ("cambria", 11),
  271.             justify = "left").pack(padx = 10, pady = 12, anchor = "w")
  272.         # Sortierungsmethode alphabetisch oder nach zeitlichen Vorgaben
  273.         for key, wert in self.auswahl_buttons.items():
  274.             Radiobutton(
  275.                 frame_re,
  276.                 text = key,
  277.                 bg = "#6f6352",
  278.                 fg = "#ffce58",
  279.                 selectcolor = "#606060",
  280.                 activebackground = "#6f6352",
  281.                 variable = self.sortierung,
  282.                 value = wert).pack(padx = 8, anchor = "w")
  283.         # Auswahl von Dateiendungen
  284.         Label(
  285.             frame_re,
  286.             text = "Auswahl Endung",
  287.             bg = "#6f6352",
  288.             fg = "#ffe9b3",
  289.             font = ("cambria", 11),
  290.             justify = "left").pack(padx = 10, pady = 12, anchor = "w")
  291.         # Auswahl von Dateinamenserweiterungen
  292.         for key in self.endungen:
  293.             self.endungen[key] = IntVar()
  294.             check_endung = Checkbutton(
  295.                 frame_re,
  296.                 text = key,
  297.                 bg = "#6f6352",
  298.                 fg = "#ffce58",
  299.                 selectcolor = "#606060",
  300.                 activebackground = "#6f6352",
  301.                 variable=self.endungen[key])
  302.             check_endung.pack(padx = 8, anchor = "w")
  303.         # Auswahl eines Zeitraums
  304.         Label(
  305.             frame_re,
  306.             text = "Auswahl Zeitraum",
  307.             bg = "#6f6352",
  308.             fg = "#ffe9b3",
  309.             font = ("cambria", 11),
  310.             justify = "left").pack(padx = 10, pady = 12, anchor = "w")
  311.         Label(
  312.             frame_re,
  313.             text = "Beispiel: 28.06.2017\n\nVon:",
  314.             bg = "#6f6352",
  315.             fg = "#ffce58",
  316.             font = ("cambria", 10),
  317.             justify = "left").pack(padx = 10, anchor = "w")
  318.         self.von = Entry(frame_re)
  319.         self.von.pack(padx = 10, anchor = "w")
  320.         Label(
  321.             frame_re,
  322.             text = "Bis:",
  323.             bg = "#6f6352",
  324.             fg = "#ffce58",
  325.             font = ("cambria", 10),
  326.             justify = "left").pack(padx = 10, anchor = "w")
  327.         self.bis = Entry(frame_re)
  328.         self.bis.pack(padx = 10, anchor = "w")
  329.         # Durchlauf mit Sortierung oder Suche starten
  330.         Button(
  331.             frame_re,
  332.             text = "Suche",
  333.             font = ("cambria", 10, "bold"), padx = 20,
  334.             command = self.pruefe_daten).pack(side = "top", pady = 10)
  335.         # Speichern unter ...
  336.         Button(
  337.             frame_re,
  338.             text = "Speichern",
  339.             font = ("cambria", 10, "bold"), padx = 8,
  340.             command = self.speichere_suchergebnis).pack(side = "top")
  341.  
  342.         self.fenster.mainloop()
  343.  
  344. def main():
  345.     Dateisuche().layout()
  346.  
  347. if __name__ == "__main__":
  348.     main()
Benutzeravatar
BlackJack
Moderator
Beiträge: 32710
Registriert: Dienstag 25. Januar 2005, 23:29
Wohnort: Berlin
Kontaktdaten:

Re: Verzeichnis/Dateiliste als tex-Datei ausgeben

Beitragvon BlackJack » Montag 10. Juli 2017, 20:26

@Melewo: Ja klar, schlechte Namen können später immer andere umbenennen. Oft ist man aber selbst der andere der da nach ein paar Monaten wieder mit konfrontiert ist.

Bei `file_dict` ist immer noch der Fehler das Zeitpunkte auf Dateinamen/-pfade abbilden nicht eindeutig ist. Dort ein Wörterbuch zu nehmen ist nicht sinnvoll. Da reicht eine Liste mit Tupeln völlig aus. Und da dann bitte immer Tupel mit der gleichen Reihenfolge von Elementen speichern. Das ist sonst sehr verwirrend und führt gegen Ende der Funktion auch zu kopiertem Code.

Und ich finde es auch weiterhin nicht nachvollziehbar warum bei alphabetischer Sortierung nicht nach Datum gefiltert werden kann, und warum man entweder kein Datum oder beide angeben muss, und die anderen beiden Fälle, ohne irgenwie für den Nutzer erkennbar warum das so ist, einfach ein leeres Suchergebnis produzieren.

Mit literalen `True`- und `False`-Werten vergleicht man nicht. Da kommt ja eh nur wieder ein `True` oder `False` bei heraus, also hätte man gleich den Wert nehmen können den man schon hatte oder gegebenfalls seine Negation mit ``not``. Das funktioniert an einigen Stellen bei Dir nicht weil Du Namen hast die auch an etwas anderes als `True` oder `False` gebunden werden können. Damit rechnet niemand. Wenn ich den Code richtig lese kann `suche_nach` die Werte `None`, oder eine Zeichenkette, oder `False` annehmen — das man in Python jeden Typ an einen Namen binden kann, heisst nicht das es eine gute Idee ist das auch tatsächlich zu machen. Es sollte immer der gleiche „duck type“ sein. `None` kann dabei für jeden Typ verwendet werden, aber Zeichenkette und Wahrheitswert sind nicht so einfach austauschbar.

Auf die Kritik mit der (Nicht-)Auswahl der Sortierung bist Du auch nicht eingegangen. Und die Aufteilung auf die `__init__()` und `layout()` ist auch immer noch falsch.

Die lokale Suchfunktion sollte nicht lokal sein.

Insgesamt ist die Funktion in der die Programmlogik steht zu langt, und viel zu verworren und enthält an ein paar Stellen deswegen Code der nahezu identisch ist. Das wäre sinnvoller aufgeteilt in eine Funktion welche die Pfade zum Beispiel als Generator liefert, und auf den dann die verschiedenen Filter nacheinander angewendet werden und das Ergebnis dann in einem `sorted()` mit dem entsprechenden `key`-Argument aggregiert wird.
“XML combines all the inefficiency of text-based formats with most of the unreadability of binary formats :-)” — Oren Tirosh, c.l.p, 2002
Melewo
User
Beiträge: 167
Registriert: Mittwoch 3. Mai 2017, 16:30

Re: Verzeichnis/Dateiliste als tex-Datei ausgeben

Beitragvon Melewo » Mittwoch 12. Juli 2017, 14:19

False habe ich bei suche_nach und vondato und bisdato nach None geändert, die Abfragen entsprechend angepasst sowie das letzte Entry-Feld mit dem aktuellen Datum vorbelegt, wobei das Datum grau bleibt, bis ein Course bei Entry gesetzt wird. Nun kann es geändert oder bei aktuell belassen werden.
Ändern könnte man sicherlich noch mehr, doch dann könnte der Sommer um sein und was ich übers Jahr noch alles erledigen wollte, schleift vor sich hin. Doch so eine Zwischenübung war nicht verkehrt, ich merkte ja bei dem Animations-Script, was ich noch für Lücken habe und dieses sollte ja dann doch etwas werden, was sich mehr sehen lassen kann.

Zurück zu „Ideen“

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder