Schleife für mehrere Dateien nutzen und Problematik mit leeren Zeilen

[Morgoth_der_Beginner]

Guten Tag,
ich hatte zwar mal einen Kurs in den Grundlagen von Python, damals Version 2.7, bin aber dennoch Anfänger. Nun nutze ich Python 3.7 mittels Spyder (Anaconda) für einen aktuellen Simulations-Kurs von Evakuierungen an der Uni. Das Programm erzeugt für jede Tür eine Datei mit drei "Header"-Zeilen, einer leeren Zeile und dann jeweils die Zeit und kumulierte Personenanzahl (mit zwei Leerzeichen dazwischen) und anschließend zwei leere Zeilen.
Mein Ziel ist es einen Graphen zu erzeugen (x= Personenanzahl, y=Zeit). Dazu nutze ich matplotlib.pyplot und muss dafür je eine Liste für die x und y Koordinate erzeugen.
Mein Ansatz ist der folgende:

Code: Alles auswählen

#Dateien
f1 = open('a2_1_traj.txt_flow_exit_id_2.dat' , 'r')
f2 = open('a2_2_traj.txt_flow_exit_id_2.dat' , 'r')

time1 = []  
time2 = []  
ped = []

# um Header nicht zu beachten  
cnt1 = 0                             
cnt2 = 0               

# Schleifen 
for line in f1:
    cnt1 += 1
    if cnt1 > 4:                     # Anpassen, Zeilen "Header"
        line = line.rstrip('\n')
#        line = line.rstrip('\r')
        line = line.split('  ')
        time1.append(float(line[0]))
        ped.append(int(line[1]))
  
for line in f2:
    cnt2 += 1
    if cnt2 > 4:                     # Anpassen, Zeilen "Header"
        line = line.rstrip('\n')
#        line = line.rstrip('\r')
        line = line.split('  ')
        time2.append(float(line[0]))

Dies funktioniert an sich und ich kann die Graphen erzeugen, aber mit Einschränkungen. Ich muss die zweite leere Zeile der Tür-Datei löschen, sonst erhalte ich zunächst den Fehler: could not convert string to float bei Zeile 23 time1.append... , weil der letzte Eintrag der Liste ein Leerzeichen ist. Wenn ich die Anzahl an leeren Zeilen in der Tür-Datei erhöhe, erhalte ich auch mehr Leerzeichen-Einträge in der time1 Liste, aber immer einen weniger als es leere Zeilen gibt. Da habe ich ein Verständnis Problem. Es würde sich logisch anfühlen wenn der Code mit leeren Zeilen am Ende generell nicht funktioniert, aber warum eine leere Zeile kein Problem erzeugt aber ab 2 schon, verstehe ich nicht.

Ich habe versucht das Problem zu lösen:

Code: Alles auswählen

for line in f1:
    cnt1 += 1
    if cnt1 > 4:
        if f1.readline(1) != ' ':
            line = line.rstrip('\n')
            line = line.rstrip('\r')
            line = line.split('  ')
            time1.append(float(l[0]))
            ped.append(int(l[1]))
        else:
            break

Zwar wird bei zwei leeren Zeilen nun kein Leerzeichen mehr am Ende der Liste hinzugefügt (bei höherer Anzahl leerer Zeilen schon, dachte das break würde dies verhindern), aber abseits des ersten Eintrags in der time1 Liste fehlt bei allen das erste Zeichen. Ich denke das liegt daran, dass der Pointer das erste Zeichen mit readline(1) bearbeitet hat und nun dahinter weitermacht. Stimmt es, dass der Pointer nicht wieder an den Anfang der Zeile gesetzt werden kann?

Desweiteren beruht meine Methode darauf, dass ich für jede auszuwertende Datei händisch cntX=0 und die Liste für timeX (teilweise auch pedX) erstellen, sowie die Schleife kopiere und deren Inhalt auf die Datei und Liste(n) etc. anpasse. X steht für 1,2,3... abhängig von der Anzahl der Dateien. Ich habe versucht das mit einer Schleife mit range zu lösen:

Code: Alles auswählen

for i in range(1,3):
    for line in fi:
        cnti += 1
        if cnti >4:
            line = line.rstrip('\n')
#           line = line.rstrip('\r')
            line = line.split('  ')
            timei.append(float(line[0]))
            ped.append(int(line[1]))

Das funktioniert natürlich nicht, weil die Namen fi, cnti und timei nicht definiert sind. Bin ich da denn auf der richtigen Spur? Bzw. ist es generell möglich eine Schleife für mehrere Dateien zu nutzen und jeweils eine andere Liste zu füllen, oder im optimal Fall eine neue Liste automatisch pro Datei zu erzeugen?

Ich bin leider zu keinem der Probleme fündig geworden. Wie gesagt, ich kann grundsätzlich mit meinem Code mein Ziel erreichen, wenn auch durch händische Anpassungen. Daher denke ich, dass dieser stark optimiert werden kann und ich würde gerne verstehen wie und wo meine Denkfehler bei dem leeren Zeilen und meinem Lösungsansatz sind, um zu lernen. Daher bin ich für jede Hilfe, Denkanstöße, alternative Ansätze etc. sehr dankbar.

Liebe Grüße
Morgoth_der_Beginner

[noisefloor]

Hallo,

anders gesagt: du willst nur Zeilen verarbeiten, an deren Anfang eine Zahl steht, richtig?

Gruß, noisefloor

[Morgoth_der_Beginner]

@noisefloor Ja genau und die Dezimalzahl zu einer Liste und die Ganzzahl zu einer andere hinzufügen. So rum habe ich noch gar nicht gedacht, war im Kopf immer bei dem was ich nicht verarbeiten will, also den "Header" und die leeren Zeilen. Wobei ich spontan nicht weiß wie ich mein Ziel mit dem Denkansatz erreiche, aber werde darüber nachdenken.
Gruß, Morgoth_der_Beginner

[__blackjack__]

@Morgoth_der_Beginner: Ich denke das Verständnisproblem könnte an der Definition einer leeren Zeile liegen. Wenn der Texteditor Dich den Cursor in eine Zeile nach der letzten Zeile mit Inhalt setzen lässt, und die vielleicht auch mit einer Nummer versieht, dann ist das keine Zeile in der Datei. Jedenfalls nicht wenn man '\n' als Zeilenende-Zeichen sieht, und das tun vernünftige Leute. Nur Irre sehen das als Zeilentrenner bei dem davor und danach eine Zeile existiert, auch wenn die Zeile danach tatsächlich gar nichts enthält.

Du machst das auch ein wenig umständlich mit den `rstrip()` und dem `split()` Mach einfach nur ein `split()` ohne Argument, dann wird an zusammenhängenden „whitespace“ zwischen nicht-„whitespace“ getrennt. „Whitespace“ am Anfang und am Ende wird dabei auch entfernt. Wobei das aber nicht einmal notwendig wäre, denn die Umwandlung in Zahlen würde das sowieso ignorieren.

Den Iterator und `readline()` zu mischen ist keine gute Idee und kann je nach Implementierung auch zu falschen Ergebnissen führen, weil der Iterator mehr liest als er braucht und Daten zwischenspeichert die zumindest für `read()`-Aufrufe dann nicht mehr zur Verfügung stehen.

Bitte gewöhn Dir keine Abkürzungen an und schon gar keine durchnummerierte Namen. Schlag mal „cunt“ im Wörterbuch nach und überlege ob Du wirklich Variablen so benennen willst.

Die Wiederholungen von Code, also programmieren durch kopieren, einfügen, und leicht anpassen, sollte man tatsächlich vermeiden. Die beiden Wege dafür sind Schleifen und/oder Funktionen. Für das Problem mit den Namen mit dem `i` am Ende ist die Lösung die gleiche wie bei manuell durchnummerierten Namen: In der Regel will man da keine einzelnen Namen, sondern eine Datenstruktur verwenden. Meistens eine Liste.

Anstelle des Zeilenzählers der manuell für jede Zeile der Datei mitgeführt wird, würde man eher vor der Schleife zum Einlesen vier Zeilen überlesen mit denen man nichts macht. Dann braucht man den Zähler nicht für die Mehrzahl der Zeilen mitführen die diese Information gar nicht brauchen und braucht auch für diese Zeilen den Test auf den Zählerstand nicht machen.

Dateien die man öffnet, sollte man auch wieder schliessen. Die ``with``-Anweisung kann dabei sehr nützlich sein.

Da innerhalb der Daten keine Leerzeilen vorkommen, kann man auch einfach das einlesen/verarbeiten bei der ersten Leerzeile abbrechen. Dann ist egal wie viele davon in der Eingabedatei am Ende stehen.

Ich würde auch dabei bleiben und nicht mit Zahlen am Anfang operieren. Das ist weniger robust als dem tatsächlichen Format der Daten zu folgen.

[nezzcarth]

Schade, dass du dein Beispiel nur als Bild gepostet hast; so fällt es schwer, die Daten zum Testen zu verwenden, weil man sie abtippen müsste. Wenn ich nichts übersehen habe, machst du es dir mit dem ganzen Zählen usw. schwieriger als es sein müsste. Ignorier Leerzeilen und Kommentare und dann hast du es doch schon fast, oder? Ich meine, wenn du die Vorgaben streng implementieren willst, brauchst du im Prinzip eine Art Automaten. Nachfolgend mal ein Beispiel, wie ich solche Skripte meistens aufbaue. Vielleicht hilft dir das ja ein bisschen, um der Lösung näher zu kommen:

Code: Alles auswählen

#!/usr/bin/env python
COMMENT = '#'

def is_comment(line):
    return line.lstrip().startswith('#')


def iter_parse_lines(lines):
    for line in lines:
        result = line.split()
        assert len(result) == 2, result
        yield float(result[0]), int(result[1])


def iter_file(filename):
    with open(filename) as fh:
        for line in fh:
            if not line.strip():
                continue
            if is_comment(line):
                continue
            yield line


def main():
    files = ('file1.dat', 'file2.dat')
    for file in files:
        print('Open:', file)
        for line in iter_parse_lines(iter_file(file)):
            print(line)


if __name__ == '__main__':
    main()

[ThomasL]

Einfach Module benutzen die für sowas gedacht sind:

Code: Alles auswählen

import pandas as pd
import matplotlib.pyplot as plt

# erst mal deine Datendatei nachbilden
with open('a2_1.dat', 'w') as fhandle:
    fhandle.write('#Simulation time: 49.83\n')
    fhandle.write('#Flow at exit NaN( ID 2 )\n')
    fhandle.write('#Time (s) cummulative number of agents\n')
    fhandle.write('\n')
    start_value = 27.166667
    for i in range(1, 26):
        fhandle.write(f'{start_value+i*0.904936:.6f}  {i}\n')

# bequem einlesen per read_csv
df = pd.read_csv('a2_1.dat', skiprows=4, names=['time', 'number'], sep='  ', engine='python')

# plotten
plt.plot(df.number, df.time)
plt.show()

[__blackjack__]

Ungetestet:

Code: Alles auswählen

#!/usr/bin/env python3


def read(filename):
    times = list()
    pedestrian_counts = list()
    with open(filename, 'r', encoding='ASCII') as lines:
        # 
        # Skip header.
        # 
        for _ in range(3):
            next(lines)
        
        for line in lines:
            if not line.lstrip():
                break
            time, pedestrian_count = line.split()
            times.append(float(time))
            pedestrian_counts.append(int(pedestrian_count))
    
    return times, pedestrian_counts


def main():
    filename_template = 'a2_{}_traj.txt_flow_exit_id_2.dat'
    datasets = [
        read(filename_template.format(file_number))
        for file_number in range(1, 3)
    ]
    print(datasets)


if __name__ == '__main__':
    main()

[Morgoth_der_Beginner]

@__blackjack__ Danke für deine ausführliche Antworten, gestern hatte ich leider nicht die Zeit entsprechend auf deine Aspekte einzugehen. Auf Anregung von nezzcarth sind hier Links zu den beiden Tür-Dateien aus der kleinen Test-Simulation: https://1drv.ms/u/s!AsV6LgpLPxYhgZ5uW7RrbdYflRbPqQ und https://1drv.ms/u/s!AsV6LgpLPxYhgZ52ugJmC-sNsQFFRA
Aha, ich bin wirklich davon ausgegangen, dass es sich um "richtige" Zeilen handelt weil der Editor diese mit Nummern anzeigt. Dennoch bin ich irritiert warum diese Zeilen dann Auswirkungen auf mein Skript haben, wenn sie nicht Teil der Datei sind.
Ich dachte, dass 'split()' immer ein Argument braucht. Das potenzielle Problem durch 'readline()' war mir auch nicht bewusst. Habe beides nun in meiner Python-Hilfe-Datei korrigiert.
Ich habe natürlich ganz unschuldig an counter gedacht, aber sehe welche unangenehme Probleme durch Abkürzungen entstehen können.
Habe die geöffneten Dateien am End von dem Skript eines mit '.close()' geschlossen. Den Teil und den über das Erstellen des Diagrammes hatte ich für die Übersichtlichkeit weggelassen. Die 'with'-Anweisung scheint aber praktischer zu sein, toller Hinweis.

Ich habe dein Skript einfach mal laufen lassen und als Ausgabe dies erhalten: [([], []), ([], [])]
Die Struktur sieht Sinnvoll aus, eine Liste mit zwei Listenpaaren. Warum das Skript dies erzeugt ist mir allerdings nicht ganz klar. Ich hoffe es ist ok wenn ich das Skript hier durchgehe und sage wie ich was verstehe und wo es hapert um möglichst sinnvoll dazuzulernen und korrigiert zu werden.
Du arbeitest mit Funktionen. 'read(filename)' gewährt Zugriff auf die Datei, muss dieser noch eingetragen werden? Da 'filename' nicht weiter definiert ist.
Erstellen von 2 passenden leeren Listen --> verstanden
öffnen der Datei zum lesen. Gleiche Frage: woher nimmt das Skript den 'filename' ? Welchen Unterschied macht das 'encoding='ASCII''? Habe versucht mich da rein zu lesen, muss aber eingestehen das ich es nicht verstanden habe. Wird der Code der hinter allem steht dadurch verkleinert?. Bei mir steht immer automatisch # -*- coding: utf-8 -*- in der ersten Zeile.
Skip Header Ansatz ist viel besser als meiner, wie du gesagt hast wird so nichts unnützes die ganze Zeit mitgeschleppt. Wenn ich die ersten 4 Zeilen überspringen will, müsste ich dann nicht 'range(4)' anstatt 'range(3)' nutzen? Oder erkenne ich nur nicht warum die leere Zeile zwischen Header und Daten übersprungen wird?
Nun gehst du mit der Schleife die Daten durch. '.lstrip()' an sich entfernt linksseitig die Leerzeichen. Warum dann 'if not' und nicht 'if' ? Weil wenn links ein Leerzeichen ist soll doch 'break' aktiviert werden. Wo liegt da mein Denkfehler?
Teilen der Zeile anhand der Leerzeichen und definieren des ersten Eintrags als time und des zweiten als pedestrian_count und anschließendes hinzufügen in Listen --> verstanden

Du nutzt die 'main()'-Funktion damit diese wie ein eigenständiges Programm im Skript agiert.
Definierst Varibale 'filename_template' mit der grundlegenden Struktur der Dateinamen und ersetzt den Unterschied durch { }
Definierst 'datasets' als Liste. Liest die einzelnen Dateien ein dadurch, dass '.format(file_number)' mit der Schleife den Eintragt in den { } ändert. Was ist wenn sich die Dateien in mehr als einer Zahl unterscheiden? Zum Beispiel auch die Tür mit der ID 1 beachtet werden soll? Dann bräuchte man zweimal 'range(1, 3)' . Würde man dann in 'filename_template' zwei { } einsetzen, 'read' anpassen zu 'read(filename_template.format(file_number1, file_number2) und eine Schleife in der vorhanden Schleife für 'file_number2' ergänzen?
Anschließenden Boilerplate damit 'main()' überhaupt ausgeführt wird.
Aber wo ist die Verbindung der beiden Funktionen? Es muss doch eine geben weil 'print(datasets)' die Struktur mit den Listenpaaren wiedergibt, welche in der ersten Funktion erzeugt wird.
Hoffe es sind nicht zu viele und dumme Fragen. Ich würde wirklich gerne verstehen wie die dieses Skript funktioniert, das ist ja das Spannende und nicht das einfache verwenden von Skripten von anderen. Daher würde ich mich sehr über eine Antwort freuen.

[__blackjack__]

@Morgoth_der_Beginner: Du hast da ja *eine* Leerzeile am Ende Deiner Dateien die Probleme bereitet. Es werden ja zwei zusätzliche Zeilennummern im Editor angezeigt, das heisst Du hast da eine tatsächliche Leerzeile in der Textdatei, also eine Zeile die mindestens aus einem Zeilenendezeichen besteht.

Der Wert für `filename` wird beim Aufruf von `read()` als Argument übergeben.

Das ``encoding='ASCII'`` sorgt dafür, dass das Programm sich auf jedem System gleich verhält und aussteigt wenn in der Datei irgend etwas ausserhalb von ASCII vorkommt. Wenn man die Kodierung von Textdateien bei `open()` nicht angibt, dann wird da automatisch geraten was das System auf dem das läuft, gerade verwendet. Was dann dazu führen kann, dass das gleich Programm, mit den gleichen Datendateien, unter verschiedenen Systemen oder auch nur Einstellungen nicht läuft oder andere, falsche Ergebnisse liefert.

Der Kodierungskommentar bezieht sich nur auf die Kodierung der Quelltextdatei in der er steht. Der ist bei Python 3 nur noch notwendig wenn die Datei in einer anderen Kodierung als UTF-8 vorliegt, denn das wird angenommen wenn kein Kodierungskommentar vorhanden ist.

Das mit der 4 zum überspringen der vier Leerzeilen hast Du richtig erkannt! Das ist auch genau das Problem warum mein Code zwei leere Datensätze liefert: Es werden drei Zeilen übersprungen und dann so lange gelesen bis eine Leerzeile auftritt. Und das passiert halt *sofort*, weil die vierte Zeile der Datei eine Leerzeile ist. In solchen Fällen bin ich immer froh das ich „ungetestet“ dazu geschrieben habe.

``if not`` weil leere Zeichenketten im boole'schen Kontext ”unwahr” sind. Und man möchte da ja reagieren wenn kein Inhalt in der Zeile ist wenn man alle „whitespace“-Zeichen entfernt hat.

Code: Alles auswählen

In [16]: bool('line content\n')
Out[16]: True

In [17]: bool('')
Out[17]: False

In [18]: bool('line content\n'.lstrip())
Out[18]: True

In [19]: bool('\n'.lstrip())
Out[19]: False

Wenn es mehr Dateien gibt, die sich in mehr als einem Namensteil unterscheiden, braucht man entsprechend mehr Schleifen – oder `itertools.product()`.

Code: Alles auswählen

In [22]: list(itertools.product(range(1, 3), repeat=2))
Out[22]: [(1, 1), (1, 2), (2, 1), (2, 2)]

Und ja, dann bräuchte man in der Vorlage für den Dateinamen einen weiteren Platzhalter und muss dafür im `format()`-Aufruf den passenden Wert übergeben.

Die Verbindung zwischen den beiden Funktionen liegt darin das in der `main()`-Funktion die `read()`-Funktion aufgerufen wird. Bei der Definition von `datasets`.

[Morgoth_der_Beginner]

@nezzcarth Danke für deine Antwort. Du hast natürlich vollkommen recht, die Datei zur Verfügung zu stellen macht deutlich mehr Sinn als das Bild. Entschuldige bitte. Falls du noch Interesse hast, wären hier zwei Dateien aus der kleinen Test Simulation: https://1drv.ms/u/s!AsV6LgpLPxYhgZ5uW7RrbdYflRbPqQ und https://1drv.ms/u/s!AsV6LgpLPxYhgZ52ugJmC-sNsQFFRA.

Ich würde gerne dein Skript durch gehen um Verständnisprobleme auszumerzen und zu Überprüfung ob ich etwas richtig verstanden habe um zu lernen.
Die erste Funktion definiert was eine Kommentarzeile ist, indem überprüft wird ob die Zeile linksseitig mit '#' beginnt.
Die zweite Funktion dient der Teilung mittels '.split()' anhand der Leerzeichen. Mit 'assert len(result) == 2' wird überprüft ob 'result' genau zwei Einträge besitzt. Warum dann noch das ', result' in der Zeile?
Mit Automaten hatte ich bisher nichts zu tun (der Kurs den ich hatte war wohl noch rudimentärer als gedacht). 'yield' gibt die Ergebnisse zurück zur einmaligen Verwendung, welche ich dann zum plotten nutzen könnte.
Die dritte Funktion 'def iter_file(filename)' öffnet die Datei zunächst. Dann wird die Datei mit 'if' auf leere Zeilen und auf Kommentarzeilen überprüft und anschließen falls keines von beiden zutrifft die Zeile mit 'yield' zurückgegeben.
Die 'main()'-Funktion sorgt dafür, dass mehre Dateien nach einander genutzt werden können. Die erste 'for'-Schleife greift nach einander auf die Dateien zu. 'print' soll nur veranschaulichen welche Datei gerade dran ist. Die zweite Schleife kombiniert das Teilen mit dem Überprüfen in der aktuellen Datei der ersten Schleife und gibt alle zutreffenden Zeilen aus mit 'print (line)'.
Anschließend die Boilerplate um 'main()' überhaupt ausführen zu können.

Habe ich das soweit richtig verstanden? Auf jeden Fall sehr interessante Ansätze, die mein Verständnis von Funktionen und deren Möglichkeiten steigern. Danke für deine Antwort und ich würde mich freuen wenn du mich korrigierst um weiter zu lernen und hinter die Strukturen von Python zu blicken.

[Morgoth_der_Beginner]

@__blackjack__: Ok, das leuchtet mir jetzt ein und klärt das Leerzeilen-Verständnis.

Ok, verstanden 'endcodig='ASCII' sorgt für die sichere und systemunabhängige Nutzung. Sehr gut zu wissen. Aus einem ähnlichen Grund wird auch #!/usr/bin/env python3 verwendet. Richtig?

Und ich bin froh, dass ich etwas richtig erkannt, auch wenn es nur die Kleinigkeit mit der 'range(4)' ist. Das macht Mut

Ok, 'if not' wird hier verwendet weil es sonst auf *gefüllte* Zeilen reagiert, da diese 'True' sind.

'itertools.produkt()' sieht sehr hilfreich aus, falls der Fall mal eintritt. Ich werde das mal testen und schauen ob ich es damit hin bekomme.

Jetzt habe ich die Verbindung gesehen. Vollkommen logisch die 'main()'-Funktion sorgt für die Übergabe des Wertes für 'filename'. Da stand ich aber richtig auf dem Schlauch

Ich danke dir sehr, dass du dir die Zeit genommen hast auf meine Fragen einzugehen. Ich kann sehr viele Erkenntnisse daraus ziehen.

[Morgoth_der_Beginner]

@ThomasL: Auch dir danke ich für deine Antwort. Der Ansatz mit dem Modul ist durchaus interessant und ich werde mich mal mit den Möglichkeiten von pandas beschäftigen.
Wenn ich das richtig verstehe basiert das Nachbilden der Zeit-Einträge darauf, dass diese sich konstant um den selben Wert steigern. Das ist nicht unbedingt der Fall.
Danke auf jeden Fall für den Denkanstoß.

[ThomasL]

@ThomasL: Wenn ich das richtig verstehe basiert das Nachbilden der Zeit-Einträge darauf, dass diese sich konstant um den selben Wert steigern.

Hmm, ich hatte keine Lust dein Bild abzutippen und habe die Daten nachgebildet. (Bitte demnächst Copy-Paste to Screen )
Die Werte der Zeiteinträge sind für die Funktionalität des Einzeilers unerheblich.