如何检查字符串输入是否为数字？

只需尝试将其转换为 int，如果它不起作用，则将其保释。

try:
    val = int(userInput)
except ValueError:
    print("That's not an int!")

请参阅官方教程中的处理异常。

显然，这不适用于负值，但适用于正数。

用isdigit()

if userinput.isdigit():
    #do stuff

对于 Python 3，以下操作将起作用。

userInput = 0
while True:
  try:
     userInput = int(input("Enter something: "))       
  except ValueError:
     print("Not an integer!")
     continue
  else:
     print("Yes an integer!")
     break 

这适用于任何数字，包括分数：

import fractions

def isnumber(s):
   try:
     float(s)
     return True
   except ValueError:
     try: 
       Fraction(s)
       return True
     except ValueError: 
       return False

检查输入是否正常 特定范围内的正整数 AND

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)

编辑： 您也可以使用下面的代码来确定它是一个数字还是一个负数

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"

您也可以根据具体要求更改格式。 我看到这篇文章有点太晚了，但希望这对其他正在寻找答案的人有所帮助:)。如果给定的代码中有任何错误，请告诉我。

@karthik27，对于负数，我建议这样做

import re
num_format = re.compile(r'^\-?[1-9][0-9]*\.?[0-9]*')

然后用那个正则表达式做任何你想做的事情，match（），findall（）等

今天早上我还遇到了一些问题，用户能够输入非整数响应来响应我对整数的特定请求。

这是最终让我无法得到我想要的答案的解决方案：

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'..."

当我使用 try： 语句时，我什至会在到达 try： 语句之前收到异常

player_number = int(raw_input("Are you Player 1 or 2? ") 

并且用户输入了“J”或任何其他非整数字符。最好将其作为原始输入，检查原始输入是否可以转换为整数，然后再进行转换。

我知道这已经很晚了，但它可以帮助其他不得不花 6 个小时试图解决这个问题的人。（我就是这么做的）：

这完美无缺：（检查输入中是否有任何字母/检查输入是整数还是浮点数）

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

isnumeric（） 方法将完成这项工作：

>>>a = '123'
>>>a.isnumeric()
True

但请记住：

>>>a = '-1'
>>>a.isnumeric()
False

isnumeric()如果字符串中的所有字符都是数字字符，并且至少有一个字符，则返回。True

所以不接受负数。

a=10

isinstance(a,int)  #True

b='abc'

isinstance(b,int)  #False

这是一个简单的函数，用于检查 INT 和 RANGE 的输入。在这里，如果输入是介于 1-100 之间的整数，则返回“True”，否则返回“False”

def validate(userInput):

    try:
        val = int(userInput)
        if val > 0 and val < 101:
            valid = True
        else:
            valid = False

    except Exception:
        valid = False

    return valid

这是最简单的解决方案：

a= input("Choose the option\n")

if(int(a)):
    print (a);
else:
    print("Try Again")

最优雅的解决方案是已经提出的，

a = 123
bool_a = a.isnumeric()

不幸的是，它既不适用于负整数，也不适用于 a 的一般浮点值。如果你的意思是检查'a'是否是超过整数的通用数，我建议你使用以下一个，它适用于各种浮点数和整数:)。这是测试：

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

这是基于答案的灵感。我定义了一个函数，如下所示。看起来它工作正常。

def isanumber(inp):
    try:
        val = int(inp)
        return True
    except ValueError:
        try:
            val = float(inp)
            return True
        except ValueError:
            return False

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

这会产生一个循环来检查输入是否为整数，结果如下所示：

>>> %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.
>>> 

如果你想计算浮点数，并且你想接受 s 作为输入，而不是其他字符串，比如 ，你可以执行以下操作：NaN'abc'

def isnumber(x):
    import numpy
    try:
        return type(numpy.float(x)) == float
    except ValueError:
        return False

您可以将 isdigit（） 方法用于字符串。 在这种情况下，正如您所说，输入始终是一个字符串：

    user_input = input("Enter something:")
    if user_input.isdigit():
        print("Is a number")
    else:
        print("Not a number")

如果你特别需要一个 int 或 float，你可以尝试 “is not int” 或 “is not 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(user_input))

如果您只需要使用 ints，那么我见过的最优雅的解决方案是“.isdigit（）”方法：

a = ''
while a.isdigit() == False:
    a = input('Enter a number: ')

print('You entered {}'.format(a))

我一直在使用一种我认为我会分享的不同方法。首先创建一个有效的范围：

valid = [str(i) for i in range(-10,11)] #  ["-10","-9...."10"] 

现在询问一个号码，如果不在列表中，请继续询问：

p = input("Enter a number: ")

while p not in valid:
    p = input("Not valid. Try to enter a number again: ")

最后转换为 int（这将起作用，因为列表仅包含整数作为字符串：

p = int(p)

为什么不将输入除以一个数字呢？这种方式适用于一切。负数、浮点数和负数浮点数。还有空格和零。

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

结果：

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: 

自然： [0， 1， 2 ...∞]

Python 2 中文文档

it_is = unicode(user_input).isnumeric()

Python 3 （英语）

it_is = str(user_input).isnumeric()

整数： [-∞， ..， -2， -1， 0， 1， 2， ∞]

try:
    int(user_input)
    it_is = True
except ValueError:
    it_is = False
 

浮点数： [-∞， ..， -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

此解决方案将只接受整数，而只接受整数。

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: "))

试试这个！即使我输入负数，它也对我有用。

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)))

这将起作用：

print(user_input.isnumeric())

这将检查字符串中是否只有数字并且长度至少为 1。 但是，如果您尝试使用包含负数的字符串进行 isnumeric，则 isnumeric 将返回 .False

现在，这是一个适用于负数和正数的解决方案

try:
    user_input = int(user_input)
except ValueError:
    process_non_numeric_user_input()  # user_input is not a numeric string!
else:
    process_user_input()

您可以键入：

user_input = input("Enter something: ")

if type(user_input) == int:
    print(user_input, "Is a number")
else:
    print("Not a number")
  
try:
    val = int(user_input)
except ValueError:
    print("That's not an int!")

检查类型：Decimal

import decimal
isinstance(x, decimal.Decimal)

我认为在一行中不做一件简单的事情不是 Pythonic。

没有 的版本，使用正则表达式匹配：try..except

法典：

import re

if re.match('[-+]?\d+$', the_str):
  # Is integer

测试：

>>> import re
>>> def test(s): return bool(re.match('[-+]?\d+$', s))

>>> test('0')
True
>>> test('1')
True
>>> test('-1')
True

>>> test('-0')
True
>>> test('+0')
True
>>> test('+1')
True


>>> test('-1-1')
False
>>> test('+1+1')
False

看起来到目前为止只有两个答案可以处理负数和小数（尝试...除了答案和正则表达式？不久前在某个地方找到了第三个答案（尝试搜索它，但没有成功），它使用显式直接检查每个字符而不是完整的正则表达式。

看起来它仍然比 try/exceptions 方法慢得多，但如果您不想弄乱这些，那么在大量使用时，某些用例可能会比正则表达式更好，特别是如果某些数字是短/非负数：

>>> from timeit import timeit

在 Windows 上的 Python 3.10 上为我显示了具有代表性的结果：

显式检查每个字符：

>>> print(timeit('text="1234"; z=text[0]; (z.isdigit() or z == "-" or z == ".") and all(character.isdigit() or character == "." for character in text[1:])'))
0.5673831000458449
>>> print(timeit('text="-4089175.25"; z=text[0]; (z.isdigit() or z == "-" or z == ".") and all(character.isdigit() or character == "." for character in text[1:])'))
1.0832774000009522
>>> print(timeit('text="-97271851234.28975232364"; z=text[0]; (z.isdigit() or z == "-" or z == ".") and all(character.isdigit() or character == "." for character in text[1:])'))
1.9836419000057504

比尝试慢很多，但以下情况除外：

>>> def exception_try(string):
...   try:
...     return type(float(string)) == int
...   except:
...     return false

>>> print(timeit('text="1234"; exception_try(text)', "from __main__ import exception_try"))
0.22721579996868968
>>> print(timeit('text="-4089175.25"; exception_try(text)', "from __main__ import exception_try"))
0.2409859000472352
>>> print(timeit('text="-97271851234.28975232364"; exception_try(text)', "from __main__ import exception_try"))
0.45190039998851717

但是比正则表达式快一点，除非你有一个非常长的字符串？

>>> print(timeit('import re'))
0.08660140004940331

（如果您已经在使用它）...然后：

>>> print(timeit('text="1234"; import re; num_format = re.compile("^[\-]?[1-9][0-9]*\.?[0-9]+$"); re.match(num_format,text)'))
1.3882658999646083
>>> print(timeit('text="-4089175.25"; import re; num_format = re.compile("^[\-]?[1-9][0-9]*\.?[0-9]+$"); re.match(num_format,text)'))
1.4007637000177056
>>> print(timeit('text="-97271851234.28975232364"; import re; num_format = re.compile("^[\-]?[1-9][0-9]*\.?[0-9]+$"); re.match(num_format,text)'))
1.4191589000402018

没有一个接近最简单的十进制，但这当然不会捕捉到负面因素......

>>> print(timeit('text="1234"; text.isdecimal()'))
0.04747540003154427

根据需要有选择总是好的？

我发现一些 Python 库使用断言来确保程序员用户提供的值是一个数字。

有时，看到一个“来自野外”的例子是件好事。用/：assertisinstance

def check_port(port):
    assert isinstance(port, int), 'PORT is not a number'
    assert port >= 0, 'PORT < 0 ({0})'.format(port)