Le didacticiel Python#Entrée et sortie

[Traduction]Le tutoriel Python#Entrée et sortie

Il existe de nombreuses façons d'afficher la sortie d'un programme en Python ; les données peuvent être imprimées de manière lisible par l'homme ou sorties dans un fichier pour une utilisation ultérieure. Ce chapitre en discutera en détail.

7.1 Formatage de sortie plus sophistiqué

Deux façons de générer des valeurs ont été introduites jusqu'à présent : instruction d'expression et print() fonction. (La troisième méthode consiste à utiliser la méthode write() de l'objet ; utilisez sys.stdout pour référencer le fichier de sortie standard. Consultez le manuel de référence des fichiers de bibliothèque pour plus de détails.)

Parfois, il est nécessaire d'avoir plus de contrôle sur le résultat que de simplement utiliser des espaces pour séparer les valeurs. Il existe deux manières de formater la sortie : la première consiste à traiter manuellement les chaînes, en utilisant des opérations de découpage et de concaténation de chaînes pour créer n'importe quelle disposition de sortie imaginable. Le type string fournit des méthodes utiles pour remplir des chaînes jusqu'à une largeur de colonne spécifiée, qui seront abordées sous peu. La deuxième façon consiste à utiliser la chaîne de format ou la méthode str.format().

Le module

string contient la classe Template, qui fournit des méthodes pour remplacer des valeurs dans des chaînes.

Bien sûr, il y a encore une question : comment convertir la valeur en chaîne ? Python fournit un moyen de convertir n'importe quelle valeur en chaîne : transmettez simplement la valeur à la fonction repr() ou str().

str()La fonction renvoie la forme lisible par l'homme de la valeur, tandis que repr() produit la forme lisible par l'interprète de la valeur (s'il n'y a pas de syntaxe équivalente, SyntaxError sera forcé d'être lancé). Pour les objets qui ne fournissent pas de forme spécifiquement adaptée à la lecture humaine, la fonction str() renvoie la même valeur que repr(). L'utilisation des fonctions str() et repr() donnera la même valeur de retour pour de nombreuses valeurs, telles que des nombres ou des structures comme des listes et des dictionnaires. En particulier, les chaînes ont deux représentations distinctes.

Voici quelques exemples :

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

Il existe deux façons de générer un tableau carré et cubique :

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

(Dans le premier exemple, l'espace entre les colonnes est ajouté automatiquement par print() : la fonction insère toujours des espaces entre les arguments en sortie)

Cet exemple montre la méthode str.rjust() de l'objet chaîne, qui aligne la chaîne à droite dans une colonne d'une largeur donnée, en ajoutant des espaces à gauche. str.ljust() et str.center() sont des méthodes similaires. Ces méthodes ne modifient pas la chaîne d'origine, elles renvoient simplement une nouvelle chaîne. Si la chaîne d'entrée est trop longue, ces méthodes ne tronquent pas la chaîne, mais la renvoient inchangée ; même si cela gâchera la disposition des colonnes, c'est mieux que de produire des valeurs irréelles. (Si vous voulez vraiment tronquer, vous pouvez utiliser des opérations de découpage, telles que : x.ljust(n)[:n].)

Méthodestr.zfill()Ajoute un zéro à gauche de la chaîne numérique pour identifier les signes positifs et négatifs :

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

L'utilisation de base de

str.format() est :

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

L'objet passé dans str.format() remplacera les accolades et les caractères qu'elles contiennent (appelés champs de formatage). Le numéro entre accolades peut être utilisé pour faire correspondre l'objet à la position correspondante dans la liste d'objets transmise à str.format().

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

Vous pouvez utiliser des paramètres de mot-clé dans str.format() et utiliser le nom du paramètre pour référencer la valeur correspondante :

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

Possibilité de combiner des arguments de position et de mot-clé :

<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 (correspond à ascii()), !s (correspond à str()) et !r (correspond à repr()), utilisés pour convertir les valeurs avant le formatage :

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

Le champ de formatage peut être suivi d'un : facultatif et d'une commande de formatage, permettant un contrôle supplémentaire sur le formatage de la valeur. L'exemple suivant précise que PI a une précision de 3 chiffres :

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

Un entier suivi de : précise la largeur minimale du champ formaté. Ceci est utile lors de la création de tableaux :

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

Si vous avez une longue chaîne et que vous ne souhaitez pas la séparer, vous pouvez référencer la variable par son nom plutôt que par sa position. Passez simplement un dictionnaire et utilisez des crochets pour accéder aux clés :

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

Vous pouvez également utiliser ** pour décompresser un dictionnaire en arguments de mots-clés :

<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()。

7.1.1 Old string formatting

可以使用%操作符格式化字符串。这种方式像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 章节。

7.2 Reading and Writing Files

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>

7.2.1 Methods of File Objects

这个章节以下的示例中，假设已经创建了一个叫做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()。查阅库文件手册获取关于文件对象的完整信息。

7.2.2 Saving structured data with json

字符串可以很容易从文件中读取或写入到文件中。由于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 数据可以执行任意代码。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!