This is documentation for Mathematica 4, which was
based on an earlier version of the Wolfram Language.
View current documentation (Version 11.2)

 Documentation /  Mathematica /  Das Mathematica Buch /  Die Prinzipien von Mathematica /  Dateien und Ströme /

Import und Export von DateienSuchen in Dateien

2.11.8 Lesen von Daten

Mit << kann man Dateien lesen, die Mathematica-Ausdrücke in Eingabeform enthalten. Manchmal muß man jedoch stattdessen Dateien mit Daten in anderen Formaten lesen. Angenommen, Sie haben mit einem externen Programm Daten erzeugt, die aus einer durch Leerzeichen getrennten Folge von Zahlen bestehen. Diese Daten können nicht direkt als Mathematica-Eingabe gelesen werden. Die Funktion ReadList kann jedoch solche Daten aus einer Datei oder einem Eingabestrom nehmen und in eine Mathematica-Liste konvertieren.

Lesen von Zahlen aus einer Datei

Hier ist eine Datei mit Zahlen.

In[1]:= !!zahlen

11.1 22.2 33.3

44.4 55.5 66.6

Dies liest alle Zahlen der Datei und gibt sie als Liste zurück.

In[2]:= ReadList["zahlen", Number]

Out[2]=

Lesen von Zahlenblöcken

Hier wird jedes aufeinanderfolgende Zahlenpaar aus der Datei in eine separate Liste gesetzt.

In[3]:= ReadList["zahlen", {Number, Number}]

Out[3]=

So bringt man jede Zeile einer Datei in eine separate Liste.

In[4]:= ReadList["zahlen", Number, RecordLists -> True]

Out[4]=

ReadList kann auch mit Zahlen umgehen, die in Fortran-ähnlicher „E"-Notation angegeben sind. So wird zum Beispiel ReadList 2.5E+5 als lesen. Ebenso kann ReadList Zahlen mit einer beliebigen Anzahl signifikanter Stellen handhaben.

Hier ist eine Datei, die Zahlen in Fortran-ähnlicher „E"-Notation enthält.

In[5]:= !!bignum

4.5E-5 7.8E4

2.5E2 -8.9

ReadList kann mit Zahlen in dieser Form umgehen.

In[6]:= ReadList["bignum", Number]

Out[6]=

Lesen von Objekten unterschiedlichen Typs

ReadList kann nicht nur Zahlen lesen, sondern auch eine Reihe anderer Objekttypen. Jeder Objekttyp ist durch ein Symbol wie Number spezifiziert.

Hier ist eine Datei mit Text.

In[7]:= !!strings

Here is text.

And more text.

Hier wird eine Liste der Zeichen der Datei erzeugt, wobei jedes Zeichen als Ein-Zeichen-String gegeben wird.

In[8]:= ReadList["strings", Character]

Out[8]=

Hier sind die ganzzahligen Codes, die den Bytes in der Datei entsprechen.

In[9]:= ReadList["strings", Byte]

Out[9]=

Dies setzt die Daten jeder Dateizeile in eine separate Liste.

In[10]:= ReadList["strings", Byte, RecordLists -> True]

Out[10]=

Lesbare Objekttypen

Hier wird eine Liste der „Wörter" in der Datei strings zurückgegeben.

In[11]:= ReadList["strings", Word]

Out[11]=

Mit ReadList können „Wörter" aus einer Datei gelesen werden. Ein Wort wird als eine beliebige durch Separatoren begrenzte Zeichenfolge betrachtet. Mit der Option WordSeparators können Zeichenketten festgelegt werden, die als Wort-Separatoren gelten sollen. In Voreinstellung werden Leer- und Tabulatorzeichen verwendet, jedoch zum Beispiel keine normalen Satzzeichen. Zu beachten ist, daß in allen Fällen aufeinanderfolgende Wörter durch eine beliebige Anzahl von Wort-Separatoren getrennt werden können. Diese Separatoren werden niemals als Bestandteil der durch ReadList zurückgegebenen Wörter interpretiert.

Optionen für ReadList

Dies liest den Text aus der Datei strings als Wort-Sequenz, dabei werden die Zeichen e und . als Wort-Separatoren erkannt.

In[12]:= ReadList["strings", Word, WordSeparators -> {"e", "."}]

Out[12]=

Mathematica betrachtet jede Daten-Datei als Sequenz von Records. In Voreinstellung wird jede Zeile als separater Record angesehen. Im allgemeinen können mit der Option RecordSeparators eine Liste von Separatoren für Records angegeben werden. Beachten Sie, daß Wörter niemals Record-Separatoren überschreiten können. Wie bei Wort-Separatoren, so kann es auch zwischen aufeinanderfolgenden Records eine beliebige Anzahl von Record-Separatoren geben. Diese Separatoren werden nicht als Bestandteil des Records angesehen.

In der Voreinstellung wird jede Zeile der Datei als Record betrachtet.

In[13]:= ReadList["strings", Record] // InputForm

Out[13]//InputForm= {"Here is text. ", "And more text."}

Hier ist eine Datei, die drei „Sätze" enthält, die mit einem Punkt enden.

In[14]:= !!sentences

Here is text. And more.

And a second line.

Dies erlaubt sowohl Punkte als auch Zeilenvorschübe als Record-Separatoren.

In[15]:= ReadList["sentences", Record,
RecordSeparators -> {".", "\n"}]

Out[15]=

Dies setzt die Wörter eines jeden „Satzes" in eine separate Liste.

In[16]:= ReadList["sentences", Word, RecordLists -> True,
RecordSeparators -> {".", "\n"}]

Out[16]=

Einstellungen für die Option RecordSeparators

Hier ist eine Datei, die etwas Text enthält.

In[17]:= !!quelle

f[x] (: function f :)

g[x] (: function g :)

Dies liest den gesamten Text der Datei quelle und gibt ihn als einfachen String zurück.

In[18]:= InputForm[
ReadList["quelle", Record, RecordSeparators -> { }]
]

Out[18]//InputForm= {"f[x] (: function f :)\ng[x] (: function g :)\n"}

Dies ergibt eine Liste aller Teile einer Datei, die zwischen den Separatoren (: und :) liegen.

In[19]:= ReadList["quelle", Record,
RecordSeparators -> {{"(: "}, {" :)"}}]

Out[19]=

Durch Wahl geeigneter Separatoren können Sie bestimmte Teile einer Datei auswählen.

In[20]:= ReadList[ "quelle", Record,
RecordSeparators ->
{{"(: function ", "["}, {" :)", "]"}} ]

Out[20]=

Normalerweise erlaubt Mathematica eine beliebige Anzahl geeigneter Separatoren zwischen aufeinanderfolgenden Records oder Wörtern. Manchmal jedoch, wenn mehrere Separatoren vorhanden sind, will man vielleicht die Vereinbarung gelten lassen, daß zwischen jedem Paar unmittelbar benachbarter Separatoren ein „leerer Record" oder ein „leeres Wort" steht. Dies wird durch Setzen der Optionen NullRecords -> True oder NullWords -> True erreicht.

Hier ist eine Datei, die durch Doppelpunkt getrennte Wörter enthält.

In[21]:= !!woerter

first:second::fourth:::seventh

Hier werden die wiederholten Doppelpunkte als einfache Separatoren behandelt.

In[22]:= ReadList["woerter", Word, WordSeparators -> {":"}]

Out[22]=

Nun wird angenommen, daß wiederholte Doppelpunkte leere Wörter einschließen.

In[23]:= ReadList["woerter", Word, WordSeparators -> {":"},
NullWords -> True]

Out[23]=

In den meisten Fällen will man, daß Wörter durch Separatoren begrenzt werden, die selbst nicht als Wörter betrachtet werden. Manchmal ist es jedoch vorteilhaft, Wörter durch besondere „Symbolwörter" (oder Token-Wörter) abzugrenzen, die selbst Wörter sind. Eine Liste derartiger „Symbolwörter" kann als Einstellung der Option TokenWords angegeben werden.

Hier ist etwas Text.

In[24]:= !!sprache

22*a*b+56*c+13*a*d

So wird der Text gelesen und die spezifizierten Symbolwörter dabei zur Abgrenzung der Wörter verwendet.

In[25]:= ReadList["sprache", Word, TokenWords -> {"+", "*"}]

Out[25]=

Mit ReadList können Mathematica-Ausdrücke aus Dateien eingelesen werden. Im allgemeinen muß jeder Ausdruck mit einem Zeilenvorschub enden, obwohl sich ein einfacher Ausdruck über mehrere Zeilen erstrecken kann.

Hier ist eine Datei, die Text enthält, der als Mathematica-Eingabe benutzt werden kann.

In[26]:= !!exprs

x + y +

z

2^8

Dies liest den Text in exprs als Mathematica-Ausdrücke.

In[27]:= ReadList["exprs", Expression]

Out[27]=

Dies verhindert, daß die Ausdrücke evaluiert werden.

In[28]:= ReadList["exprs", Hold[Expression]]

Out[28]=

ReadList kann gelesene Objekte in jeden beliebigen Mathematica-Ausdruck einfügen. Das zweite Argument für ReadList kann aus einem beliebigen Ausdruck bestehen, der Symbole wie Number und Word enthält, die die zu lesenden Objekte genauer spezifizieren. So fügt zum Beispiel ReadList["datei", Number, Number] aufeinanderfolgende Zahlenpaare, die es liest, in Listen ein. Ähnlich werden durch ReadList["datei", Hold[Expression]] gelesene Ausdrücke in Hold eingehüllt.

Wenn ReadList das Ende der Datei erreicht, bevor es die angeforderte Menge von Objekten komplett gelesen hat, fügt es das Spezialsymbol EndOfFile an die Stelle der Objekte ein, die noch nicht gelesen wurden.

Hier ist eine Datei mit Zahlen.

In[29]:= !!zahlen

11.1 22.2 33.3

44.4 55.5 66.6

Das Symbol EndOfFile erscheint anstelle der Zahlen, die bei Erreichen des Endes der Datei noch einzulesen waren.

In[30]:= ReadList["zahlen", {Number, Number, Number, Number}]

Out[30]=

Lesen aus Anweisungen und aus Strömen

Dies führt die Unix-Anweisung date aus und liest deren Ausgabe als Zeichenkette ein.

In[31]:= ReadList["!date", String]

Out[31]=

Funktionen zum Lesen aus Eingabeströmen

Mit ReadList können alle Daten in einer Datei oder in einem Eingabestrom eingelesen werden. Manchmal möchte man jedoch die Daten nur stückweise lesen, zum Beispiel um dann zu prüfen, welche Art von Daten als nächstes zu erwarten sind.

Werden einzelne Datenteile aus einer Datei eingelesen, so merkt sich Mathematica immer den „Lesezeiger", das ist die Position, an der man sich in der Datei befindet. Wird OpenRead aufgerufen, so richtet Mathematica einen Eingabestrom von einer Datei ein und macht die gegenwärtige Position zum Dateianfang. Jedesmal, wenn ein Objekt aus einer Datei mit Read gelesen wird, setzt Mathematica die aktuelle Position direkt hinter das gelesene Objekt. Mit Skip kann der Lesezeiger an einer Objektsequenz vorbeigeführt werden, ohne die Objekte zu lesen.

Hier ist eine Datei mit Zahlen.

In[32]:= !!zahlen

11.1 22.2 33.3

44.4 55.5 66.6

Dies öffnet einen Eingabestrom von der Datei.

In[33]:= snum = OpenRead["zahlen"]

Out[33]=

Dies liest die erste Zahl in der Datei.

In[34]:= Read[snum, Number]

Out[34]=

So wird das zweite Zahlenpaar gelesen.

In[35]:= Read[snum, {Number, Number}]

Out[35]=

Hier wird die nächste Zahl übersprungen.

In[36]:= Skip[snum, Number]

Und dies liest die restlichen Zahlen.

In[37]:= ReadList[snum, Number]

Out[37]=

So wird der Eingabestrom geschlossen.

In[38]:= Close[snum]

Out[38]=

Die Optionen WordSeparators und RecordSeparators können in Read und Skip genauso wie in ReadList verwendet werden.

Beachten Sie: Wird versucht, über das Ende der Datei hinaus zu lesen, gibt Read das Symbol EndOfFile zurück.

Import und Export von DateienSuchen in Dateien