Pour recevoir une entrée

Utilisez la fonction d'entrée pour affecter l'entrée de la console à un objet. À propos, la fonction raw_input est obsolète dans python3.

inp=input('Entrez quelque chose>')

 # [In]#Entrez quelque chose>hogehoge
 # [In]# inp
 # [Out]# 'hogehoge'

Trouvez l'entrée standard jusqu'à ce que la valeur correcte soit obtenue

S'il y a un désir de "taper dans ce format!", Une technique qui boucle jusqu'à ce que cette forme soit tapée. Bouclez infiniment avec while True: et demandez la valeur de ʻinp` jusqu'à ce que'hoge' soit entré. «Briser» la boucle lorsque «oge» est entré.

while True:
	inp=input('Entrez hoge>>')
	if inp=='hoge':break

 # [Out]#Entrez hoge>>foo
 # [Out]#Entrez hoge>>hogehoge
 # [Out]#Entrez hoge>>hoge

 # [In]# inp
 # [Out]# 'hoge'

Il renvoie un message d'erreur et écoute jusqu'à ce que vous saisissiez 6 chiffres.

C'est encore mieux si vous recevez un message d'erreur indiquant que vous vous trompez lorsque vous faites une erreur. Utilisez l'instruction try-except en plus de while True pour passer à ʻexcept` si une erreur se produit.

while True:
	try:
		inp=input('Entrez un numéro à 6 chiffres>> ')
		if inp.isdigit() and len(inp)==6:
			break
	except:
		pass
	print('Dans la ville d'entrée')


 # [Out] #Entrez un numéro à 6 chiffres>> 3
 # [Out]#Dans la ville d'entrée
 # [Out] #Entrez un numéro à 6 chiffres>> 45
 # [Out]#Dans la ville d'entrée
 # [Out] #Entrez un numéro à 6 chiffres>> 666666
 # [In] # inp
 # [Out]# 666666

Boucle infinie avec while True: Utilisez la fonction isdigit pour déterminer si le contenu de la chaîne est un nombre Et vérifiez la longueur de la chaîne de caractères avec la fonction len Si vous entrez une valeur incorrecte, l'instruction try sera omise et un message d'erreur sera imprimé, revenant au début de la clause while.

Demandez oui / non

L'acronyme commun «Oui» «y» est entré comme «Vrai» et l'acronyme «Non» est entré comme «Faux» ». Entrer «y» entre la valeur booléenne «True» et entrer «n» la valeur booléenne «False» dans imp.

~~inp=True if input('y/n? >> ')=='y' else False~~ Simplifié car c'est un orokanakoto qui remplace la valeur de vérité par la valeur de vérité

inp=input('y/n? >> ')=='y'




 # In# inp=True if input('y/n? >> ')=='y' else False
 y/n? >> y

 # In# inp
 # Out# True

 # In# inp=True if input('y/n? >> ')=='y' else False
y/n? >> n

 # In# inp
 # Out# False

Puisqu'il peut être écrit sur une seule ligne, il est pratique de l'écrire comme un test à la condition que "je n'entre absolument que" ou "ou" "". Mais c'est facile, mais ce n'est pas suffisant. Renvoie «True» lorsque «y» est entré, mais renvoie «False» lorsque «oui» est entré. Même si une chaîne de caractères autre que «y» et «n» est entrée, «False» est renvoyé.


 # In# inp=True if input('y/n? >> ')=='y' else False
y/n? >> yes

 # In# inp
 # Out# False

 # In# inp=True if input('y/n? >> ')=='y' else False
y/n? >> t

 # In# inp
 # Out# False

Utilisez un dictionnaire pour le choix

Par conséquent, préparez un dictionnaire contenant «y», «oui», «n» et «non». Le dictionnaire peut être utilisé comme une instruction switch-case en langage C.

dic={'y':True,'yes':True,'n':False,'no':False}
dic[input('[Y]es/[N]o? >> ').lower()]




 # [In]# dic[input('[Y]es/[N]o? >> ').lower()]
 # [Out]# [Y]es/[N]o? >> y
 # [Out]# True

 # [In]# dic[input('[Y]es/[N]o? >> ').lower()]
 # [Out]# [Y]es/[N]o? >> NO
 # [Out]# False

 # [In]# dic[input('[Y]es/[N]o? >> ').lower()]
 # [Out]# [Y]es/[N]o? >> ye
 # [Out]# ---------------------------------------------------------------------------
 # KeyError                                  Traceback (most recent call last)
 # <ipython-input-34-67f9611165bf> in <module>()
       # 1 dic={'y':True,'yes':True,'n':False,'no':False}
 # ----> 2 dic[input('[Y]es/[N]o? >> ').lower()]
 # 
 # KeyError: 'ye'

En utilisant avec désinvolture la fonction inférieure pour rendre l'entrée toute inférieure, «OUI» et «oui» sont considérés comme synonymes. Ce n'est pas encore suffisant, et si vous tapez "oe" là où vous voulez taper "oui", vous pouvez taper "KeyError"

Nous utilisons donc les états «while True:» et «try».

dic={'y':True,'yes':True,'n':False,'no':False}
while True:
	try:
		inp=dic[input('[Y]es/[N]o? >> ').lower()]
		break
	except:
		pass
	print('Error! Input again.')


 # [Out]# [Y]es/[N]o? >> ye
 # [Out]# Error! Input again.
 # [Out]# [Y]es/[N]o? >> yes

 # [In]# inp
 # [Out]# True

La méthode indiquée par shiracamus ci-dessous

Comment utiliser dans

while True:
    inp = input('[Y]es/[N]o? >> ').lower()
    if inp in dic:
        inp = dic[inp]
        break
    print('Error! Input again.')

Comment déterminer si le premier caractère de la chaîne saisie est "y" ou "n"

while True:
    inp = input('[Y]es/[N]o? >> ').lower()
    if inp in ('y', 'yes', 'n', 'no'):
        inp = inp.startswith('y') # inp[0] == 'y'Synonyme de
                                  # string.startwith recherche la première chaîne
        break
    print('Error! Input again.')

Comment renvoyer une valeur non booléenne et faire une nouvelle boucle si une valeur qui n'est pas dans le dictionnaire est entrée

while True:
    inp = dic.get(input('[Y]es/[N]o? >> ').lower(), -1)   #valeur par défaut de inp-1(← Tout va bien tant que ce n'est pas une valeur booléenne)Garder
    if type(inp) is bool:
        break
    print('Error! Input again.')

Recevez plusieurs entrées standard

Je souhaite recevoir le nombre spécifié d'entrées standard et les stocker dans la liste

Si vous demandez trois fois de suite et que vous souhaitez le stocker dans une liste, vous pouvez utiliser la notation dans la liste.

[input() for _ in range(3)]
 # [In]# a
 # [In]# d
 # [In]# v
 # [Out]#: ['a', 'd', 'v']

Je souhaite recevoir plusieurs entrées standard sur une ligne et les stocker dans une liste

Parfois, vous souhaitez accepter plusieurs entrées sur une seule ligne. Dans un tel cas, ajoutez une fonction de division après la fonction d'entrée pour la diviser. L'argument par défaut de la fonction de fractionnement est un caractère vide, il est donc stocké dans la liste séparée par des espaces. Si vous souhaitez le séparer avec un autre caractère, placez ce caractère dans l'argument de la fonction de fractionnement. Par exemple, si vous souhaitez les séparer par des virgules, procédez comme suit.

a=input('Entrez quelque chose séparé par des virgules>> ').split(',')


	# [In] a=input('Entrez quelque chose séparé par des virgules>> ').split(',')
	# [Out]Entrez quelque chose dans la virgule>> 2016,2017

	# [In] a
	# [Out] ['2016', '2017']

Je veux recevoir n'importe quel numéro de l'entrée standard et le stocker dans la liste

Une technique qui prend l'entrée standard et la stocke dans une liste jusqu'à ce que la commande de suspension (ctrl + Z dans Windows) soit pressée. La série sys.stdin.readline est un ensemble de fonctions permettant d'acquérir des entrées standard à des fins plus larges que ʻinput`.

Vous pouvez l'utiliser en important la bibliothèque sys.

readline () est une fonction pour obtenir une ligne à partir de l'entrée standard. Contrairement à ʻinput () , input supprime automatiquement le caractère de saut de ligne, tandis que readline () récupère le contenu donné à l'entrée standard tel quel. Utilisez la méthode strip ()` pour supprimer les sauts de ligne.

import sys
inp=sys.stdin.readline().strip()




 # [In]# inp=sys.stdin.readline()
 # [In]# pp

 # [In]# inp
 # [Out]# 'pp\n'

 # [In]# inp=sys.stdin.readline().strip()
 # [In]# inp
 # [Out]# 'pp'

readlines est une fonction permettant d'obtenir plusieurs lignes à partir d'une entrée standard. La valeur de retour est une liste et la chaîne de caractères d'entrée est stockée sous forme d'élément ligne par ligne. Il n'y a pas non plus de suppression automatique des caractères de saut de ligne ici, alors utilisez sprit ().

import sys
[i.strip() for i in sys.stdin.readlines()]


 # [In]# ho
 # [In]# hsop
 # [In]# hpoge
 # [In]# ^Z
 # [Out]# ['ho', 'hsop', 'hpoge']

Recevoir des conseils d'entrée standard @ python