.. _tut-io:
*********************************** ***** **
Entrée et sortie
****************************** ** *******
Il existe plusieurs façons de présenter la sortie d'un programme ; les données peuvent être imprimées
sous une forme lisible par l'homme ou écrites dans un fichier pour utilisation future. Ce chapitre
abordera certaines des possibilités.
Il existe plusieurs façons d'exprimer la sortie du programme : elle peut être imprimée sous une forme lisible par l'homme ou écrite >Saisir le fichier pour ; utilisation ultérieure. Ce chapitre présente plusieurs méthodes alternatives.
.. _tut-formatting :
Formatage de sortie plus sophistiqué
==================== === =======================
Jusqu'à présent, nous avons rencontré deux façons d'écrire des valeurs : *instructions d'expression* et
l'instruction :keyword:`print`. (Une troisième méthode consiste à utiliser la méthode :meth:`write`
des objets fichier ; le fichier de sortie standard peut être référencé comme ``sys. stdout`` .
Voir la référence de la bibliothèque pour plus d'informations à ce sujet.)
Nous avons deux méthodes très différentes pour générer des valeurs : *instruction d'expression* et instruction :keyword:`print` . (Le troisième type d'accès
consiste à utiliser la méthode :meth:`write` de l'objet fichier. Pour la sortie de fichier standard, veuillez vous référer à
``sys.stdout``. Pour plus de détails, consultez le manuel de référence de la bibliothèque. )
.. index:: module: string
Souvent, vous souhaiterez plus de contrôle sur le formatage de votre sortie que simplement
imprimer des valeurs séparées par des espaces. Il existe deux façons de formater votre sortie : la première consiste à effectuer vous-même toute la gestion des chaînes ; mise en page que vous pouvez imaginer. Le
module standard :mod:`string` contient quelques opérations utiles pour remplir
des chaînes à une largeur de colonne donnée, celles-ci seront abordées sous peu ;
la méthode consiste à utiliser la méthode : meth:`str.format`.Peut-être souhaitez-vous souvent avoir un contrôle plus complexe sur le format de sortie que la simple impression du délimiteur d'espace. Il existe deux méthodes pour formater la sortie. La première est que vous contrôlez la chaîne entière et utilisez les opérations de coupe de caractères et de concaténation pour créer le formulaire de sortie de votre choix. Le module standard :mod:`string` inclut un certain nombre d'opérations utiles pour remplir des chaînes dans des colonnes données. Nous en discuterons plus tard. La deuxième méthode consiste à utiliser la méthode :meth:`str.format`. Une question demeure, bien sûr : comment convertir des valeurs en chaînes ? Heureusement,Python a des moyens de convertir n'importe quelle valeur en chaîne : transmettez-la au :func:` repr` ou :func:`str` fonctions.Bien sûr, il y a une autre question, comment convertir la valeur en chaîne ? Heureusement, Python a un moyen de convertir n'importe quelle valeur en chaîne : transmettez-la dans la fonction :func:`repr` ou :func:`str`. La fonction :func:`str` est destinée à renvoyer des représentations de valeurs qui sontassez lisibles par l'homme, tandis que :func:`repr` est destinée à générer des représentationsqui pourra être lu par l'interpréteur (ou forcera un :exc:`SyntaxError` siil n'y a pas de syntaxe équivalente pour les objets qui n'ont pas dereprésentation pour la consommation humaine, :func:`str` renverra la même valeur que
:func:`repr` De nombreuses valeurs, telles que des nombres ou des structures comme des listes et
dictionnaires, ont la même représentation en utilisant l'une ou l'autre fonction. Les chaînes et
les nombres à virgule flottante, en particulier, ont deux représentations distinctes.
Fonction :func:`str` est utilisée pour convertir des valeurs en valeurs humaines. -forme lisible, et :func:`repr` est converti en une forme que l'interpréteur peut lire
(s'il n'y a pas de syntaxe équivalente, une exception :exc:`SyntaxError` se produira) Un objet n'est pas approprié
Sous une forme lisible par l'homme, :func:`str` renverra la même valeur que :func:`repr`. De nombreux types, tels que les structures
telles que les valeurs numériques ou les listes chaînées et les dictionnaires, ont une méthode d'interprétation unifiée pour chaque fonction. Les chaînes et les
nombres à virgule flottante ont des méthodes d'interprétation uniques.
Quelques exemples :
Voici quelques exemples ::
>>> 'Bonjour tout le monde.'
> > > str(s)
'Bonjour tout le monde.'
>>> repr(s)
"'Bonjour tout le monde.'"
>>> s = 'La valeur de x est ' repr(x) ', et y est ' repr(y) '...'
>>> print s
La valeur de x est 32,5 et y est 40000...
>>> ajoute des guillemets de chaîne et des barres obliques inverses :
... bonjour = 'bonjour, monde/n'
>>> bonjour = repr(bonjour)
>>> imprimer bonjour
'bonjour, monde/n'
>>> # L'argument de repr() peut être n'importe quel objet Python :
... repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"
Voici deux façons d'écrire un tableau de carrés et de cubes :
有两种方式可以写平方和立方表 ::
>>> pour x dans la plage (1, 11):
... print repr(x).rjust(2), repr(x*x).rjust(3),
.. . # Notez la virgule de fin sur la ligne précédente
... print repr(x*x*x).rjust(4)
...
1 1 1
2 8
3 9 27
4 16 64
5 25 125
6 36 2 16
7 49 343
8 64 512
9 81 729
10 100 1000
>>> pour x dans la plage (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
(Notez que dans le premier exemple, un espace entre chaque colonne a été ajouté par la
façon :keyword:`print` fonctionne : il ajoute toujours des espaces entre ses arguments.)
（注意第一个例子， :keyword:`print` 在每列之间加了一个空格，它总是在参
数间加入空格。）
Cet exemple montre la méthode :meth:`rjust` des objets chaîne, qui
justifie à droite une chaîne dans un champ d'une largeur donnée en la remplissant avec des espaces
à gauche. Il existe des méthodes similaires :meth:`ljust` et :meth:`center`. Ces
méthodes n’écrivent rien, elles renvoient simplement une nouvelle chaîne. Si la chaîne d'entrée
est trop longue, ils ne la tronquent pas, mais la renvoient inchangée ; cela va
gâcher la disposition de votre colonne, mais c'est généralement mieux que l'alternative,
qui mentirait sur une valeur. (Si vous voulez vraiment une troncature, vous pouvez
toujours ajouter une opération de tranche, comme dans ``x.ljust(n)[:n]``.)
以上是一个 :meth: "rjust"的方法还有 :meth:`ljust` et :meth:` centre`
。这些函数只是输出新的字符串，并不改变什么。如果输出的字符串太长，它们也不会截断
它，而是原样输出，这会使你的输出格式变得混乱，不过总强过另一种选择（截
断字符串），因为那样会产生错误的输出值。(如果你确实需要截断它，可以使
用切割操作，例如： ``x.ljust( n)[:n]`` 。）
Il existe une autre méthode, :meth:`zfill`, qui remplit une valeur numérique chaîne à gauche
avec des zéros. Il comprend les signes plus et moins :可以正确理解正负号 ::
>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'
L'utilisation de base de la méthode :meth:`str.format` ressemble à ceci :
方法 :meth: `str.format` 的基本用法如下 ::
>>> print 'Nous sommes les {} qui disent "{}!"'.format('knights', 'Ni')
Nous sommes les chevaliers qui disent "Ni!"
Les parenthèses et les caractères qu'ils contiennent (appelés champs de format) sont remplacés par
les objets passés dans la méthode :meth:`~str.format`. Un nombre entre
crochets fait référence à la position de l'objet passé dans la méthode
:meth:`~str.format`. :
的数值指明使用传入 :meth:` ~str.format` 方法的对象中的哪一个 ::
>>> imprimer '{0} et {1}'.format('spam', 'eggs')
spam et œufs
>>> ; imprimer '{1} et {0}'.format('spam', 'eggs')
oeufs et spam
Si des arguments de mots clés sont utilisés dans le :meth:`~str .format`, leurs valeurs
sont référencées en utilisant le nom de l'argument :
Si vous utilisez des arguments de mots-clés lors de l'appel de :meth:`~str.format`, vous pouvez. Référencez la valeur
par nom de paramètre ::
>>> print 'This {food} is {adjective}.'.format(
... food='spam', adjective='absolutely horrible')
Ce spam est absolument horrible.
Les arguments de position et de mot-clé peuvent être arbitrairement combinés :
Arguments de positionnement et de mot-clé Les paramètres peuvent être utilisés en combinaison : :
>>> print 'L'histoire de {0}, {1} et {other}.'.format('Bill', 'Manfred',
... other='Georg')
L'histoire de Bill, Manfred et Georg.
``'!s'`` (apply :func: `str `) et ``'!r'`` (apply :func:`repr`) peuvent être utilisés pour
convertir la valeur avant qu'elle ne soit formatée :
``'. !s '`` (en appliquant :func:`str` ) et ``'!r'`` (en appliquant :func:`repr` ) peuvent
convertir les valeurs avant le formatage. ::
>>> import math
>>> print 'La valeur de PI est d'environ {}.'.format(math.pi)
La valeur de PI est d'environ 3,14159265359.
>>> print 'La valeur de PI est d'environ {!r}.'.format(math.pi)
La valeur de PI est d'environ 3,141592653589793.
Un ``':'`` facultatif et un spécificateur de format peuvent suivre le nom du champ.
un plus grand contrôle sur la façon dont la valeur est formatée. L'exemple suivant
tronque Pi à trois places après la virgule.
Autorise ``':'`` facultative et les directives de format après le nom du champ. Cela permet un contrôle
plus approfondi sur le formatage des valeurs. L'exemple suivant convertit Pi en trois chiffres de précision. ::
>>> import math
>>> print 'La valeur de PI est d'environ {0:.3f}.'.format(math.pi )
La valeur de PI est d'environ 3,142.
Le passage d'un entier après ``':'`` fera en sorte que ce champ soit un minimum
nombre de caractères wide. Ceci est utile pour rendre les tableaux jolis. :
Ajouter un entier après ``':'`` après le champ limitera la largeur minimale du champ, ce qui est utile pour embellir les tableaux
Très utile. ::
>>> table = {'Sjoerd' : 4127, 'Jack' : 4098, 'Dcab' : 7678}
>>> téléphone dans table.items() :
... imprime '{0:10} ==> {1:10d}'.format(nom, téléphone)
...
Jack ==> 4098
Dcab ==> 7678
Sjoerd ==> 4127
Si vous avez une chaîne de format très longue que vous ne voulez pas diviser, ce
serait bien si vous pouviez référencer les variables à formater par nom
au lieu de par position. Cela peut être fait en passant simplement le. dictez et utilisez
crochets ``'[]'`` pour accéder aux clés :
Si vous avez une chaîne de format très longue et que vous ne voulez pas la diviser. Ce serait bien si vous pouviez faire référence aux variables formatées
par leur nom plutôt que par leur position. Il existe un moyen simple de passer dans un dictionnaire et d'accéder à ses clés en utilisant
parenthèses ::
>>> table = {'Sjoerd' : 4127, 'Jack' : 4098 , 'Dcab' : 8637678}
>>> imprimer ('Jack : {0[Jack]:d}; Sjoerd : {0[Sjoerd]:d}; '
... 'Dcab : {0[Dcab]:d}'.format(table))
Jack : 4098 ; Dcab : 8637678
Cela pourrait également être fait en passant le tableau comme arguments de mots-clés avec la notation '**'
. ::
>>> table = {'Sjoerd' : 4127, 'Jack' : 4098, 'Dcab' : 8637678}
>>> : {Jack:d};
Ceci est particulièrement utile en combinaison avec le nouveau :func:`vars`fonction, qui renvoie un dictionnaire contenant toutes les variables locales.
Cette approche fonctionne très bien en combinaison avec la nouvelle fonction intégrée :func:`vars`. Cette fonction renvoie un dictionnaire contenant toutes les variables
locales.
Pour un aperçu complet du formatage de chaîne avec :meth:`str.format`, voir
:ref:`formatstrings`.
Pour en savoir plus sur la méthode de formatage de chaîne :meth:`str.format`, voir
:ref:`formatstrings`.
Ancien formatage de chaîne Ancien formatage de chaîne
----------------------------- --- ----------
L'opérateur ``%`` peut également être utilisé pour le formatage de chaîne. Il interprète l'argument
gauche un peu comme un :cfunc :`sprintf. `/ -style chaîne de format à appliquer
au bon argument, et renvoie la chaîne résultant de cette opération de formatage
Par exemple :
opérateur ``%`. ` peut également être utilisé pour le formatage de chaîne. Il analyse le paramètre de gauche d'une manière similaire à :cfunc:`sprintf`
, lui applique le paramètre de droite et obtient la chaîne générée par l'opération de formatage, par exemple ::
>> > import math
>>> print 'La valeur de PI est d'environ % 5,3f.' .
Comme :meth:`str.format` est assez nouveau, beaucoup de code Python utilise encore l'opérateur ``%``
Cependant, parce que cet ancien style de formatage le fera. éventuellement
supprimé du langage, :meth:`str.format` devrait généralement être utilisé.
Parce que :meth:`str.format` est encore très nouveau et beaucoup de Python le code l'utilise toujours.
Cependant, étant donné que les anciennes méthodes de formatage seront éventuellement supprimées du langage,
:meth:`str.format` doit être utilisé autant que possible.
Plus d'informations peuvent être trouvées dans la section :ref:`string-formatting`.
De plus amples informations peuvent être trouvées dans la section :ref:`string-formatting`.
.. _tut-files :
Lecture et écriture de fichiers Lecture et écriture de fichiers
=================== == ===========================
.. index ::
intégré : ouvert
object : file
:func:`open` renvoie un objet fichier et est le plus souvent utilisé avec deux
arguments : ``open(filename, mode)`` .
Function:func:`open` renvoie un objet fichier. L'usage courant nécessite deux paramètres :
``open(filename, mode)``.
::
>>> f = open('/tmp/workfile', 'w')
>>> 🎜>
automatiquement ajouté à la fin. ``'r ''` ouvre le fichier à la fois en lecture et en
l'argument *mode* est facultatif ; s'il est
omis.
Le premier paramètre est une chaîne identifiant le nom du fichier. Le deuxième paramètre est une chaîne de caractères
composée d'un nombre limité de lettres, décrivant la manière dont le fichier sera utilisé. Les *modes* facultatifs sont : ``'r'``, cette option rend le fichier en lecture seule
``'w'``, cette option rend le fichier en écriture seule (pour les fichiers avec le même nom, cette opération provoque l'écrasement du fichier original); ``'a'``,
Cette option ouvre le fichier en mode ajout ; ``'r ''`, cette option ouvre le fichier ; en mode lecture-écriture ;
Le paramètre *mode* est facultatif. S'il n'est pas spécifié, la valeur par défaut est le mode ``'r'``.
Sous Windows, ``'b'`` ajouté au mode ouvre le fichier en mode binaire, il y a donc
il y a aussi des modes comme ``'rb'``, ``' wb'`` et ``'r b'``. Python sous Windows fait
une distinction entre les fichiers texte et binaires ; les caractères de fin de ligne dans les fichiers texte
sont automatiquement légèrement modifié lorsque les données sont lues ou écrites. Cette
modification en coulisse des données du fichier convient aux fichiers texte ASCII, mais
elle corrompt les données binaires comme celle-ci : file:`JPEG` ou :file:`EXE`. Soyez
très prudent lorsque vous lisez et écrivez de tels fichiers,
cela ne fait pas de mal d'ajouter. a ``'b'`` au mode, vous pouvez donc l'utiliser
indépendamment de la plate-forme pour tous les fichiers binaires.
Sur la plate-forme Windows, le mode ``'b'`` Ouvrir le fichier en mode binaire, il peut donc y avoir
combinaisons de modes similaires à ``'rb'``, ``'wb'``, ``'r b'``, etc. Il existe une différence entre les fichiers texte et les fichiers binaires sur la plate-forme Windows. Lors de la lecture et de l'écriture de fichiers texte, des terminateurs de ligne sont automatiquement ajoutés à la fin des lignes. Ce genre de baise en coulisses
La méthoden'a aucun problème avec les fichiers texte ASCII, mais elle causera des dommages lors de l'utilisation de fichiers
binaires tels que JPEG ou .EXE. Lorsque vous utilisez ces fichiers, assurez-vous de les ouvrir en mode binaire. Sous
Unix, il est également inoffensif d'ajouter un mode ``'b'``, vous pouvez donc l'utiliser indépendamment de la plate-forme avec tous les traitements de fichiers binaires.
.. _tut-filemethods :
Méthodes des objets de fichier Méthodes des objets de fichier
------------------ - ----------------------
Le reste des exemples de cette section supposera qu'un objet fichier appelé
` `f`` a déjà été créé.
Les exemples de cette section supposent tous que l'objet fichier ``f`` a déjà été créé.
Pour lire le contenu d'un fichier, appelez ``f.read(size)``, qui lit une certaine quantité de
données et la renvoie sous forme de chaîne *size* est un chiffre facultatif. Lorsque
*size* est omis ou négatif, tout le contenu du fichier sera lu et
renvoyé c'est votre problème si le fichier est deux fois plus volumineux que celui de votre machine
mémoire. Sinon, au plus *size* octets sont lus et renvoyés Si la fin dufichier a été atteinte, ``f.read()`` renverra une chaîne vide (. ``""``).Pour lire le contenu du fichier, vous devez appeler ``f.read(size)`` Cette méthode lit une certaine quantité de données et l'écrit en motsRenvoie son contenu sous forme de chaîne, *size* est une valeur facultative spécifiant la longueur de la chaîne. Si
taille n'est pas spécifiée ou est spécifiée sous forme de nombre négatif, l'intégralité du fichier sera lue et renvoyée. Des problèmes surviennent lorsque la taille du fichier est deux fois
fois la mémoire actuelle de la machine. Au contraire, les données seront lues et renvoyées aussi volumineuses que possible.
Si la fin du fichier est atteinte, f.read() renverra une chaîne vide ("").
::
>>> f.read()
'Ceci est le fichier entier./n'
>> ;> f.read()
''
``f.readline()`` lit une seule ligne du fichier ; un caractère de nouvelle ligne (``/n``)
est laissé à la fin de la chaîne et n'est omis que sur la dernière ligne du
fichier si le fichier ne se termine pas par une nouvelle ligne. Cela donne la valeur de retour
sans ambiguïté ; si ``f.readline()`` renvoie une chaîne vide, la fin du fichiera été atteinte, alors qu'une ligne vide est représentée par ``'/n'' ` `, une chaînecontenant une seule nouvelle ligne ``f.readline()`` lit une seule ligne du fichier et un caractère de nouvelle ligne est automatiquement ajouté à la fin. de la chaîne ( ``/n`` ), cette opération ne sera ignorée que si la dernière ligne du fichier ne se termine pas par un caractère de nouvelle ligne. De cette façon, la valeur de retour ne sera pas confondue. Si ``f.readline()`` renvoie une chaîne vide, cela signifie que la fin du fichier a été atteinte. c'est une ligne vide qui sera décrite comme ``'/n``, une chaîne contenant uniquement des nouvelles lignes. :: >>> f.readline() 'Ceci est la première ligne du fichier./n' >>> f.readline() 'Deuxième ligne du fichier/n' >>> f.readline() ''``f.readlines()`` renvoie une liste contenant toutes les lignes de données du fichier.Si on lui donne un paramètre facultatif *sizehint*, il lit autant d'octets dans lefichier et suffisamment d'autres pour compléter une ligne, et renvoie les lignes de celui-ciest souvent utilisé pour permettre une lecture efficace d'un gros fichier par lignes, mais sansavoir à charger le fichier. fichier entier en mémoire. Seules les lignes complètes seront renvoyées.f.readlines() renvoie une liste contenant toutes les lignes de données du fichier. Si le paramètre *sizehint* est donné, plus d'une ligne de bits sera lue et plusieurs lignes de texte seront renvoyées. Cette fonction est généralement utilisée pour lire efficacement des fichiers de lignes volumineux, évitant ainsi d'avoir à lire l'intégralité du fichier en mémoire. Cette opération ne renvoie que les lignes complètes. :: >>> f.readlines() ['Ceci est la première ligne du fichier./n', 'Deuxième ligne du fichier/n'] Une approche alternative à la lecture des lignes consiste à effectuer une boucle sur l'objet fichier.mémoire efficace, rapide et conduit à un code plus simpleIl y a un saut de ligne. -lecture en ligne Un bon moyen consiste à parcourir l'objet fichier. C'est facile à retenir, rapide et le code est plus simple :: >>> for line in f: print line, C'est le premier ligne du fichier. Deuxième ligne du fichierL'approche alternative est plus simple mais ne fournit pas un contrôle aussi finpuisque les deux approches gèrent la mise en mémoire tampon des lignes. autrement, ils ne doivent pas être mélangés.Cette méthode est très simple, mais elle ne peut pas contrôler complètement l'opération. Parce que les deux méthodes gèrent le tampon de manières différentes, elles ne peuvent pas être mélangées.``f.write(string)`` écrit le contenu de *string* dans le fichier, renvoyant
``Aucun``.
``f.write(string)`` 将 *string* 的内容写入文件，返回 ``Aucun`` 。 ::
>>> f.write('This is a test/n')
Pour écrire autre chose qu'une chaîne, il doit être converti en chaîne
d'abord :
如果就要先把这些数据转换为字符串。 ::
>>> valeur = ('la réponse', 42)
>>> s = str(valeur)
>>> f.write(s)
``f.tell()`` renvoie un entier donnant la position actuelle de l'objet fichier dans le
fichier, mesurée en octets depuis le début du fichier. Pour changer la position du fichier
objet, utilisez ``f.seek(offset, from_what)``. La position est calculée
en ajoutant *offset* à un point de référence ; le point de référence est sélectionné par
l'argument *from_what*. Une valeur *from_what* de 0 mesure à partir du début
du fichier, 1 utilise la position actuelle du fichier et 2 utilise la fin du fichier comme
point de référence. *from_what* peut être omis et la valeur par défaut est 0, en utilisant le
début du fichier comme point de référence.
``f.tell()`` 返回一个整数，代表文件对象在文件中的指针位置，该数值计量了自文
件开头到指针处的比特数。需要改变文件对象指针话话，使用
``f.seek(offset,from_what)`` *décalage*
比特， *from_what* 参数指定。 *from_what* 值为 0 表示自文件
起始处开始，1 表示自当前文件指针位置开始，2 表示自文件末尾开始。 *from_what* 可以
忽略，其默认值为零，此时从文件头开始。 ::
>>> f = open('/tmp/workfile', 'r ')
>>> f.write('0123456789abcdef')
>>> f.seek(5) # Aller au 6ème octet du fichier
>>> f.read(1)
'5'
>>> f.seek(-3, 2) # Aller au 3ème octet avant la fin
>>> f.read(1)
'd'
Lorsque vous avez terminé avec un fichier, appelez ``f.close()`` pour le fermer et libérer tout
ressources système occupées par le fichier ouvert. Après avoir appelé ``f.close()``,
les tentatives d'utilisation de l'objet fichier échoueront automatiquement.
文件使用完后，调用 ``f.close()`` 可以关闭文件，释放打开文件后占用的系统资源。
调用``f.close()``之后，再调用文件对象会自动引发错误。 ::
>>> f.close()
>>> f.read()
Traceback (dernier appel le plus récent) :
Fichier "
ValueError : opération d'E/S sur un fichier fermé
Il est recommandé d'utiliser le mot-clé :keyword:`with` lorsque vous traitez des objets fichier
. Cela présente l'avantage que le fichier est correctement fermé une fois sa
suite terminée, même si une exception est levée en cours de route. Il est également beaucoup
plus court que l'équivalent écrit :keyword:`try`/ -/ :keyword:`finally` block
用关键字 :keyword:`with` 处理文件对象是个好习惯。它的先进之处在于文件
用完后会自动关闭，就算发生异常也没关系。它是 :keyword:`try`/ -/
:keyword:`enfin ` 块的简写。 ::
>>> avec open('/tmp/workfile', 'r') comme f:
... read_data = f.read()
>>> f.closed
True
Les objets File ont des méthodes supplémentaires, telles que :meth:`~file.isatty` et
:meth:`~file.truncate` qui sont moins fréquemment utilisés; consultez la Bibliothèque
Référence pour un guide complet sur les objets fichier.
文件对象还有一些不太常用的附加方法，比如 :meth:`~file.isatty` et :meth: `~file.truncate` 在库参
考手册中有文件对象的完整指南。
.. _tut-pickle:
Le :mod:`pickle` Module :mod:`pickle` 模块
--------------------------------------------------- ------------
.. index:: module: pickle
Les chaînes peuvent facilement être écrites et lues à partir d'un fichier. Les nombres demandent un peu plus
d'efforts, puisque la méthode :meth:`read` ne renvoie que des chaînes, qui devront
être transmises à une fonction comme :func:`int`, qui prend une chaîne comme ``'123'``
et renvoie sa valeur numérique 123. Cependant, lorsque vous souhaitez enregistrer plus complexe
Les types de données comme les listes, les dictionnaires ou les instances de classe, les choses deviennent beaucoup plus
compliquées.
Nous pouvons facilement lire et écrire des chaînes dans des fichiers. Les valeurs numériques nécessitent un peu plus de problèmes, car la méthode :meth:`read`
ne renverra qu'une chaîne, et elle doit être transmise à une méthode comme :func:`int`, puis
Les caractères comme ``'123'`` sont convertis en la valeur correspondante 123. Cependant, les choses deviennent plus compliquées lorsque vous devez enregistrer des types de données
plus complexes, tels que des listes, des dictionnaires et des instances de classe.
Plutôt que de laisser les utilisateurs écrire et déboguer constamment du code pour enregistrer
des types de données compliqués, Python fournit un module standard appelé :mod:`pickle`.
Il s'agit d'un module étonnant qui peut prendre presque n'importe quel objet Python (même certaines
formes de code Python !) et le convertir en une représentation sous forme de chaîne
est appelé :dfn:`pickling` ; La reconstruction de l'objet à partir de la représentation chaîne
s'appelle :dfn:`unpickling`. Entre le décapage et le décapage,
la chaîne représentant l'objet peut avoir été stockée dans un fichier ou des données, ou<.>
envoyé via une connexion réseau à une machine distante. Heureusement, les utilisateurs n'ont pas besoin d'écrire et de déboguer du code pour enregistrer eux-mêmes des types de données complexes. Python fournit un module standard appelé :mod:`pickle`. Il s'agit d'un module étonnant qui peut exprimer presque n'importe quel objet Python (même certains extraits de code Python !) sous forme de chaîne. Ce processus est appelé encapsulation ( :dfn:`pickling` ). La reconstruction d'un objet à partir d'une expression de chaîne s'appelle unpacking ( :dfn:`unpickling` ). Les objets à l'état encapsulé peuvent être stockés dans des fichiers ou des objets, et peuvent également être transférés entre des machines distantes via le réseau. Si vous avez un objet ``x`` et un objet fichier ``f`` qui a été ouvert pourécriture, la manière la plus simple de décaper l'objet ne prend qu'une seule ligne de codeSi vous avez un objet ``x`` et un objet fichier ``f`` ouverts en mode écriture, la façon la plus simple d'encapsuler l'objet ne nécessite qu'une seule ligne de code : : pickle.dump(x, f)Pour décocher à nouveau l'objet, si ``f`` est un objet fichier qui a été ouverten lecture Si ``f`` est un objet fichier ouvert en mode lecture, vous pouvez recharger et décompresser l'objet :: x = pickle.load(f) (Il existe d'autres variantes de ceci, utilisées lors du décapage de nombreux objets ou lorsque vousne souhaitez pas écrire les données décapées dans un fichier ; consultez ladocumentation complète pour :mod: ` pickle` dans la référence de la bibliothèque Python.) (Si vous ne souhaitez pas écrire les données compressées dans un fichier, il existe d'autres variantes disponibles. Complet :mod:`pickle ` Pour la documentation, voir le Manuel de référence de la bibliothèque Python). :mod:`pickle` est le moyen standard de créer des objets Python qui peuvent être stockés etréutilisés par d'autres programmes ou par une invocation future du même programme ; 🎜>le terme technique pour ceci est un objet :dfn:`persistent`. Parce que :mod:`pickle` estsi largement utilisé, de nombreux auteurs qui écrivent des extensions Python prennent soin de s'assurer que les nouveaux types de données tels que les matrices peuvent être correctement décapés et décapés.:mod:`pickle` est le moyen standard de stocker des objets Python pour une utilisation ultérieure par d'autres programmes ou eux-mêmes. Fournir cet ensemble de technologies est un objet :dfn:`persistent`. Parce que :mod:`pickle` est largement utilisé, de nombreux auteurs d'extensions Python accordent une grande attention à la question de savoir si les nouveaux types de données comme les matrices sont adaptés à l'empaquetage et au déballage. Ce qui précède est le tutoriel de base de Python 2.7 : contenu d'entrée et de sortie. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
