Öffnen von txt Dateien aus einem Ordner und nach Bearbeitung in einem anderen speichern

[mplahl]

Hallo zusammen,

ich habe erst vor kurzem mit dem programmieren angefangen und komme gerade nicht mehr weiter. Wäre toll wenn mir jemand helfen könnte.

Und zwar möchte ich aus einem Ordner Namens "Datei" alle darin befindlichen txt-Dateien bearbeiten.
Die Dateien sind wie folgt aufgebaut:
2008-01-29 10:00:00,9.5100,9.9900,9.5000,9.5000,89745
2008-01-29 10:01:00,9.5000,9.6400,9.3500,9.6000,55200
2008-01-29 10:02:00,9.5800,9.6400,9.3500,9.5000,62650
2008-01-29 10:03:00,9.5000,9.5500,9.4200,9.5000,50191
2008-01-29 10:04:00,9.5000,9.5900,9.4500,9.5200,32550
...
Und zwar muss ich Spalte 5 und 6 miteinander multiplizieren und das Ergebnis in einer Spalte 7 darstellen.

Anschließend sollen die bearbeiteten Dateien in dem Ordner "New_Datei" unter dem jeweiligen Dateinamen_bearbeitet gespeichert werden.

Ich hoffe Ihr könnt mir bei meinem Problem weiterhelfen.

Liebe Grüße

[__deets__]

Sowas kann man gut mit der Bibliothek pandas (extra zu installieren) und dem eingebauten Paket pathlib machen. Schau dir die Dokumentation dazu an, versuch was damit hinzubekommen, und meld dich mit Code (in code tags zur Lesbarkeit) und konkreten Fragen. Viel Erfolg.

[mplahl]

Funktioniert jetzt zum großen Teil. Jedoch wird bei jedem File erneut eine Spalte mit dem gleichen Ergebnis ausgegeben. Also im ersten File stimmt es und im zweiten gibt es dann zwei neue Spalten jeweils mit dem Ergebnis und beim dritten dann drei neue Spalten jeweils mit dem Ergebnis. Es soll aber nur eine neue Spalt mit dem Ergebnis geben. Ich weiß jedoch nicht, wie ich die For-Schleife umbauen muss, damit es so funktioniert.

import os

path = r"C:\Users\Marco\PycharmProjects\pythonProject\ABCD"

os.chdir(path)

def addLines(path):
for files in os.listdir():
file = open(files, "r")

newLines = []

for row in file.read().split("\n"):
items = row.split(" ")
if len(items) >= 2:
newLines.append(row + " " + str("%.2f" % (float(items[0]) * float(items[1]) * float(items[2]))))

file.close()

file = open(filepath, "w+")

for line in newLines:
file.write(line + "\n")

for filename in os.listdir():
filepath = os.path.join("edited_" + filename)
addLines(filepath)

[DeaD_EyE]

Ich mag Pandas nicht, da sich immer alle direkt auf Pandas stürzen und kein Python lernen, sondern Pandas lernen.
Hier mal ein Beispiel mit Python:

Code: Alles auswählen

import csv
import io

lines = """2008-01-29 10:00:00,9.5100,9.9900,9.5000,9.5000,89745
2008-01-29 10:01:00,9.5000,9.6400,9.3500,9.6000,55200
2008-01-29 10:02:00,9.5800,9.6400,9.3500,9.5000,62650
2008-01-29 10:03:00,9.5000,9.5500,9.4200,9.5000,50191
2008-01-29 10:04:00,9.5000,9.5900,9.4500,9.5200,32550"""


# 2 Fake Dateien
with (
    io.StringIO(lines) as csv_in,
    io.StringIO() as csv_out,
):
    reader = csv.reader(csv_in)
    writer = csv.writer(csv_out)
    # hier wird die Zeile aufgesplittet
    # in row4, row5 und der verbleibende rest vom Anfang nach row
    for *row, row4, row5 in reader:
        row6 = str(float(row4) * float(row5))
        # neue Liste erstellen und row in der liste entpacken
        # und die letzten 3 Elemente hinzufügen
        writer.writerow([*row, row4, row5, row6])
    # Wert aus StringIO() anzeigen
    # nach dem Verlassen des Kontextmanagers ist der Inhalt verloren
    print(csv_out.getvalue())

Mit echten Dateien:

Code: Alles auswählen

with (
    open("csv_in.csv", newline="", encoding="ascii") as csv_in,
    open("csv_out.csv", "w", newline="", encoding="ascii") as csv_out,
):
    ... code

Kann man bestimmt noch schöner machen, aber im Endeffekt geht es mir hier drum: https://peps.python.org/pep-3132/

[Sirius3]

os.chrdir darf in einem sauberen Programm nicht vorkommen, da es einen globalen Zustand ändert, der an anderer Stelle zu "Überraschungen" führen kann.

Variablennamen und Funktionen werden komplett klein geschrieben.
Dateien sollte man immer mit dem with-Statement öffnen.
`files` ist der falsche Name für EINEN Dateinamen.
Du öffnest viele Dateien, die Du nicht mehr schließt und benutzt dann nur das letzte `file`. Das sieht für mich nach einem Einrückfehler aus.
Das `path`-Argument wird gar nicht benutzt. filepath ist nur global definiert, das muß auch als Argument übergeben werden.
Heutzutage benutzt man f-Strings für Stringformatierung.
Der Filemodus w+ ist für Text-Dateien nie sinnvoll, in Deinem Fall besteht die Gefahr, dass Reste der alten Datei erhalten bleiben und zu Datenmüll führen.
Text-Dateien sollte man immer explizit mit einem Encoding öffnen.
os.path.join mit nur einem Argument macht keinen Sinn.

Code: Alles auswählen

from pathlib import Path

BASEPATH = Path(r"C:\Users\Marco\PycharmProjects\pythonProject\ABCD")

def add_lines(inputpath, outputpath):
    with inputpath.open(encoding="utf8") as lines:
        new_lines = []
        for row in lines:
            row = row.rstrip()
            items = row.split()
            if len(items) >= 2:
                value = float(items[0]) * float(items[1]) * float(items[2])
                new_lines.append(f"{row} {value:%.2f}\n")

    with outputpath.open("w", encoding="utf8") as file:
        file.writelines(new_lines)


def main():
    for path in BASEPATH.iterdir():
        outputpath = path.with_stem(f"edited_{path.stem}")
        add_lines(path, outputpath)

if __name__ == "__main__":
    main()

[__blackjack__]

@mplahl: Das funtkioniert nicht zum grossen Teil. Das ist Murks. Und die Fehlerbeschreibung stimmt auch nicht.

Am besten komplett neu anfangen. Schritt für Schritt. Ohne `os`, insbesondere ohne `os.chdir()`, das verwendet man nicht. `pathlib` wurde bereits genannt. Wenn man keine externen Bibliotheken hinzunehmen will okay, aber `pathlib` ist in der Standardbibliothek, da gibt es keinen Grund das nicht zu verwenden.

Mit korrekten Namen. `addLines()` fügt keine Zeilen hinzu. `row` wäre eigentlich `line` und `items` könnte man dann `row` nennen.

Die Funktion verwendet das `path`-Argument gar nicht. Kann sie auch nicht wirklich, denn das scheint ja der Name der Ergebnisdatei zu sein.

Dateien die man öffnet, sollte man auch wieder schliessen. Am besten verwendet man die ``with``-Anweisung.

`listdir()` garantiert keine Reihenfolge in der die Dateinamen geliefert werden. Im Grunde wird also bei jedem Funktionsaufruf eine zufällige Datei als Eingabedatei verwendet. Wobei jedes mal alle Dateien geöffnet werden und nur die letzte explizit geschlossen wird. Dass das nicht die Systemressourcen was offene Dateien pro Prozess angeht sprengt, ist quasi Glück, das zumindest CPython momentan die Dateien trotzdem sehr zeitnah wieder schliesst.

``.split("\n")`` ist problematisch weil das am Ende eine leere Zeichenkette liefert. Die korrekte Methode wäre `splitlines()`. Und dann kann vielleicht auch der Test auf die Länge des Ergebnis weg. Der wäre auch fehlerhaft, denn damit das summieren der ersten drei Spalten funktioniert, muss die Länge ≥3 sein, nicht nur ≥2.

Zeichenkettenformatierung mit dem ``%``-Operator ist veraltet. Das hat man unter Python 2.7 schon nicht mehr gemacht. Es gibt f-Zeichenkettenliterale.

Das Ergebnis von der Zeichenkettenformatierung ist eine Zeichenkette. Die wird durch einen weiteren `str()`-Aufruf nicht irgendwie *noch* “zeichenkettiger“.

Wenn man für die Ergebniszeile sowieso schon Zeichenkettenformatierung verwendet, macht es keinen Sinn das dann zusätzlich noch mit Zeichenketten mit ``+`` zu verketten zu vermischen.

Beim öffnen von Textdateien sollte man immer die Kodierung explizit angeben.

"w+" ist für Textdateien eigentlich nie ein sinnvoller Dateimodus. Es wird hier ja auch gar nicht verwendet. Ganz normal "w" reicht aus.

Auf Modulebene sollte nur Code stehen der Konstanten, Funktionen, und Klassen definiert. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst.

Dann kann auch die bisher einzige Funktion nicht einfach so magisch auf `filepath` ausserhalb der Funktion zugreifen.

Namen werden in Python klein_mit_unterstrichen geschrieben. Ausnahmen sind Konstanten (KOMPLETT_GROSS) und Klassen (PascalCase).

Wenn Du neu anfängst, dann entwickle das in Schritten. Ein Funktion schreiben die *eine* Datei verarbeitet. Testen ob die geht. Quelldateipfade ermitteln. Testen ob das geht. Die Funktion für jeden Pfad aufrufen. Testen ob das geht. Falls irgendeiner der Schritte nicht funktioniert, erst weitermachen wenn er das tut.