Wie kann ich Dateien mit fester Breite in Python effizient analysieren: Strukturmodul vs. optimiertes String-Slicing?

Effizientes Parsen von Dateien mit fester Breite

Dateien mit fester Breite stellen aufgrund ihrer vorgegebenen Spaltenlängen eine einzigartige Parsing-Herausforderung dar. Für die Datenverarbeitung ist es von entscheidender Bedeutung, effiziente Wege zum Extrahieren von Daten aus solchen Dateien zu finden.

Problemstellung

Gegeben sei eine Datei mit Zeilen fester Breite, wobei jede Spalte einen bestimmten Wert darstellt , entwickeln Sie eine effiziente Methode, um diese Zeilen in separate Komponenten zu zerlegen. Derzeit wird String-Slicing eingesetzt, es bestehen jedoch Bedenken hinsichtlich der Lesbarkeit und Eignung für große Dateien.

Lösung

Es werden zwei effiziente Parsing-Methoden vorgestellt:

Methode 1: Verwenden des Strukturmoduls

Das Strukturmodul der Python-Standardbibliothek bietet eine praktische Möglichkeit, Daten aus binären Datenströmen zu entpacken. Es kann mit Dateien mit fester Breite verwendet werden, indem eine Formatzeichenfolge definiert wird, die die Breite und den Typ jedes Felds angibt. Diese Methode bietet sowohl Geschwindigkeit als auch Einfachheit.

Beispiel:

<code class="python">import struct

fieldwidths = (2, -10, 24)
fmtstring = ' '.join('{}{}'.format(abs(fw), 'x' if fw < 0 else 's') for fw in fieldwidths)

# Convert Unicode input to bytes and the result back to Unicode string.
unpack = struct.Struct(fmtstring).unpack_from  # Alias.
parse = lambda line: tuple(s.decode() for s in unpack(line.encode()))

print('fmtstring: {!r}, record size: {} chars'.format(fmtstring, struct.calcsize(fmtstring)))

line = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\n'
fields = parse(line)
print('fields: {}'.format(fields))</code>

Methode 2: String-Slicing mit Kompilierung verwenden

Während das String-Slicing unkompliziert erscheinen mag, kann seine Geschwindigkeit verbessert werden, indem eine effizientere Version mit eval() kompiliert wird. Diese Methode generiert eine Liste von Slice-Grenzen, die konstant sind und daher schneller ausgeführt werden können.

Beispiel (optimiert):

<code class="python">def make_parser(fieldwidths):
    cuts = tuple(cut for cut in accumulate(abs(fw) for fw in fieldwidths))
    pads = tuple(fw < 0 for fw in fieldwidths) # bool flags for padding fields
    flds = tuple(zip_longest(pads, (0,)+cuts, cuts))[:-1]  # ignore final one
    slcs = ', '.join('line[{}:{}]'.format(i, j) for pad, i, j in flds if not pad)
    parse = eval('lambda line: ({})\n'.format(slcs))  # Create and compile source code.
    # Optional informational function attributes.
    parse.size = sum(abs(fw) for fw in fieldwidths)
    parse.fmtstring = ' '.join('{}{}'.format(abs(fw), 'x' if fw < 0 else 's')
                                                for fw in fieldwidths)
    return parse</code>

Beide Methoden bieten effiziente Möglichkeiten zum Parsen Dateien mit fester Breite. Methode 1 mit dem Strukturmodul ist einfach zu verwenden, während Methode 2 mit optimiertem String-Slicing bei Optimierung eine etwas bessere Leistung bietet.

Das obige ist der detaillierte Inhalt vonWie kann ich Dateien mit fester Breite in Python effizient analysieren: Strukturmodul vs. optimiertes String-Slicing?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!