.. _tut-io:
*********************************** ******* **
Eingabe und Ausgabe
****************************** **** *******
Es gibt verschiedene Möglichkeiten, die Ausgabe eines Programms darzustellen; Daten können
in einer für Menschen lesbaren Form gedruckt oder in eine geschrieben werden Datei für die zukünftige Verwendung. In diesem Kapitel werden einige der Möglichkeiten erläutert Datei zur späteren Verwendung. In diesem Kapitel werden mehrere alternative Methoden erläutert.
.. _tut-formatting:
Ausgefallenere Ausgabeformatierung
=================== ==== ======================
Bisher sind wir auf zwei Möglichkeiten gestoßen, Werte zu schreiben: *Ausdrucksanweisungen* und
die :keyword:`print`-Anweisung. (Eine dritte Möglichkeit ist die Verwendung der :meth:`write`-Methode
von Dateiobjekten; die Standardausgabedatei kann als „sys. stdout“ referenziert werden.
Weitere Informationen hierzu finden Sie in der Bibliotheksreferenz.)
Wir haben zwei sehr unterschiedliche Methoden zur Ausgabe von Werten: *Ausdrucksanweisung* und :keyword:`print`-Anweisung. (Die dritte Zugriffsart
besteht darin, die :meth:`write`-Methode des Dateiobjekts zu verwenden. Informationen zur Standarddateiausgabe finden Sie unter
``sys.stdout``. Einzelheiten finden Sie im Referenzhandbuch der Bibliothek. )
.. index:: module: string
Oft möchten Sie mehr Kontrolle über die Formatierung Ihrer Ausgabe als nur
Drucken von durch Leerzeichen getrennten Werten. Es gibt zwei Möglichkeiten, Ihre Ausgabe zu formatieren: Die erste Möglichkeit besteht darin, die gesamte String-Verarbeitung selbst durchzuführen Layout, das Sie sich vorstellen können. Das
Standardmodul :mod:`string` enthält einige nützliche Operationen zum Auffüllen von Zeichenfolgen
diese werden in Kürze besprochen
Die Möglichkeit besteht darin, die Methode : meth:`str.format` zu verwenden.Vielleicht möchten Sie oft eine komplexere Kontrolle über das Ausgabeformat haben, als nur das Leerzeichen auszudrucken. Es gibt zwei Methoden zum Formatieren der Ausgabe. Die erste besteht darin, dass Sie die gesamte Zeichenfolge steuern und Zeichenausschneide- und Verkettungsvorgänge verwenden, um jede gewünschte Ausgabeform zu erstellen. Das Standardmodul :mod:`string` enthält eine Reihe von Operationen, die beim Füllen von Zeichenfolgen in bestimmte Spalten nützlich sind. Wir werden das später besprechen. Die zweite Methode ist die Verwendung der :meth:`str.format`-Methode. Eine Frage bleibt natürlich bestehen: Wie konvertiert man Werte in Strings? Glücklicherweise gibt es in Python Möglichkeiten, jeden Wert in einen String umzuwandeln: Übergeben Sie ihn an :func:` repr` oder :func:`str`-Funktionen.Natürlich gibt es noch eine andere Frage: Wie konvertiert man den Wert in einen String? Glücklicherweise hat Python eine Möglichkeit, jeden -Wert in einen String umzuwandeln: Übergeben Sie ihn an die Funktion :func:`repr` oder :func:`str`. Die Funktion :func:`str` soll Darstellungen von Werten zurückgeben, dieziemlich menschenlesbar sind, während :func:`repr` Darstellungen generieren sollwas vom Interpreter gelesen werden kann (oder einen :exc:`SyntaxError` erzwingen wird, wennes keine äquivalente Syntax gibt, die keine bestimmteDarstellung für den menschlichen Verzehr, :func:`str` gibt den gleichen Wert zurück wie
:func:`repr` Viele Werte, wie Zahlen oder Strukturen wie Listen und
Wörterbücher, haben mit beiden Funktionen die gleiche Darstellung. Insbesondere Strings und Gleitkommazahlen haben zwei unterschiedliche Darstellungen.
Funktion:func:`str` wird verwendet, um Werte in menschliche Werte umzuwandeln -lesbare Form, und :func:`repr` wird in eine Form umgewandelt, die der Interpreter lesen kann
(wenn es keine entsprechende Syntax gibt, tritt eine :exc:`SyntaxError`-Ausnahme auf). Ein Objekt ist nicht vorhanden geeignet
In menschenlesbarer Form gibt :func:`str` denselben Wert zurück wie :func:`repr`. Viele Typen, wie zum Beispiel
-Strukturen wie numerische Werte oder verknüpfte Listen und Wörterbücher, verfügen über eine einheitliche Interpretationsmethode für jede Funktion. Zeichenfolgen und
Gleitkommazahlen verfügen über einzigartige Interpretationsmethoden.
Einige Beispiele:
Das Folgende sind einige Beispiele::
>>> > > str(s)
'Hallo Welt.'
>>> repr(s)
"'Hallo Welt'"
>>>
>>> print s
Der Wert von x ist 32,5 und y ist 40000...
>>> ) einer Zeichenfolge fügt Zeichenfolgen-Anführungszeichen und Backslashes hinzu:
... hello = 'hello, world/n'
>>> hellos = repr(hello)
>>> print hellos
'hello, world/n'
>>> # Das Argument für repr() kann ein beliebiges Python-Objekt sein:
... repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"
Hier sind zwei Möglichkeiten, eine Tabelle mit Quadraten und Würfeln zu schreiben:
有两种方式可以写平方和立方表 ::
>>> für x im Bereich(1, 11):
... print repr(x).rjust(2), repr(x*x).rjust(3),
.. . # Nachgestelltes Komma in der vorherigen Zeile beachten
... print repr(x*x*x).rjust(4)
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
>>> für x im Bereich(1,11):
... print '{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x* x)
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
(Beachten Sie, dass im ersten Beispiel ein Leerzeichen zwischen jeder Spalte hinzugefügt wurde,
auf die Art und Weise, wie :keyword:`print` funktioniert: Es fügt immer Leerzeichen zwischen seinen Argumenten ein.)
（注意第一个例子， :keyword:`print` ）
Dieses Beispiel demonstriert die :meth:`rjust`-Methode von String-Objekten, die
einen String in einem Feld einer bestimmten Breite rechtsbündig ausrichtet, indem er ihn links mit Leerzeichen auffüllt
. Es gibt ähnliche Methoden :meth:`ljust` und :meth:`center`. Diese
Methoden schreiben nichts, sie geben lediglich eine neue Zeichenfolge zurück. Wenn die Eingabezeichenfolge zu lang ist, wird sie nicht abgeschnitten, sondern unverändert zurückgegeben. Dies wird
Ihr Spaltenlayout durcheinander bringen, aber das ist normalerweise besser als die Alternative,
die über einen Wert lügen würde. (Wenn Sie wirklich eine Kürzung wünschen, können Sie
immer eine Slice-Operation hinzufügen, wie in „x.ljust(n)[:n]“.)
以上是一个 :meth: "rjust"的方法还有 :meth:`ljust` und :meth:` center`
。这些函数只是输出新的字符串，并不改变什么。如果输出的字符串太长，它们也不会截断
它，而是原样输出，这会使你的输出格式变得混乱，不过总强过另一种选择（截
断字符串），因为那样会产生错误的输出值.（如果你确实需要截断它，可以使
用切割操作，例如： ``x.ljust( n)[:n]`` 。）
Es gibt eine andere Methode, :meth:`zfill`, die eine Zahl auffüllt Zeichenfolge links
mit Nullen. Es versteht Plus- und Minuszeichen:可以正确理解正负号 ::
>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'
Die grundlegende Verwendung der :meth:`str.format`-Methode sieht folgendermaßen aus:
方法 :meth: `str.format` 的基本用法如下 ::
>>> print 'Wir sind die {}, die "{} sagen!"'.format('knights', 'Ni')
Wir sind die Ritter, die "Ni!" sagen
Die Klammern und die darin enthaltenen Zeichen (Formatfelder genannt) werden durch
die Objekte ersetzt, die an die Methode :meth:`~str.format` übergeben werden. Eine Zahl in den Klammern
bezieht sich auf die Position des Objekts, das an die Methode
:meth:`~str.format` übergeben wurde. :
大括号和其中的字符会被替换成传入 :meth:`~str.format` 的参数。大括号中
的数值指明使用传入 :meth:` ~str.format` 方法的对象中的哪一个 ::
>>> print '{0} und {1}'.format('spam', 'eggs')
Spam und Eier
>>> ; print '{1} und {0}'.format('spam', 'eggs')
Eier und Spam
Wenn Schlüsselwortargumente in :meth:`~str verwendet werden .format`-Methode, auf deren Werte
über den Namen des Arguments verwiesen wird :
Wenn Sie beim Aufruf von :meth:`~str.format` Schlüsselwortargumente verwenden, können Sie dies tun Referenzieren Sie den
-Wert über den Parameternamen::
>>> print 'This {food} is {adjective}.'.format(
... food='spam', adjective='absolutely horrible')
Dieser Spam ist absolut schrecklich.
Positions- und Schlüsselwortargumente können beliebig kombiniert werden:
Positionierungs- und Schlüsselwortparameter kann in Kombination verwendet werden::
>>> print 'Die Geschichte von {0}, {1} und {other}.'.format('Bill', 'Manfred',
... other='Georg')
Die Geschichte von Bill, Manfred und Georg.
``'!s''` (apply :func:` str `) und ``'!r'' (apply :func:`repr`) können verwendet werden, um
den Wert zu konvertieren, bevor er formatiert wird :
``'! s ''` (anwenden von :func:`str` ) und ``'!r'`` (anwenden von :func:`repr` ) können
Werte vor der Formatierung konvertieren. ::
>>> import math
>>> print 'Der Wert von PI beträgt ungefähr {}.'.format(math.pi)
Der Wert von PI beträgt ungefähr 3,14159265359.
>>> print 'Der Wert von PI beträgt ungefähr {!r}.'.format(math.pi)
Der Wert von PI beträgt ungefähr 3,141592653589793.
Ein optionaler „:“ und ein Formatbezeichner können auf den Feldnamen folgen. Dies ermöglicht eine bessere Kontrolle darüber, wie der Wert formatiert wird Das folgende Beispiel
kürzt Pi auf drei Nachkommastellen.
Ermöglicht optionale „“:“- und Formatanweisungen nach dem Feldnamen. Dies ermöglicht eine tiefere
Kontrolle über die Formatierung von Werten. Das folgende Beispiel wandelt Pi in eine dreistellige Genauigkeit um. ::
>>> import math
>>> print 'Der Wert von PI beträgt ungefähr {0:.3f}.'.format(math.pi )
Der Wert von PI beträgt ungefähr 3,142.
Die Übergabe einer Ganzzahl nach dem „“:“ führt dazu, dass dieses Feld eine Mindestanzahl von Zeichen enthält.
breit. Dies ist nützlich, um Tabellen hübscher zu gestalten:
Das Hinzufügen einer Ganzzahl nach dem „:“ nach dem Feld begrenzt die Mindestbreite des Feldes, was beim Verschönern von Tabellen nützlich ist.
Sehr nützlich. ::
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> phone in table.items():
... print '{0:10} ==> {1:10d}'.format(name, phone)
...
Jack ==> 4098
Dcab ==> 7678
Sjoerd ==> 4127
Wenn Sie eine wirklich lange Formatzeichenfolge haben Da Sie nicht aufteilen möchten, wäre es schön, wenn Sie die zu formatierenden Variablen nach Namen referenzieren könnten dict und verwenden Sie
eckige Klammern „[]“, um auf die Schlüssel zuzugreifen:
Wenn Sie eine wirklich lange Formatzeichenfolge haben und diese nicht teilen möchten. Es wäre schön, wenn Sie auf
formatierte Variablen nach Namen statt nach Position verweisen könnten. Es gibt eine einfache Möglichkeit, ein Wörterbuch zu übergeben und auf seine Schlüssel zuzugreifen, indem Sie
Klammern::
>>> verwenden , 'Dcab': 8637678}
>>> print ('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
... 'Dcab: {0[Dcab]:d}'.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
Dies wäre auch möglich indem Sie die Tabelle als Schlüsselwortargumente mit der Notation „**“
übergeben. ::
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print 'Jack : {Jack:d}; Sjoerd: {Dcab:d}'.format(**table)
Jack: 4098; Sjoerd: 8637678
Dies ist besonders nützlich in Kombination mit dem neuen integrierten :func:`vars`
Funktion, die ein Wörterbuch zurückgibt, das alle lokalen Variablen enthält.
Dieser Ansatz funktioniert sehr gut in Kombination mit der neuen integrierten Funktion :func:`vars`. Diese Funktion gibt ein Wörterbuch zurück, das alle lokalen
-Variablen enthält.
Eine vollständige Übersicht über die Zeichenfolgenformatierung mit :meth:`str.format` finden Sie unter
:ref:`formatstrings`.
Um mehr über die Zeichenfolgenformatierungsmethode zu erfahren :meth:`str.format`, siehe
:ref:`formatstrings`.
Alte String-Formatierung Alte String-Formatierung
-------------------------- ------ -------
Der Operator „%“ kann auch zur Zeichenfolgenformatierung verwendet werden. Er interpretiert das
linke Argument ähnlich wie ein :cfunc :`sprintf`/ -. Stilformatzeichenfolge, die
auf das rechte Argument angewendet werden soll, und gibt die aus dieser Formatierungsoperation resultierende Zeichenfolge zurück
Zum Beispiel:
Operator „%“ kann auch zur Zeichenfolgenformatierung verwendet werden. Es analysiert den linken Parameter auf ähnliche Weise wie :cfunc:`sprintf`
, wendet den rechten Parameter darauf an und ruft die durch den Formatierungsvorgang generierte Zeichenfolge ab, zum Beispiel::
>> > import math
>>> print 'Der Wert von PI beträgt ungefähr %5.3f.' .
Da :meth:`str.format` recht neu ist, verwendet ein Großteil des Python-Codes immer noch den Operator „%“
Allerdings wird dies bei diesem alten Formatierungsstil der Fall sein irgendwann
aus der Sprache entfernt werden, sollte generell :meth:`str.format` verwendet werden.
Weil :meth:`str.format` noch sehr neu ist und viel Python enthält Der Code verwendet ihn immer noch.
Da jedoch die alten Formatierungsmethoden irgendwann aus der Sprache entfernt werden, sollte nach Möglichkeit
:meth:`str.format` verwendet werden.
Weitere Informationen finden Sie im Abschnitt :ref:`string-formatting`.
Weitere Informationen finden Sie im Abschnitt :ref:`string-formatting`.
.. _tut-files:
Dateien lesen und schreiben Dateien lesen und schreiben
================== == ==========================
.. index::
eingebaut: offen
object: file
:func:`open` gibt ein Dateiobjekt zurück und wird am häufigsten mit zwei
Argumenten verwendet: ``open(filename, mode)`` .
Function:func:`open` gibt ein Dateiobjekt zurück. Für die allgemeine Verwendung sind zwei Parameter erforderlich:
``open(filename, mode)``.
::
>>> f = open('/tmp/workfile', 'w')
>>> 🎜>
Der Parameter *mode* ist optional. Wenn nicht angegeben, wird standardmäßig der Modus „r“ verwendet. Unter Windows öffnet das an den Modus angehängte „b“ die Datei im Binärmodus, daher gibt es auch Modi wie „rb“ und „ wb“ und „r+b“. Python unter Windows unterscheidet zwischen Text- und Binärdateien; werden automatisch geringfügig geändert, wenn Daten gelesen oder geschrieben werden. DieseÄnderung der Dateidaten im Hintergrund ist für ASCII-Textdateien in Ordnung,beschädigt jedoch solche Binärdaten :file:`JPEG`- oder :file:`EXE`-DateienSeien Sie beim Lesen und Schreiben solcher Dateien sehr vorsichtig,es schadet nicht Hängen Sie ein „b“ an den Modus an, damit Sie ihnplattformunabhängig für alle Binärdateien verwenden können.Auf der Windows-Plattform „b“ Die Der Modus öffnet die Datei im Binärmodus, daher kann es Kombinationen von Modi ähnlich wie „rb“, „wb“, „r+b“ usw. geben . Auf der Windows-Plattform gibt es einen Unterschied zwischen Textdateien und Binärdateien. Beim Lesen und Schreiben von Textdateien werden am Ende der Zeilen automatisch Zeilenabschlüsse eingefügt. Diese Art von Backstage-Ficken
Es gibt kein Problem mit ASCII-Textdateien, es kann jedoch zu Schäden führen, wenn Binärdateien
wie JPEG oder .EXE verwendet werden. Achten Sie beim Betrieb dieser Dateien darauf, sie im Binärmodus zu öffnen. Unter
Unix ist es auch unbedenklich, einen „b“-Modus hinzuzufügen, sodass Sie ihn plattformunabhängig bei der gesamten Binärdateiverarbeitung verwenden können.
.. _tut-filemethods:
Methoden von Dateiobjekten Dateiobjektmethoden
-------------------------------- - ----------------------
Bei den restlichen Beispielen in diesem Abschnitt wird davon ausgegangen, dass ein Dateiobjekt namens
` „f“ wurde bereits erstellt.
Die Beispiele in diesem Abschnitt gehen alle davon aus, dass das Dateiobjekt „f“ bereits erstellt wurde.
Um den Inhalt einer Datei zu lesen, rufen Sie „f.read(size)“ auf, das eine bestimmte Menge von
Daten liest und sie als Zeichenfolge *size* zurückgibt Argument. Wenn
*size* weggelassen oder negativ ist, wird der gesamte Inhalt der Datei gelesen und
es ist Ihr Problem, wenn die Datei doppelt so groß ist wie die Ihres Computers
Speicher. Andernfalls werden höchstens *size* Bytes gelesen und zurückgegeben. Wenn das Ende
der Datei erreicht wurde, gibt „f.read()“ einen leeren String zurück (. ``"``).
Um den Dateiinhalt zu lesen, müssen Sie „f.read(size)“ aufrufen. Diese Methode liest eine bestimmte Datenmenge und schreibt sie in Worten
Gibt seinen Inhalt in String-Form zurück, *size* ist ein optionaler Wert, der die Länge des Strings angibt. Wenn
size nicht angegeben ist oder als negative Zahl angegeben wird, wird die gesamte Datei gelesen und zurückgegeben. Probleme treten auf, wenn die Dateigröße das Doppelte
Mal so groß ist wie der aktuelle Maschinenspeicher. Im Gegenteil, die Daten werden so groß wie möglich gelesen und zurückgegeben.
Wenn das Ende der Datei erreicht ist, gibt f.read() eine leere Zeichenfolge ("") zurück.
::
>>> f.read()
'Dies ist die gesamte Datei./n'
>> ;> f.read()
''
``f.readline()`` liest eine einzelne Zeile aus der Datei (``/n``)
steht am Ende der Zeichenfolge und wird nur in der letzten Zeile der
Datei weggelassen, wenn die Datei nicht in einer neuen Zeile endet. Dies ergibt den Rückgabewert
eindeutig; wenn „f.readline()“ einen leeren String zurückgibt, ist das Ende der Datei
erreicht, während eine Leerzeile durch „/n“ dargestellt wird ` `, eine Zeichenfolge
die nur eine einzige neue Zeile enthält
``f.readline()`` liest eine einzelne Zeile aus der Datei und am Ende wird automatisch ein Zeilenumbruchzeichen hinzugefügt der Zeichenfolge
( ``/n`` ), wird dieser Vorgang nur ignoriert, wenn die letzte Zeile der Datei nicht mit einem Zeilenumbruchzeichen endet.
Auf diese Weise entsteht keine Verwirrung über den Rückgabewert. Wenn „f.readline()“ einen leeren String zurückgibt, bedeutet dies, dass das Ende der Datei erreicht wurde . Wenn es sich um eine Leerzeile handelt, wird sie als „/n“ beschrieben, eine Zeichenfolge, die nur Zeilenumbrüche enthält. ::
>>> f.readline()
'Dies ist die erste Zeile der Datei./n'
>>> f.readline()
'Zweite Zeile der Datei/n'
>>> f.readline()
''
``f.readlines()`` gibt eine Liste zurück, die alle Datenzeilen in der Datei enthält.
Wenn ein optionaler Parameter *sizehint* angegeben wird, liest es so viele Bytes aus der Datei
Datei und genug mehr, um eine Zeile zu vervollständigen, und gibt die Zeilen daraus zurück
wird oft verwendet, um das effiziente Lesen einer großen Datei zeilenweise zu ermöglichen, ohne
die laden zu müssen gesamte Datei im Speicher. Es werden nur vollständige Zeilen zurückgegeben.
f.readlines() gibt eine Liste mit allen Datenzeilen in der Datei zurück. Wenn der Parameter
*sizehint* angegeben wird, werden mehr als eine Bitzeile gelesen und mehrere Textzeilen zurückgegeben. Diese Funktion
wird normalerweise zum effizienten Lesen großer Zeilendateien verwendet, sodass nicht die gesamte Datei in den Speicher eingelesen werden muss. Dieser Vorgang gibt nur vollständige
Zeilen zurück. ::
>>> f.readlines()
['Dies ist die erste Zeile der Datei./n', 'Zweite Zeile der Datei/n']
Ein alternativer Ansatz zum Lesen von Zeilen besteht darin, das Dateiobjekt zu durchlaufen. Dies ist
speichereffizient, schnell und führt zu einfacherem Code
Es gibt ein Line-By -Zeilenlesen Eine gute Möglichkeit besteht darin, eine Schleife über das Dateiobjekt durchzuführen. Das ist leicht zu merken, schnell und der Code ist einfacher::
>>> for line in f:
print line,
Dies ist der erste Zeile der Datei.
Zweite Zeile der Datei
Der alternative Ansatz ist einfacher, bietet aber keine so feinkörnige Kontrolle
Da die beiden Ansätze die Zeilenpufferung verwalten Andernfalls sollten sie
nicht gemischt werden.
Diese Methode ist sehr einfach, kann den Vorgang jedoch nicht vollständig steuern. Da die beiden Methoden den Puffer
auf unterschiedliche Weise verwalten, können sie nicht gemischt werden.
``f.write(string)`` schreibt den Inhalt von *string* in die Datei und gibt
``None`` zurück.
``f.write(string)`` 将 *string* 的内容写入文件，返回 ``None`` 。 ::
>>> f.write('Dies ist ein Test/n')
Um etwas anderes als eine Zeichenfolge zu schreiben, muss es in eine Zeichenfolge umgewandelt werden
zuerst:
如果需要写入字符串以外的数据，就要先把这些数据转换为字符串。 ::
>>> value = ('die Antwort', 42)
>>> s = str(Wert)
>>> f.write(s)
``f.tell()`` gibt eine Ganzzahl zurück, die die aktuelle Position des Dateiobjekts in der
Datei angibt, gemessen in Bytes vom Anfang der Datei. Um die Position des Datei
Objekts zu ändern, verwenden Sie „f.seek(offset, from_what)“. Die Position wird
aus der Addition von *Offset* zu einem Referenzpunkt berechnet; Der Referenzpunkt wird durch
das *from_what*-Argument ausgewählt. Ein *from_what*-Wert von 0 misst vom Anfang
der Datei, 1 verwendet die aktuelle Dateiposition und 2 verwendet das Ende der Datei als
Referenzpunkt. *from_what* kann weggelassen werden und ist standardmäßig 0, wobei der
Anfang der Datei als Referenzpunkt verwendet wird.
``f.tell()`` 返回一个整数,代表文件对象在文件中的指针位置,该数值计量了自文
件开头到指针处的比特数.需要改变文件对象指针话话，使用
``f.seek(offset,from_what)``动 *offset*
比特，引用位置由 *from_what* 参数指定. *from_what* 值为 0 表示自文件
起始处开始, 1 表示自当前文件指针*from_what* 可以
忽略，其默认值为零，此时从文件头开始。 ::
>>> f = open('/tmp/workfile', 'r+')
>>> f.write('0123456789abcdef')
>>> f.seek(5) # Gehe zum 6. Byte in der Datei
>>> f.read(1)
'5'
>>> f.seek(-3, 2) # Gehe zum 3. Byte vor dem Ende
>>> f.read(1)
'd'
Wenn Sie mit einer Datei fertig sind, rufen Sie „f.close()“ auf, um sie zu schließen und alle Dateien freizugeben
Systemressourcen, die von der geöffneten Datei beansprucht werden. Nach dem Aufruf von „f.close()“ schlagen
Versuche, das Dateiobjekt zu verwenden, automatisch fehl.
文件使用完后，调用 ``f.close()`` Verwenden Sie „f.close()“.之后，再调用文件对象会自动引发错误。 ::
>>> f.close()
>>> f.read()
Traceback (letzter Aufruf zuletzt):
Datei „
ValueError: E/A-Vorgang in geschlossenen Dateien
Es empfiehlt sich, beim Umgang mit Dateiobjekten das Schlüsselwort :keyword:`with` zu verwenden. Dies hat den Vorteil, dass die Datei nach Abschluss ihrer
Suite ordnungsgemäß geschlossen wird, auch wenn unterwegs eine Ausnahme ausgelöst wird. Es ist auch viel
kürzer als das Schreibäquivalent :keyword:`try`/ -/ :keyword:`finally` Blöcke
用关键字 :keyword:`with` 处理文件对象是个好习惯。它的先进之处在于文件
用完后会自动关闭，就算发生异常也没关系。它是 :keyword:`try`/ -/
:keyword:`endlich ` 块的简写。 ::
>>> mit open('/tmp/workfile', 'r') as f:
... read_data = f.read()
>>> f.closed
True
Dateiobjekte verfügen über einige zusätzliche Methoden, wie zum Beispiel :meth:`~file.isatty` und
:meth:`~file.truncate` die seltener verwendet werden; Konsultieren Sie die Bibliothek
Referenz für eine vollständige Anleitung zu Dateiobjekten.
文件对象还有一些不太常用的附加方法，比如 :meth:`~file.isatty` 和 :meth: `~file.truncate` 在库参
考手册中有文件对象的完整指南.
.. _tut-pickle:
Der :mod:`pickle` Modul :mod:`pickle` 模块
------------------------------------ ------------
.. index:: module: pickle
Strings können einfach in eine Datei geschrieben und aus dieser gelesen werden. Zahlen erfordern etwas mehr
Aufwand, da die :meth:`read`-Methode nur Strings zurückgibt, die
an eine Funktion wie :func:`int` übergeben werden müssen, die Nimmt eine Zeichenfolge wie „123“ an
und gibt ihren numerischen Wert 123 zurück. Allerdings, wenn Sie komplexere Daten speichern möchten
Datentypen wie Listen, Wörterbücher oder Klasseninstanzen, die Dinge werden viel komplizierter.
Wir können problemlos Zeichenfolgen in Dateien lesen und schreiben. Numerische Werte erfordern etwas mehr Mühe, da die Methode :meth:`read`
nur eine Zeichenfolge zurückgibt und diese an eine Methode wie :func:`int` übergeben werden sollte, dann
Zeichen wie „123“ werden in den entsprechenden Wert 123 umgewandelt. Allerdings wird es komplizierter, wenn Sie komplexere
Datentypen speichern müssen, wie z. B. Listen, Wörterbücher und Klasseninstanzen.
Anstatt dass Benutzer ständig Code schreiben und debuggen müssen, um
komplizierte Datentypen zu speichern, bietet Python ein Standardmodul namens :mod:`pickle`.
Dies ist ein erstaunliches Modul, das fast jedes Python-Objekt (sogar einige
Formen von Python-Code!) in eine String-Darstellung umwandeln kann
wird :dfn:`pickling` genannt; Das Rekonstruieren des Objekts aus der Zeichenfolge
Darstellung wird als :dfn:`unpickling` bezeichnet. Zwischen Beizen und Unpickling
kann die Zeichenfolge, die das Objekt darstellt, in einer Datei oder in Daten gespeichert sein
über eine Netzwerkverbindung an einen entfernten Computer gesendet.
Glücklicherweise müssen Benutzer keinen Code schreiben und debuggen, um komplexe Datentypen selbst zu speichern. Python bietet
ein Standardmodul namens :mod:`pickle`. Dies ist ein erstaunliches Modul, das fast jedes
Python-Objekt (sogar einige Python-Codeschnipsel!) als String ausdrücken kann. Dieser Vorgang wird
Kapselung ( :dfn:`pickling` ) genannt. Das Rekonstruieren eines Objekts aus einem Zeichenfolgenausdruck wird als Entpacken
( :dfn:`unpickling` ) bezeichnet. Objekte im gekapselten Zustand können in Dateien oder Objekten gespeichert und auch über das Netzwerk zwischen Remote-Computern übertragen werden.
Wenn Sie ein Objekt „x“ und ein Dateiobjekt „f“ haben, das zum Schreiben geöffnet wurde
, dauert die einfachste Methode zum Picken des Objekts nur eine Zeile Code
Wenn Sie ein Objekt „x“ und ein Dateiobjekt „f“ im Schreibmodus geöffnet haben, erfordert die einfachste
Möglichkeit, das Objekt zu kapseln, nur eine Codezeile : :
pickle.dump(x, f)
Um das Objekt wieder zu entpicken, wenn „f“ ein Dateiobjekt ist, das
zum Lesen geöffnet wurde
Wenn „f“ ein im Lesemodus geöffnetes Dateiobjekt ist, können Sie das Objekt neu laden und entpacken::
x = pickle.load(f)
(Es gibt andere Varianten davon, die beim Beizen vieler Objekte verwendet werden oder wenn Sie
die eingelegten Daten nicht in eine Datei schreiben möchten; konsultieren Sie die vollständige
Dokumentation für :mod: ` pickle` in der Python-Bibliotheksreferenz.)
(Wenn Sie die gepackten Daten nicht in eine Datei schreiben möchten, stehen einige andere Variationen zur Verfügung. Vollständig
:mod:`pickle ` Die Dokumentation finden Sie im Referenzhandbuch der Python-Bibliothek.
:mod:`pickle` ist die Standardmethode zum Erstellen von Python-Objekten, die gespeichert und
von anderen Programmen oder durch einen zukünftigen Aufruf desselben Programms wiederverwendet werden können; 🎜>Fachbegriff dafür ist ein :dfn:`persistentes` Objekt. Da :mod:`pickle` so weit verbreitet ist, achten viele Autoren, die Python-Erweiterungen schreiben, darauf, sicherzustellen
dass neue Datentypen wie Matrizen ordnungsgemäß gepickelt und entpickt werden können.
:mod:`pickle` ist die Standardmethode zum Speichern von Python-Objekten für die spätere Verwendung durch andere Programme oder sich selbst. Die Bereitstellung
dieser Reihe von Technologien ist ein :dfn:`persistentes` Objekt. Da :mod:`pickle` weit verbreitet ist, legen viele Autoren von Python-Erweiterungen großen Wert darauf, ob neue Datentypen wie Matrizen zum Packen und Entpacken geeignet sind.
Das Obige ist das grundlegende Tutorial von Python 2.7: Eingabe- und Ausgabeinhalte. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (m.sbmmt.com)!
