Les parties d'entrée et de sortie de conseils à connaître lors de la programmation en Python2 ont été divisées.
Un exemple de la méthode d'entrée / sortie pour la programmation compétitive en Python. Le code d'entrée / sortie est souvent un obstacle lors de l'apprentissage d'une langue pour la première fois, mais une fois que vous vous en souvenez, c'est un modèle, donc je veux m'en souvenir rapidement.
La version Python est ** 2.7.5 ** (En Python3, les spécifications telles que l'entrée et la sortie sont très différentes, il est donc recommandé de se référer à d'autres articles)
Réception de l'entrée standard 1-Qiita
input
S
S est une chaîne de caractères.
S = raw_input()
input
N
N est un nombre entier ou à virgule flottante.
N = input()
input
A B C
A, B et C sont toutes des chaînes de caractères.
l = raw_input().split()
print l[0] #La valeur de A est sortie
print l[1] #La valeur de B est sortie
print l[2] #La valeur de C est sortie
split () divise la chaîne en listes séparées par des espaces.
input
A B C
A, B et C sont tous des nombres entiers ou flottants.
Si A, B, C sont tous des entiers
l = map(int, raw_input().split())
print l[0] # A
print l[1] # B
print l[2] # C
En bref, l'entrée reçue dans le type chaîne de caractères est divisée par un espace et affectée à la liste, et chaque élément est mappé au type entier.
Le nombre d'éléments peut être donné aux données d'entrée, mais dans le cas de Python cela n'a pas beaucoup d'importance même s'il n'est pas utilisé.
Pour les nombres à virgule flottante
l = map(float, raw_input().split())
Notez que si vous utilisez ʻint` pour les nombres à virgule flottante, la valeur sera tronquée.
A, B, C = map(int, raw_input().split())
print A # A
print B # B
print C # C
Si le nombre d'éléments dans la liste correspond au nombre sur le côté gauche, chaque élément de la liste peut être affecté à chaque variable sur le côté gauche. Il semble que ce type d'affectation s'appelle «affectation non compilée».
Dans le cas d'une programmation concurrentielle, elle ne devrait être utilisée que lorsque le nombre d'éléments d'entrée est clair et petit.
Bien que cela soit rarement vu, si une ligne contient un mélange de chaînes de caractères et d'entiers, prenez une ligne comme chaîne de caractères pour le moment, et convertissez-la plus tard en utilisant ʻint () , float () `, et ainsi de suite.
input
N
a1
a2
a3
...
aN
a1, a2, ..., aN sont N entiers.
N = input()
a = []
for i in range(N):
a.append(input())
print a # [a1, a2, a3, ..., aN]
C'est bon.
@ zakuro9715 m'a appris.
Ce code peut également être exprimé comme suit en utilisant la notation d'inclusion de liste. L'entrée de N lignes peut être écrite sur une seule ligne et est magnifique.
N = input()
a = [input() for i in range(N)]
print a # [a1, a2, a3, ..., aN]
Un format souvent vu dans Aizu Online Judge (AOJ).
input
a1
a2
a3
...
-1
a1, a2, ..., sont tous des entiers. -1 représente la fin de l'entrée.
a = []
while True:
n = input()
if n == -1:
break
a.append(n)
print a # [a1, a2, a3, ..., aN]
Je vois aussi cela de temps en temps sur AOJ. C'est difficile à déboguer et personnellement je n'aime pas ça.
input
a1
a2
a3
...
(EOF)
a1, a2, ..., sont tous des entiers. Lisez jusqu'à l'arrivée d'EOF.
import sys
a = []
for line in sys.stdin:
a.append(int(line))
print a # [a1, a2, a3, ...]
Un sentiment sommaire jusqu'à présent.
input
N M
a11 a12 a13 ... a1M
a21 a22 a23 ... a2M
a31 a32 a33 ... a3M
...
aN1 aN2 aN3 ... aNM
a11, a12, ..., aNM sont des entiers.
N, M = map(int, raw_input().split())
a = []
for i in range(M):
a.append(map(int, raw_input().split()))
print a
# [[a11, a12, a13, ..., a1M]
# [a21, a22, a23, ..., a2M]
# ...
# [aN1, aN2, aN3, ..., aNM]]
Peut-être que ce n'est pas grave si vous gardez cela.
J'ai appris de @ t2y.
En utilisant un générateur, il est possible de bien recevoir des entrées sur plusieurs lignes.
Par exemple
input
a1
a2
a3
...
(EOF)
a1, a2, ..., sont toutes des chaînes de caractères. Lisez jusqu'à l'arrivée d'EOF.
Si le format est comme
def get_input():
while True:
try:
yield ''.join(raw_input())
except EOFError:
break
if __name__ == '__main__':
a = list(get_input()) # [a1, a2, a3, ...]
Faire.
De plus, le contenu de get_input (),
def get_input():
while True:
try:
s = raw_input()
if s == '-1':
break
yield ''.join(s)
except EOFError:
break
En changeant en, il est possible de recevoir une entrée légèrement compliquée telle que "read" -1 "ou jusqu'à la fin de l'entrée".
output
A
Incluez un saut de ligne à la fin.
print A
Le type entier et le type de chaîne de caractères peuvent être générés. De plus, le débogage des listes et du dictionnaire peut être effectué tel quel avec l'instruction print.
Pour être honnête, je ne l'ai pas vu, mais pour le plaisir d'étudier.
output
A
N'inclut pas de saut de ligne à la fin.
import sys
sys.stdout.write(A)
Je vois souvent cela.
output
A B C
Incluez un saut de ligne à la fin.
print A, B, C
Dans l'instruction print, si vous mettez , après la variable, le saut de ligne sera converti en un espace demi-largeur.
Astuces Python: Je souhaite afficher une chaîne de caractères sans saut de ligne - Life with Python
output
A,B,C
A, B et C sont toutes des chaînes de caractères. Incluez un saut de ligne à la fin.
print ','.join([A, B, C])
join () correspond à l'opération inverse de split () et retourne la concaténation de chaque élément de la liste des chaînes d'arguments avec la chaîne de réception.
Notez que tous les éléments de la liste doivent être de type string.
Ici, par exemple, si A, B et C sont des entiers,
print ','.join(map(str, [A, B, C]))
Après avoir converti chaque élément en chaîne de caractères par str (), joignez.
Vous souhaiterez peut-être créer une sortie au format libre comme la fonction printf en C ++.
output
Case 1: A B
A et B sont des nombres entiers. Incluez un saut de ligne à la fin.
print 'Case 1: {0} {1}'.format(A, B)
format () prend un argument de longueur variable et retourne une chaîne contenant la valeur du i-ème argument dans '{i}'.
La plupart des choses que printf peut faire, telles que la conversion de base et l'alignement des chiffres au moment de la sortie, peuvent également être faites avec format ().
Pour plus de détails, voir Référence.