检查字符串是否包含数字

问题:检查字符串是否包含数字

我发现的大多数问题都偏向于他们正在寻找数字中的字母的事实,而我正在寻找我想成为无数字符串的数字。我需要输入一个字符串,并检查它是否包含任何数字以及是否确实拒绝它。

isdigit()True当所有字符均为数字时,该函数才返回。我只想看看用户是否输入了一个数字,如一个句子之类的"I own 1 dog"

有任何想法吗?

Most of the questions I’ve found are biased on the fact they’re looking for letters in their numbers, whereas I’m looking for numbers in what I’d like to be a numberless string. I need to enter a string and check to see if it contains any numbers and if it does reject it.

The function isdigit() only returns True if ALL of the characters are numbers. I just want to see if the user has entered a number so a sentence like "I own 1 dog" or something.

Any ideas?


回答 0

您可以像这样使用any函数和str.isdigit函数

>>> def hasNumbers(inputString):
...     return any(char.isdigit() for char in inputString)
... 
>>> hasNumbers("I own 1 dog")
True
>>> hasNumbers("I own no dog")
False

另外,您可以使用正则表达式,如下所示

>>> import re
>>> def hasNumbers(inputString):
...     return bool(re.search(r'\d', inputString))
... 
>>> hasNumbers("I own 1 dog")
True
>>> hasNumbers("I own no dog")
False

You can use any function, with the str.isdigit function, like this

>>> def hasNumbers(inputString):
...     return any(char.isdigit() for char in inputString)
... 
>>> hasNumbers("I own 1 dog")
True
>>> hasNumbers("I own no dog")
False

Alternatively you can use a Regular Expression, like this

>>> import re
>>> def hasNumbers(inputString):
...     return bool(re.search(r'\d', inputString))
... 
>>> hasNumbers("I own 1 dog")
True
>>> hasNumbers("I own no dog")
False

回答 1

您可以使用组合anystr.isdigit

def num_there(s):
    return any(i.isdigit() for i in s)

True如果字符串中存在数字,则该函数将返回,否则返回False

演示:

>>> king = 'I shall have 3 cakes'
>>> num_there(king)
True
>>> servant = 'I do not have any cakes'
>>> num_there(servant)
False

You can use a combination of any and str.isdigit:

def num_there(s):
    return any(i.isdigit() for i in s)

The function will return True if a digit exists in the string, otherwise False.

Demo:

>>> king = 'I shall have 3 cakes'
>>> num_there(king)
True
>>> servant = 'I do not have any cakes'
>>> num_there(servant)
False

回答 2

str.isalpha() 

参考:https : //docs.python.org/2/library/stdtypes.html#str.isalpha

如果字符串中的所有字符均为字母并且至少包含一个字符,则返回true,否则返回false。

use

str.isalpha() 

Ref: https://docs.python.org/2/library/stdtypes.html#str.isalpha

Return true if all characters in the string are alphabetic and there is at least one character, false otherwise.


回答 3

https://docs.python.org/2/library/re.html

您最好使用正则表达式。它要快得多。

import re

def f1(string):
    return any(i.isdigit() for i in string)


def f2(string):
    return re.search('\d', string)


# if you compile the regex string first, it's even faster
RE_D = re.compile('\d')
def f3(string):
    return RE_D.search(string)

# Output from iPython
# In [18]: %timeit  f1('assdfgag123')
# 1000000 loops, best of 3: 1.18 µs per loop

# In [19]: %timeit  f2('assdfgag123')
# 1000000 loops, best of 3: 923 ns per loop

# In [20]: %timeit  f3('assdfgag123')
# 1000000 loops, best of 3: 384 ns per loop

https://docs.python.org/2/library/re.html

You should better use regular expression. It’s much faster.

import re

def f1(string):
    return any(i.isdigit() for i in string)


def f2(string):
    return re.search('\d', string)


# if you compile the regex string first, it's even faster
RE_D = re.compile('\d')
def f3(string):
    return RE_D.search(string)

# Output from iPython
# In [18]: %timeit  f1('assdfgag123')
# 1000000 loops, best of 3: 1.18 µs per loop

# In [19]: %timeit  f2('assdfgag123')
# 1000000 loops, best of 3: 923 ns per loop

# In [20]: %timeit  f3('assdfgag123')
# 1000000 loops, best of 3: 384 ns per loop

回答 4

您可以在字符串中的每个字符上应用isdigit()函数。或者您可以使用正则表达式。

我也找到了如何在Python的字符串中找到一个数字?以非常适合的方式返回数字。以下解决方案来自该问题的答案。

number = re.search(r'\d+', yourString).group()

或者:

number = filter(str.isdigit, yourString)

有关更多信息,请查看正则表达式文档:http : //docs.python.org/2/library/re.html

编辑:这将返回实际数字,而不是布尔值,因此以上答案对于您的情况更为正确

第一种方法将返回第一个数字和后续的连续数字。因此1.56将被返回为1。10,000将被返回为10。0207-100-1000将被返回为0207。

第二种方法不起作用。

要提取所有数字,点和逗号,并且不丢失非连续数字,请使用:

re.sub('[^\d.,]' , '', yourString)

You could apply the function isdigit() on every character in the String. Or you could use regular expressions.

Also I found How do I find one number in a string in Python? with very suitable ways to return numbers. The solution below is from the answer in that question.

number = re.search(r'\d+', yourString).group()

Alternatively:

number = filter(str.isdigit, yourString)

For further Information take a look at the regex docu: http://docs.python.org/2/library/re.html

Edit: This Returns the actual numbers, not a boolean value, so the answers above are more correct for your case

The first method will return the first digit and subsequent consecutive digits. Thus 1.56 will be returned as 1. 10,000 will be returned as 10. 0207-100-1000 will be returned as 0207.

The second method does not work.

To extract all digits, dots and commas, and not lose non-consecutive digits, use:

re.sub('[^\d.,]' , '', yourString)

回答 5

您可以使用NLTK方法。

这将在文本中找到“ 1”和“ One”:

import nltk 

def existence_of_numeric_data(text):
    text=nltk.word_tokenize(text)
    pos = nltk.pos_tag(text)
    count = 0
    for i in range(len(pos)):
        word , pos_tag = pos[i]
        if pos_tag == 'CD':
            return True
    return False

existence_of_numeric_data('We are going out. Just five you and me.')

You can use NLTK method for it.

This will find both ‘1’ and ‘One’ in the text:

import nltk 

def existence_of_numeric_data(text):
    text=nltk.word_tokenize(text)
    pos = nltk.pos_tag(text)
    count = 0
    for i in range(len(pos)):
        word , pos_tag = pos[i]
        if pos_tag == 'CD':
            return True
    return False

existence_of_numeric_data('We are going out. Just five you and me.')

回答 6

您可以按照以下步骤完成此操作:

if a_string.isdigit(): do_this() else: do_that()

https://docs.python.org/2/library/stdtypes.html#str.isdigit

使用.isdigit()还意味着在需要使用列表理解的情况下不必使用异常处理(try / except)(在列表理解内部不可能进行try / except)。

You can accomplish this as follows:

if a_string.isdigit(): do_this() else: do_that()

https://docs.python.org/2/library/stdtypes.html#str.isdigit

Using .isdigit() also means not having to resort to exception handling (try/except) in cases where you need to use list comprehension (try/except is not possible inside a list comprehension).


回答 7

您可以使用带有计数的范围来检查数字在字符串中出现的次数,方法是对照范围进行检查:

def count_digit(a):
    sum = 0
    for i in range(10):
        sum += a.count(str(i))
    return sum

ans = count_digit("apple3rh5")
print(ans)

#This print 2

You can use range with count to check how many times a number appears in the string by checking it against the range:

def count_digit(a):
    sum = 0
    for i in range(10):
        sum += a.count(str(i))
    return sum

ans = count_digit("apple3rh5")
print(ans)

#This print 2

回答 8

我很惊讶没有人提到anyand的组合map

def contains_digit(s):
    isdigit = str.isdigit
    return any(map(isdigit,s))

在python 3中,它可能最快(因为正则表达式除外)是因为它不包含任何循环(并且对该函数进行别名避免了在中查找它str)。

不要在python 2中使用它作为map返回a list,这会中断any短路

I’m surprised that no-one mentionned this combination of any and map:

def contains_digit(s):
    isdigit = str.isdigit
    return any(map(isdigit,s))

in python 3 it’s probably the fastest there (except maybe for regexes) is because it doesn’t contain any loop (and aliasing the function avoids looking it up in str).

Don’t use that in python 2 as map returns a list, which breaks any short-circuiting


回答 9

这个如何?

import string

def containsNumber(line):
    res = False
    try:
        for val in line.split():
            if (float(val.strip(string.punctuation))):
                res = True
                break
    except ValueError:
        pass
    return res

containsNumber('234.12 a22') # returns True
containsNumber('234.12L a22') # returns False
containsNumber('234.12, a22') # returns True

What about this one?

import string

def containsNumber(line):
    res = False
    try:
        for val in line.split():
            if (float(val.strip(string.punctuation))):
                res = True
                break
    except ValueError:
        pass
    return res

containsNumber('234.12 a22') # returns True
containsNumber('234.12L a22') # returns False
containsNumber('234.12, a22') # returns True

回答 10

我将使@zyxue答案更加明确:

RE_D = re.compile('\d')

def has_digits(string):
    res = RE_D.search(string)
    return res is not None

has_digits('asdf1')
Out: True

has_digits('asdf')
Out: False

这是@zyxue在答案中提出的解决方案中最快的基准解决方案。

I’ll make the @zyxue answer a bit more explicit:

RE_D = re.compile('\d')

def has_digits(string):
    res = RE_D.search(string)
    return res is not None

has_digits('asdf1')
Out: True

has_digits('asdf')
Out: False

which is the solution with the fastest benchmark from the solutions that @zyxue proposed on the answer.


回答 11

更简单的解决方法是

s = '1dfss3sw235fsf7s'
count = 0
temp = list(s)
for item in temp:
    if(item.isdigit()):
        count = count + 1
    else:
        pass
print count

Simpler way to solve is as

s = '1dfss3sw235fsf7s'
count = 0
temp = list(s)
for item in temp:
    if(item.isdigit()):
        count = count + 1
    else:
        pass
print count

回答 12

import string
import random
n = 10

p = ''

while (string.ascii_uppercase not in p) and (string.ascii_lowercase not in p) and (string.digits not in p):
    for _ in range(n):
        state = random.randint(0, 2)
        if state == 0:
            p = p + chr(random.randint(97, 122))
        elif state == 1:
            p = p + chr(random.randint(65, 90))
        else:
            p = p + str(random.randint(0, 9))
    break
print(p)

此代码生成大小为n的序列,该序列至少包含一个大写字母,一个小写字母和一个数字。通过使用while循环,我们保证了该事件。

import string
import random
n = 10

p = ''

while (string.ascii_uppercase not in p) and (string.ascii_lowercase not in p) and (string.digits not in p):
    for _ in range(n):
        state = random.randint(0, 2)
        if state == 0:
            p = p + chr(random.randint(97, 122))
        elif state == 1:
            p = p + chr(random.randint(65, 90))
        else:
            p = p + str(random.randint(0, 9))
    break
print(p)

This code generates a sequence with size n which at least contain an uppercase, lowercase, and a digit. By using the while loop, we have guaranteed this event.


回答 13

any并且ord可以被组合以达到目的如下所示。

>>> def hasDigits(s):
...     return any( 48 <= ord(char) <= 57 for char in s)
...
>>> hasDigits('as1')
True
>>> hasDigits('as')
False
>>> hasDigits('as9')
True
>>> hasDigits('as_')
False
>>> hasDigits('1as')
True
>>>

关于此实现的几点。

  1. any 更好,因为它像C语言中的短路表达式一样工作,并且会在确定字符串后立即返回结果,例如,即使不比较字符串’a1bbbbbbc’,’b’和’c’。

  2. ord更好,因为它提供了更大的灵活性,例如仅在“ 0”和“ 5”之间或任何其他范围内的校验数字。例如,如果要编写数字的十六进制表示形式的验证器,则希望字符串的字母仅在“ A”至“ F”范围内。

any and ord can be combined to serve the purpose as shown below.

>>> def hasDigits(s):
...     return any( 48 <= ord(char) <= 57 for char in s)
...
>>> hasDigits('as1')
True
>>> hasDigits('as')
False
>>> hasDigits('as9')
True
>>> hasDigits('as_')
False
>>> hasDigits('1as')
True
>>>

A couple of points about this implementation.

  1. any is better because it works like short circuit expression in C Language and will return result as soon as it can be determined i.e. in case of string ‘a1bbbbbbc’ ‘b’s and ‘c’s won’t even be compared.

  2. ord is better because it provides more flexibility like check numbers only between ‘0’ and ‘5’ or any other range. For example if you were to write a validator for Hexadecimal representation of numbers you would want string to have alphabets in the range ‘A’ to ‘F’ only.


回答 14

alp_num = [x for x in string.split() if x.isalnum() and re.search(r'\d',x) and 
re.search(r'[a-z]',x)]

print(alp_num)

这将返回其中包含字母和数字的所有字符串。isalpha()返回包含所有数字或所有字符的字符串。

alp_num = [x for x in string.split() if x.isalnum() and re.search(r'\d',x) and 
re.search(r'[a-z]',x)]

print(alp_num)

This returns all the string that has both alphabets and numbers in it. isalpha() returns the string with all digits or all characters.


回答 15

这可能不是Python中最好的方法,但是作为Haskeller,这种lambda / map方法对我来说非常有意义,而且非常简短:

anydigit = lambda x: any(map(str.isdigit, x))

当然不需要命名。命名它可以像一样使用anydigit("abc123"),感觉就像我在寻找什么!

This probably isn’t the best approach in Python, but as a Haskeller this lambda/map approach made perfect sense to me and is very short:

anydigit = lambda x: any(map(str.isdigit, x))

Doesn’t need to be named of course. Named it could be used like anydigit("abc123"), which feels like what I was looking for!