Comment vérifier si une chaîne est un nombre?
Comment vérifier si la chaîne d'entrée d'un utilisateur est un nombre (par exemple, -1, 0, 1, etc.)?
user_input = input("Enter something:")
if type(user_input) == int:
print("Is a number")
else:
print("Not a number")
Ce qui précède ne fonctionnera pas puisque input renvoie toujours une chaîne.
Essayez simplement de le convertir en int puis de le sauver si cela ne fonctionne pas.
try:
val = int(userInput)
except ValueError:
print("That's not an int!")
Apparemment, cela ne fonctionnera pas pour les valeurs négatives, mais cela restera positif. Désolé, je viens d'apprendre cela il y a quelques heures alors que je viens tout juste d'entrer en Python.
Utilisez isdigit ()
if userinput.isdigit():
#do stuff
Je pense que ce que vous recherchez ici est la méthode isnumeric() ( Documentation pour python3.x ):
>>>a = '123'
>>>a.isnumeric()
true
J'espère que cela t'aides
Pour Python 3, ce qui suit fonctionnera.
userInput = 0
while True:
try:
userInput = int(input("Enter something: "))
except ValueError:
print("Not an integer!")
continue
else:
print("Yes an integer!")
break
Vous pouvez également utiliser le code ci-dessous pour déterminer s’il s’agit d’un numéro ou d’un chiffre négatif.
import re
num_format = re.compile("^[\-]?[1-9][0-9]*\.?[0-9]+$")
isnumber = re.match(num_format,givennumber)
if isnumber:
print "given string is number"
vous pouvez également modifier le format en fonction de vos besoins spécifiques ..__ Je vois ce message un peu trop tard.mais espère que cela aidera d'autres personnes à la recherche de réponses :). laissez-moi savoir si quelque chose ne va pas dans le code donné.
Si vous avez spécifiquement besoin d'un int ou float, vous pouvez essayer "n'est pas int" ou "n'est pas float":
user_input = ''
while user_input is not int:
try:
user_input = int(input('Enter a number: '))
break
except ValueError:
print('Please enter a valid number: ')
print('You entered {}'.format(a))
Si vous ne devez travailler qu'avec ints, la solution la plus élégante que j'ai vue est la méthode ".isdigit ()":
a = ''
while a.isdigit() == False:
a = input('Enter a number: ')
print('You entered {}'.format(a))
Fonctionne bien pour vérifier si une entrée est un entier positif ET dans une plage spécifique
def checkIntValue():
'''Works fine for check if an **input** is
a positive Integer AND in a specific range'''
maxValue = 20
while True:
try:
intTarget = int(input('Your number ?'))
except ValueError:
continue
else:
if intTarget < 1 or intTarget > maxValue:
continue
else:
return (intTarget)
les solutions les plus élégantes seraient les solutions déjà proposées,
a=123
bool_a = a.isnumeric()
Malheureusement, cela ne fonctionne pas à la fois pour les entiers négatifs et pour les valeurs flottantes générales de a. Si votre but est de vérifier si "a" est un nombre générique au-delà d'un nombre entier, je vous suggérerais le suivant, qui fonctionne pour tous les types de flottant et de nombre entier :) Voici le test:
def isanumber(a):
try:
float(repr(a))
bool_a = True
except:
bool_a = False
return bool_a
a = 1 # integer
isanumber(a)
>>> True
a = -2.5982347892 # general float
isanumber(a)
>>> True
a = '1' # actually a string
isanumber(a)
>>> False
J'espère que tu trouves cela utile :)
Je recommanderais ceci, @ karthik27, pour les nombres négatifs
import re
num_format = re.compile(r'^\-?[1-9][0-9]*\.?[0-9]*')
Faites ensuite ce que vous voulez avec cette expression rationnelle, match (), findall (), etc.
Vous pouvez utiliser la méthode isdigit () pour les chaînes . Dans ce cas, comme vous l'avez dit, l'entrée est toujours une chaîne:
user_input = input("Enter something:")
if user_input.isdigit():
print("Is a number")
else:
print("Not a number")
Cette solution n'acceptera que des entiers et rien que des entiers.
def is_number(s):
while s.isdigit() == False:
s = raw_input("Enter only numbers: ")
return int(s)
# Your program starts here
user_input = is_number(raw_input("Enter a number: "))
Cela fonctionne avec n'importe quel nombre, y compris une fraction:
import fractions
def isnumber(s):
try:
float(s)
return True
except ValueError:
try:
Fraction(s)
return True
except ValueError:
return False
Pourquoi ne pas diviser l'entrée par un nombre? Cette façon fonctionne avec tout. Négatifs, flotteurs et flotteurs négatifs. Aussi espaces vides et zéro.
numList = [499, -486, 0.1255468, -0.21554, 'a', "this", "long string here", "455 street area", 0, ""]
for item in numList:
try:
print (item / 2) #You can divide by any number really, except zero
except:
print "Not A Number: " + item
Résultat:
249
-243
0.0627734
-0.10777
Not A Number: a
Not A Number: this
Not A Number: long string here
Not A Number: 455 street area
0
Not A Number:
naturel : [0, 1, 2 ...]
Python 2
it_is = unicode(user_input).isnumeric()
Python 3
it_is = str(user_input).isnumeric()
entier : [-∞, .., -2, -1, 0, 1, 2,]
try:
int(user_input)
it_is = True
except ValueError:
it_is = False
float : [-∞, .., -2, -1.0 ... 1, -1, -0.0 ... 1, 0, 0.0 ... 1, ..., 1, 1.0 .. .1, ..., ∞]
try:
float(user_input)
it_is = True
except ValueError:
it_is = False
Je sais que c'est assez tard, mais c'est pour aider ceux qui ont dû passer 6 heures à essayer de comprendre cela. (C'est ce que j'ai fait):
Cela fonctionne parfaitement: (vérifie s'il y a une lettre dans l'entrée/vérifie si l'entrée est un entier ou un flottant)
a=(raw_input("Amount:"))
try:
int(a)
except ValueError:
try:
float(a)
except ValueError:
print "This is not a number"
a=0
if a==0:
a=0
else:
print a
#Do stuff
Si vous souhaitez évaluer les flottants et accepter NaNs comme entrée, mais pas d'autres chaînes telles que 'abc', vous pouvez procéder comme suit:
def isnumber(x):
import numpy
try:
return type(numpy.float(x)) == float
except ValueError:
return False
Voici une fonction simple qui vérifie les entrées pour INT et RANGE. Ici, retourne 'True' si l'entrée est un entier compris entre 1-100, 'False' sinon
def validate(userInput):
try:
val = int(userInput)
if val > 0 and val < 101:
valid = True
else:
valid = False
except Exception:
valid = False
return valid
J'ai utilisé une approche différente que je pensais partager. Commencez par créer une plage valide:
valid = [str(i) for i in range(-10,11)] # ["-10","-9...."10"]
Maintenant, demandez un numéro et si ce n’est pas dans la liste, continuez à demander:
p = input("Enter a number: ")
while p not in valid:
p = input("Not valid. Try to enter a number again: ")
Enfin, convertissez en int (ce qui fonctionnera car la liste ne contient que des entiers sous forme de chaînes:
p = int(p)
essaye ça! cela a fonctionné pour moi même si je saisis des nombres négatifs.
def length(s):
return len(s)
s = input("Enter the String: ")
try:
if (type(int(s)))==int :
print("You input an integer")
except ValueError:
print("it is a string with length " + str(length(s)))
while True:
b1=input('Type a number:')
try:
a1=int(b1)
except ValueError:
print ('"%(a1)s" is not a number. Try again.' %{'a1':b1})
else:
print ('You typed "{}".'.format(a1))
break
Cela fait une boucle pour vérifier si l'entrée est un entier ou non, le résultat ressemblerait à ceci:
>>> %Run 1.1.py
Type a number:d
"d" is not a number. Try again.
Type a number:
>>> %Run 1.1.py
Type a number:4
You typed 4.
>>>
Voici la solution la plus simple:
a= input("Choose the option\n")
if(int(a)):
print (a);
else:
print("Try Again")
J'ai également rencontré des problèmes ce matin avec la possibilité pour les utilisateurs de saisir des réponses non entières à ma demande spécifique pour un entier.
C’est la solution qui a bien fonctionné pour moi d’imposer la réponse que je voulais:
player_number = 0
while player_number != 1 and player_number !=2:
player_number = raw_input("Are you Player 1 or 2? ")
try:
player_number = int(player_number)
except ValueError:
print "Please enter '1' or '2'..."
Je voudrais obtenir des exceptions avant même d’atteindre l’essai: déclaration quand j’ai utilisé
player_number = int(raw_input("Are you Player 1 or 2? ")
et l'utilisateur a entré "J" ou tout autre caractère non entier. Cela fonctionnait mieux de le prendre comme entrée brute, de vérifier si cette entrée brute pouvait être convertie en un entier, puis de le convertir ensuite.