Es gibt viele Möglichkeiten, die Programmausgabe in Python anzuzeigen; Daten können für Menschen lesbar ausgedruckt oder zur späteren Verwendung in eine Datei ausgegeben werden. In diesem Kapitel wird dies ausführlich besprochen.
Bisher wurden zwei Möglichkeiten zur Ausgabe von Werten eingeführt: Ausdrucksanweisung und print() Funktion. (Die dritte Möglichkeit besteht darin, die write()-Methode des Objekts zu verwenden; verwenden Sie sys.stdout, um auf die Standardausgabedatei zu verweisen. Weitere Informationen finden Sie im Bibliotheksdatei-Referenzhandbuch.)
Manchmal ist es notwendig, mehr Kontrolle über die Ausgabe zu haben, als einfach Leerzeichen zum Trennen von Werten zu verwenden. Es gibt zwei Möglichkeiten, die Ausgabe zu formatieren: Die erste besteht darin, Zeichenfolgen manuell zu verarbeiten und dabei String-Slicing- und Verkettungsvorgänge zu verwenden, um jedes erdenkliche Ausgabelayout zu erstellen. Der String-Typ bietet einige nützliche Methoden zum Auffüllen von Strings auf eine bestimmte Spaltenbreite, die in Kürze besprochen werden. Die zweite Möglichkeit besteht darin, eine Formatzeichenfolge oder die Methode str.format() zu verwenden.
string enthält die Klasse Template, die Methoden zum Ersetzen von Werten in Zeichenfolgen bereitstellt.
Natürlich gibt es noch eine andere Frage: Wie konvertiert man den Wert in einen String? Python bietet eine Möglichkeit, jeden Wert in eine Zeichenfolge umzuwandeln: Übergeben Sie den Wert einfach an die Funktion repr() oder str().
str() gibt die für Menschen lesbare Form des Werts zurück, während repr() die vom Interpreter lesbare Form des Werts generiert (wenn keine entsprechende Syntax vorhanden ist, muss SyntaxError ausgelöst werden). Für Objekte, die keine speziell an die menschliche Lesbarkeit angepasste Form bieten, gibt die Funktion str() denselben Wert zurück wie repr(). Die Verwendung der Funktionen str() und repr() liefert für viele Werte den gleichen Rückgabewert, beispielsweise für Zahlen oder Strukturen wie Listen und Wörterbücher. Insbesondere gibt es für Zeichenfolgen zwei unterschiedliche Darstellungen.
Hier einige Beispiele:
<code class="sourceCode python"><span class="op">>>></span> s <span class="op">=</span> <span class="st">'Hello, world.'</span>
<span class="op">>>></span> <span class="bu">str</span>(s)
<span class="co">'Hello, world.'</span>
<span class="op">>>></span> <span class="bu">repr</span>(s)
<span class="co">"'Hello, world.'"</span>
<span class="op">>>></span> <span class="bu">str</span>(<span class="dv">1</span><span class="op">/</span><span class="dv">7</span>)
<span class="co">'0.14285714285714285'</span>
<span class="op">>>></span> x <span class="op">=</span> <span class="dv">10</span> <span class="op">*</span> <span class="fl">3.25</span>
<span class="op">>>></span> y <span class="op">=</span> <span class="dv">200</span> <span class="op">*</span> <span class="dv">200</span>
<span class="op">>>></span> s <span class="op">=</span> <span class="st">'The value of x is '</span> <span class="op">+</span> <span class="bu">repr</span>(x) <span class="op">+</span> <span class="st">', and y is '</span> <span class="op">+</span> <span class="bu">repr</span>(y) <span class="op">+</span> <span class="st">'...'</span>
<span class="op">>>></span> <span class="bu">print</span>(s)
The value of x <span class="op">is</span> <span class="fl">32.5</span>, <span class="op">and</span> y <span class="op">is</span> <span class="dv">40000</span>...
<span class="op">>>></span> <span class="co"># The repr() of a string adds string quotes and backslashes:</span>
... hello <span class="op">=</span> <span class="st">'hello, world</span><span class="ch">\n</span><span class="st">'</span>
<span class="op">>>></span> hellos <span class="op">=</span> <span class="bu">repr</span>(hello)
<span class="op">>>></span> <span class="bu">print</span>(hellos)
<span class="co">'hello, world\n'</span>
<span class="op">>>></span> <span class="co"># The argument to repr() may be any Python object:</span>
... <span class="bu">repr</span>((x, y, (<span class="st">'spam'</span>, <span class="st">'eggs'</span>)))
<span class="co">"(32.5, 40000, ('spam', 'eggs'))"</span></code>Es gibt zwei Möglichkeiten, eine Quadrat- und Würfeltabelle auszugeben:
<code class="sourceCode python"><span class="op">>>></span> <span class="cf">for</span> x <span class="op">in</span> <span class="bu">range</span>(<span class="dv">1</span>, <span class="dv">11</span>):
... <span class="bu">print</span>(<span class="bu">repr</span>(x).rjust(<span class="dv">2</span>), <span class="bu">repr</span>(x<span class="op">*</span>x).rjust(<span class="dv">3</span>), end<span class="op">=</span><span class="st">' '</span>)
... <span class="co"># Note use of 'end' on previous line</span>
... <span class="bu">print</span>(<span class="bu">repr</span>(x<span class="op">*</span>x<span class="op">*</span>x).rjust(<span class="dv">4</span>))
...
<span class="dv">1</span> <span class="dv">1</span> <span class="dv">1</span>
<span class="dv">2</span> <span class="dv">4</span> <span class="dv">8</span>
<span class="dv">3</span> <span class="dv">9</span> <span class="dv">27</span>
<span class="dv">4</span> <span class="dv">16</span> <span class="dv">64</span>
<span class="dv">5</span> <span class="dv">25</span> <span class="dv">125</span>
<span class="dv">6</span> <span class="dv">36</span> <span class="dv">216</span>
<span class="dv">7</span> <span class="dv">49</span> <span class="dv">343</span>
<span class="dv">8</span> <span class="dv">64</span> <span class="dv">512</span>
<span class="dv">9</span> <span class="dv">81</span> <span class="dv">729</span>
<span class="dv">10</span> <span class="dv">100</span> <span class="dv">1000</span>
<span class="op">>>></span> <span class="cf">for</span> x <span class="op">in</span> <span class="bu">range</span>(<span class="dv">1</span>, <span class="dv">11</span>):
... <span class="bu">print</span>(<span class="st">'</span><span class="sc">{0:2d}</span><span class="st"> </span><span class="sc">{1:3d}</span><span class="st"> </span><span class="sc">{2:4d}</span><span class="st">'</span>.<span class="bu">format</span>(x, x<span class="op">*</span>x, x<span class="op">*</span>x<span class="op">*</span>x))
...
<span class="dv">1</span> <span class="dv">1</span> <span class="dv">1</span>
<span class="dv">2</span> <span class="dv">4</span> <span class="dv">8</span>
<span class="dv">3</span> <span class="dv">9</span> <span class="dv">27</span>
<span class="dv">4</span> <span class="dv">16</span> <span class="dv">64</span>
<span class="dv">5</span> <span class="dv">25</span> <span class="dv">125</span>
<span class="dv">6</span> <span class="dv">36</span> <span class="dv">216</span>
<span class="dv">7</span> <span class="dv">49</span> <span class="dv">343</span>
<span class="dv">8</span> <span class="dv">64</span> <span class="dv">512</span>
<span class="dv">9</span> <span class="dv">81</span> <span class="dv">729</span>
<span class="dv">10</span> <span class="dv">100</span> <span class="dv">1000</span></code> (Im ersten Beispiel wird das Leerzeichen zwischen den Spalten automatisch durch print() hinzugefügt: Die Funktion fügt bei der Ausgabe immer Leerzeichen zwischen Argumenten ein)
Dieses Beispiel demonstriert die str.rjust()-Methode des String-Objekts, die die Zeichenfolge in einer Spalte mit einer bestimmten Breite rechts ausrichtet und links Leerzeichen hinzufügt. str.ljust() und str.center() sind ähnliche Methoden. Diese Methoden ändern nicht die ursprüngliche Zeichenfolge, sondern geben lediglich eine neue Zeichenfolge zurück. Wenn die Eingabezeichenfolge zu lang ist, kürzen diese Methoden die Zeichenfolge nicht, sondern geben sie unverändert zurück. Dies führt zwar zu einem Durcheinander im Spaltenlayout, ist jedoch besser als die Ausgabe unrealistischer Werte. (Wenn Sie wirklich abschneiden möchten, können Sie Slicing-Operationen verwenden, wie zum Beispiel: x.ljust(n)[:n].)
Methodestr.zfill()Fügt links von der numerischen Zeichenfolge eine Null hinzu, um positive und negative Vorzeichen zu identifizieren:
<code class="sourceCode python"><span class="op">>>></span> <span class="st">'12'</span>.zfill(<span class="dv">5</span>) <span class="co">'00012'</span> <span class="op">>>></span> <span class="st">'-3.14'</span>.zfill(<span class="dv">7</span>) <span class="co">'-003.14'</span> <span class="op">>>></span> <span class="st">'3.14159265359'</span>.zfill(<span class="dv">5</span>) <span class="co">'3.14159265359'</span></code>
str.format() ist:
<code class="sourceCode python"><span class="op">>>></span> <span class="bu">print</span>(<span class="st">'We are the {} who say "{}!"'</span>.<span class="bu">format</span>(<span class="st">'knights'</span>, <span class="st">'Ni'</span>))
We are the knights who say <span class="st">"Ni!"</span></code>Das an str.format() übergebene Objekt ersetzt die geschweiften Klammern und die darin enthaltenen Zeichen (Formatierungsfelder genannt). Zahlen in geschweiften Klammern können verwendet werden, um Objekte an entsprechenden Positionen in der an str.format() übergebenen Objektliste abzugleichen.
<code class="sourceCode python"><span class="op">>>></span> <span class="bu">print</span>(<span class="st">'</span><span class="sc">{0}</span><span class="st"> and </span><span class="sc">{1}</span><span class="st">'</span>.<span class="bu">format</span>(<span class="st">'spam'</span>, <span class="st">'eggs'</span>))
spam <span class="op">and</span> eggs
<span class="op">>>></span> <span class="bu">print</span>(<span class="st">'</span><span class="sc">{1}</span><span class="st"> and </span><span class="sc">{0}</span><span class="st">'</span>.<span class="bu">format</span>(<span class="st">'spam'</span>, <span class="st">'eggs'</span>))
eggs <span class="op">and</span> spam</code>Sie können Schlüsselwortparameter in str.format() verwenden und den Parameternamen verwenden, um auf den entsprechenden Wert zu verweisen:
<code class="sourceCode python"><span class="op">>>></span> <span class="bu">print</span>(<span class="st">'This </span><span class="sc">{food}</span><span class="st"> is </span><span class="sc">{adjective}</span><span class="st">.'</span>.<span class="bu">format</span>(
... food<span class="op">=</span><span class="st">'spam'</span>, adjective<span class="op">=</span><span class="st">'absolutely horrible'</span>))
This spam <span class="op">is</span> absolutely horrible.</code>Möglicherweise können Positions- und Schlüsselwortargumente kombiniert werden:
<code class="sourceCode python"><span class="op">>>></span> <span class="bu">print</span>(<span class="st">'The story of </span><span class="sc">{0}</span><span class="st">, </span><span class="sc">{1}</span><span class="st">, and </span><span class="sc">{other}</span><span class="st">.'</span>.<span class="bu">format</span>(<span class="st">'Bill'</span>, <span class="st">'Manfred'</span>,
other<span class="op">=</span><span class="st">'Georg'</span>))
The story of Bill, Manfred, <span class="op">and</span> Georg.</code>!a (entspricht ascii()), !s (entspricht str()) und !r (entspricht repr()), werden zum Konvertieren von Werten vor der Formatierung verwendet:
<code class="sourceCode python"><span class="op">>>></span> contents <span class="op">=</span> <span class="st">'eels'</span>
<span class="op">>>></span> <span class="bu">print</span>(<span class="st">'My hovercraft is full of {}.'</span>.<span class="bu">format</span>(contents))
My hovercraft <span class="op">is</span> full of eels.
<span class="op">>>></span> <span class="bu">print</span>(<span class="st">'My hovercraft is full of {!r}.'</span>.<span class="bu">format</span>(contents))
My hovercraft <span class="op">is</span> full of <span class="st">'eels'</span>.</code>Dem Formatierungsfeld kann ein optionaler : und ein Formatierungsbefehl folgen, der eine weitere Kontrolle über die Formatierung des Werts ermöglicht. Das folgende Beispiel gibt an, dass PI eine Genauigkeit von 3 Ziffern hat:
<code class="sourceCode python"><span class="op">>>></span> <span class="im">import</span> math
<span class="op">>>></span> <span class="bu">print</span>(<span class="st">'The value of PI is approximately </span><span class="sc">{0:.3f}</span><span class="st">.'</span>.<span class="bu">format</span>(math.pi))
The value of PI <span class="op">is</span> approximately <span class="fl">3.142</span>.</code>Eine Ganzzahl gefolgt von : gibt die Mindestbreite des formatierten Felds an. Dies ist nützlich, wenn Sie Tabellen erstellen:
<code class="sourceCode python"><span class="op">>>></span> table <span class="op">=</span> {<span class="st">'Sjoerd'</span>: <span class="dv">4127</span>, <span class="st">'Jack'</span>: <span class="dv">4098</span>, <span class="st">'Dcab'</span>: <span class="dv">7678</span>}
<span class="op">>>></span> <span class="cf">for</span> name, phone <span class="op">in</span> table.items():
... <span class="bu">print</span>(<span class="st">'</span><span class="sc">{0:10}</span><span class="st"> ==> </span><span class="sc">{1:10d}</span><span class="st">'</span>.<span class="bu">format</span>(name, phone))
...
Jack <span class="op">==></span> <span class="dv">4098</span>
Dcab <span class="op">==></span> <span class="dv">7678</span>
Sjoerd <span class="op">==></span> <span class="dv">4127</span></code>Wenn Sie eine lange Zeichenfolge haben und diese nicht trennen möchten, können Sie die Variable nach Namen statt nach Position referenzieren. Übergeben Sie einfach ein Wörterbuch und verwenden Sie eckige Klammern, um auf die Schlüssel zuzugreifen:
<code class="sourceCode python"><span class="op">>>></span> table <span class="op">=</span> {<span class="st">'Sjoerd'</span>: <span class="dv">4127</span>, <span class="st">'Jack'</span>: <span class="dv">4098</span>, <span class="st">'Dcab'</span>: <span class="dv">8637678</span>}
<span class="op">>>></span> <span class="bu">print</span>(<span class="st">'Jack: </span><span class="sc">{0[Jack]:d}</span><span class="st">; Sjoerd: </span><span class="sc">{0[Sjoerd]:d}</span><span class="st">; '</span>
... <span class="st">'Dcab: </span><span class="sc">{0[Dcab]:d}</span><span class="st">'</span>.<span class="bu">format</span>(table))
Jack: <span class="dv">4098</span><span class="op">;</span> Sjoerd: <span class="dv">4127</span><span class="op">;</span> Dcab: <span class="dv">863767</span></code>Sie können auch ** verwenden, um ein Wörterbuch in Schlüsselwortargumente zu entpacken:
<code class="sourceCode python"><span class="op">>>></span> table <span class="op">=</span> {<span class="st">'Sjoerd'</span>: <span class="dv">4127</span>, <span class="st">'Jack'</span>: <span class="dv">4098</span>, <span class="st">'Dcab'</span>: <span class="dv">8637678</span>}
<span class="op">>>></span> <span class="bu">print</span>(<span class="st">'Jack: </span><span class="sc">{Jack:d}</span><span class="st">; Sjoerd: </span><span class="sc">{Sjoerd:d}</span><span class="st">; Dcab: </span><span class="sc">{Dcab:d}</span><span class="st">'</span>.<span class="bu">format</span>(<span class="op">**</span>table))
Jack: <span class="dv">4098</span><span class="op">;</span> Sjoerd: <span class="dv">4127</span><span class="op">;</span> Dcab: <span class="dv">8637678</span></code>built-in函数vars()返回将当前局部变量作为字典返回，结合vars()使用时，以上特别有用。
参考Format String Syntax，完全了解str.format()。
可以使用%操作符格式化字符串。这种方式像sprintf()风格一样解析%左边的格式化参数，并将右边的参数应用到左边，然后返回格式化后的字符串。示例：
<code class="sourceCode python"><span class="op">>>></span> <span class="im">import</span> math <span class="op">>>></span> <span class="bu">print</span>(<span class="st">'The value of PI is approximately </span><span class="sc">%5.3f</span><span class="st">.'</span> <span class="op">%</span> math.pi) The value of PI <span class="op">is</span> approximately <span class="fl">3.142</span>.</code>
更多信息参见printf-style String Formatting 章节。
open()函数返回文件对象（file object），通常使用两个参数调用：open(filename, mode)。
<code class="sourceCode python"><span class="op">>>></span> f <span class="op">=</span> <span class="bu">open</span>(<span class="st">'workfile'</span>, <span class="st">'w'</span>)</code>
第一个参数是文件的字符串路径。第二个参数是包含几个字符的字符串，描述文件的使用方式。模式r用于读；w只用于写（存在的同名文件将会被删除）；a打开文件追加内容，所有写到文件中的内容都会自动添加到文件末尾；r+打开文件可读可写。模式参数是可选的，r是默认模式参数。
通常，文件以文本模式打开，意味着可以从文件中读写字符串，字符串以特定的格式编码。如果没有指定字符编码，那默认值是平台相关的编码（参见open()）。追加到模式参数的b指定文件以二进制模式打开：数据以字节对象的形式读写。这种模式用于不包含文本的文件。
文本模式中，读文件时默认将平台特定的行尾结束符（Unix中的\n，Windows中的\r\n）转换为\n。以文本模式写文件时，默认将所有出现的\n转换为平台特定的行尾结束符。这种暗地修改文件数据对于文本文件没有影响，但是会损坏JPEG或者EXE之类的文件的数据。使用二进制模式读写这类文件是要谨慎。
处理文件对象时使用with是比较好的实践。好处是当操作完成后文件可以恰当关闭，即使有异常发生。使用with比使用与其等价的try-finally语句块也简洁得多：
<code class="sourceCode python"><span class="op">>>></span> <span class="cf">with</span> <span class="bu">open</span>(<span class="st">'workfile'</span>) <span class="im">as</span> f: ... read_data <span class="op">=</span> f.read() <span class="op">>>></span> f.closed <span class="va">True</span></code>
如果没有使用with关键字，必须手动调用f.close()方法关闭文件，立即释放占用的系统资源。如果没有明确关闭文件，Python的垃圾收集程序最终会销毁对象并关闭文件，但是这之前文件会保持打开状态一段时间。另一个风险是不同的Python解释器实现会在不同的时刻做回收操作。
文件对象关闭后，无论通过with语句还是使用f.close()试图使用文件对象都会失败：
<code class="sourceCode python"><span class="op">>>></span> f.close() <span class="op">>>></span> f.read() Traceback (most recent call last): File <span class="st">"<stdin>"</span>, line <span class="dv">1</span>, <span class="op">in</span> <span class="op"><</span>module<span class="op">></span> <span class="pp">ValueError</span>: I<span class="op">/</span>O operation on closed <span class="bu">file</span></code>
这个章节以下的示例中，假设已经创建了一个叫做f的文件对象。
使用f.read(size)读取文件内容，该方法读取指定数量数据并作为字符串（文本模式）或者字节对象（二进制模式）返回。size是可选的数字参数。size省略或者为负数时，会读取整个文件内容并且返回，如果文件大小比机器内存要大时，全部读取会产生问题。若指定size，至多size大小的字节被读取并返回。如果读到了文件末尾，f.read()返回空字符串（''）。
<code class="sourceCode python"><span class="op">>>></span> f.read() <span class="co">'This is the entire file.\n'</span> <span class="op">>>></span> f.read() <span class="co">''</span></code>
f.readline()从文件中读取单行，读取到的字符串末尾会自动加上换行符（\n），只有当文件不以换行符结尾时，读取到文件的最后一行才不会自动加'\n'。这样使得返回值不会含糊不清，如果f.readline()返回空字符串时，那么就读到了文件末尾，而空行则返回\n表示，这是一个只包含单个换行符的字符串。
<code class="sourceCode python"><span class="op">>>></span> f.readline() <span class="co">'This is the first line of the file.\n'</span> <span class="op">>>></span> f.readline() <span class="co">'Second line of the file\n'</span> <span class="op">>>></span> f.readline() <span class="co">''</span></code>
使用迭代文件对象的方式，从文件中读取行。这种方式内存高效，快速，代码简洁：
<code class="sourceCode python"><span class="op">>>></span> <span class="cf">for</span> line <span class="op">in</span> f: ... <span class="bu">print</span>(line, end<span class="op">=</span><span class="st">''</span>) ... This <span class="op">is</span> the first line of the <span class="bu">file</span>. Second line of the <span class="bu">file</span></code>
如果需要读取文件所有行到列表中，可以使用list(f)或者f.readlines()。
f.write(string)将内容string写入文件，返回写入的字符串数。
<code class="sourceCode python"><span class="op">>>></span> f.write(<span class="st">'This is a test</span><span class="ch">\n</span><span class="st">'</span>) <span class="dv">15</span></code>
其他类型的对象在写入之前对象需要转换，要么转换为字符串（文本模式），要么转换为字节对象（二进制模式）：
<code class="sourceCode python"><span class="op">>>></span> value <span class="op">=</span> (<span class="st">'the answer'</span>, <span class="dv">42</span>) <span class="op">>>></span> s <span class="op">=</span> <span class="bu">str</span>(value) <span class="co"># convert the tuple to string</span> <span class="op">>>></span> f.write(s) <span class="dv">18</span></code>
在二进制模式中，f.tell()方法返回一个数字，该数字指示文件对象在文件中的当前位置，是相对于文件开始的字节数目。在文本模式中，该方法返回一个模糊的数字。
使用f.seek(offset, from_what)改变文件对象的位置。offset（偏移量）加上from_what参数指定的参考点计算出要移动到的位置。from_what值为0时表示文件开头为参考点，1表示当前文件位置为参考点，2表示文件末尾为参考点。from_what可以省略，默认为0，指示文件开头为参考点。
<code class="sourceCode python"><span class="op">>>></span> f <span class="op">=</span> <span class="bu">open</span>(<span class="st">'workfile'</span>, <span class="st">'rb+'</span>) <span class="op">>>></span> f.write(b<span class="st">'0123456789abcdef'</span>) <span class="dv">16</span> <span class="op">>>></span> f.seek(<span class="dv">5</span>) <span class="co"># Go to the 6th byte in the file</span> <span class="dv">5</span> <span class="op">>>></span> f.read(<span class="dv">1</span>) b<span class="st">'5'</span> <span class="op">>>></span> f.seek(<span class="op">-</span><span class="dv">3</span>, <span class="dv">2</span>) <span class="co"># Go to the 3rd byte before the end</span> <span class="dv">13</span> <span class="op">>>></span> f.read(<span class="dv">1</span>) b<span class="st">'d'</span></code>
文本文件中（没有使用b，以文本模式打开），只允许使用相对于文件开头的seek()方法（使用seek(0, 2)寻找文件末尾例外），并且有效的offset值（偏移量）只能是f.tell()的返回值或者0。任何其他的offset值（偏移量）都会发生未定义的行为。
文件对象有一些额外的方法，比如很少使用的isatty()和truncate()。查阅库文件手册获取关于文件对象的完整信息。
字符串可以很容易从文件中读取或写入到文件中。由于read()方法只返回字符串，数字需要额外转换，使用如int()的函数，输入字符串'123'返回数字值123。当希望保存更为复杂的数据类型，像嵌套列表或者字典之类的，手动解析和序列化就变得复杂了。
不需要用户不断编写和调试保存复杂数据类型到文件的代码，Python提供了流行的数据交换格式JSON(JavaScript Object Notation)。标准模块json可以接收Python数据结构，并把它们转换为字符串表示形式，这个过程称为序列化。从字符串形式重新构造数据称为反序列化。在序列化合反序列换之间，字符串形式表示的对象可以存储到文件或者数据中，或者通过网络连接发送到远程目标机器。
注解：JSON格式普遍用于现代应用程序中，用于数据交换。许多程序员已经熟悉了，是一种不错的协作选择
可以使用以下代码查看对象x的JSON字符串表示形式：
<code class="sourceCode python"><span class="op">>>></span> <span class="im">import</span> json <span class="op">>>></span> json.dumps([<span class="dv">1</span>, <span class="st">'simple'</span>, <span class="st">'list'</span>]) <span class="co">'[1, "simple", "list"]'</span></code>
另一种dumps()方法的变种，dump()，该方法简单将对象序列化到文本文件。如果f是已经以写模式打开的文本文件对象，可以使用如下代码：
<code class="sourceCode python">json.dump(x, f)</code>
可以再次解码对象，如果f是以读模式打开的文本文件对象：
<code class="sourceCode python">x <span class="op">=</span> json.load(f)</code>
以上是可以处理列表和字典的简单序列化技术，但是要处理任意类实例需要额外的操作。json模块的参考内容包含以下解释：
参见：
pickle- pickle模块与JSON不同，pickle是一种协议，允许任意复杂Python对象序列化。就这一点论，它只能用于 Python， 而不能用于与其他语言编写的应用程序通信。默认情况下它是不安全的：如果数据由熟练的攻击者精心制作， 反序列化来自一个不受信任源的 pickle 数据可以执行任意代码。
Das obige ist der detaillierte Inhalt von[译]Das Python-Tutorial#Eingabe und Ausgabe. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
