Grundlegendes Python 2.7-Tutorial: Eingabe und Ausgabe

.. _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, die

ziemlich menschenlesbar sind, während :func:`repr` Darstellungen generieren soll

was vom Interpreter gelesen werden kann (oder einen :exc:`SyntaxError` erzwingen wird, wenn

es keine äquivalente Syntax gibt, die keine bestimmte

Darstellung 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')

>>> 🎜>

Das erste Argument ist eine Zeichenfolge, die den Dateinamen enthält.

ein anderes Zeichenfolge, die einige Zeichen enthält, die die Art und Weise beschreiben, in der die Datei verwendet wird. *Modus* kann „r“ sein, wenn die Datei nur gelesen wird, „w“

nur zum Schreiben (eine vorhandene Datei mit demselben Namen wird gelöscht) und

„'a“ öffnet die Datei zum Anhängen aller in die Datei geschriebenen Daten.

automatisch am Ende hinzugefügt, öffnet die Datei sowohl zum Lesen als auch zum Schreiben

Das Argument *mode* ist optional; wenn es

weggelassen wird.

Der erste Parameter ist eine Zeichenfolge, die den Dateinamen identifiziert. Der zweite Parameter ist eine Zeichenfolge

, die aus einer begrenzten Anzahl von Buchstaben besteht und beschreibt, wie die Datei verwendet wird. Optionale *Modi* sind: „r“, diese Option macht die Datei schreibgeschützt gleicher Name, dieser Vorgang führt dazu, dass die Originaldatei überschrieben wird); ``'a'',

Diese Option öffnet die Datei im Anhängemodus im Lese-/Schreibmodus;

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`-Dateien

Seien Sie beim Lesen und Schreiben solcher Dateien sehr vorsichtig,

es schadet nicht Hängen Sie ein „b“ an den Modus an, damit Sie ihn

plattformunabhä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 „“, Zeile 1, in ?

   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 (www.php.cn)!