テキスト内のコンマと小数の有無にかかわらず数値を照合する正規表現

96

テキスト本文内のすべての数字を見つけて置換しようとしています。問題をほぼ解決する正規表現の例をいくつか見つけましたが、まだ完全なものはありません。私の問題は、テキスト内の数値に小数とコンマがある場合とない場合があることです。例えば：

「5000ポンドのキツネは99,999.99998713フィートのフェンスを飛び越えました。」

正規表現は「5000」と「99,999.99998713」を返す必要があります。例カンマで数字を分割したり、小数点以下2桁に制限したりしました。いくつかの例が小数点以下2桁に制限されている理由を理解するのに十分な正規表現を理解し始めていますが、それを克服する方法と、シーケンス全体を取得するためのコンマをまだ含んでいません。

これが私の最新バージョンです： 

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

これは、上記のテキストに対して「5000」、「99,99」、「9.99」、「」を返し998713ます。

regex 
— ドーナツ
ソース
1
どのプログラミング言語または正規表現フレーバー？
— マットボール、
7
ここでのほとんどすべての回答は、.,.,.または9,9,9,9またはのようなものを許可するという間違いを犯しているよう9,9.99.9です。これらの正規表現では、数字が正しい形式である必要はなく、最悪の場合、句読点が数字として扱われます。可能なオプションの微調整がいくつかあります（たとえば、先行ゼロと後続ゼロを許可するかどうか）。私は、特に正直な試みの場合、実際に反対投票することは好きではありませんが、ここでの答えは整理する必要があるように感じます。これはよくある質問で、間違いなくまた尋ねられるでしょう。
— Justin Morgan、
itbyetがわからない場合は、regexpal.comをご覧ください
— entonio
遅れてすみません。私はAdobeのActionScript 3を使用しています。正規表現の動作はJavaScriptと同じだと思いましたが、regexpal.comで Justinの提案をテストし、それを私のFlashアプリケーションの結果と比較して、2つの異なる結果を両方とも間違っていました。
今回は、自分のテストに基づいて動作するはずです。それでもまだ改善が必要かどうか教えてください。
— Justin Morgan、

回答:

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-引きに失敗しIMHOの何とのみの数字をする-outはabc22 1,234.56 9.9.9.9 def 1234間違った答えです。

まず第一に、これをすべて1つの正規表現で行う必要がない場合は、行わないでください。2つの異なる数値形式の単一の正規表現は、他のテキストに埋め込まれていない場合でも維持するのが困難です。あなたが本当にすべきことは、全体を空白で分割し、結果に対して2つまたは3つの小さな正規表現を実行することです。それが選択肢にならない場合は、読み続けてください。

基本パターン

あなたが与えた例を考慮して、これは0000フォーマットでほとんどすべての整数または小数を許可し、他のすべてをブロックする単純な正規表現です：

^\d*\.?\d+$

これは0,000フォーマットが必要なものです：

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

それらをまとめると、コンマが一貫している限り、コンマはオプションになります。

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

埋め込み番号

上記のパターンでは、入力全体を数値にする必要があります。テキストに埋め込まれた数値を探しているので、その部分を緩める必要があります。一方、あなたはそれを見たくないcatch22、あなたは（.NETのような）後読みをサポートするものを使用している場合、それが数22を発見したと思う、これは非常に簡単です：置き換える^と(?<!\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）
  • 小数点で始まる小数（0.001ではなく.001など）

地獄のために、最初の3つをブロックし、最後の3つは許可したいとします。あなたは何をするべきか？私はあなたが何をすべきかをあなたに教えます、あなたは各ルールに異なる正規表現を使用し、徐々にあなたのマッチを絞り込むべきです。しかし、挑戦のために、これを1つの巨大なパターンですべて行う方法を次に示します。

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

最後に

明らかに、これは大規模で複雑な、ほとんど読めない正規表現です。チャレンジは楽しかったですが、これを本番環境で本当に使用したいかどうかを検討する必要があります。すべてを1つのステップで実行する代わりに、2つで実行することもできます。つまり、数値である可能性のあるものをすべてキャッチする正規表現と、数値ではないものを取り除く別の正規表現です。または、基本的な処理を行ってから、言語の組み込みの数値解析関数を使用することもできます。あなたの選択。

— ジャスティン・モーガン
ソース
1
これは非常に良い試みですが、問題がある可能性があります-エンジンの貪欲さによっては、指定された数値が競合するフォーマットの2つと部分的に一致する可能性があります。 0そのため、1つの式だけで多くをカバーしようとするのには少し懐疑的です。そのため、誤検出の可能性があるという警告に基づいて、より簡単な答えを出しました。結局のところ、要件の厳格さがソリューションを決定するはずです。
— entonio、
@entonio-それは公平な点です。最新の編集で動作する可能性があります。ところで、あなたが1,11,11の試合の可能性を指摘したので、あなたの反対票は私からのものではありませんでした。
— Justin Morgan、
私はActionScriptを使用していますが、これはJavaScriptと同じように動作すると思います。最初に推奨したパターンを使用して、テスト文字列で次の結果を取得します（検証のために、 "<< [result] >>"でラップされた一致を単純に返します）：The << 5 >> 000 lb. fox << 9 >> 9 <<、9 >> << 99 >> <<。9 >> << 99 >> << 98 >> << 71 >> 3フィートのフェンスを飛び越えた。
2
ええと、あなたの賛成票の1つは私からのものです:)私はあなたの答えはできる限り徹底的であり、あなたはそれに仕事を入れたと思います。これをコンテンツコメントにするために、OPへのメモである？：グループの先頭にあります。これにより、グループは、式全体; 入力のフォーマットされた各数値は、式全体と一致します。
— entonio
@Michaelと@entonio-最新の編集を参照してください。これは、表示されるよりも難しい正規表現の問題の1つです。
— Justin Morgan、
10

数日前、数値の文字列から末尾のゼロを削除する問題に取り組みました。

その問題の続きで、これは問題をカンマを含む数値に広げるので、これは興味深いものだと思います。

私は、以前に取り組んだその問題で書いた正規表現のパターンを採用し、この問題の答えとしてカンマ付きの数値を処理できるように改善しました。

私は私の熱意と正規表現の好みに夢中になりました。結果がマイケルプレスコットが表明したニーズにぴったり合うかどうかはわかりません。私の正規表現で過剰または不足している点を知り、それを修正してあなたにとってより適切なものにしたいと思います。

さて、この正規表現での長いセッションの後、私は一種の脳の重みを持っているので、私は多くの説明をするのに十分なほど新鮮ではありません。ポイントが曖昧な方、気になる方がいらっしゃいましたら、是非ご質問ください。

正規表現は、科学表記法で表現された数値を検出できるように構築されています 2E10または5,22,454.12E-00.0478でで、そのような数値の2つの部分の不要なゼロも削除されます。指数がゼロに等しい場合は、指数がなくなるように数値が変更されます。

例として'12 ..57 'が一致しないため、一部の特定のケースが一致しないように、パターンに検証を入れました。しかし '、111'では、文字列'111'、先行するコンマは数字ではなく文のコンマと見なされるため一致します。

インドの番号付けでは、コンマの間に2桁しかないと思われるので、コンマの管理を改善する必要があると思います。修正するのは難しくないと思います

以下は、私の正規表現がどのように機能するかを示すコードです。二つの機能は、1つの数字たい場合には、必要に応じ、あります」0.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
ソース
8

以下の正規表現は、例の両方の数値と一致します。 

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

5000と99,999.99998713を返します-要件に一致します。

— レオン
ソース
3
これはのカンマと一致しますthis,that。
— Justin Morgan、
@ジャスティンモーガン-あなたは正しいです、私はその状態をテストしませんでした。以下は、カンマまたはピリオドで始まる番号を除いて、すべてのケースで問題が発生する更新バージョンです。\b\d[\d,.]+\b
— レオン
はるかに良いが、それはまだできるようになります9....9か1,,,,X（Xは試合には含まれませんが）。
— Justin Morgan、
1
ちなみに、\b\d[\d,.]*\bあなたの回答を編集した場合は-1を削除するのに十分近いです。ただし、+ではなく*にする必要があります。\b\d[\d,.]+\b1桁の数字は使用できません。
— Justin Morgan、
@Justin Morgan-洞察をありがとう。この質問は、明らかにそれよりも複雑でした。私はあなたのフィードバックに基づいて私の答えを更新しました-それは理にかなっています。
— Leons
3

要件に一定の自由を取り、あなたは探しています

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

ただし、これはたとえば11,11,1と一致することに注意してください。

— entonio
ソース
好奇心から、\d+([\d,]?\d)*(\.\d+)?代わりに行った理由はあります\d+(,\d+)*(\.\d+)?か？キャプチャグループは異なりますが、同等の一致が得られると思います。
— Justin Morgan、
こんにちは。特別な理由はありません。無効な形式に一致しないようにするために、より複雑な式から始めることからの休憩でした。
— entonio、
3 
\d+(,\d+)*(\.\d+)?

これは、コンマまたは小数の前後に常に少なくとも1桁あると想定し、また、最大で1つの小数があり、すべてのコンマが小数の前にあると想定します。

— ニール
ソース
2
これは、コンマグループを3桁の形式に制限しません。受け付け999999,9,9,9,9ます。
— Justin Morgan、
私はおそらくこれが他のほとんどのものよりも正しいことに近いことを指摘しなければなりません。あなたの-1は私からのものではありません。
— Justin Morgan、
これは私が使用するREですが、後で別の検証手順を実行します（REを使用しない可能性があります）。1つの REですべてを実行しようとすると、生活がはるかに困難になります。
— ドナルフェロー
@Justin Morganコンマが3桁のグループでのみ受け入れられるかどうかは明確ではありませんでした。しかし、それは私が推測する(,\d+)よう(,\d\d\d)に変更することで簡単に解決されます。
— Neil、
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
ソース
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

— カッパーCz
ソース
これはregexr.comでは正常に機能しますが、Python reモジュールでは機能しません
— Pardhu
1

以下は、最も単純な数値形式で始まり、重複しない方法で、より複雑な数値形式を徐々に追加する別の構造です。

Java正規表現：

(\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が必要な一致に失敗した場合は、Aのマイナー変更であり、必要なものをもう少し含むBを作成します。次に、Bに基づいて、より多くをキャッチするCを作成します。また、重複しない正規表現を作成する方が簡単です。ORで接続された20個の単純な重複しない正規表現を持つ正規表現を理解する方が、より複雑なマッチングを持ついくつかの正規表現よりも簡単です。しかし、それぞれ独自のものにします！

  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 +）で、10進数の後に1つ以上の数字が続くものにのみ一致します。Cは.0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .00 .01 .02 ...のいずれかに正確に一致します。.23000 ... Cを使用すると、右側で後続のエロスを使用できます。これが測定データの場合、後続のゼロの数は精度のレベルを示します。右側の後続ゼロが不要な場合は、（。\ d +）を（。\ d * [1-9]）に変更しますが、これにより、許可されているはずの.0も除外されます。CもAの小さな変更です。

  5. Dは（\ d。\ d *）で、これはAと小数点以下が右側にあるゼロです。Dは、1つの数字、10進数、0個以上の数字の順に一致します。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に10進数を加えたもので、右側に後続ゼロが付きます。たとえば、「13。」を除外する場合は、Eを（[1-9] \ d +。\ d +）に変更します。EはA、B、CまたはDとオーバーラップしません。Eは10.に一致します。10.010.0100 .... 99.9999999999 ...末尾のゼロは、4および5のように処理できます。

  7. Fは（[1-9] \ d {0,2}（、\ d {3}）+（。\ d *）？）であり、カンマと、場合によっては小数を含む数値のみに一致し、右側に後続ゼロを付けることができます。最初のグループ（[1-9] \ d {0,2}）は、0以外の数字の後に0、1、または2桁続くものと一致します。2番目のグループ（、\ d {3}）+は4文字のグループ（カンマの後に正確に3桁が続く）に一致し、このグループは1回以上一致できます（一致しないとコンマがないことを意味します！）。最後に、（。\ d *）？何も一致しない、またはと一致する。単独で、または小数と一致します。その後に、任意の桁数、おそらくなし。ここでも、「1,111。」などを除外するには、（。\ d *）を（。\ d +）に変更します。末尾のゼロは4または5のように処理できます。FはA、B、C、D、またはEと重複しません。Fの簡単な正規表現は考えられませんでした。

興味があれば教えてください。上で編集して、右側の後続ゼロを必要に応じて処理できます。

正規表現に一致するものと一致しないものを次に示します。

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
— デビッドアレクサンダー
ソース
1 
\b\d+,

\ b ------->単語境界

\ d + ------> 1桁または数字

、-------->コンマを含む、

例えば：

sddsgg 70,000 sdsfdsf fdgfdg70,00

sfsfsd 5,44,4343 5.7788,44 555

一致します：

70、

5、

44、

、44

— Ibz.Shaikh
ソース
0 
(,*[\d]+,*[\d]*)+

これは、コンマの有無にかかわらず、以下の任意の小さい数または大きい数に一致します

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

または

1
100
1262
156262
1078999
123456789
— phpnerd
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.