Vérifier une entrée nombre

Je voudrais mettre une vérification que les caractères tapés pour une entrée de nombre ne sont bien que des chiffres ou un point.
J'ai essayé quelque chose comme

Code:

---

1 2	x = input('Entrer la valeur : ') if type(x)==type('int'):

---

et

Code:

---

1 2	x = input('Entrer la valeur : if type(x)=='float':

---

mais ça ne marche pas.

Bien sûr, je pourrais utiliser raw_input et faire la vérification sur la chaine de caractères entrée avec une regex et la transformer en nombre avec int() ou float() mais ça me plairait mieux d'utiliser input.

PS

Code:

---

if type(x)=="<type 'int'>":

---

ne marche pas non plus

Input essaye d'évaluer l'expression que tu saisis :

Code:

---

1 2 3 4 5 6 7 8

y = 12 x = input('Entrer la valeur : ') try: v = int(x) except: print x + " n'est pas un entier"   print v

---

Si lors de l'exécution tu tapes, soit une valeur : 12 soit y, l'exception n'est pas lévée (y est évalué et la valeur renvoyé sera 12). Si par contre si tu saisis n'importe quoi : aze par exemple, une exception est levée au niveau de l'input, aze n'étant pas une expression python.

Il est donc préférable de passer par raw_input :

Code:

---

1 2 3 4 5 6 7

x = raw_input('Entrer la valeur : ') try: v = int(x) except: print x + " n'est pas un entier"   print v

---

Ou alors je n'ai pas bien compris la question !!

Merci pour la réponse. Je pensais m'en sortir avec un if et une regex, mais c'est beaucoup mieux avec un try...except et les fonctions int() et float().

En cherchant dans les docus, j'ai trouvé qu'il existe un module types, qui permet de faire ceci par exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

from types import IntType,FloatType   x =12   if type(x) is FloatType: print 'la valeur de x est un réel' else: print "x n'est pas un réel"   if type(x) is IntType: print 'la valeur de x est un entier' else: print "x n'est pas un entier"

---

Mais dans mon cas où je cherche à controler une entrée ce module ne m'est pas utile car je suis obligé de faire une saisie d'entrée par raw_input().

tu peux plutôt utiliser la fonction isinstance

Code:

---

1 2 3 4 5 6

>>> isinstance(5, float) False >>> isinstance(5.0, float) True >>> isinstance(5, int) True

---

Citation:

---

Envoyé par Guigui_

tu peux plutôt utiliser la fonction isinstance

Code:

---

1 2 3 4 5 6

>>> isinstance(5, float) False >>> isinstance(5.0, float) True >>> isinstance(5, int) True

---

---

Je n'ai pas tout compris alors !!

Si je fais le test avec ce code :

Code:

---

1 2 3 4 5 6 7

x = raw_input('Entrer la valeur : ')   if isinstance(x, int): v = int(x) print v else: print x + " n'est pas un entier"

---

cela ne fonctionne pas, vu que x est de type str, et si je passe par un input, j'ai une exception en saisissant de l'alpha comme indiqué plus haut.

Pourrais tu être plus explicite ?

Bonjour,

En utilisant raw_input():

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#!/usr/bin/python # -*- coding: utf-8 -*-   x = raw_input("x = ") try: y = eval(x) if isinstance(y,int): print u"x est un entier" elif isinstance(y,float): print u"x est un réel" else: print u"x n'est ni un entier ni un réel" except: print u"x n'est ni un entier ni un réel"

---

Avec ce code, si je rentre:

123 => il affiche "x est un entier"
1.23 => il affiche "x est un réel"
azerty => il affiche "x n'est ni un entier ni un réel"

Il y a cependant un effet de bord: si je rentre 2*3 (qui n'est pas un entier mais une expression), il est tout de même affiché "x est un entier" parce qu'eval calcule l'expression avant le test.

Mais avec input(), c'est pareil, et ça donne les mêmes résultats:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

try: y = input("x = ") if isinstance(y,int): print u"x est entier" elif isinstance(y,float): print u"x est un réel" else: print u"x n'est ni un entier ni un réel" except: print u"x n'est ni un entier ni un réel"

---

Manifestement, en partant d'une chaine et sans vouloir qu'une expression mathématique soit calculée avant le test, je ne vois qu'une expression régulière:

Code:

---

1 2 3 4 5 6 7 8 9 10

import re   x = raw_input("x = ").strip() if re.match(r"^[+-]?[0-9]+$", x): print u"x est entier" elif re.match(r"^[+-]?[0-9]+(\.[0-9]*)?([eE][+-]?[0-9]+)?$", x): print u"x est un réel" else: print u"x n'est ni un entier ni un réel"

---

Et là, ça donne le bon résultat. Je crois qu'en plus, c'est ça qui colle le mieux avec ce qu'on veut faire: vérifier les caractères.

De plus, on peut modifier l'expression régulière pour, par exemple, inclure ou exclure la présence d'un exposant dans l'entrée d'un réel.

Tyrtamos

Je répondais simplement à l'usage de type plutôt que isinstance.

Après, tout dépend de ce qu'il attend en entrée. S'il accepte de pouvoir recevoir des variables, input est tout indiqué (l'avantage, est que isinstance est facile d'utilisation), sinon s'il attend une chaîne de caractères, il doit forcément passer par raw_input et traiter lui-même l'expression

Juste un petit ajout: tant avec "raw_input + eval" qu'avec "input", il faut ajouter le test "long" pour les entiers, parce qu'un nombre comme "5555555555555555" n'est pas un "int". Problème qu'on n'a pas avec les expressions régulières.

Je veux rentrer de façon répétitive des nombres, parmi d'autres instructions, au sein d'une boucle: comme pour toute tâche répétitive, il arrivera nécessairement des fois où je taperai des erreurs (lettres, ou deux fois un point, ou une virgule au lieu du point, etc).
Or si on entre autre chose qu'un nombre à une instruction x = input('x ='), une erreur d'exécution est déclenchée et je veux éviter de devoir arrêter le programme et recommencer dans ces cas là.
Donc je n'ai pas d'autre possibilité que de rentrer les nombres avec une instruction x= raw_input('x =') et de controler si x peut être transformé en nombre.

Ce qui fait que le code que j'ai mis en exemple dans les message #3 et qui commençait par x=12 ne pouvait qu'induire en erreur par rapport à ce que je veux faire. De ce point de vue, je trouve que isinstance ou type dans ce code tel quel sont équivalents et n'apportent rien pour la résolution de mon problème, mais la faute en revient à cet exemple de code qui est idiot en lui-même.

Je trouve que le try...except proposé par DelphiMan est meilleur qu'une regex, dans la mesure où je n'entrerai pas des expressions ou des exposants.
Je retiens aussi la fonction eval() proposée par tyrtamos qui me permet de traiter en une seule fois tous les cas de nombre entré (entier, long, float).
Mais il faut se méfier:
eval('13.6') est un float
eval('13,8') est un tuple ! et donc ça ne déclenchera pas une exception.
Ce qui fait que dans tes codes, tyrtamos, le cas

Code:

---

1 2	else: print u"x n'est ni un entier ni un réel"

---

correspond à une entrée de tuple
tandis que le cas

Code:

---

1 2	except: print u"x n'est ni un entier ni un réel"

---

correspond à une entrée autre que nombre ou tuple.

J'ai donc le choix entre deux façons de faire:

Code:

---

1 2 3 4 5 6 7 8 9 10

x = raw_input("x = ") try: y = eval(x) if isinstance(y,float) or isinstance(y,int) or isinstance(y,long): print 'ahh!' else: print "pas bon: c'est un tuple"   except: print "pas bon: ni nombre, ni tuple"

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

from types import IntType,FloatType   x = raw_input("x = ") try: y = eval(x) if type(y) in(FloatType,IntType,LongType): print 'ahh!' else: print "pas bon: c'est un tuple"   except: print "pas bon: ni nombre, ni tuple"

---

Je préfère isinstance() parce qu'il n'y a rien à importer

------------------

Je ne pensais pas que le problème intéresse autant.
Ne pensez vous pas qu'on pourrait suggérer la création dans la prochaine version de Python d'une fonction numbereval() qui prendrait en entrée une chaine et qui renverrait un nombre (float,integer ou long) quand c'est possible ou False quand ce n'est pas possible ?
Cela permettrait de rendre concises les entrées comme ceci:

Code:

---

1 2 3

y = numbereval(raw_input('x =')) if y: print 3,14159 * y

---

Citation:

---

Envoyé par eyquem

[COLOR="Sienna"]
Ne pensez vous pas qu'on pourrait suggérer la création dans la prochaine version de Python d'une fonction numbereval() qui prendrait en entrée une chaine et qui renverrait un nombre (float,integer ou long) quand c'est possible ou False quand ce n'est pas possible ?

---

Voilà une fonction de ce genre:

Code:

---

1 2 3 4 5 6 7 8 9 10

import re   def numbereval(x): if re.match(r"^[+-]?[0-9]+$", x): return int(x) elif re.match(r"^[+-]?(([0-9]+[eE][+-]?[0-9]+)|([0-9]+\.[0-9]*([eE][+-]?[0-9]+)?)|(\.[0-9]+([eE][+-]?[0-9]+)?))$", x): return float(x) else: return False

---

Et voilà pour la tester:

Code:

---

1 2 3 4 5 6 7

while True: y = numbereval(raw_input('x =').strip()) if y: print type(y), y else: print u"ce n'est pas un nombre"

---

La fonction renvoie un long quand le nombre entier "déborde" le type "int". Par contre, elle ne détecte pas un nombre entier suivi de "L" (à améliorer si nécessaire).

Je ne suis pas sûr d'avoir pensé à tout, mais ça a l'air de marcher.

Tyrtamos

Edit: Et voilà la version avec reconnaissance des nombres entiers longs (avec "l" ou "L" à la fin):

Code:

---

1 2 3 4 5 6 7 8 9 10 11

def numbereval(x): if re.match(r"^[+-]?[0-9]+[lL]?$", x): if x!="" and x[-1] in "lL": return long(x[:-1]) else: return int(x) elif re.match(r"^[+-]?(([0-9]+[eE][+-]?[0-9]+)|([0-9]+\.[0-9]*([eE][+-]?[0-9]+)?)|(\.[0-9]+([eE][+-]?[0-9]+)?))$", x): return float(x) else: return False

---

DelphiManiac a la bonne solution: tu lis en string, tu essaies de convertir en int (ou en float) et si tu as une exception TypeError ou ValueError, tu sais que l'entrée n'était pas valide.

Bonjour,

S'il s'agit simplement de s'assurer que l'entrée est calculable, il y a peut-être plus simple: essayer de calculer!

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

x = input('Entrer la valeur : ') try: x = 0 + x print x, type(x) except TypeError: x = None   #ou   while True: x = input('Entrer la valeur : ') try: x = 0 + x break except TypeError: continue

---

Avec input, tu as une exception dès que tu saisis une chaine alphanumérique qui n'est pas évaluable par python.

D'autre part, si à la place d'un input, tu fais un raw_input et que tu saisie une valeur entière, une exception est levée, vu que raw_input renvoi toujours un string.

Code:

---

1 2 3 4

Traceback (most recent call last): File "d:\temp\test.py", line 3, in <module> x = 0 + x TypeError: unsupported operand type(s) for +: 'int' and 'str'

---

Citation:

---

Envoyé par DelphiManiac

Avec input, tu as une exception dès que tu saisis une chaine alphanumérique qui n'est pas évaluable par python.

D'autre part, si à la place d'un input, tu fais un raw_input et que tu saisie une valeur entière, une exception est levée, vu que raw_input renvoi toujours un string.

Code:

---

1 2 3 4

Traceback (most recent call last): File "d:\temp\test.py", line 3, in <module> x = 0 + x TypeError: unsupported operand type(s) for +: 'int' and 'str'

---

---

Code:

---

1 2 3 4 5 6 7 8

while True: try: x = 0 + input('Entrer la valeur : ') break except Exception: continue   print x, type(x)

---

ou plus réaliste:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

import sys   nbreEssais = 4 while nbreEssais: nbreEssais -= 1 try: x = 0 + input('Entrer la valeur : ') break except Exception: continue if nbreEssais == 0: print u'Décidément, vous n\'y arriverez pas ...' sys.exit()   print x, type(x)

---

Il me semble qu'on peut s'autoriser à capturer Exception. Sinon, j'ai identifié TypeError, NameError et SyntaxError.
Attention, ça prend les complexes (5j, 1+2J, complex(12,3), etc.).

Je trouve l'utilisation d'input toujours très dangereuse :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

def format(): print "je formate"   while True: try: x = 0 + input('Entrer la valeur : ') break except Exception: continue   print x, type(x)

---

et tapes format() en entrée.

En gros je reste partisan de toujours controler au maximum les entrées utilisateur.

1)

Citation:

---

« Or si on entre autre chose qu'un nombre à une instruction x = input('x ='), une erreur d'exécution est déclenchée et je veux éviter de devoir arrêter le programme et recommencer dans ces cas là.
Donc je n'ai pas d'autre possibilité que de rentrer les nombres avec une instruction x= raw_input('x =') et de controler si x peut être transformé en nombre. »

---

N'IMPORTE QUOI.
C'est moi qui ai écrit ça.
Pour éviter un arrêt d'exécution de programme sur une erreur IL Y A TRY...EXCEPT qui est fait pour ça, comme l'a dit DelphiMan.
pfffffffff.......


2) En fait, je suis réellement obligé d'utiliser raw_input() parce que même avec un try...except,
ni input() ni eval() ne permettent de faire ce que je veux.

En effet eval() ne permet pas de distinguer si des caractères tapés au clavier
- représentent un nombre strictement simple tel que 5 ou 89.3, le seul type de nombre que je prévois d'entrer
- ou s'ils représentent une expression mathématiquement calculable comme 3.6*5 ou 13,8-3**10 ou 4j+89 ou même autre chose puisque 67,23 est transformé en tuple par eval().

Par ailleurs, input est kifkif

Citation:

---

« input( [prompt]) : Equivalent to eval(raw_input(prompt)). »
in Python Library Reference.

---

Inconvénient supplémentaire de input(): cette fonction évalue tout entrée avant même qu'on puisse l'examiner.

Ces "découvertes" confirme mon impression qu'il manque une fonction toute prête dans Python qui n'accepterait qu'un nombre simple en entrée (que j'ai appelée numbereval() dans un précédent message)

----------

Je ne suis pas sûr que pour mon objectif, il soit absolument préférable d'utiliser une regex, mais tyrtamos avait raison, pour mon objectif je suis obligé d'analyser une entrée en tant que chaine de caractères.
Ceci dit le problème est différent selon ce qu'on cherche à vérifier comme entrées.