正则表达式匹配文本中包含逗号和小数点的数字或不包含的数字。

Question

我试图定位并替换文本中的所有数字。我已经找到了一些正则表达式的例子，它们几乎解决了问题，但是还没有完全符合我的需求。我遇到的问题是，我的文本中的数字可能有小数和逗号。例如:

"The 5000 lb. fox jumped over a 99,999.99998713 foot fence."

正则表达式应该返回 "5000" 和 "99,999.99998713"。我发现的例子只是在逗号处将数字分割开来，或者只限于两位小数。我开始理解正则表达式为什么只限于两位小数，但我还没有学会如何克服这个问题，并且包含逗号以获取整个数字序列。

这是我最新版本的代码:

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

对于上述文本，将返回 "5000", "99,99", "9.99",和"998713"。

- user56512

---

使用哪种编程语言或正则表达式风格？ - Matt Ball

这里似乎几乎每一个答案都犯了一个错误，允许像.,.,.或9,9,9,9或9,9.99.9这样的格式。这些正则表达式不会要求数字以正确的格式输入，最糟糕的是将标点符号视为数字。还有一些可选的微调(例如是否允许前导和尾随零)，但我看到的一些答案是绝对错误的。我真的不喜欢投反对票，尤其是在诚实尝试时，但我觉得这里的答案需要整理。这是一个常见的问题，肯定会再次被问到。 - Justin Morgan

如果你还不知道，可以看一下http://regexpal.com/。 - entonio

抱歉耽搁了，马特。我正在使用Adobe的ActionScript 3。我以为正则表达式的行为与JavaScript相同，但我在http://regexpal.com/上测试了Justin的建议，并将其与我的Flash应用程序的结果进行了比较，发现两个不同的错误结果。 - user56512

这次应该可以正常工作，基于我的测试。如果还需要优化，请告诉我。 - Justin Morgan

最佳答案，也是一篇研究文章在这里：https://dev59.com/83E85IYBdhLWcg3wXCS1#39399503 - Gangnus

Answer 1

编辑：由于这篇文章获得了很多阅读量，所以我首先给大家提供他们搜索的内容：

#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，甚至.,,.。即使数字嵌入在其他文本中，也很容易解决。在我的看法中，任何无法从abc22 1,234.56 9.9.9.9 def 1234中提取1,234.56和1234，而且只有这些数字的答案都是错误的。

首先，如果您不需要在一个正则表达式中完成所有操作，请不要这样做。即使它们没有嵌入在其他文本中，单个正则表达式用于两种不同的数字格式也很难维护。您真正需要做的是将整个字符串按空格分割，然后在结果上运行两个或三个较小的正则表达式。如果这对您来说不是一个选项，请继续阅读。

基本模式

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

^\d*\.?\d+$

这里有一个需要使用 0,000 格式的例子:

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

将它们放在一起，只要保持一致，逗号就变成了可选项：

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

嵌入数字

上述模式要求整个输入都是数字。你要寻找文本中嵌入的数字，因此你需要放松这一部分。另一方面，你不希望它看到catch22并认为它已经找到了数字22。如果你正在使用支持回顾后发功能（例如C#，.NET 4.0+），那么这很容易：将^替换为(?<!\S)，将$替换为(?!\S)，然后你就可以开始了：

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

如果你正在使用JavaScript，Ruby或其他语言进行开发，事情开始变得更加复杂：

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

你需要使用捕获组；没有回顾支持，我想不到其他的替代方案。你想要的数字将在第一组中（假设整个匹配是第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

---

这是一个非常好的尝试，但它可能存在问题 - 根据引擎的贪婪程度，给定的数字可能部分匹配两个竞争格式，而不是单独匹配正确的格式 - 例如，5000可能会产生500加0。这让我有点怀疑只用一个表达式来覆盖太多内容，这就是为什么我给出了一个更简单的答案，并附带可能的误报警告。归根结底，要求的严格性应该决定解决方案。 - entonio

好的，你得到了我的一票👍，因为我认为你的答案已经非常详尽，并且你也付出了很多努力。只是为了让这个评论有内容，对于提问者的一个提示，正则表达式中开头的 ?: 是为了避免它们被单独返回（“捕获”），即使它们对整个表达式的匹配有贡献；输入中每个格式化的数字都与整个表达式匹配。 - entonio

看到你提出的那些正则表达式，我想起了Zawinski的格言。你在这里遇到的问题是“理解”和“维护”。一个更简单的正则表达式和一个额外的验证步骤可以使得首先正确编写代码变得更加容易，并且之后也能够保持正确。 - Donal Fellows

@Donal - 在这个特定的模式上，你对 Zawinski 的格言是正确的。请注意，我说我假设了最困难的要求，并打算稍后缩短它。通常我会选择类似于 \d{1,3}(,\d{3})*(\.\d+)? 这样的东西。上面的可能有些过度，但在我看来，过度不如不足。 - Justin Morgan

我想在国际审计中使用这个正则表达式，但印度会计师使用“laks”系统，在每隔2或3个数字之间插入逗号。（美国：$1,000,000.00 印度：$10,00,000.00）-- 那么接受这些数字的正则表达式是什么？ - Marc Maxmeister

Answer 2

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

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

它将返回5000和99,999.99998713 - 与您的要求相匹配。

- Leons

---

这将匹配 this,that 中的逗号。 - Justin Morgan

@Justin Morgan - 你说得对，我没有测试那个条件。这是一个更新的版本，可以适用于所有情况，除了以逗号或句点开头的数字。\b\d[\d,.]+\b - Leons

好多了，但它仍然允许 9....9 或 1,,,,X（尽管 X 不会包含在匹配中）。 - Justin Morgan

顺便说一下，\b\d[\d,.]*\b已经足够接近了，如果您编辑您的答案，我会撤销-1。不过应该是*而不是+；\b\d[\d,.]+\b不允许单个数字。 - Justin Morgan

@Justin Morgan - 感谢您的见解。这个问题肯定比看起来更复杂。根据您的反馈，我更新了我的答案 - 现在更有意义了。 - Leons

Answer 3

几天前，我处理了一个问题，即从数字字符串中删除尾随零的问题。

在这个问题的基础上，我发现这个问题很有趣，因为它将问题扩展到包含逗号的数字。

我采用了我之前编写的正则表达式模式，并对其进行了改进，以便它可以处理逗号分隔的数字作为此问题的答案。

我被我的热情和对正则表达式的喜爱所带动。我不知道结果是否完全符合Michael Prescott所表达的需求。我很想知道我的正则表达式中哪些是多余的或缺少的，并进行更正，使其更适合您。

现在，在长时间的处理该正则表达式的会话后，我的大脑感到沉重，所以我没有足够的精力来进行详细的解释。如果有任何不清楚的地方，如果有人可能足够感兴趣，请问我。

该正则表达式的构建是为了检测科学计数法表示的数字2E10甚至5,22,454.12E-00.0478，同时还删除这些数字两部分中的不必要的零。如果指数等于零，则修改数字，以便不再有指数。

我在模式中添加了一些验证，以便某些特定情况不匹配，例如'12..57'不匹配。但在',111'中，字符串'111'匹配，因为前面的逗号被认为是不属于数字而是句子的逗号。

我认为逗号的管理应该得到改善，因为在印度计数中，逗号之间似乎只有两个数字。我认为这不难修正。

下面是演示我的正则表达式如何工作的代码。有两个函数，根据是否要将数字'.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', '', '', '', '')

- eyquem

---

宁愿得到一个答案，也不要一篇大学论文。 - PastExpiry.com

Answer 4

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

这假设在逗号或小数点前后总有至少一个数字，并且假设最多只有一个小数点，所有逗号都在小数点之前。

- Neil

---

这不限制逗号分组为3位数字格式。它将接受 999999,9,9,9,9。 - Justin Morgan

虽然我应该指出这个比大多数其他人更接近正确，但你的-1不是来自我。 - Justin Morgan

这是我会使用的正则表达式，不过之后可能还需要进行另一个验证步骤（可能不是用正则表达式）。试图用一个正则表达式完成所有操作会让生活变得更加困难。 - Donal Fellows

@Justin Morgan，不清楚逗号只能在三位数字组中使用。但是将(,\d+)更改为(,\d\d\d)就可以轻松解决了。 - Neil

正是我所需要的。不是一篇关于正则表达式是什么以及如何在20种不同的数字格式上工作的长篇论文，这样我就可以证明我需要一根棍子来支撑我的巨大大脑。 - PastExpiry.com

Answer 5

为了符合要求，您正在寻找一些自由。

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

但需要注意的是，这将匹配例如11,11,1这样的内容。

- entonio

---

纯属好奇，你使用\d+([\d,]?\d)*(\.\d+)?而不是\d+(,\d+)*(\.\d+)?有什么特别的原因吗？我认为它们会产生等效的匹配，尽管捕获组会有所不同。 - Justin Morgan

嗨。没有特别的原因，这只是为了避免匹配无效格式而从更复杂的表达式开始的余波。 - entonio

Answer 6

这个正则表达式：

(\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

- Eric D

Answer 7

这里是一个正则表达式：

(?:\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

- Kacper Cz

---

这在regexr.com上运行良好，但在Python的re模块中无法工作。 - Pardhu

Answer 8

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

这将匹配以下任何带有或不带逗号的小数或大数。最初的回答：

这将匹配任何带或不带逗号的小数或大数。

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

最初的回答

或者

1
100
1262
156262
1078999
123456789

- phpnerd

---

最佳且有效的答案 :) - devzom

Answer 9

\b\d+,

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

\d+------>一个或多个数字

,-------->包含逗号的字符

例如:

sddsgg 70,000 sdsfdsf fdgfdg70,00

sfsfsd 5,44,4343 5.7788,44 555

它将匹配:

70,

5,

44,

,44

- Ibz.Shaikh

Answer 10

这里是我的回答：

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

- Petro Python