Binäre Dateien in Python lesen und schreiben: Ein vollständiger Leitfaden

1. Einführung

Python unterstützt nicht nur Textdateien, sondern auchdas Lesen und Schreiben binärer Dateien. Durch die Arbeit mit binären Dateien können Sie verschiedene Arten von Daten wie Bilder, Audio, Video und komprimierte Dateien manipulieren. Dieser Artikel erklärt, wie manbinäre Dateien sicher und effizient mit Python liest.

1.1 Was ist eine Binärdatei?

Eine Binärdatei ist eine Dateibestehend aus Binärdaten (einer Kombination aus 0en und 1en), die Computer verstehen können, anstelle von lesbarem Text für Menschen. Beispiele für Binärdateien umfassen:

• Bilddateien (PNG, JPEG, BMP usw.)
• Audiodateien (WAV, MP3, AAC usw.)
• Videodateien (MP4, AVI, MOV usw.)
• Komprimierte Dateien (ZIP, RAR, GZ usw.)
• Ausführbare Dateien (EXE, DLL, BIN usw.)

Wenn sie in einem normalen Texteditor geöffnet werden, erscheinen Binärdateien oft als „Gekrakel“. Dies geschieht, weil die Daten in einem spezifischen Format kodiert sind und sinnvolle Informationen nur mit einem geeigneten Programm extrahiert werden können.

1.2 Unterschied zwischen Text- und Binärdateien

Der Hauptunterschied zwischen Binär- und Textdateien liegt in ihrerDatenspeichermethode.

Hauptunterschiede

1. Datenstruktur

• Textdateien enthalten nur Daten, die als Zeichen interpretierbar sind.
• Binärdateien können jede Art von Daten enthalten (Bilder, Audio, ausführbarer Code usw.).

1. Größe

• Textdateien sind normalerweise kleiner, wenn kleine Datenmengen gespeichert werden.
• Binärdateien können aufgrund von Kodierungs-Overhead größer sein.

1. Bearbeitungsmethode

• Textdateien können direkt mit Editoren wie Notepad oder VS Code geöffnet und bearbeitet werden.
• Binärdateien erfordern spezielle Tools (z. B. Binär-Editoren) zur Bearbeitung.

1.3 Warum Binärdateien in Python handhaben?

Häufige Gründe für die Handhabung binärer Dateien mit Python umfassen:

1 Verarbeiten von Bild- und Audiodaten

Durch das Lesen binärer Dateien können Python-ProgrammeBilder analysieren oder Audiodaten verarbeiten.

# Beispiel: Lesen eines PNG-Bildes als Binär
with open("image.png", "rb") as file:
    binary_data = file.read()
    print(binary_data[:20])  # Anzeigen der ersten 20 Bytes

2 Analysieren komprimierter Daten

Python stellt Module wie zipfile und gzip zur Verfügung, umZIP/GZ-Dateien programmgesteuert zu extrahieren oder zu komprimieren.

import gzip

# Beispiel: Öffnen einer GZ-komprimierten Datei
with gzip.open("example.gz", "rb") as file:
    content = file.read()
    print(content)

3 Parsen binärer Protokolle

In Low-Level-Operationen wie Netzwerkkommunikation oder Datenbanken ist das Parsen binärer Daten essenziell. Das struct-Modul ermöglicht es, binäre Daten in Zahlen oder Strings umzuwandeln.

import struct

# Beispiel: Umwandeln binärer Daten in Ganzzahl
binary_data = b'
   '  # 4 Bytes an Daten
integer_value = struct.unpack('<i', #="" 1<="" ausgabe:="" binary_data)[0]="" code="" print(integer_value)=""></i',>

1.4 Zusammenfassung

• Binärdateienspeichern Informationen wie Bilder, Audio und komprimierte Daten.
• Im Gegensatz zu Textdateienwerden Daten als Sequenzen von 0en und 1en gespeichert.
• Python ermöglicht das Parsen, Verarbeiten und Konvertieren binärer Daten.
• Mit Pythons open()-Funktion und struct-Modul können Binärdateien effizient gehandhabt werden.

2. Wie man Binärdateien in Python liest und grundlegende Operationen

In Python können SieBinärdateien mit der open()-Funktion öffnen und lesen. Dieser Abschnitt erklärt die grundlegenden Operationen zum Arbeiten mit Binärdateien in Python.

2.1 Das Lesen von Binärdateien mit der open()-Funktion

Die open()-Funktion in Python ist der grundlegende Weg, um Dateien zu öffnen. Um eine Binärdatei zu öffnen, müssen Sie'rb' (schreibgeschützter Binärmodus)angeben.

Grundlegende Syntax

file = open("example.bin", "rb")  # 'rb' bedeutet „Lesen im Binärmodus“
binary_data = file.read()  # Den Dateiinhalt lesen
file.close()  # Die Datei schließen

Allerdings kann bei dieser Methode, wenn Sie close() nicht explizit aufrufen, die Datei nicht geschlossen werden, was zu einemRessourcenleckführt. Daher ist es in Python übliche Praxis, den with-Statement für sicherere Dateihandhabung zu verwenden.

2.2 Sicheres Binäres Lesen mit dem with-Statement

Der with-Statement schließt die Datei automatisch, wenn die Arbeit abgeschlossen ist, und stellt sicher, dass Ressourcen ordnungsgemäß freigegeben werden, auch wenn ein Fehler auftritt.

Beispiel: Sicheres Lesen von Binärdaten

with open("example.bin", "rb") as file:
    binary_data = file.read()

# Sobald der with-Block endet, wird die Datei automatisch geschlossen

Vorteile der Verwendung des with-Statements

1. Kein Bedarf, file.close() aufzurufen(es schließt automatisch)
2. Keine Ressourcenlecksauch wenn ein Fehler auftritt
3. Der Code wird einfacher und lesbarer

2.3 Varianten der Lese-Methoden

Python bietet mehrere Möglichkeiten, um Binärdateien zu lesen. Wählen Sie die geeignete Methode je nach Anwendungsfall.

1 Die gesamte Datei auf einmal lesen (read())

Diese Methode lädt dengesamten Dateiinhalt in den Speicher.

with open("example.bin", "rb") as file:
    binary_data = file.read()  # Die gesamte Datei auf einmal lesen

Vorteile

• Einfach und leicht verständlich
• Effizient für kleine Dateien

Nachteile

• Bei großen Dateien (Hunderte von MB bis GB) kann der Speicherverbrauch übermäßig werden

2 In festen Größenblöcken lesen (read(n))

Diese Methode liest die Dateiin partiellen Blöcken, was ideal für große Dateien ist.

with open("example.bin", "rb") as file:
    chunk = file.read(1024)  # 1024 Bytes (1 KB) auf einmal lesen
    while chunk:
        print(chunk)  # Den Block verarbeiten
        chunk = file.read(1024)  # Den nächsten 1 KB lesen

Vorteile

• Reduziert den Speicherverbrauch
• Effizient für die Handhabung großer Dateien

Nachteile

• Nicht geeignet, wenn die gesamte Datei auf einmal geladen werden muss

3 Binärdaten zeilenweise lesen (readline())

Wenn die Binärdatei Zeilenumbruchzeichen enthält, kann sie zeilenweise gelesen werden.

with open("example.bin", "rb") as file:
    line = file.readline()  # Eine Zeile lesen
    while line:
        print(line)
        line = file.readline()  # Die nächste Zeile lesen

Anwendungsfall

• Binäre Logdateienoder Binärdaten, die Zeilenumbrüche enthalten

Hinweis

• Wenn kein Zeilenumbruch vorhanden ist, wird der gesamte Inhalt als eine Zeile behandelt, daher ist diese Methode nur für spezifische Dateien gültig

2.4 Dateipositionierung mit seek()

Die seek()-Methode ermöglicht es, Daten von jeder Position in der Datei zu lesen.

Grundlegende Syntax von seek()

file.seek(offset, whence)

Beispiel: Lesen von Daten aus der Mitte einer Datei

with open("example.bin", "rb") as file:
    file.seek(10)  # Zum 10. Byte vom Anfang verschieben
    data = file.read(5)  # 5 Bytes lesen
    print(data)

Anwendungsfälle

• Headerinformationen extrahieren
• Spezifische Datenabschnitte analysieren

2.5 Die aktuelle Dateiposition mit tell() abrufen

Die tell()-Methode gibt die aktuelle Dateiposition (Byte-Offset) zurück.

Beispiel: Dateiposition überprüfen

with open("example.bin", "rb") as file:
    file.read(10)  # 10 Bytes lesen
    position = file.tell()  # Die aktuelle Position abrufen
    print(f"Aktuelle Dateiposition: {position} Bytes")

Anwendungsfälle

• Überprüfen, wie viel von der Datei gelesen wurde
• Debugging beim Verarbeiten von Dateien in der Mitte

2.6 Zusammenfassung

• Verwenden Sie den 'rb'-Modus beim Öffnen von Binärdateien in Python
• Das with-Statement stellt sicher, dass Dateien sicher geschlossen werden
• read() lädt die gesamte Datei in den Speicher, was für große Dateien ineffizient sein kann — verwenden Sie stattdessen read(n)
• seek() ermöglicht das Verschieben zu jeder Dateiposition, und tell() ruft die aktuelle Position ab

3. Effiziente Methoden zum Lesen binärer Dateien in Python

Im vorherigen Abschnitt haben wir die grundlegenden Wege zum Öffnen binärer Dateien erklärt. In diesem Abschnitt gehen wir detailliert aufeffiziente Wege zum Lesen binärer Dateien ein. Python bietet mehrere Methoden zum Lesen binärer Daten, und die Wahl des richtigen Ansatzes hängt vom Anwendungsfall ab.

3.1 Lesen der gesamten Binärdatei auf einmal (read())

Um eine Binärdatei auf einmal zu lesen, verwenden Sie die read()-Methode.

Grundlegende Syntax

with open("example.bin", "rb") as file:
    binary_data = file.read()

Vorteile

• Einfach und intuitiv
• Geeignet für kleine Dateien (ein paar MB oder weniger)

Nachteile

• Verbraucht viel Speicher, wenn die Datei groß ist (hunderte MB oder mehr)
• Kann zu Abstürzen führen, wenn die Dateigröße den verfügbaren Speicher überschreitet

Beispiel

with open("sample.bin", "rb") as file:
    binary_data = file.read()
    print(len(binary_data))  # Zeigt die Dateigröße in Bytes an

Diese Methode ist sicher für Dateien, dieein paar MB groß sind.

3.2 Lesen in festen Größenblöcken (read(n))

Beim Umgang mit großen Binärdateien wird empfohlen,die Datei in festen Größenblöcken zu lesen, um den Speicherverbrauch zu optimieren.

Grundlegende Syntax

with open("example.bin", "rb") as file:
    chunk = file.read(1024)  # Liest 1024 Bytes (1 KB) auf einmal
    while chunk:
        print(chunk)
        chunk = file.read(1024)  # Liest den nächsten 1 KB

Vorteile

• Verringert den Speicherverbrauch beim Verarbeiten großer Dateien
• Unterstützt streaming-ähnliche Verarbeitung

Nachteile

• Zusätzliche Verarbeitung für Echtzeit-Handhabung erforderlich

Beispiel

with open("large_file.bin", "rb") as file:
    while True:
        chunk = file.read(4096)  # Liest 4 KB auf einmal
        if not chunk:
            break  # Beendet, wenn keine Daten mehr vorhanden
        print(f"Read {len(chunk)} bytes")

Diese Methode ermöglicht es Ihnen,Dateien im GB-Bereich zu verarbeiten, ohne den Speicher zu erschöpfen.

3.3 Lesen binärer Daten Zeile für Zeile (readline())

Wenn die Binärdaten Zeilenumbruchzeichen enthalten, können sie zeilenweise gelesen werden.

Grundlegende Syntax

with open("example.bin", "rb") as file:
    line = file.readline()
    while line:
        print(line)
        line = file.readline()

Anwendungsfälle

• Binäre Logdateienoder Binärdaten, die Zeilenumbruchzeichen enthalten

Hinweise

• Wenn keine Zeilenumbrüche vorhanden sind, wird die gesamte Datei als eine Zeile behandelt
• Nicht üblicherweise in der allgemeinen Binärverarbeitung verwendet

3.4 Lesen von Daten von spezifischen Dateipositionen (seek())

Beim Analysieren binärer Dateien möchten Sie möglicherweiseDaten ab einer spezifischen Dateiposition lesen. In solchen Fällen verwenden Sie die seek()-Methode.

Grundlegende Syntax

file.seek(offset, whence)

Beispiel: Lesen von Daten ab einer spezifischen Position

with open("example.bin", "rb") as file:
    file.seek(10)  # Verschiebt zum 10. Byte ab dem Anfang
    data = file.read(5)  # Liest 5 Bytes
    print(data)

Diese Methode ist nützlich fürdas Parsen von Datei-Headernoderdie Verarbeitung von Dateien mit strukturierten Daten.

3.5 Abrufen der aktuellen Dateiposition (tell())

Die tell()-Methode gibt die aktuelle Dateiposition (Byte-Offset) zurück.

Beispiel

with open("example.bin", "rb") as file:
    file.read(20)  # Liest 20 Bytes
    position = file.tell()  # Holt die aktuelle Position
    print(f"Current position: {position} bytes")

Anwendungsfälle

• Überprüfen, wie viel von der Datei gelesen wurde
• Debugging der Verarbeitung innerhalb der Datei

3.6 Verwendung von speicherabbildenden Dateien für schnelleres Lesen (mmap)

Das mmap-Modul ermöglicht es Ihnen,große Binärdateien in den virtuellen Speicher zu mappen, für schnelleren Zugriff.

Grundlegende Syntax

import mmap

with open("example.bin", "rb") as file:
    with mmap.mmap(file.fileno(), 0, access=mmap.ACCESS_READ) as mmapped_file:
        print(mmapped_file[:100])  # Holt die ersten 100 Bytes

Vorteile

• Schnellerer Zugriff, da die Datei im Speicher gehandhabt wird
• Ermöglicht direkten Zugriff auf spezifische Bereiche

Nachteile

• Komplexer als die Standard-Dateihandhabung
• Kann Speicherprobleme verursachen, wenn die Datei extrem groß ist

3.7 Zusammenfassung

• Effizientes Lesen binärer Dateien erfordert die Auswahl von Methoden basierend auf Dateigröße und Zweck
• Verwenden Sie read() für kleine Dateien
• Verwenden Sie read(n) für große Dateien, um sie in Blöcken zu verarbeiten
• Verwenden Sie seek(), um Daten von spezifischen Positionen abzurufen
• Verwenden Sie mmap für schnellen Zugriff, aber wenden Sie es sorgfältig je nach Fall an

4. Wie analysiert man gelesene Binärdaten

Nach dem Lesen einer Binärdatei in Python ist es wichtig, die Daten ordnungsgemäß zu analysieren. Da Binärdaten normalerweise in Formaten wie Ganzzahlen, Strings oder Gleitkommazahlen gespeichert werden,ist das Verständnis der Datenstruktur und die Anwendung der richtigen Methode für die Analyse essenziell.

In diesem Abschnitt erklären wir, wie man Binärdaten mit dem Python-Modul struct analysiert.

4.1 Was ist das struct-Modul?

Das struct-Modul in Python ist eineStandardbibliothek zum Kodieren und Dekodieren von Binärdaten mit angegebenen Formaten.

Hauptmerkmale

• Binärdaten in Ganzzahlen, Gleitkommazahlen und Strings umwandeln (Auspacken)
• Werte in Binärformat umwandeln (Verpacken)
• Byte-Reihenfolge (Endianness) angeben

Grundlegende Syntax des struct-Moduls

import struct

# Binärdaten in spezifische Typen umwandeln (Auspacken)
data = struct.unpack(format, binary_data)

# Werte in Binärdaten umwandeln (Verpacken)
binary_data = struct.pack(format, value1, value2, ...)

4.2 Auspacken (Dekodieren) von Binärdaten

Um Binärdaten, die aus einer Datei gelesen wurden, als Python-Werte (Ganzzahlen, Strings usw.) zu interpretieren, verwenden Siestruct.unpack().

Beispiel: Dekodieren einer 4-Byte-Ganzzahl (32-Bit)

import struct

# Binärdaten (4 Bytes)
binary_data = b'
   '  # Stellt 1 dar (Little Endian)

# Als unsignierte 32-Bit-Ganzzahl in Little Endian auspacken
value = struct.unpack('<i', #="" 1<="" ausgabe:="" binary_data)[0]="" code="" print(value)=""></i',>

4.3 Parsen von String-Daten

Wenn eine Binärdatei String-Daten enthält, können Sie struct.unpack() verwenden, um sie zu dekodieren, und dann die entsprechende Zeichenkodierung anwenden.

Beispiel: Dekodieren eines 10-Byte-Strings

import struct

# 10-Byte-Binärdaten
binary_data = b'HelloWorld'

# Als String interpretieren
decoded_string = struct.unpack('10s', binary_data)[0].decode('utf-8')
print(decoded_string)  # Ausgabe: HelloWorld

Hinweise

• Durch Angabe der Byte-Größe (z. B. 10s) können Siefeste Längen-Strings extrahieren.
• Verwenden Sie .decode('utf-8'), um in die korrekte Zeichenkodierung umzuwandeln.

4.4 Parsen von Gleitkommazahlen

Einige Binärdateien speichernnumerische Daten im IEEE 754-Gleitkommaformat. Das struct-Modul ermöglicht das Dekodieren dieser Werte.

Beispiel: Dekodieren einer 4-Byte-Gleitkommazahl

import struct

# 4-Byte-Gleitkommazahl (IEEE 754-Format)
binary_data = b'  €?'  # Stellt 1.0 dar

# Auspacken
value = struct.unpack('<f', #="" 1.0<="" ausgabe:="" binary_data)[0]="" code="" print(value)=""></f',>

4.5 Angabe der Endianness (Byte-Reihenfolge)

Binärdaten können in zwei Byte-Reihenfolgen gespeichert werden:Little EndianundBig Endian. Die korrekte Angabe der Endianness ist entscheidend für die richtige Interpretation.

Beispiel: Unterschied zwischen Little und Big Endian

import struct

binary_data = b'
   '  # Stellt 1 dar (Little Endian)

# Little Endian (geringstwertiges Byte zuerst)
little_endian = struct.unpack('<i', #="" (bedeutendstes="" 1="" ausgabe:="" big="" big_endian="struct.unpack('" binary_data)[0]="" byte="" endian="" endian:="" print(f"little="" zuerst)="" {little_endian}")="">I', binary_data)[0]
print(f"Big Endian: {big_endian}")  # Ausgabe: 16777216</i',>

4.6 Zusammenfassung

• Das struct-Modul ermöglicht das Parsen von Binärdaten in Zahlen und Strings
• Das Verständnis der Endianness ist essenziell für genaues Dekodieren
• Sie können Datei-Header und strukturierte Daten effizient parsen, indem Sie mehrere Datentypen gemeinsam auspacken

5. Wie man Binärdateien in Python erstellt und schreibt

Im vorherigen Abschnitt haben wir erklärt, wie man Binärdaten in Python analysiert. In diesem Abschnitt werden wir behandelnwie man Binärdaten erstellt und in eine Binärdatei mit Python schreibt.

5.1 Schreiben von Dateien im Binärmodus

Um eine Binärdatei in Python zu erstellen, verwenden Sie den'wb' (nur-Schreib-Binärmodus)Modus mit der open()-Funktion.

Grundlegende Syntax

with open("example.bin", "wb") as file:
    file.write(binary_data)

• 'wb' bedeutet„schreiben im Binärmodus“.
• Verwenden Sie die write()-Methode, umBinärdaten in eine Datei zu schreiben.

Einfaches Beispiel: Schreiben von Binärdaten

with open("output.bin", "wb") as file:
    file.write(b'
')  # 4 Bytes Daten schreiben

Wichtige Punkte

• b'
' stellt4 Bytes Binärdatendar (im Hexadezimalformat).
• Die tatsächliche Dateigröße beträgt4 Bytes.

5.2 Erstellen von Binärdaten mit struct.pack()

Als Umkehrung von struct.unpack() wird struct.pack() von Python verwendet, umDaten in Binärformat zu konvertieren, bevor sie geschrieben werden.

Grundlegende Syntax

import struct
binary_data = struct.pack(format, value1, value2, ...)

• format gibt denBinärdatentyp (Ganzzahl, Gleitkommazahl, String usw.)an.
• value1, value2, ... sind die zu packenden Werte.

5.3 Schreiben numerischer Daten in eine Binärdatei

Um Ganzzahlen oder Gleitkommazahlen in eine Binärdatei zu speichern, verwenden Sie zuerst struct.pack(), um sie in Binär umzuwandeln.

Beispiel: Konvertieren von Ganzzahlen in Binär und Schreiben

import struct

# Unsigned 16-bit integer (H) and unsigned 32-bit integer (I)
binary_data = struct.pack('<hi', "wb")="" #="" 123456789)="" 512,="" as="" code="" datei="" file.write(binary_data)<="" file:="" in="" open("numbers.bin",="" schreiben="" with=""></hi',>

Erklärung

• <hi< code=""> →Little Endian: Unsigned 16-Bit-Ganzzahl (2 Bytes) + Unsigned 32-Bit-Ganzzahl (4 Bytes)</hi<>
• 512 →  (hex: 0x0200)
• 123456789 → Í[ (hex: 0x075BCD15)

5.4 Schreiben von String-Daten in eine Binärdatei

Binärdateien können auchStrings fester Längespeichern.

Beispiel: Schreiben eines 10-Byte-Strings

import struct

text = "Hello"
binary_data = struct.pack('10s', text.encode('utf-8'))  # Feste Länge: 10 Bytes

with open("text.bin", "wb") as file:
    file.write(binary_data)

Wichtige Punkte

• '10s' bedeutet einenString fester Länge von 10 Bytes.
• Konvertieren in Binär mit encode('utf-8').
• Wenn der String kürzer als 10 Bytes ist, wird automatisch mit Füllbytes (Null-Bytes) aufgefüllt.

5.5 Schreiben von Gleitkommazahlen in eine Binärdatei

Gleitkommazahlen können ebenfalls mit struct.pack() gespeichert werden.

Beispiel: Schreiben einer Gleitkommazahl

import struct

float_value = 3.14
binary_data = struct.pack('<f', "wb")="" #="" 4-byte-gleitkommazahl="" as="" code="" file.write(binary_data)<="" file:="" float_value)="" open("float.bin",="" with=""></f',>

Erklärung

• <f< code=""> bedeutet eineLittle Endian 4-Byte-Gleitkommazahl.</f<>
• Die IEEE 754-Darstellung von 3.14 lautet0xC3F54840.

5.6 Anhängen an eine Binärdatei ('ab'-Modus)

UmDaten an eine bestehende Binärdatei anzuhängen, verwenden Sie 'ab' (Anhangmodus) anstelle von 'wb'.

Beispiel: Daten an eine Binärdatei anhängen

with open("output.bin", "ab") as file:
    file.write(b'ÿÿ')  # Zusätzliche Daten schreiben

Wichtige Punkte

• 'ab' bedeutet„anhängen im Binärmodus“.
• Daten werden am Ende hinzugefügt, ohne bestehenden Inhalt zu überschreiben.

5.7 Schreiben von Daten an spezifische Positionen mit seek()

Es ist auch möglich,Daten an einer spezifischen Positionin einer Datei zu schreiben.

Beispiel: Schreiben von Daten am 10. Byte vom Anfang

with open("output.bin", "r+b") as file:
    file.seek(10)  # Zum 10. Byte springen
    file.write(b'a»')  # 2 Bytes schreiben

Wichtige Punkte

• 'r+b'-Modus bedeutet„lesen/schreiben im Binärmodus“.
• seek(10) springt zur10. Byte vom Anfang, bevor geschrieben wird.

5.8 Zusammenfassung

• Verwenden Sie den 'wb'-Modus in Python, um Binärdateien zu schreiben
• struct.pack() konvertiert Zahlen, Strings und Gleitkommazahlen in Binär
• 'ab' (Anhangmodus) ermöglicht das Hinzufügen von Daten zu bestehenden Binärdateien
• seek() ermöglicht das Schreiben von Daten an spezifischen Positionen in einer Datei

6. Praktische Beispiele zum Umgang mit Binärdateien in Python

Bislang haben wir die Grundlagen des Lesens und Schreibens von Binärdateien behandelt. In diesem Abschnitt stellen wirpraktische Beispiele vor, wie man Binärdateien mit Python handhabt.

6.1 Lesen und Schreiben von Bilddateien

Binärdateien werden häufig fürBildverarbeitung verwendet. Hier ist, wie man einebinäre Bilddatei liest und kopiert.

Beispiel: Kopieren einer Bilddatei

# Binäre Bilddaten lesen
with open("input.png", "rb") as infile:
    image_data = infile.read()

# Binäre Bilddaten in eine andere Datei schreiben
with open("copy.png", "wb") as outfile:
    outfile.write(image_data)

Wichtige Punkte

• Die Bilddaten werden binär gelesen und wie sie sind in eine andere Datei geschrieben.
• Dies stellt sicher, dass das Bildohne Beschädigung kopiert wird.

6.2 Lesen und Schreiben von Audiodateien

Binärdateien werden auch in derVerarbeitung von Audiodaten verwendet. Zum Beispiel können WAV-Dateien in Python gelesen und verarbeitet werden.

Beispiel: Lesen des Headers einer WAV-Datei

with open("sample.wav", "rb") as file:
    header = file.read(44)  # Der Header einer WAV-Datei umfasst 44 Bytes
    print(header)

Erklärung

• Durch das Lesen der ersten 44 Bytes können SieMetadaten der WAV-Datei wie Abtastrate und Kanalanzahl erhalten.

6.3 Umgang mit Komprimierungsdateien (ZIP/GZ)

Python stellt die zipfile– und gzip-Module zur Verfügung, um komprimierte Binärdateien zu verarbeiten.

Beispiel: Extrahieren einer ZIP-Datei

import zipfile

with zipfile.ZipFile("archive.zip", "r") as zip_ref:
    zip_ref.extractall("extracted")  # Inhalte in den Ordner „extracted“ extrahieren

Beispiel: Lesen einer GZ-komprimierten Datei

import gzip

with gzip.open("compressed.gz", "rb") as file:
    content = file.read()
    print(content[:50])  # Die ersten 50 Bytes anzeigen

6.4 Lesen und Schreiben von ausführbaren Dateien

Binärdateien umfassen auchausführbare Dateien (.exe, .bin usw.). Diese können im Binärmodus gelesen und in eine andere Datei geschrieben werden.

Beispiel: Kopieren einer ausführbaren Datei

with open("program.exe", "rb") as infile:
    exe_data = infile.read()

with open("copy.exe", "wb") as outfile:
    outfile.write(exe_data)

Hinweise

• Beim Umgang mit ausführbaren Dateiensollten Sie sie nie ohne spezielles Wissen bearbeiten.
• Unangemessene Änderungen können dazu führen, dass die Datei beschädigt oder unsicher wird.

6.5 Verwendung von struct zum Parsen von Binärdatensstrukturen

Wenn Binärdaten strukturierte Werte enthalten, verwenden Sie das struct-Modul, um sie zu parsen.

Beispiel: Parsen eines benutzerdefinierten Binärformats

Angenommen, Sie haben Binärdaten im folgenden Format:

• 2-Byte-Ganzzahl ohne Vorzeichen
• 4-Byte-Gleitkommazahl
• 10-Byte-String

Sie können es wie folgt parsen:

import struct

binary_data = struct.pack("<hf10s", #="" (unpack)="" 1000,="" 3.14,="" b"helloworld")="" binary_data)="" code="" dekodieren="" print(value1,="" value1,="" value2,="" value3='struct.unpack("<Hf10s",' value3.decode("utf-8"))<=""></hf10s",>

Ergebnis

1000 3.14 HelloWorld

6.6 Zusammenfassung

• Binärdateien werden weit verbreitet für Bilder, Audio, Video, komprimierte Daten und Ausführbare verwendet.
• Die Standardbibliothek von Python unterstützt die Verarbeitung von Binärdateien mit Modulen wie zipfile, gzip und struct.
• Durch die Kombination von Lesen, Schreiben und Parsen können Sie verschiedene Binärdateiformate handhaben.

7. Häufige Fallstricke und Best Practices beim Umgang mit Binärdateien

Beim Arbeiten mit Binärdateien in Python gibt es mehrereFallstricke und Vorsichtsmaßnahmen, auf die man achten sollte. Hier fassen wir gängige Fehler undBest Practices zusammen.

7.1 Häufige Fallstricke

1. Dateien ohne Angabe des Binärmodus öffnen

• Wenn Sie eine Binärdatei ohne Verwendung von 'rb' oder 'wb' öffnen, versucht Python möglicherweise, sie als Text zu interpretieren, was potenziell zuKorruption oder Fehlern führen kann.

1. Übermäßiger Speicherverbrauch beim Lesen großer Dateien

• Die Verwendung von read() lädt die gesamte Datei auf einmal in den Speicher. Bei Dateien von mehreren hundert MB oder GB kann dies zu einemMemoryError führen.

1. Endianness (Byte-Reihenfolge) ignorieren

• Wenn Sie Binärdaten ohne Angabe der korrekten Endianness dekodieren, können Wertefalsch interpretiert werden.

1. Ausführbare Dateien ohne Kenntnisse bearbeiten

• Unangemessene Bearbeitung von Binärausführbaren Dateien (EXE, DLL usw.) kanndie Datei beschädigen oder Sicherheitsprobleme verursachen.

1. Falsche String-Kodierung

• Binärstrings müssen mit der korrekten .decode('utf-8') oder einer anderen Kodierung dekodiert werden. Die Verwendung der falschen Kodierung kann zuverstümmeltem Text oder Fehlern führen.

7.2 Best Practices

1. Immer die with-Anweisung verwenden

• Die with-Anweisung stellt sicher, dassDateien automatisch geschlossen werden, und verhindert Ressourcenlecks.

1. read(n) für große Dateien verwenden

• Für große Dateien lesen Sie siein Stücken, um den Speicherverbrauch zu reduzieren.

1. Endianness explizit angeben

• Beim Verwenden von struct.unpack() immer < (Little Endian)oder> (Big Endian) angeben.

1. Dateiformat vor der Verarbeitung validieren

• Überprüfen Sie Header oder Magic Numbers, um sicherzustellen, dass der Dateityp korrekt ist, bevor Sie lesen.

1. Angemessene Bibliotheken verwenden

• Für Bilder: PIL/Pillow
• Für Audio: wave, pydub
• Für komprimierte Dateien: zipfile, gzip

1. Speicher-mapped Dateien (mmap) für Leistung verwenden

• Große Dateien effizient verarbeiten, ohne die gesamte Datei in den Speicher zu laden.

7.3 Zusammenfassung

• Binärmodus ('rb', 'wb') beim Öffnen von Binärdateien angeben.
• with für sichere Dateibehandlung verwenden.
• Für große Dateien in Stücken lesen.
• Bei der Dekodierung auf Endianness achten.
• Spezialisierte Bibliotheken für jedes Dateiformat verwenden.

8. Schluss

In diesem Artikel haben wir erklärt, wie manbinäre Dateien in Python liest, schreibt und analysiert.
Binäre Dateien sind essenziell, wenn es um den Umgang mitBildern, Audio, Video, komprimierten Daten oder benutzerdefinierten Datenformaten geht, und ihre Beherrschung erweitert den Anwendungsbereich von Python-Programmen erheblich.

Wichtige Erkenntnisse

• Binäre Dateien speichern Daten als Sequenzen von Bytes anstelle von lesbarem Text für Menschen.
• Verwenden Sie 'rb', 'wb', 'ab' Modi, um binäre Daten korrekt zu lesen, zu schreiben oder anzuhängen.
• Das struct-Modul ermöglicht die Umwandlung binärer Daten in Ganzzahlen, Gleitkommazahlen und Strings.
• Endianness (Byte-Reihenfolge) muss korrekt angegeben werden, um eine genaue Dateninterpretation zu gewährleisten.
• Große binäre Dateien sollten in Chunks verarbeitet oder über mmap bearbeitet werden, um den Speicherverbrauch zu optimieren.
• Beste Practices: Verwenden Sie immer die with-Anweisung, behandeln Sie Ausnahmen und nutzen Sie spezialisierte Bibliotheken je nach Dateityp.

Abschließende Gedanken

Indem Sie den Umgang mit binären Dateien in Python beherrschen, können Sie mit einer Vielzahl von Datenformaten arbeiten – vonBild- und Audioverarbeitung über Protokollanalyse bis hin zu benutzerdefinierten Datenformaten.
Dies ist eine entscheidende Fähigkeit für alle, die inDatenengineering, wissenschaftlichem Rechnen oder Systemprogrammierung vorankommen möchten.

Nun, da Sie die Theorie und praktischen Techniken gelernt haben, versuchen Sie, sie in Ihren eigenenProjekten, Forschungen und Entwicklungen anzuwenden. 🚀