Entrée et sortie Python3


Dans les chapitres précédents, nous avons en fait été exposés aux fonctions d'entrée et de sortie de Python. Dans ce chapitre, nous présenterons en détail les entrées et sorties de Python.

Embellissement du format de sortie

Python a deux façons de générer des valeurs : les instructions d'expression et la fonction print().

La troisième méthode consiste à utiliser la méthode write() de l'objet fichier. Le fichier de sortie standard peut être référencé avec sys.stdout.


Si vous souhaitez que la sortie soit plus diversifiée, vous pouvez utiliser la fonction str.format() pour formater la valeur de sortie.

Si vous souhaitez convertir la valeur de sortie en chaîne, vous pouvez utiliser la fonction repr() ou str() pour y parvenir.

  • str() : La fonction renvoie une expression lisible par l'utilisateur.

  • repr() : Produire une représentation lisible par l'interprète.

Par exemple, 

>>> s = 'Hello, php'
>>> str(s)
'Hello, php'
>>> repr(s)
"'Hello, php'"
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'x 的值为： ' + repr(x) + ',  y 的值为：' + repr(y) + '...'
>>> print(s)
x 的值为： 32.5,  y 的值为：40000...
>>> #  repr() 函数可以转义字符串中的特殊字符
... hello = 'hello, php\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, php\n'
>>> # repr() 的参数可以是 Python 的任何对象
... repr((x, y, ('Google', 'php')))
"(32.5, 40000, ('Google', 'php'))"

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

>>> for x in range(1, 11):
...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
...     # 注意前一行 'end' 的使用
...     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

>>> for x in range(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

Remarque : se trouve au chapitre 1. Dans un exemple, des espaces entre chaque colonne sont ajoutés par print().

Cet exemple montre la méthode rjust() de l'objet chaîne, qui peut décaler la chaîne vers la droite et remplir des espaces à gauche.

Il existe également des méthodes similaires, telles que ljust() et center(). Ces méthodes n'écrivent rien, elles renvoient simplement de nouvelles chaînes.

Une autre méthode zfill(), qui remplira le nombre avec des zéros à gauche comme indiqué ci-dessous : 

>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'

L'utilisation de base de str.format() est la suivante : 

>>> print('{}网址： "{}!"'.format('php中文网', 'www.php.cn'))
php中文网网址： "www.php.cn!"

Les crochets et les caractères qu'ils contiennent (appelés champs de format) seront remplacés par les paramètres dans format().

Le nombre entre parenthèses est utilisé pour pointer vers la position de l'objet entrant dans format(), comme suit : 

>>> print('{0} 和 {1}'.format('Google', 'php'))
Google 和 php
>>> print('{1} 和 {0}'.format('Google', 'php'))
php 和 Google

Si des arguments de mots clés sont utilisés dans format(), alors ils La valeur pointera vers le paramètre utilisant ce nom. 

>>> print('{name}网址： {site}'.format(name='php中文网', site='www.php.cn'))
php中文网网址： www.php.cn

Les arguments de position et de mot-clé peuvent être combinés de n'importe quelle manière : 

>>> print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'php',
                                                       other='Taobao'))
站点列表 Google, php, 和 Taobao。
'!a' (en utilisant ascii()), '!s' (en utilisant str()) et '!r' (en utilisant repr()) peut être utilisé pour transformer une valeur avant de la formater :
>>> import math
>>> print('常量 PI 的值近似为： {}。'.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。
>>> print('常量 PI 的值近似为： {!r}。'.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。

Le ':' facultatif et l'identifiant de format peuvent suivre le nom du champ. Cela permet un meilleur formatage des valeurs. L'exemple suivant préserve Pi à trois décimales : 

>>> import math
>>> print('常量 PI 的值近似为 {0:.3f}。'.format(math.pi))
常量 PI 的值近似为 3.142。

Passer un entier après le ':' garantit que le champ a au moins cette largeur. Utile pour embellir les tables. 

>>> table = {'Google': 1, 'php': 2, 'Taobao': 3}
>>> for name, number in table.items():
...     print('{0:10} ==> {1:10d}'.format(name, number))
...
php     ==>          2
Taobao     ==>          3
Google     ==>          1

Si vous avez une chaîne de formatage longue et que vous ne souhaitez pas les séparer, ce serait bien de la formater par nom de variable au lieu de position.

Le plus simple est de passer dans un dictionnaire, puis d'utiliser les crochets '[]' pour accéder à la valeur de la clé :

>>> table = {'Google': 1, 'php': 2, 'Taobao': 3}
>>> print('php: {0[php]:d}; Google: {0[Google]:d}; '
          'Taobao: {0[Taobao]:d}'.format(table))
php: 2; Google: 1; Taobao: 3

Vous pouvez également réaliser la même chose en utilisant '** ' avant la variable de table Fonctions : 

>>> table = {'Google': 1, 'php': 2, 'Taobao': 3}
>>> print('php: {php:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
php: 2; Google: 1; Taobao: 3

Formatage de chaîne à l'ancienne

L'opérateur % peut également implémenter le formatage de chaîne. Il prend le paramètre de gauche sous la forme d'une chaîne formatée similaire à sprintf(), remplace le paramètre de droite et renvoie la chaîne formatée. Par exemple :

.
>>> import math
>>> print('常量 PI 的值近似为：%5.3f。' % math.pi)
常量 PI 的值近似为：3.142。

Parce que str.format() est une fonction relativement nouvelle, la plupart du code Python utilise toujours l'opérateur %. Mais comme ce formatage à l'ancienne sera éventuellement supprimé du langage, str.format() devrait être utilisé plus souvent.

Lecture de la saisie au clavier

Python fournit l'input() La fonction lit une ligne de texte à partir de l’entrée standard. L’entrée standard par défaut est le clavier.

input peut recevoir une expression Python en entrée et renvoyer le résultat de l'opération. 

#!/usr/bin/python3

str = input("请输入：");
print ("你输入的内容是: ", str)

Cela produira les résultats suivants correspondant à l'entrée : 

请输入：php中文网
你输入的内容是:  php中文网

Lecture et écriture de fichiers

open() renverra un objet fichier, syntaxe de base. Le format est le suivant : 

open(filename, mode)

  • filename : La variable filename est une valeur de chaîne qui contient le nom du fichier auquel vous souhaitez accéder.

  • mode : mode détermine le mode d'ouverture du fichier : lecture seule, écriture, ajout, etc. Consultez la liste complète de toutes les valeurs possibles ci-dessous. Ce paramètre est facultatif et le mode d'accès aux fichiers par défaut est en lecture seule (r).

Liste complète des fichiers ouverts dans différents modes :

模式描述
r以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+打开一个文件用于读写。文件指针将会放在文件的开头。
rb+以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

L'exemple suivant écrit une chaîne dans le fichier foo.txt : 

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "w")

f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )

# 关闭打开的文件
f.close()

  • Le premier paramètre est le nom du fichier à ouvrir.

  • Le deuxième paramètre décrit la manière dont le fichier utilise les caractères. le mode peut être « r » si le fichier est en lecture seule, « w » pour l'écriture uniquement (un fichier portant le même nom sera supprimé s'il existe) et « a » pour ajouter le contenu du fichier le sera ; automatiquement ajouté à la fin 'r+' est utilisé à la fois pour la lecture et l'écriture. Le paramètre mode est facultatif ; « r » sera la valeur par défaut.

Ouvrez le fichier foo.txt à ce moment-là, et il s'affichera comme suit : 

$ cat /tmp/foo.txt 
Python 是一个非常好的语言。
是的，的确非常好!!

Méthodes de l'objet fichier

Les autres exemples de cette section Supposons qu'un objet fichier appelé f ait été créé.

f.read()

Pour lire le contenu d'un fichier, appelez f.read(size), qui lira une certaine quantité de données, puis sous forme de retour d'objet chaîne ou octets .

size est un paramètre numérique facultatif. Lorsque la taille est omise ou négative, tout le contenu du fichier sera lu et renvoyé.

L'exemple suivant suppose que le fichier foo.txt existe déjà (créé dans l'exemple ci-dessus) : 

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "r")

str = f.read()
print(str)

# 关闭打开的文件
f.close()

Exécutez le programme ci-dessus, le résultat de sortie est : 

Python 是一个非常好的语言。
是的，的确非常好!!

f.readline()

f.readline() lira une seule ligne du fichier. Le caractère de nouvelle ligne est « n ». Si f.readline() renvoie une chaîne vide, cela signifie que la dernière ligne a été lue. 

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "r")

str = f.readline()
print(str)

# 关闭打开的文件
f.close()

Exécutez le programme ci-dessus, le résultat de sortie est : 

Python 是一个非常好的语言。

f.readlines()

f.readlines() renverra toutes les lignes contenues dans le fichier.

Si le paramètre facultatif sizehint est défini, les octets de la longueur spécifiée sont lus et divisés en lignes. 

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "r")

str = f.readlines()
print(str)

# 关闭打开的文件
f.close()

Exécutez le programme ci-dessus, le résultat de sortie est :

['Python 是一个非常好的语言。\n', '是的，的确非常好!!\n']

Une autre façon consiste à parcourir un objet fichier et à lire chaque ligne :

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "r")

for line in f:
    print(line, end='')

# 关闭打开的文件
f.close()

Exécutez le programme ci-dessus, sortez le résultat Pour : 

Python 是一个非常好的语言。
是的，的确非常好!!

Cette méthode est simple, mais ne permet pas un bon contrôle. Les deux mécanismes de traitement étant différents, il est préférable de ne pas les mélanger.

f.write()

f.write(string) écrit une chaîne dans le fichier et renvoie le nombre de caractères écrits. 

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "w")

num = f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
print(num)
# 关闭打开的文件
f.close()

Exécutez le programme ci-dessus, le résultat de sortie est :

29

Si vous voulez écrire quelque chose qui n'est pas une chaîne, vous devrez d'abord le convertir :

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo1.txt", "w")

value = ('www.php.cn', 14)
s = str(value)
f.write(s)

# 关闭打开的文件
f.close()

Exécutez le programme ci-dessus, ouvrez le fichier foo1.txt : 

$ cat /tmp/foo1.txt 
('www.php.cn', 14)

f.tell()

f.tell() renvoie la position actuelle de l'objet fichier, qui correspond aux octets comptés à partir du début du numéro de dossier.

f.seek()

Si vous souhaitez modifier la position actuelle du fichier, vous pouvez utiliser la fonction f.seek(offset, from_what). La valeur de

from_what, si c'est 0, cela signifie le début, si c'est 1, cela signifie la position actuelle, et 2 signifie la fin du fichier, par exemple :


  • seek(x,0) : Déplacer x caractères de la position de départ, qui est le premier caractère de la première ligne du fichier

  • seek(x,1) : indique un recul par rapport à la position actuelle de x caractères.

  • seek(-x,2) : signifie déplacer x caractères vers l'avant depuis la fin du file

from_what est la valeur par défaut 0, qui est le début du fichier. Un exemple complet est donné ci-dessous : 

>>> f = open('/tmp/foo.txt', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5)     # 移动到文件的第六个字节
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # 移动到文件的倒数第三字节
13
>>> f.read(1)
b'd'


f.close()

Dans les fichiers texte (ceux sans b dans le mode d'ouverture du fichier), il ne sera positionné que par rapport à la position de départ du fichier.


Lorsque vous avez terminé le traitement d'un fichier, appelez f.close() pour fermer le fichier et libérer les ressources système. Si vous essayez d'appeler à nouveau le fichier, une exception sera levée. 

>>> f.close()
>>> f.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file
<pre>
<p>
当处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件。 而且写起来也比 try - finally 语句块要简短:</p>
<pre>
>>> with open('/tmp/foo.txt', 'r') as f:
...     read_data = f.read()
>>> f.closed
True

Les objets File ont d'autres méthodes, telles que isatty() et trucate(), mais celles-ci sont généralement moins utiles.

module pickle

Le module pickle de Python implémente la séquence de données de base et la désérialisation.

Grâce à l'opération de sérialisation du module pickle, nous pouvons enregistrer les informations sur les objets exécutés dans le programme dans un fichier et les stocker de manière permanente.

Grâce à l'opération de désérialisation du module pickle, nous pouvons créer l'objet enregistré par le dernier programme à partir du fichier.

Interface de base : 

pickle.dump(obj, file, [,protocol])

Avec l'objet pickle, le fichier peut être ouvert en lecture : 

x = pickle.load(file)

Remarque : From file Lit une chaîne de Python et le reconstruit dans l'objet Python d'origine.

file : Objet de type fichier avec les interfaces read() et readline().

Instance 1 : 

#!/usr/bin/python3
import pickle

# 使用pickle模块将数据对象保存到文件
data1 = {'a': [1, 2.0, 3, 4+6j],
         'b': ('string', u'Unicode string'),
         'c': None}

selfref_list = [1, 2, 3]
selfref_list.append(selfref_list)

output = open('data.pkl', 'wb')

# Pickle dictionary using protocol 0.
pickle.dump(data1, output)

# Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)

output.close()

Instance 2 : 

#!/usr/bin/python3
import pprint, pickle

#使用pickle模块从文件中重构python对象
pkl_file = open('data.pkl', 'rb')

data1 = pickle.load(pkl_file)
pprint.pprint(data1)

data2 = pickle.load(pkl_file)
pprint.pprint(data2)

pkl_file.close()