Regulärer Ausdruck zum Abgleichen von Zahlen mit oder ohne Kommas und Dezimalstellen im Text

Ich versuche, alle Zahlen in einem Textkörper zu finden und zu ersetzen. Ich habe ein paar Regex-Beispiele gefunden, die das Problem fast lösen, aber noch keine sind perfekt. Das Problem, das ich habe, ist, dass die Zahlen in meinem Text Dezimalstellen und Kommas haben können oder nicht. Beispielsweise:

"Der 5000 Pfund schwere Fuchs sprang über einen 99.999.99998713 Fußzaun."

Die Regex sollte " 5000" und " 99,999.99998713" zurückgeben. Beispiele Ich habe festgestellt, dass die Zahlen im Komma aufgelöst sind oder auf zwei Dezimalstellen beschränkt sind. Ich fange an, Regex genug zu verstehen, um zu verstehen, warum einige Beispiele auf zwei Dezimalstellen beschränkt sind, aber ich habe noch nicht gelernt, wie man sie überwindet und auch das Komma einfügt, um die gesamte Sequenz zu erhalten.

Hier ist meine neueste Version:

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

Was für den obigen Text " 5000", " 99,99", " 9.99" und " 998713" zurückgibt .

EDIT: Da dies viele Ansichten bekommen hat, lassen Sie mich damit beginnen, allen zu geben, wonach sie gegoogelt haben:

#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])?$

Nun, da dies nicht im Weg ist, sind die meisten der folgenden Punkte als Kommentar dazu gedacht, wie komplex Regex werden kann, wenn Sie versuchen, klug damit umzugehen, und warum Sie nach Alternativen suchen sollten. Lesen Sie auf eigenes Risiko.

Dies ist eine sehr häufige Aufgabe, aber alle Antworten , die ich hier sehen , so weit werden Eingänge akzeptieren , die, wie Sie nicht Ihre Nummer Format entsprechen ,111, 9,9,9oder sogar .,,.. Das ist einfach zu beheben, selbst wenn die Zahlen in anderen Text eingebettet sind. IMHO alles, was nicht 1.234,56 und 1234 - und nur diese Zahlen - herausziehen kannabc22 1,234.56 9.9.9.9 def 1234 eine falsche Antwort.

Wenn Sie dies nicht alles in einem regulären Ausdruck tun müssen, tun Sie dies zunächst nicht. Eine einzelne Regex für zwei verschiedene Zahlenformate ist schwer zu pflegen, selbst wenn sie nicht in anderen Text eingebettet sind. Was Sie wirklich tun sollten, ist, das Ganze auf Leerzeichen aufzuteilen und dann zwei oder drei kleinere reguläre Ausdrücke für die Ergebnisse auszuführen. Wenn dies für Sie keine Option ist, lesen Sie weiter.

Grundverhalten

In Anbetracht der Beispiele, die Sie gegeben haben, ist hier eine einfache Regex, die so ziemlich jede Ganzzahl oder Dezimalzahl im 0000Format zulässt und alles andere blockiert:

^\d*\.?\d+$

Hier ist eines, das 0,000Format erfordert :

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

Fügen Sie sie zusammen und Kommas werden optional, solange sie konsistent sind:

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

Eingebettete Zahlen

Für die obigen Muster muss die gesamte Eingabe eine Zahl sein. Sie suchen nach Zahlen, die in Text eingebettet sind, also müssen Sie diesen Teil lösen. Auf der anderen Seite möchten Sie nicht, dass es catch22die Nummer 22 sieht und denkt, dass es gefunden wurde. Wenn Sie etwas mit Lookbehind-Unterstützung (wie .NET) verwenden, ist dies ziemlich einfach: Ersetzen Sie es ^durch (?<!\S)und $mit (?!\S)und Sie sind gut gehen:

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

Wenn Sie mit JavaScript oder Ruby oder etwas anderem arbeiten, sehen die Dinge komplexer aus:

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

Sie müssen Erfassungsgruppen verwenden. Ich kann mir keine Alternative ohne Lookbehind-Unterstützung vorstellen. Die gewünschten Zahlen befinden sich in Gruppe 1 (vorausgesetzt, die gesamte Übereinstimmung ist Gruppe 0).

Validierung und komplexere Regeln

Ich denke, das deckt Ihre Frage ab. Wenn das alles ist, was Sie brauchen, hören Sie jetzt auf zu lesen. Wenn Sie schicker werden möchten, werden die Dinge sehr schnell sehr komplex. Abhängig von Ihrer Situation möchten Sie möglicherweise einige oder alle der folgenden Elemente blockieren:

• Eingabe leeren
• Führende Nullen (zB 000123)
• Nachgestellte Nullen (z. B. 1.2340000)
• Dezimalstellen, die mit dem Dezimalpunkt beginnen (z. B. 0,001 im Gegensatz zu 0,001)

Nehmen wir zum Teufel an, Sie möchten die ersten 3 blockieren, aber die letzte zulassen. Was tun? Ich werde Ihnen sagen, was Sie tun sollten. Sie sollten für jede Regel einen anderen regulären Ausdruck verwenden und Ihre Übereinstimmungen schrittweise eingrenzen. Aber um der Herausforderung willen, machen Sie Folgendes in einem riesigen Muster:

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

Und hier ist was es bedeutet:

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

Hier getestet: http://rextester.com/YPG96786

Dies ermöglicht Dinge wie:

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

Es wird Dinge blockieren wie:

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

Es gibt verschiedene Möglichkeiten, diesen regulären Ausdruck einfacher und kürzer zu gestalten. Verstehen Sie jedoch, dass durch Ändern des Musters das, was es als Zahl betrachtet, gelockert wird.

Da viele Regex-Engines (z. B. JavaScript und Ruby) das negative Lookbehind nicht unterstützen, können Sie dies nur mit Erfassungsgruppen korrekt tun:

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

Die gesuchten Nummern befinden sich in Erfassungsgruppe 1.

Hier getestet: http://rubular.com/r/3HCSkndzhT

Eine letzte Anmerkung

Offensichtlich ist dies eine massive, komplizierte, nahezu unlesbare Regex. Ich habe die Herausforderung genossen, aber Sie sollten überlegen, ob Sie dies wirklich in einer Produktionsumgebung verwenden möchten. Anstatt zu versuchen, alles in einem Schritt zu tun, können Sie es in zwei Schritten tun: eine Regex, um alles zu fangen, was eine Zahl sein könnte , und eine andere, um alles auszusortieren, was keine Zahl ist. Oder Sie können eine grundlegende Verarbeitung durchführen und dann die in Ihrer Sprache integrierten Funktionen zum Parsen von Zahlen verwenden. Deine Entscheidung.

Vor einigen Tagen habe ich an dem Problem gearbeitet, nachgestellte Nullen aus der Zeichenfolge einer Zahl zu entfernen .

In der Kontinuität dieses Problems finde ich dieses interessant, weil es das Problem auf Zahlen erweitert, die Kommas enthalten.

Ich habe das Muster des regulären Ausdrucks, das ich in dem vorherigen Problem geschrieben habe, an dem ich gearbeitet habe, übernommen und es verbessert, damit die Zahlen als Antwort auf dieses Problem mit Kommas behandelt werden können.

Ich bin von meiner Begeisterung und meiner Vorliebe für Regexes mitgerissen worden. Ich weiß nicht, ob das Ergebnis genau zu dem von Michael Prescott geäußerten Bedarf passt. Es würde mich interessieren, welche Punkte in meinem regulären Ausdruck zu viel oder zu wenig vorhanden sind, und ihn zu korrigieren, um ihn für Sie besser geeignet zu machen.

Jetzt, nach einer langen Arbeitssitzung an diesem regulären Ausdruck, habe ich eine Art Gewicht im Gehirn, daher bin ich nicht frisch genug, um viele Erklärungen abzugeben. Wenn Punkte dunkel sind und jemand interessiert genug sein könnte, fragen Sie mich bitte.

Der Regex ist so aufgebaut, dass er die in der wissenschaftlichen Notation 2E10 oder sogar 5,22,454.12E-00.0478 ausgedrückten Zahlen erkennen kann , wobei auch unnötige Nullen in den beiden Teilen solcher Zahlen entfernt werden. Wenn ein Exponent gleich Null ist, wird die Zahl so geändert, dass kein Exponent mehr vorhanden ist.

Ich habe das Muster überprüft, damit einige bestimmte Fälle nicht übereinstimmen, zum Beispiel '12 ..57 ' nicht. Aber in ', 111' die Zeichenfolge '111' stimmt überein, da das vorhergehende Komma als Komma betrachtet wird, das nicht in einer Zahl, sondern als Komma eines Satzes steht.

Ich denke, dass die Verwaltung von Kommas verbessert werden sollte, da es meiner Meinung nach nur zwei Ziffern zwischen Kommas in der indischen Nummerierung gibt. Es wird nicht schwer zu korrigieren sein, nehme ich an

Hier ist ein Code, der zeigt, wie meine Regex funktioniert. Es gibt zwei Funktionen, je nachdem, ob die Zahlen '.1245' in '0.1245' transformiert werden sollen oder nicht. Es würde mich nicht wundern, wenn Fehler oder unerwünschte Übereinstimmungen oder Nichtübereinstimmungen für bestimmte Fälle von Zahlenfolgen bestehen bleiben. dann möchte ich diese Fälle kennen, um den Mangel zu verstehen und zu korrigieren.

Ich entschuldige mich für diesen in Python geschriebenen Code, aber Regexes sind trans-langage und ich denke, jeder wird in der Lage sein, das Muster des Reex zu verstehen

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

Ergebnis

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

Die Regex unten entspricht beiden Zahlen aus Ihrem Beispiel.

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

Es werden 5000 und 99.999.99998713 zurückgegeben - entsprechend Ihren Anforderungen.

Nehmen Sie sich eine gewisse Freiheit mit den Anforderungen, die Sie suchen

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

Beachten Sie jedoch, dass dies z. B. 11,11,1 entspricht

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

Dies setzt voraus, dass vor oder nach einem Komma oder einer Dezimalstelle immer mindestens eine Ziffer steht, und setzt voraus, dass höchstens eine Dezimalstelle vorhanden ist und dass alle Kommas vor der Dezimalstelle stehen.

Diese Regex:

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

Stimmt mit jeder Zahl in der Zeichenfolge überein:

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

Hier ist eine Regex:

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

das akzeptiert Zahlen:

• ohne Leerzeichen und / oder Dezimalstellen, z. 123456789,123.123
• mit Kommas oder Leerzeichen als Tausendertrennzeichen und / oder Dezimalstellen, z. 123 456 789, 123 456 789.100, 123,456,3,232,300,000.00

Tests: http://regexr.com/3h1a2

Hier ist eine weitere Konstruktion, die mit dem einfachsten Zahlenformat beginnt und dann auf nicht überlappende Weise zunehmend komplexere Zahlenformate hinzufügt:

Java-Regep:

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

Als Java-Zeichenfolge (beachten Sie, dass das zusätzliche \, das benötigt wird, um nach \ und. Zu maskieren, da \ und. Allein in einem regulären Ausdruck eine besondere Bedeutung haben):

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

Erläuterung:

1. Dieser reguläre Ausdruck hat die Form A | B | C | D | E | F, wobei A, B, C, D, E, F selbst reguläre Ausdrucke sind, die sich nicht überlappen. Im Allgemeinen fällt es mir leichter, mit den einfachsten Übereinstimmungen A zu beginnen. Wenn A die gewünschten Übereinstimmungen verfehlt, erstellen Sie ein B, das eine geringfügige Änderung von A darstellt und etwas mehr von dem enthält, was Sie möchten. Erstellen Sie dann basierend auf B ein C, das mehr fängt usw. Ich finde es auch einfacher, reguläre Ausdrücke zu erstellen, die sich nicht überlappen. Es ist einfacher, einen regulären Ausdruck mit 20 einfachen, nicht überlappenden regulären Ausdrücken zu verstehen, die mit OPs verbunden sind, als einige reguläre Ausdrücke mit komplexeren Übereinstimmungen. Aber jeder für sich!

2. A ist (\ d) und entspricht genau einem von 0,1,2,3,4,5,6,7,8,9, was nicht einfacher sein kann!

3. B ist ([1-9] \ d +) und stimmt nur mit Zahlen mit 2 oder mehr Ziffern überein, wobei die erste 0 ausschließt. B entspricht genau einem von 10,11,12, ... B überlappt A nicht, ist aber eine kleine Modifikation von A.

4. C ist (. \ D +) und entspricht nur einer Dezimalstelle, gefolgt von einer oder mehreren Ziffern. C entspricht genau einem von .0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .00 .01 .02 .... .23000 ... C erlaubt rechts ablaufende Eros, was ich bevorzuge: Wenn es sich um Messdaten handelt, gibt die Anzahl der nachgestellten Nullen die Genauigkeit an. Wenn Sie die nachgestellten Nullen rechts nicht möchten, ändern Sie (. \ D +) in (. \ D * [1-9]), aber dies schließt auch .0 aus, was meiner Meinung nach zulässig sein sollte. C ist auch eine kleine Modifikation von A.

5. D ist (\ d. \ D *), was A plus Dezimalstellen mit nachgestellten Nullen rechts ist. D entspricht nur einer einzelnen Ziffer, gefolgt von einer Dezimalstelle, gefolgt von null oder mehr Ziffern. D entspricht 0. 0.0 0.1 0.2 .... 0.01000 ... 9. 9.0 9.1..0.0230000 .... 9.9999999999 ... Wenn Sie "0" ausschließen möchten. Ändern Sie dann D in (\ d. \ d +). Wenn Sie rechts abschließende Nullen ausschließen möchten, ändern Sie D in (\ d. \ D * [1-9]), aber dies schließt 2.0 aus, was meiner Meinung nach enthalten sein sollte. D überlappt A, B oder C nicht.

6. E ist ([1-9] \ d +. \ D *), was B plus Dezimalstellen mit nachgestellten Nullen rechts ist. Wenn Sie beispielsweise "13" ausschließen möchten, ändern Sie E in ([1-9] \ d +. \ D +). E überlappt A, B, C oder D. E stimmt nicht mit 10. 10.0 10.0100 .... 99.9999999999 ... Nachgestellte Nullen können wie in 4. und 5 behandelt werden.

7. F ist ([1-9] \ d {0,2} (, \ d {3}) + (. \ D *)?) Und stimmt nur mit Kommas und möglicherweise Dezimalstellen überein, die rechts nachgestellte Nullen zulassen. Die erste Gruppe ([1-9] \ d {0,2}) stimmt mit einer Ziffer ungleich Null überein, gefolgt von null, einer oder zwei weiteren Ziffern. Die zweite Gruppe (, \ d {3}) + entspricht einer 4-stelligen Gruppe (ein Komma gefolgt von genau drei Ziffern) und diese Gruppe kann ein- oder mehrmals übereinstimmen (keine Übereinstimmungen bedeuten keine Kommas!). Schließlich (. \ D *)? passt nichts oder passt. für sich oder entspricht einer Dezimalstelle. gefolgt von einer beliebigen Anzahl von Ziffern, möglicherweise keiner. Um Dinge wie "1.111." Auszuschließen, ändern Sie (. \ D *) in (. \ D +). Nachgestellte Nullen können wie in 4. oder 5 behandelt werden. F überlappt A, B, C, D oder E nicht. Ich könnte mir keinen einfacheren regulären Ausdruck für F vorstellen.

Lassen Sie mich wissen, wenn Sie interessiert sind, und ich kann oben bearbeiten, um die nachfolgenden Nullen auf der rechten Seite wie gewünscht zu behandeln.

Folgendes passt zu regulärem Ausdruck und was nicht:

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

\b\d+,

\ b -------> Wortgrenze

\ d + ------> eine oder eine Ziffer

, --------> mit Kommas,

Z.B:

sddsgg 70.000 sdsfdsf fdgfdg70,00

sfsfsd 5,44,4343 5,7788,44 555

Es wird passen:

70,

5,

44,

44

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

Dies würde mit jeder kleinen oder großen Zahl wie folgt mit oder ohne Komma übereinstimmen

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

oder

1
100
1262
156262
1078999
123456789