entrée et sortie python3

Dans les premiers chapitres, nous avons effectivement touché la fonction d'entrée-sortie de Python et. Ce chapitre, nous allons introduire entrée spécifique Python et la sortie.

Format de sortie embellir

Python ainsi deux valeurs de sortie: déclarations d'expression et la fonction d'impression ().

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

Si vous voulez sortir sous la forme de plus diversifiée, vous pouvez utiliser la fonction str.format () pour formater la valeur de sortie.

Si vous voulez transformer en une valeur de chaîne de la sortie, vous pouvez utiliser la repr () ou la fonction str () à atteindre.

str (): fonction retourne un utilisateur sous une forme lisible d'expression.
rééd (): génère une forme d'expression interprète lisible.

Par exemple

>>> s = 'Hello, w3big'
>>> str(s)
'Hello, w3big'
>>> repr(s)
"'Hello, w3big'"
>>> 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, w3big\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, w3big\n'
>>> # repr() 的参数可以是 Python 的任何对象
... repr((x, y, ('Google', 'w3big')))
"(32.5, 40000, ('Google', 'w3big'))"

Il y a deux façons pour produire un carré et cube tables:

>>> 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: Dans le premier exemple, l'espace entre chaque colonne a été ajoutée par le print ().

Cet exemple montre la méthode objet chaîne rjust (), qui peut être une chaîne à droite, et remplir l'espace sur la gauche.

Il existe des procédés similaires, comme ljust () et le centre (). Ces méthodes n'écrivent rien, ils reviennent tout simplement une nouvelle chaîne.

Une autre méthode zfill (), il remplira le chiffre de gauche 0, comme suit:

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

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

>>> print('{}网址： "{}!"'.format('本教程', 'www.w3big.com'))
本教程网址： "www.w3big.com!"

Et à l'intérieur des caractères de parenthèses (champs appelés format) seront remplacés par le paramètre de format () dans.

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

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

Si l'argument mot-clé () dans le format, puis leur valeur pointera vers le nom du paramètre.

>>> print('{name}网址： {site}'.format(name='本教程', site='www.w3big.com'))
本教程网址： www.w3big.com

Localisation et mots clés arguments peuvent être une combinaison de:

>>> print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'w3big',
                                                       other='Taobao'))
站点列表 Google, w3big, 和 Taobao。

'! A' (en utilisant le ascii ()), (en utilisant str ()) et (Utilisation repr ()) peut être utilisé pour formater une valeur avant sa transformation 'r!' 'S!':

>>> import math
>>> print('常量 PI 的值近似为： {}。'.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。
>>> print('常量 PI 的值近似为： {!r}。'.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。

Options ':', suivi par le nom et le format identifiant peuvent aligner. Cela permet une meilleure forme de valeur. L'exemple suivant conservera le Pi à trois décimales:

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

Dans ':' après le passage d'un nombre entier, vous pouvez au moins veiller à ce que il y a tant de largeur de domaine. Utile quand il est utilisé sous forme d'aménagement paysager.

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

Si vous avez une longue chaîne de format, et vous ne voulez pas les séparer, puis lors du formatage par nom de variable plutôt que l'emplacement serait une bonne chose.

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

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

Vous pouvez également utiliser la variable avant la table '**' pour obtenir la même fonctionnalité:

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

formatage de chaîne de style ancien

L'opérateur% peut être réalisé en forme de chaîne. Format argument de chaîne à la gauche car elle est similaire à sprintf () formule, et le droit de substitution, puis la chaîne formatée exemple retournée:

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

Parce que la fonction str.format () est relativement nouveau, la plupart du code Python utilise encore l'opérateur%. Cependant, parce que ce ancien format sera finalement retiré de la langue, vous devez utiliser plus str.format ().

Lire la saisie au clavier

Python fournit la fonction d'entrée () de l'entrée est réglée pour lire une ligne de texte de la norme, l'entrée standard par défaut est le clavier.

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

#!/usr/bin/python3

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

Ceci produit les résultats suivants correspondant à l'entrée:

请输入：本教程
你输入的内容是:  本教程

Lire et écrire des fichiers

open () retourne un objet fichier, et la syntaxe de base est la suivante:

open(filename, mode)

filename: nom variable est une chaîne contenant la valeur que vous souhaitez accéder à un nom de fichier.
Mode: mode de mode détermine le fichier ouvert: lecture, écriture, annexant. Voir la liste complète de toutes les valeurs possibles comme suit. Ce paramètre non obligatoire, le mode d'accès de fichier par défaut est en lecture seule (r).

Ouvrez la liste complète des différents modes de fichier:

mode	description
r	Ouvrez le fichier en mode lecture seule. fichier pointeur sera placé au début du fichier. Ceci est le mode par défaut.
rb	Ouvrir un fichier en lecture seule au format binaire. Will pointeur de fichier au début du fichier. Ceci est le mode par défaut.
r +	Ouvrir un fichier pour la lecture et l'écriture. Will pointeur de fichier au début du fichier.
rb +	Ouvrir un fichier pour la lecture et l'écriture en format binaire. Will pointeur de fichier au début du fichier.
w	Ouvrir un fichier en écriture seule. Si le fichier existe déjà, il sera écrasé. Si le fichier n'existe pas, créer un nouveau fichier.
wb	Ouvrir un fichier pour l'écriture en format binaire uniquement. Si le fichier existe déjà, il sera écrasé. Si le fichier n'existe pas, créer un nouveau fichier.
w +	Ouvrir un fichier pour la lecture et l'écriture. Si le fichier existe déjà, il sera écrasé. Si le fichier n'existe pas, créer un nouveau fichier.
wb +	Ouvrir un fichier pour la lecture et l'écriture en format binaire. Si le fichier existe déjà, il sera écrasé. Si le fichier n'existe pas, créer un nouveau fichier.
un	Ouvrez un fichier pour l'ajout. Si le fichier existe déjà, le pointeur de fichier sera placé à la fin du fichier. En d'autres termes, après le nouveau contenu sera écrit dans le contenu existant. Si le fichier n'existe pas, créer un nouveau fichier pour l'écriture.
ab	Ouvrir un fichier pour l'ajout au format binaire. Si le fichier existe déjà, le pointeur de fichier sera placé à la fin du fichier. En d'autres termes, après le nouveau contenu sera écrit dans le contenu existant. Si le fichier n'existe pas, créer un nouveau fichier pour l'écriture.
a +	Ouvrir un fichier pour la lecture et l'écriture. Si le fichier existe déjà, le pointeur de fichier sera placé à la fin du fichier. Il sera le mode le fichier est ouvert append. Si le fichier n'existe pas, créer un nouveau fichier pour la lecture et l'écriture.
ab +	Ouvrir un fichier pour l'ajout au format binaire. Si le fichier existe déjà, le pointeur de fichier sera placé à la fin du fichier. Si le fichier n'existe pas, créer un nouveau fichier pour la lecture et l'écriture.

Les exemples suivants seront écrits dans le fichier foo.txt dans la chaîne:

#!/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 que vous souhaitez ouvrir.
Caractère second paramètre décrit comment utiliser le fichier. mode peut être 'r' Si le fichier est en lecture seule, 'w' pour seulement écrit (si le fichier existe, il sera supprimé), et «a» pour les contenus de fichiers supplémentaires, les données écrites seront automatiquement ajoutées à la fin . 'r +' pour lire et écrire. argument mode est facultatif; 'r' sera la valeur par défaut.

Ouvre le fichier foo.txt, apparaît comme suit:

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

Le procédé d'objets de fichiers

Cet exemple suppose que la partie restante a créé un objet fichier appelé f de.

f.read ()

Pour lire le contenu d'un fichier, appelez f.read (taille), qui va lire un certain nombre de données, et est ensuite retourné comme un objet de chaîne ou octets.

la taille est un paramètre numérique en option. Lorsque la taille est ignoré ou est négatif, tout le contenu du fichier sera lu et retourné.

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

#!/usr/bin/python3

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

str = f.read()
print(str)

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