正则表达式匹配文本中带或不带逗号和小数的数字

96

我正在尝试查找并替换文本正文中的所有数字。我找到了一些正则表达式示例，它们几乎可以解决问题，但是还没有一个完美的例子。我的问题是文本中的数字可能带有小数点和逗号，也可能没有。例如：

“ 5000磅重的狐狸跳过了99,999.99998713英尺的围栏。”

正则表达式应返回“ 5000”和“ 99,999.99998713”。示例我发现分解逗号上的数字或限制为两位小数。我已经开始足够了解正则表达式，以了解为什么某些示例限于两位小数，但是我还没有学会如何克服它，还没有包括逗号来获得整个序列。

这是我的最新版本： 

[0-9]+(\.[0-9][0-9]?)?

返回上面的文本的“ 5000”，“ 99,99”，“ 9.99”和“ 998713”。

regex 
— 甜甜圈
source
1
什么编程语言或正则表达式风格？
— 马特·鲍尔
7
似乎几乎每个答案都在允许类似.,.,.or 9,9,9,9或or 这样的错误9,9.99.9。这些正则表达式不需要数字采用正确的格式，并且在最坏的情况下，会将标点符号视为数字。有一些可选的调整（例如，是否允许前导零和尾随零），但是我看到的某些答案是完全错误的。我真的不喜欢投票，特别是在诚实尝试时，但是我觉得这里的答案需要清理。这是一个常见问题，一定会再次被问到。
— 贾斯汀·摩根
如果您不知道itbyet，请访问regexpal.com
— entonio
抱歉，延迟了Matt。我使用的是Adobe的ActionScript3。我认为regex行为与JavaScript相同，但是我在regexpal.com上测试了Justin的建议，并将其与Flash应用程序的结果进行了比较，发现两个不同的结果都错了。
根据我自己的测试，这次应该可以工作了。让我知道它是否仍然需要改进。
— 贾斯汀·摩根

Answers:

288

编辑：由于这已经获得了很多意见，所以让我开始向每个人提供他们在Google上寻求的东西：

#ALL THESE REQUIRE THE WHOLE STRING TO BE A NUMBER
#For numbers embedded in sentences, see discussion below

#### NUMBERS AND DECIMALS ONLY ####
#No commas allowed
#Pass: (1000.0), (001), (.001)
#Fail: (1,000.0)
^\d*\.?\d+$

#No commas allowed
#Can't start with "."
#Pass: (0.01)
#Fail: (.01)
^(\d+\.)?\d+$

#### CURRENCY ####
#No commas allowed
#"$" optional
#Can't start with "."
#Either 0 or 2 decimal digits
#Pass: ($1000), (1.00), ($0.11)
#Fail: ($1.0), (1.), ($1.000), ($.11)
^\$?\d+(\.\d{2})?$

#### COMMA-GROUPED ####
#Commas required between powers of 1,000
#Can't start with "."
#Pass: (1,000,000), (0.001)
#Fail: (1000000), (1,00,00,00), (.001)
^\d{1,3}(,\d{3})*(\.\d+)?$

#Commas required
#Cannot be empty
#Pass: (1,000.100), (.001)
#Fail: (1000), ()
^(?=.)(\d{1,3}(,\d{3})*)?(\.\d+)?$

#Commas optional as long as they're consistent
#Can't start with "."
#Pass: (1,000,000), (1000000)
#Fail: (10000,000), (1,00,00)
^(\d+|\d{1,3}(,\d{3})*)(\.\d+)?$

#### LEADING AND TRAILING ZEROES ####
#No commas allowed
#Can't start with "."
#No leading zeroes in integer part
#Pass: (1.00), (0.00)
#Fail: (001)
^([1-9]\d*|0)(\.\d+)?$

#No commas allowed
#Can't start with "."
#No trailing zeroes in decimal part
#Pass: (1), (0.1)
#Fail: (1.00), (0.1000)
^\d+(\.\d*[1-9])?$

既然这已经成为现实，下面的大部分内容旨在说明如果您尝试更聪明的正则表达式会变得多么复杂，以及为什么要寻找替代方法。阅读风险自负。

这是一个很常见的任务，但我到目前为止看到这里的答案将接受不数字格式相匹配的输入，如,111，9,9,9或甚.,,.。即使将数字嵌入其他文本中，也很容易修复。恕我直言，任何无法拉出1,234.56和1234 （仅这些数字）的东西abc22 1,234.56 9.9.9.9 def 1234都是错误的答案。

首先，如果您不需要在一个正则表达式中全部执行此操作，则不需要。即使两种不同数字格式的正则表达式未嵌入其他文本中，也很难维护。您真正应该做的是将整个内容拆分为空白，然后对结果运行两个或三个较小的正则表达式。如果那不是您的选择，请继续阅读。

基本模式

考虑到您给出的示例，这是一个简单的正则表达式，它几乎允许任何整数或十进制0000格式，并阻止其他所有内容：

^\d*\.?\d+$

这是一种需要0,000格式的文件：

^\d{1,3}(,\d{3})*(\.\d+)?$

将它们放在一起，只要它们是一致的，逗号就成为可选的：

^(\d*\.?\d+|\d{1,3}(,\d{3})*(\.\d+)?)$

嵌入式号码

上面的模式要求整个输入为数字。您正在寻找嵌入文本的数字，因此您必须松开该部分。在另一方面，你不想它，看catch22，并认为它的发现在22号。如果您使用的是与回顾后支持（如.NET）的东西，这是很容易：更换^同(?<!\S)和$与(?!\S)你是好去：

(?<!\S)(\d*\.?\d+|\d{1,3}(,\d{3})*(\.\d+)?)(?!\S)

如果您使用的是JavaScript或Ruby或其他工具，则事情看起来会更加复杂：

(?:^|\s)(\d*\.?\d+|\d{1,3}(?:,\d{3})*(?:\.\d+)?)(?!\S)

您必须使用捕获组。没有后盾的支持，我无法想到其他选择。您想要的号码将在第1组中（假设整个比赛都是第0组）。

验证和更复杂的规则

我认为这涵盖了您的问题，因此，如果仅此而已，请立即停止阅读。如果您想发烧友，事情会很快变得非常复杂。根据您的情况，您可能希望阻止以下任何或全部操作：

  • 空输入
  • 前导零（例如000123）
  • 尾随零（例如1.2340000）
  • 以小数点开头的小数（例如.001而不是0.001）

仅此而已，让我们假设您要阻止前三个，但允许最后一个。你该怎么办？我将告诉您您应该怎么做，应该为每个规则使用不同的正则表达式，并逐步缩小匹配范围。但是为了应对挑战，以下是您如何以一种巨大的方式完成所有工作：

(?<!\S)(?=.)(0|([1-9](\d*|\d{0,2}(,\d{3})*)))?(\.\d*[1-9])?(?!\S)

这是什么意思：

(?<!\S) to (?!\S) #The whole match must be surrounded by either whitespace or line boundaries. So if you see something bogus like :;:9.:, ignore the 9.
(?=.)             #The whole thing can't be blank.

(                    #Rules for the integer part:
  0                  #1. The integer part could just be 0...
  |                  #
  [1-9]              #   ...otherwise, it can't have leading zeroes.
  (                  #
    \d*              #2. It could use no commas at all...
    |                #
    \d{0,2}(,\d{3})* #   ...or it could be comma-separated groups of 3 digits each.
  )                  # 
)?                   #3. Or there could be no integer part at all.

(       #Rules for the decimal part:
  \.    #1. It must start with a decimal point...
  \d*   #2. ...followed by a string of numeric digits only.
  [1-9] #3. It can't be just the decimal point, and it can't end in 0.
)?      #4. The whole decimal part is also optional. Remember, we checked at the beginning to make sure the whole thing wasn't blank.

在这里测试：http : //rextester.com/YPG96786

这将允许以下内容：

100,000
999.999
90.0009
1,000,023.999
0.111
.111
0

它将阻止诸如：

1,1,1.111
000,001.111
999.
0.
111.110000
1.1.1.111
9.909,888

有几种方法可以使此正则表达式更简单，更短，但是要理解，更改模式会松散它认为是数字的内容。

由于许多正则表达式引擎（例如JavaScript和Ruby）不支持负向后视，因此正确执行此操作的唯一方法是使用捕获组：

(:?^|\s)(?=.)((?:0|(?:[1-9](?:\d*|\d{0,2}(?:,\d{3})*)))?(?:\.\d*[1-9])?)(?!\S)

您要查找的数字将在捕获组1中。

在这里测试：http : //rubular.com/r/3HCSkndzhT

最后一点

显然，这是一个庞大，复杂，几乎无法读取的正则表达式。我很喜欢这个挑战，但是您应该考虑是否真的要在生产环境中使用它。您可以分两步来完成它，而不是一步一步地去做：一个正则表达式来捕获可能是数字的任何东西，然后再去掉一个不是数字的正则表达式。或者，您可以进行一些基本处理，然后使用您语言的内置数字解析功能。你的选择。

— 贾斯汀·摩根（Justin Morgan）
source
1
这是一个很好的尝试，但是可能会有问题-根据引擎的贪婪程度，给定的数字可能会部分匹配两种竞争格式，而单次匹配正确的格式-即5000可能会产生500+ 0这让我有点怀疑只用一个表达式覆盖太多内容，这就是为什么我给出了一个可能的误报的简单答案。归根结底，要求的严格性应决定解决方案。
— entonio
@entonio-这很公平。它可能适用于最新的编辑。顺便说一句，您的反对票不是来自我，因为您指出了可能的1,11,11比赛。
— 贾斯汀·摩根
我正在使用ActionScript，我相信它的行为与JavaScript相同。使用您建议的第一种模式，我在测试字符串上得到以下结果（为进行验证，我只返回包装在“ << [结果] >>”中的匹配项）：The << 5 >> 000 lb. fox跳过了<< 9 >> 9 <<，9 >> << 99 >> <<。9 >> << 99 >> << 98 >> << 71 >> 3英尺围栏。
2
好吧，您的其中一项赞成票是来自我的:)，因为我确实认为您的答案已尽可能详尽，您已投入工作。只是为了使其成为内容注释，给操作人员的注释，？：在分组的开头，即使它们有助于匹配以下内容，也不会自动将它们返回结果（“捕获”）中：整个表达；输入中的每个格式化数字都与整个表达式匹配。
— entonio
@Michael和@entonio-查看最新编辑，似乎可以正常工作。这是比正则表达式更难解决的正则表达式问题之一。
— 贾斯汀·摩根
10

几天前，我研究了从数字的字符串中删除尾随零的问题。

在该问题的连续性中，我发现这个问题很有趣，因为它将问题扩展到了包含逗号的数字。

我采用了我在以前处理的上一个问题中编写的正则表达式的模式，并对其进行了改进，以便可以用逗号将数字视为该问题的答案。

我对自己的热情和对正则表达式的喜爱使我无所适从。我不知道结果是否完全符合迈克尔·普雷斯科特（Michael Prescott）表示的需求。我想知道我的正则表达式中过多或不足的地方，并对其进行更正以使其更适合您。

现在，经过长时间的正则表达式工作之后，我的脑袋有了很大的重量，因此我还不够新鲜，无法给出很多解释。如果要点不清楚，或者是否有人对它感兴趣，请问我。

正则表达式是建立，以便它可以检测以科学计数法表示的数字2E10甚至5,22,454.12E-00.0478，在这些数字的两个部分删除不必要的零了。如果指数等于零，则会修改数字，以使不再有指数。

我在模式中进行了一些验证，以使某些特定情况不匹配，例如“ 12..57”将不匹配。但是在'，111'中，字符串'111'匹配，因为前面的逗号被视为不是逗号，而不是数字的逗号。

我认为应该改进逗号的管理，因为在我看来，印度编号中逗号之间只有2位数字。我想纠正不会困难

以下是演示我的正则表达式工作方式的代码。有两个函数，根据一个函数是否要将数字“ .1245”转换为“ 0.1245”。如果在某些情况下仍然存在错误或不必要的匹配或不匹配，我不会感到惊讶。那么我想知道这些情况，以了解并纠正缺陷。

我为用Python编写的代码道歉，但是正则表达式是跨语言的，我认为每个人都可以理解reex的模式

import re

regx = re.compile('(?<![\d.])(?!\.\.)(?<![\d.][eE][+-])(?<![\d.][eE])(?<!\d[.,])'
                  '' #---------------------------------
                  '([+-]?)'
                  '(?![\d,]*?\.[\d,]*?\.[\d,]*?)'
                  '(?:0|,(?=0)|(?<!\d),)*'
                  '(?:'
                  '((?:\d(?!\.[1-9])|,(?=\d))+)[.,]?'
                  '|\.(0)'
                  '|((?<!\.)\.\d+?)'
                  '|([\d,]+\.\d+?))'
                  '0*'
                  '' #---------------------------------
                  '(?:'
                  '([eE][+-]?)(?:0|,(?=0))*'
                  '(?:'
                  '(?!0+(?=\D|\Z))((?:\d(?!\.[1-9])|,(?=\d))+)[.,]?'
                  '|((?<!\.)\.(?!0+(?=\D|\Z))\d+?)'
                  '|([\d,]+\.(?!0+(?=\D|\Z))\d+?))'
                  '0*'
                  ')?'
                  '' #---------------------------------
                  '(?![.,]?\d)')


def dzs_numbs(x,regx = regx): # ds = detect and zeros-shave
    if not regx.findall(x):
        yield ('No match,', 'No catched string,', 'No groups.')
    for mat in regx.finditer(x):
        yield (mat.group(), ''.join(mat.groups('')), mat.groups(''))

def dzs_numbs2(x,regx = regx): # ds = detect and zeros-shave
    if not regx.findall(x):
        yield ('No match,', 'No catched string,', 'No groups.')
    for mat in regx.finditer(x):
        yield (mat.group(),
               ''.join(('0' if n.startswith('.') else '')+n for n in mat.groups('')),
               mat.groups(''))

NS = ['  23456000and23456000. or23456000.000  00023456000 s000023456000.  000023456000.000 ',
      'arf 10000 sea10000.+10000.000  00010000-00010000. kant00010000.000 ',
      '  24:  24,  24.   24.000  24.000,   00024r 00024. blue 00024.000  ',
      '  8zoom8.  8.000  0008  0008. and0008.000  ',
      '  0   00000M0. = 000.  0.0  0.000    000.0   000.000   .000000   .0   ',
      '  .0000023456    .0000023456000   '
      '  .0005872    .0005872000   .00503   .00503000   ',
      '  .068    .0680000   .8   .8000  .123456123456    .123456123456000    ',
      '  .657   .657000   .45    .4500000   .7    .70000  0.0000023230000   000.0000023230000   ',
      '  0.0081000    0000.0081000  0.059000   0000.059000     ',
      '  0.78987400000 snow  00000.78987400000  0.4400000   00000.4400000   ',
      '  -0.5000  -0000.5000   0.90   000.90   0.7   000.7   ',
      '  2.6    00002.6   00002.60000  4.71   0004.71    0004.7100   ',
      '  23.49   00023.49   00023.490000  103.45   0000103.45   0000103.45000    ',
      '  10003.45067   000010003.45067   000010003.4506700 ',
      '  +15000.0012   +000015000.0012   +000015000.0012000    ',
      '  78000.89   000078000.89   000078000.89000    ',
      '  .0457e10   .0457000e10   00000.0457000e10  ',
      '   258e8   2580000e4   0000000002580000e4   ',
      '  0.782e10   0000.782e10   0000.7820000e10  ',
      '  1.23E2   0001.23E2  0001.2300000E2   ',
      '  432e-102  0000432e-102   004320000e-106   ',
      '  1.46e10and0001.46e10  0001.4600000e10   ',
      '  1.077e-300  0001.077e-300  0001.077000e-300   ',
      '  1.069e10   0001.069e10   0001.069000e10   ',
      '  105040.03e10  000105040.03e10  105040.0300e10    ',
      '  +286E000024.487900  -78.4500e.14500   .0140E789.  ',
      '  081,12.40E07,95.0120     0045,78,123.03500e-0.00  ',
      '  0096,78,473.0380e-0.    0008,78,373.066000E0.    0004512300.E0000  ',
      '  ..18000  25..00 36...77   2..8  ',
      '  3.8..9    .12500.     12.51.400  ',
      '  00099,111.8713000   -0012,45,83,987.26+0.000,099,88,44.or00,00,00.00must',
      '  00099,44,and   0000,099,88,44.bom',
      '00,000,00.587000  77,98,23,45.,  this,that ',
      '  ,111  145.20  +9,9,9  0012800  .,,.  1  100,000 ',
      '1,1,1.111  000,001.111   -999.  0.  111.110000  1.1.1.111  9.909,888']


for ch in NS:
    print 'string: '+repr(ch)
    for strmatch, modified, the_groups in dzs_numbs2(ch):
        print strmatch.rjust(20),'',modified,'',the_groups
    print

结果

string: '  23456000and23456000. or23456000.000  00023456000 s000023456000.  000023456000.000 '
            23456000  23456000  ('', '23456000', '', '', '', '', '', '', '')
           23456000.  23456000  ('', '23456000', '', '', '', '', '', '', '')
        23456000.000  23456000  ('', '23456000', '', '', '', '', '', '', '')
         00023456000  23456000  ('', '23456000', '', '', '', '', '', '', '')
       000023456000.  23456000  ('', '23456000', '', '', '', '', '', '', '')
    000023456000.000  23456000  ('', '23456000', '', '', '', '', '', '', '')

string: 'arf 10000 sea10000.+10000.000  00010000-00010000. kant00010000.000 '
               10000  10000  ('', '10000', '', '', '', '', '', '', '')
              10000.  10000  ('', '10000', '', '', '', '', '', '', '')
           10000.000  10000  ('', '10000', '', '', '', '', '', '', '')
            00010000  10000  ('', '10000', '', '', '', '', '', '', '')
           00010000.  10000  ('', '10000', '', '', '', '', '', '', '')
        00010000.000  10000  ('', '10000', '', '', '', '', '', '', '')

string: '  24:  24,  24.   24.000  24.000,   00024r 00024. blue 00024.000  '
                  24  24  ('', '24', '', '', '', '', '', '', '')
                 24,  24  ('', '24', '', '', '', '', '', '', '')
                 24.  24  ('', '24', '', '', '', '', '', '', '')
              24.000  24  ('', '24', '', '', '', '', '', '', '')
              24.000  24  ('', '24', '', '', '', '', '', '', '')
               00024  24  ('', '24', '', '', '', '', '', '', '')
              00024.  24  ('', '24', '', '', '', '', '', '', '')
           00024.000  24  ('', '24', '', '', '', '', '', '', '')

string: '  8zoom8.  8.000  0008  0008. and0008.000  '
                   8  8  ('', '8', '', '', '', '', '', '', '')
                  8.  8  ('', '8', '', '', '', '', '', '', '')
               8.000  8  ('', '8', '', '', '', '', '', '', '')
                0008  8  ('', '8', '', '', '', '', '', '', '')
               0008.  8  ('', '8', '', '', '', '', '', '', '')
            0008.000  8  ('', '8', '', '', '', '', '', '', '')

string: '  0   00000M0. = 000.  0.0  0.000    000.0   000.000   .000000   .0   '
                   0  0  ('', '0', '', '', '', '', '', '', '')
               00000  0  ('', '0', '', '', '', '', '', '', '')
                  0.  0  ('', '0', '', '', '', '', '', '', '')
                000.  0  ('', '0', '', '', '', '', '', '', '')
                 0.0  0  ('', '', '0', '', '', '', '', '', '')
               0.000  0  ('', '', '0', '', '', '', '', '', '')
               000.0  0  ('', '', '0', '', '', '', '', '', '')
             000.000  0  ('', '', '0', '', '', '', '', '', '')
             .000000  0  ('', '', '0', '', '', '', '', '', '')
                  .0  0  ('', '', '0', '', '', '', '', '', '')

string: '  .0000023456    .0000023456000     .0005872    .0005872000   .00503   .00503000   '
         .0000023456  0.0000023456  ('', '', '', '.0000023456', '', '', '', '', '')
      .0000023456000  0.0000023456  ('', '', '', '.0000023456', '', '', '', '', '')
            .0005872  0.0005872  ('', '', '', '.0005872', '', '', '', '', '')
         .0005872000  0.0005872  ('', '', '', '.0005872', '', '', '', '', '')
              .00503  0.00503  ('', '', '', '.00503', '', '', '', '', '')
           .00503000  0.00503  ('', '', '', '.00503', '', '', '', '', '')

string: '  .068    .0680000   .8   .8000  .123456123456    .123456123456000    '
                .068  0.068  ('', '', '', '.068', '', '', '', '', '')
            .0680000  0.068  ('', '', '', '.068', '', '', '', '', '')
                  .8  0.8  ('', '', '', '.8', '', '', '', '', '')
               .8000  0.8  ('', '', '', '.8', '', '', '', '', '')
       .123456123456  0.123456123456  ('', '', '', '.123456123456', '', '', '', '', '')
    .123456123456000  0.123456123456  ('', '', '', '.123456123456', '', '', '', '', '')

string: '  .657   .657000   .45    .4500000   .7    .70000  0.0000023230000   000.0000023230000   '
                .657  0.657  ('', '', '', '.657', '', '', '', '', '')
             .657000  0.657  ('', '', '', '.657', '', '', '', '', '')
                 .45  0.45  ('', '', '', '.45', '', '', '', '', '')
            .4500000  0.45  ('', '', '', '.45', '', '', '', '', '')
                  .7  0.7  ('', '', '', '.7', '', '', '', '', '')
              .70000  0.7  ('', '', '', '.7', '', '', '', '', '')
     0.0000023230000  0.000002323  ('', '', '', '.000002323', '', '', '', '', '')
   000.0000023230000  0.000002323  ('', '', '', '.000002323', '', '', '', '', '')

string: '  0.0081000    0000.0081000  0.059000   0000.059000     '
           0.0081000  0.0081  ('', '', '', '.0081', '', '', '', '', '')
        0000.0081000  0.0081  ('', '', '', '.0081', '', '', '', '', '')
            0.059000  0.059  ('', '', '', '.059', '', '', '', '', '')
         0000.059000  0.059  ('', '', '', '.059', '', '', '', '', '')

string: '  0.78987400000 snow  00000.78987400000  0.4400000   00000.4400000   '
       0.78987400000  0.789874  ('', '', '', '.789874', '', '', '', '', '')
   00000.78987400000  0.789874  ('', '', '', '.789874', '', '', '', '', '')
           0.4400000  0.44  ('', '', '', '.44', '', '', '', '', '')
       00000.4400000  0.44  ('', '', '', '.44', '', '', '', '', '')

string: '  -0.5000  -0000.5000   0.90   000.90   0.7   000.7   '
             -0.5000  -0.5  ('-', '', '', '.5', '', '', '', '', '')
          -0000.5000  -0.5  ('-', '', '', '.5', '', '', '', '', '')
                0.90  0.9  ('', '', '', '.9', '', '', '', '', '')
              000.90  0.9  ('', '', '', '.9', '', '', '', '', '')
                 0.7  0.7  ('', '', '', '.7', '', '', '', '', '')
               000.7  0.7  ('', '', '', '.7', '', '', '', '', '')

string: '  2.6    00002.6   00002.60000  4.71   0004.71    0004.7100   '
                 2.6  2.6  ('', '', '', '', '2.6', '', '', '', '')
             00002.6  2.6  ('', '', '', '', '2.6', '', '', '', '')
         00002.60000  2.6  ('', '', '', '', '2.6', '', '', '', '')
                4.71  4.71  ('', '', '', '', '4.71', '', '', '', '')
             0004.71  4.71  ('', '', '', '', '4.71', '', '', '', '')
           0004.7100  4.71  ('', '', '', '', '4.71', '', '', '', '')

string: '  23.49   00023.49   00023.490000  103.45   0000103.45   0000103.45000    '
               23.49  23.49  ('', '', '', '', '23.49', '', '', '', '')
            00023.49  23.49  ('', '', '', '', '23.49', '', '', '', '')
        00023.490000  23.49  ('', '', '', '', '23.49', '', '', '', '')
              103.45  103.45  ('', '', '', '', '103.45', '', '', '', '')
          0000103.45  103.45  ('', '', '', '', '103.45', '', '', '', '')
       0000103.45000  103.45  ('', '', '', '', '103.45', '', '', '', '')

string: '  10003.45067   000010003.45067   000010003.4506700 '
         10003.45067  10003.45067  ('', '', '', '', '10003.45067', '', '', '', '')
     000010003.45067  10003.45067  ('', '', '', '', '10003.45067', '', '', '', '')
   000010003.4506700  10003.45067  ('', '', '', '', '10003.45067', '', '', '', '')

string: '  +15000.0012   +000015000.0012   +000015000.0012000    '
         +15000.0012  +15000.0012  ('+', '', '', '', '15000.0012', '', '', '', '')
     +000015000.0012  +15000.0012  ('+', '', '', '', '15000.0012', '', '', '', '')
  +000015000.0012000  +15000.0012  ('+', '', '', '', '15000.0012', '', '', '', '')

string: '  78000.89   000078000.89   000078000.89000    '
            78000.89  78000.89  ('', '', '', '', '78000.89', '', '', '', '')
        000078000.89  78000.89  ('', '', '', '', '78000.89', '', '', '', '')
     000078000.89000  78000.89  ('', '', '', '', '78000.89', '', '', '', '')

string: '  .0457e10   .0457000e10   00000.0457000e10  '
            .0457e10  0.0457e10  ('', '', '', '.0457', '', 'e', '10', '', '')
         .0457000e10  0.0457e10  ('', '', '', '.0457', '', 'e', '10', '', '')
    00000.0457000e10  0.0457e10  ('', '', '', '.0457', '', 'e', '10', '', '')

string: '   258e8   2580000e4   0000000002580000e4   '
               258e8  258e8  ('', '258', '', '', '', 'e', '8', '', '')
           2580000e4  2580000e4  ('', '2580000', '', '', '', 'e', '4', '', '')
  0000000002580000e4  2580000e4  ('', '2580000', '', '', '', 'e', '4', '', '')

string: '  0.782e10   0000.782e10   0000.7820000e10  '
            0.782e10  0.782e10  ('', '', '', '.782', '', 'e', '10', '', '')
         0000.782e10  0.782e10  ('', '', '', '.782', '', 'e', '10', '', '')
     0000.7820000e10  0.782e10  ('', '', '', '.782', '', 'e', '10', '', '')

string: '  1.23E2   0001.23E2  0001.2300000E2   '
              1.23E2  1.23E2  ('', '', '', '', '1.23', 'E', '2', '', '')
           0001.23E2  1.23E2  ('', '', '', '', '1.23', 'E', '2', '', '')
      0001.2300000E2  1.23E2  ('', '', '', '', '1.23', 'E', '2', '', '')

string: '  432e-102  0000432e-102   004320000e-106   '
            432e-102  432e-102  ('', '432', '', '', '', 'e-', '102', '', '')
        0000432e-102  432e-102  ('', '432', '', '', '', 'e-', '102', '', '')
      004320000e-106  4320000e-106  ('', '4320000', '', '', '', 'e-', '106', '', '')

string: '  1.46e10and0001.46e10  0001.4600000e10   '
             1.46e10  1.46e10  ('', '', '', '', '1.46', 'e', '10', '', '')
          0001.46e10  1.46e10  ('', '', '', '', '1.46', 'e', '10', '', '')
     0001.4600000e10  1.46e10  ('', '', '', '', '1.46', 'e', '10', '', '')

string: '  1.077e-300  0001.077e-300  0001.077000e-300   '
          1.077e-300  1.077e-300  ('', '', '', '', '1.077', 'e-', '300', '', '')
       0001.077e-300  1.077e-300  ('', '', '', '', '1.077', 'e-', '300', '', '')
    0001.077000e-300  1.077e-300  ('', '', '', '', '1.077', 'e-', '300', '', '')

string: '  1.069e10   0001.069e10   0001.069000e10   '
            1.069e10  1.069e10  ('', '', '', '', '1.069', 'e', '10', '', '')
         0001.069e10  1.069e10  ('', '', '', '', '1.069', 'e', '10', '', '')
      0001.069000e10  1.069e10  ('', '', '', '', '1.069', 'e', '10', '', '')

string: '  105040.03e10  000105040.03e10  105040.0300e10    '
        105040.03e10  105040.03e10  ('', '', '', '', '105040.03', 'e', '10', '', '')
     000105040.03e10  105040.03e10  ('', '', '', '', '105040.03', 'e', '10', '', '')
      105040.0300e10  105040.03e10  ('', '', '', '', '105040.03', 'e', '10', '', '')

string: '  +286E000024.487900  -78.4500e.14500   .0140E789.  '
  +286E000024.487900  +286E24.4879  ('+', '286', '', '', '', 'E', '', '', '24.4879')
     -78.4500e.14500  -78.45e0.145  ('-', '', '', '', '78.45', 'e', '', '.145', '')
          .0140E789.  0.014E789  ('', '', '', '.014', '', 'E', '789', '', '')

string: '  081,12.40E07,95.0120     0045,78,123.03500e-0.00  '
081,12.40E07,95.0120  81,12.4E7,95.012  ('', '', '', '', '81,12.4', 'E', '', '', '7,95.012')
   0045,78,123.03500  45,78,123.035  ('', '', '', '', '45,78,123.035', '', '', '', '')

string: '  0096,78,473.0380e-0.    0008,78,373.066000E0.    0004512300.E0000  '
    0096,78,473.0380  96,78,473.038  ('', '', '', '', '96,78,473.038', '', '', '', '')
  0008,78,373.066000  8,78,373.066  ('', '', '', '', '8,78,373.066', '', '', '', '')
         0004512300.  4512300  ('', '4512300', '', '', '', '', '', '', '')

string: '  ..18000  25..00 36...77   2..8  '
           No match,  No catched string,  No groups.

string: '  3.8..9    .12500.     12.51.400  '
           No match,  No catched string,  No groups.

string: '  00099,111.8713000   -0012,45,83,987.26+0.000,099,88,44.or00,00,00.00must'
   00099,111.8713000  99,111.8713  ('', '', '', '', '99,111.8713', '', '', '', '')
  -0012,45,83,987.26  -12,45,83,987.26  ('-', '', '', '', '12,45,83,987.26', '', '', '', '')
         00,00,00.00  0  ('', '', '0', '', '', '', '', '', '')

string: '  00099,44,and   0000,099,88,44.bom'
           00099,44,  99,44  ('', '99,44', '', '', '', '', '', '', '')
     0000,099,88,44.  99,88,44  ('', '99,88,44', '', '', '', '', '', '', '')

string: '00,000,00.587000  77,98,23,45.,  this,that '
    00,000,00.587000  0.587  ('', '', '', '.587', '', '', '', '', '')
        77,98,23,45.  77,98,23,45  ('', '77,98,23,45', '', '', '', '', '', '', '')

string: '  ,111  145.20  +9,9,9  0012800  .,,.  1  100,000 '
                ,111  111  ('', '111', '', '', '', '', '', '', '')
              145.20  145.2  ('', '', '', '', '145.2', '', '', '', '')
              +9,9,9  +9,9,9  ('+', '9,9,9', '', '', '', '', '', '', '')
             0012800  12800  ('', '12800', '', '', '', '', '', '', '')
                   1  1  ('', '1', '', '', '', '', '', '', '')
             100,000  100,000  ('', '100,000', '', '', '', '', '', '', '')

string: '1,1,1.111  000,001.111   -999.  0.  111.110000  1.1.1.111  9.909,888'
           1,1,1.111  1,1,1.111  ('', '', '', '', '1,1,1.111', '', '', '', '')
         000,001.111  1.111  ('', '', '', '', '1.111', '', '', '', '')
               -999.  -999  ('-', '999', '', '', '', '', '', '', '')
                  0.  0  ('', '0', '', '', '', '', '', '', '')
          111.110000  111.11  ('', '', '', '', '111.11', '', '', '', '')
— 来克
source
8

下面的正则表达式将匹配您示例中的两个数字。 

\b\d[\d,.]*\b

它将返回5000和99,999.99998713-符合您的要求。

— 里昂斯
source
3
这将与中的逗号匹配this,that。
— 贾斯汀·摩根
@贾斯汀·摩根-你是正确的，我没有测试这种情况。这是一个更新的版本，适用于所有情况，但以逗号或句点开头的数字除外。\b\d[\d,.]+\b
— 莱昂斯
更好，但是它仍然允许9....9或1,,,,X（尽管X不会包含在比赛中）。
— 贾斯汀·摩根
1
顺便说一句，\b\d[\d,.]*\b它足够接近，如果您编辑答案，我将删除-1。它应该是*而不是+；\b\d[\d,.]+\b不允许使用一位数字。
— 贾斯汀·摩根
@Justin Morgan-感谢您的见识。这个问题肯定比看起来要复杂。我根据您的反馈更新了答案-这很有意义。
— 莱昂斯
3

在满足要求的前提下，您正在寻找

\d+([\d,]?\d)*(\.\d+)?

但是请注意，这将匹配例如11,11,1

— 恩托尼奥
source
出于好奇，您有什么理由要\d+([\d,]?\d)*(\.\d+)?选择\d+(,\d+)*(\.\d+)?吗？我认为他们会给予相同的匹配，尽管捕获组会有所不同。
— 贾斯汀·摩根
你好 没什么特别的原因，这是为了避免不匹配无效格式而从更复杂的表达式开始的过程。
— 2011年
3 
\d+(,\d+)*(\.\d+)?

这假定在任何逗号或十进制之前或之后始终至少有一个数字，并且还假定最多有一个十进制，并且所有逗号都在十进制之前。

— 尼尔
source
2
这不会将逗号组限制为3位数字格式。它将接受999999,9,9,9,9。
— 贾斯汀·摩根
尽管我可能应该指出，这比大多数其他方法更接近正确。你的-1不是我的。
— 贾斯汀·摩根
这是我要使用的RE，尽管此后还要进行另一个验证步骤（可能不使用RE）。尝试用一个 RE 做所有事情会使生活变得更加艰难。
— Donal Fellows，
@Justin Morgan尚不清楚逗号仅以3位数的组被接受。但这可以通过更改(,\d+)为(,\d\d\d)我想的方法轻松解决。
— 尼尔，
2

此正则表达式：

(\d{1,3},\d{3}(,\d{3})*)(\.\d*)?|\d+\.?\d*

匹配字符串中的每个数字：

1 1.0 0.1 1.001 1,000 1,000,000 1000.1 1,000.1 1,323,444,000 1,999 1,222,455,666.0 1,244

— 埃里克·D
source
2

这是一个正则表达式：

(?:\d+)((\d{1,3})*([\,\ ]\d{3})*)(\.\d+)?

接受数字：

  • 没有空格和/或小数，例如。123456789，123.123
  • 用逗号或空格作为千​​位分隔符和/或小数，例如 123 456 789，123 456 789.100，123,456，3,232,300,000.00

测试：http：//regexr.com/3h1a2

— 卡克珀
source
这在regexr.com上工作正常，但在python re模块中却无法正常工作
— Pardhu
1

这是从最简单的数字格式开始的另一种构造，然后以不重叠的方式逐步添加更复杂的数字格式：

Java regep：

(\d)|([1-9]\d+)|(\.\d+)|(\d\.\d*)|([1-9]\d+\.\d*)|([1-9]\d{0,2}(,\d{3})+(\.\d*)?)

作为Java字符串（请注意，转至\和。所需的额外\ \，因为\和。在单独使用时在正则表达式中具有特殊含义）：

String myregexp="(\\d)|([1-9]\\d+)|(\\.\\d+)|(\\d\\.\\d*)|([1-9]\\d+\\.\\d*)|([1-9]\\d{0,2}(,\\d{3})+(\\.\\d*)?)";

说明：

  1. 此正则表达式具有A | B | C | D | E | F的形式，其中A，B，C，D，E，F本身是不重叠的正则表达式。通常，我发现从最简单的匹配项A开始比较容易。如果A错过了您想要的匹配项，则创建一个B，它是对A的较小修改，并且包含您想要的内容。然后，基于B，创建一个可以捕获更多内容的C，依此类推。我还发现创建不重叠的正则表达式会更容易。通过20个简单的不重叠的正则表达式与OR连接来理解正则表达式要比使用更复杂的匹配的一些正则表达式更容易理解。但是，每个人都要自己！

  2. A是（\ d），它与0、1、2、3、4、5、6、7、8、9中的一个完全匹配，这再简单不过了！

  3. B是（[1-9] \ d +），并且仅匹配具有2个或多个数字的数字，第一个不包括0。B恰好匹配10,11,12，...中的一个... B不与A重叠，而是对A的小修改。

  4. C是（。\ d +），并且仅与十进制数后跟一个或多个数字匹配。C精确匹配.0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .00 .01 .02 ...之一。.23000 ... C允许在我更喜欢的右侧显示尾随eros：如果这是测量数据，则尾随零的数量表示精度级别。如果您不希望右边的尾随零，请将（。\ d +）更改为（。\ d * [1-9]），但这也排除了.0，我认为应该允许。C也是A的小修改。

  5. D是（\ d。\ d *），它是A加上小数点，右边带尾随零。D仅匹配一个数字，后跟一个十进制，然后是零个或多个数字。D匹配0.0.0 0.1 0.2 .... 0.01000 ... 9。9.0 9.1..0.0230000 .... 9.9999999999 ...如果要排除“ 0”。然后将D更改为（\ d。\ d +）。如果要排除右边的尾随零，请将D更改为（\ d。\ d * [1-9]），但这不包括2.0，我认为应该包括在内。D与A，B或C不重叠。

  6. E是（[1-9] \ d +。\ d *），它是B加小数，右边带有尾随零。例如，如果要排除“ 13.”，则将E更改为（[1-9] \ d +。\ d +）。E不与A，B，C或D重叠。E匹配10。10.0 10.0100 .... 99.9999999999 ...尾随零可以按4.和5处理。

  7. F是（[1-9] \ d {0,2}（，\ d {3}）+（。\ d *）？），并且仅匹配带逗号的数字，也可能匹配小数，允许在右边尾随零。第一组（[1-9] \ d {0,2}）匹配一个非零数字，后跟零个，一个或两个其他数字。第二组（，\ d {3}）+匹配一个4个字符的组（一个逗号，后跟正好三位数字），并且该组可以匹配一次或多次（不匹配意味着没有逗号！）。最后，（。\ d *）？不匹配或匹配。本身，或匹配小数。后跟任意数量的数字，可能没有。同样，要排除类似“ 1,111。”的内容，请将（。\ d *）更改为（。\ d +）。尾随零可以按照4.或5处理。F不与A，B，C，D或E重叠。我想不出F更容易的正则表达式。

让我知道您是否有兴趣，我可以在上面进行编辑以根据需要处理右侧的尾随零。

这是匹配regexp的东西，不匹配的东西：

0
1
02 <- invalid
20
22
003 <- invalid
030 <- invalid
300
033 <- invalid
303
330
333
0004 <- invalid
0040 <- invalid
0400 <- invalid
4000
0044 <- invalid
0404 <- invalid
0440 <- invalid
4004
4040
4400
0444 <- invalid
4044
4404
4440
4444
00005 <- invalid
00050 <- invalid
00500 <- invalid
05000 <- invalid
50000
00055 <- invalid
00505 <- invalid
00550 <- invalid
05050 <- invalid
05500 <- invalid
50500
55000
00555 <- invalid
05055 <- invalid
05505 <- invalid
05550 <- invalid
50550
55050
55500
. <- invalid
.. <- invalid
.0
0.
.1
1.
.00
0.0
00. <- invalid
.02
0.2
02. <- invalid
.20
2.0
20.
.22
2.2
22.
.000
0.00
00.0 <- invalid
000. <- invalid
.003
0.03
00.3 <- invalid
003. <- invalid
.030
0.30
03.0 <- invalid
030. <- invalid
.033
0.33
03.3 <- invalid
033. <- invalid
.303
3.03
30.3
303.
.333
3.33
33.3
333.
.0000
0.000
00.00 <- invalid
000.0 <- invalid
0000. <- invalid
.0004
0.0004
00.04 <- invalid
000.4 <- invalid
0004. <- invalid
.0044
0.044
00.44 <- invalid
004.4 <- invalid
0044. <- invalid
.0404
0.404
04.04 <- invalid
040.4 <- invalid
0404. <- invalid
.0444
0.444
04.44 <- invalid
044.4 <- invalid
0444. <- invalid
.4444
4.444
44.44
444.4
4444.
.00000
0.0000
00.000 <- invalid
000.00 <- invalid
0000.0 <- invalid
00000. <- invalid
.00005
0.0005
00.005 <- invalid
000.05 <- invalid
0000.5 <- invalid
00005. <- invalid
.00055
0.0055
00.055 <- invalid
000.55 <- invalid
0005.5 <- invalid
00055. <- invalid
.00505
0.0505
00.505 <- invalid
005.05 <- invalid
0050.5 <- invalid
00505. <- invalid
.00550
0.0550
00.550 <- invalid
005.50 <- invalid
0055.0 <- invalid
00550. <- invalid
.05050
0.5050
05.050 <- invalid
050.50 <- invalid
0505.0 <- invalid
05050. <- invalid
.05500
0.5500
05.500 <- invalid
055.00 <- invalid
0550.0 <- invalid
05500. <- invalid
.50500
5.0500
50.500
505.00
5050.0
50500.
.55000
5.5000
55.000
550.00
5500.0
55000.
.00555
0.0555
00.555 <- invalid
005.55 <- invalid
0055.5 <- invalid
00555. <- invalid
.05055
0.5055
05.055 <- invalid
050.55 <- invalid
0505.5 <- invalid
05055. <- invalid
.05505
0.5505
05.505 <- invalid
055.05 <- invalid
0550.5 <- invalid
05505. <- invalid
.05550
0.5550
05.550 <- invalid
055.50 <- invalid
0555.0 <- invalid
05550. <- invalid
.50550
5.0550
50.550
505.50
5055.0
50550.
.55050
5.5050
55.050
550.50
5505.0
55050.
.55500
5.5500
55.500
555.00
5550.0
55500.
.05555
0.5555
05.555 <- invalid
055.55 <- invalid
0555.5 <- invalid
05555. <- invalid
.50555
5.0555
50.555
505.55
5055.5
50555.
.55055
5.5055
55.055
550.55
5505.5
55055.
.55505
5.5505
55.505
555.05
5550.5
55505.
.55550
5.5550
55.550
555.50
5555.0
55550.
.55555
5.5555
55.555
555.55
5555.5
55555.
, <- invalid
,, <- invalid
1, <- invalid
,1 <- invalid
22, <- invalid
2,2 <- invalid
,22 <- invalid
2,2, <- invalid
2,2, <- invalid
,22, <- invalid
333, <- invalid
33,3 <- invalid
3,33 <- invalid
,333 <- invalid
3,33, <- invalid
3,3,3 <- invalid
3,,33 <- invalid
,,333 <- invalid
4444, <- invalid
444,4 <- invalid
44,44 <- invalid
4,444
,4444 <- invalid
55555, <- invalid
5555,5 <- invalid
555,55 <- invalid
55,555
5,5555 <- invalid
,55555 <- invalid
666666, <- invalid
66666,6 <- invalid
6666,66 <- invalid
666,666
66,6666 <- invalid
6,66666 <- invalid
66,66,66 <- invalid
6,66,666 <- invalid
,666,666 <- invalid
1,111.
1,111.11
1,111.110
01,111.110 <- invalid
0,111.100 <- invalid
11,11. <- invalid
1,111,.11 <- invalid
1111.1,10 <- invalid
01111.11,0 <- invalid
0111.100, <- invalid
1,111,111.
1,111,111.11
1,111,111.110
01,111,111.110 <- invalid
0,111,111.100 <- invalid
1,111,111.
1,1111,11.11 <- invalid
11,111,11.110 <- invalid
01,11,1111.110 <- invalid
0,111111.100 <- invalid
0002,22.2230 <- invalid
.,5.,., <- invalid
2.0,345,345 <- invalid
2.334.456 <- invalid
— 大卫·亚历山大
source
1 
\b\d+,

\ b ------->单词边界

\ d + ------>一位或一位数字

，-------->包含逗号，

例如：

sddsgg 70,000 sdsfdsf fdgfdg70,00

sfsfsd 5,44,4343 5.7788,44 555

它将匹配：

70

5

44

，44

— 伊布·沙克（Ibz.Shaikh）
source
0 
(,*[\d]+,*[\d]*)+

这将与以下任何大小数匹配（带或不带逗号）

1
100
1,262
1,56,262
10,78,999
12,34,56,789

要么

1
100
1262
156262
1078999
123456789
— phpnerd
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.