Wyrażenie regularne do dopasowywania liczb z przecinkami i miejscami dziesiętnymi lub bez nich w tekście

Próbuję znaleźć i zamienić wszystkie liczby w tekście. Znalazłem kilka przykładowych wyrażeń regularnych, które prawie rozwiązują problem, ale żadne nie są jeszcze doskonałe. Problem polega na tym, że liczby w moim tekście mogą mieć lub nie miejsca dziesiętne i przecinki. Na przykład:

„Lis 5000 funtów przeskoczył przez płot o wielkości 99,999,9998713 stóp”.

Wyrażenie regularne powinno zwracać „ 5000” i „ 99,999.99998713”. Przykłady, które znalazłem, dzielą liczby w przecinku lub są ograniczone do dwóch miejsc po przecinku. Zaczynam rozumieć wystarczające wyrażenia regularne, aby zobaczyć, dlaczego niektóre przykłady są ograniczone do dwóch miejsc po przecinku, ale nie nauczyłem się jeszcze, jak je przezwyciężyć, a także dołączyć przecinek, aby uzyskać całą sekwencję.

Oto moja najnowsza wersja:

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

Który zwraca „ 5000”, „ 99,99”, „ 9.99” i „ 998713” dla powyższego tekstu.

EDYCJA: Ponieważ zyskało to wiele wyświetleń, pozwól mi zacząć od podania wszystkim tego, czego szukali w 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])?$

Skoro to już nie przeszkadza, większość poniższych ma stanowić komentarz na temat tego, jak złożone wyrażenie regularne może uzyskać, jeśli spróbujesz być z nim sprytny, i dlaczego powinieneś szukać alternatyw. Czytaj na własne ryzyko.

Jest to bardzo częste zadanie, ale wszystkie odpowiedzi widzę tutaj tak daleko zaakceptuje wejść, które nie pasują do Twojego formatu liczb, takich jak ,111, 9,9,9lub nawet .,,.. To dość proste do naprawienia, nawet jeśli liczby są osadzone w innym tekście. IMHO wszystko, co nie wyciąga 1,234,56 i 1234 - i tylko te liczby - abc22 1,234.56 9.9.9.9 def 1234jest błędną odpowiedzią.

Po pierwsze, jeśli nie musisz robić tego wszystkiego w jednym wyrażeniu regularnym, nie rób tego. Jedno wyrażenie regularne dla dwóch różnych formatów liczb jest trudne do utrzymania, nawet jeśli nie są one osadzone w innym tekście. To, co naprawdę powinieneś zrobić, to podzielić całość na białe znaki, a następnie uruchomić dwa lub trzy mniejsze wyrażenia regularne na wynikach. Jeśli to nie jest dla Ciebie opcja, czytaj dalej.

Podstawowy wzór

Biorąc pod uwagę podane przez Ciebie przykłady, oto proste wyrażenie regularne, które zezwala na prawie dowolną liczbę całkowitą lub dziesiętną w 0000formacie i blokuje wszystko inne:

^\d*\.?\d+$

Oto jeden, który wymaga 0,000formatu:

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

Połącz je razem, a przecinki staną się opcjonalne, o ile są spójne:

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

Wbudowane liczby

Powyższe wzorce wymagają, aby całe dane wejściowe były liczbą. Szukasz liczb osadzonych w tekście, więc musisz poluzować tę część. Z drugiej strony, nie chcesz to zobaczyć catch22i myślę, że znalazł numer 22. Jeśli używasz coś podobnego wsparcia lookbehind (NET), to jest całkiem proste: zastąpić ^z (?<!\S)i $z (?!\S)i jesteś dobry iść:

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

Jeśli pracujesz z JavaScript, Ruby lub czymś podobnym, sprawy zaczynają wyglądać bardziej skomplikowane:

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

Będziesz musiał użyć grup przechwytywania; Nie mogę wymyślić alternatywy bez wsparcia patrzenia w tył. Liczby, które chcesz, będą w grupie 1 (zakładając, że cały mecz to grupa 0).

Walidacja i bardziej złożone zasady

Myślę, że to wystarcza na twoje pytanie, więc jeśli to wszystko, czego potrzebujesz, przestań teraz czytać. Jeśli chcesz być bardziej wyhodowany, sprawy bardzo szybko się komplikują. W zależności od sytuacji możesz zablokować dowolne lub wszystkie z poniższych:

• Puste dane wejściowe
• Zera wiodące (np. 000123)
• Końcowe zera (np. 1.2340000)
• Liczby dziesiętne zaczynające się od przecinka (np. 0,001 zamiast 0,001)

Po prostu załóżmy, że chcesz zablokować pierwsze 3, ale pozwól na ostatnią. Co powinieneś zrobić? Powiem ci, co powinieneś zrobić, powinieneś użyć innego wyrażenia regularnego dla każdej reguły i stopniowo zawężać swoje dopasowania. Ale ze względu na wyzwanie, oto jak to zrobić w jednym gigantycznym schemacie:

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

A oto co to oznacza:

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

Przetestowano tutaj: http://rextester.com/YPG96786

Pozwoli to na:

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

Zablokuje takie rzeczy jak:

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

Jest kilka sposobów na uproszczenie i skrócenie tego wyrażenia regularnego, ale pamiętaj, że zmiana wzorca osłabi to, co uważa on za liczbę.

Ponieważ wiele silników wyrażeń regularnych (np. JavaScript i Ruby) nie obsługuje negatywnego lookbehind, jedynym sposobem, aby to zrobić poprawnie, są grupy przechwytywania:

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

Liczby, których szukasz, będą w grupie przechwytywania 1.

Przetestowano tutaj: http://rubular.com/r/3HCSkndzhT

Ostatnia uwaga

Oczywiście jest to masywne, skomplikowane, prawie nieczytelne wyrażenie regularne. Podobało mi się wyzwanie, ale powinieneś się zastanowić, czy naprawdę chcesz użyć tego w środowisku produkcyjnym. Zamiast próbować zrobić wszystko w jednym kroku, możesz zrobić to na dwa sposoby: wyrażenie regularne, aby złapać wszystko, co może być liczbą, a następnie drugie, aby wyeliminować to, co nie jest liczbą. Możesz też wykonać podstawowe przetwarzanie, a następnie użyć wbudowanych w język funkcji analizujących liczby. Twój wybór.

Kilka dni temu pracowałem nad problemem usuwania końcowych zer z ciągu liczbowego .

Uważam, że ciągłość tego problemu jest interesująca, ponieważ rozszerza problem na liczby zawierające przecinki.

Wziąłem wzór wyrażenia regularnego, który zapisałem w poprzednim problemie, nad którym pracowałem, i poprawiłem go, aby można było traktować liczby z przecinkami jako odpowiedź na ten problem.

Porwał mnie mój entuzjazm i zamiłowanie do wyrażeń regularnych. Nie wiem, czy wynik dokładnie odpowiada potrzebie wyrażonej przez Michaela Prescotta. Chciałbym poznać punkty, których brakuje w moim wyrażeniu regularnym w nadmiarze lub których brakuje, i poprawić je, aby było bardziej odpowiednie dla Ciebie.

Teraz, po długiej sesji pracy nad tym wyrażeniem regularnym, mam pewien rodzaj obciążenia w mózgu, więc nie jestem wystarczająco świeży, aby udzielić wielu wyjaśnień. Jeśli punkty są niejasne i jeśli ktoś może być wystarczająco zainteresowany, zapytaj mnie.

Wyrażenie regularne jest zbudowane w taki sposób, że może wykryć liczby wyrażone w notacji naukowej 2E10 lub nawet 5,22,454.12E-00.0478 , usuwając również niepotrzebne zera w dwóch częściach takich liczb. Jeśli wykładnik jest równy zero, liczba jest modyfikowana tak, że nie ma już wykładnika.

Umieściłem we wzorcu pewną weryfikację, aby niektóre przypadki nie pasowały, na przykład „12.57” nie będzie pasować. Ale w „, 111” ciąg „111” pasuje, ponieważ poprzedzający przecinek jest traktowany jako przecinek, który nie jest liczbą, ale przecinkiem w zdaniu.

Uważam, że należy poprawić zarządzanie przecinkami, ponieważ wydaje mi się, że w numeracji indyjskiej między przecinkami są tylko 2 cyfry. Przypuszczam, że nie będzie trudno to poprawić

Poniżej znajduje się kod demonstrujący, jak działa moje wyrażenie regularne. Istnieją dwie funkcje, zależnie od tego, czy chcemy, aby liczby „.1245” zostały przekształcone na „0,1245”, czy nie. Nie zdziwiłbym się, gdyby w niektórych przypadkach ciągów liczbowych pozostały błędy lub niechciane dopasowania lub niedopasowania; wtedy chciałbym poznać te przypadki, aby zrozumieć i poprawić brak.

Przepraszam za ten kod napisany w Pythonie, ale wyrażenia regularne są tłumaczone i myślę, że każdy będzie w stanie rozpoznać wzorzec reexu

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

wynik

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

Poniższe wyrażenie regularne będzie pasowało do obu liczb z Twojego przykładu.

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

Zwróci 5000 i 99 999.99998713 - zgodnie z Twoimi wymaganiami.

Biorąc pod uwagę wymagania, których szukasz

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

Ale zauważ, że to będzie pasować np. 11,11,1

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

Zakłada się, że przed przecinkiem lub po przecinku lub po przecinku zawsze znajduje się co najmniej jedna cyfra, a także zakłada się, że jest co najwyżej jedna cyfra po przecinku i że wszystkie przecinki poprzedzają przecinek.

To wyrażenie regularne:

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

Dopasowano każdą liczbę w ciągu:

1 1,0 0,1 1,001 1000 1000000 1000,1 1000,1 1 233 444 000 1999 1222 455666,0 1244

Oto wyrażenie regularne:

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

który akceptuje liczby:

• bez spacji i / lub miejsc po przecinku, np. 123456789,123.123
• z przecinkami lub spacjami jako separatorem tysięcy i / lub cyframi dziesiętnymi, np. 123 456 789, 123 456 789.100, 123,456,3,232,300,000.00

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

Oto kolejna konstrukcja, która zaczyna się od najprostszego formatu liczb, a następnie, w sposób nienakładający się, stopniowo dodaje bardziej złożone formaty liczb:

Regep Java:

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

Jako ciąg w języku Java (zwróć uwagę, że dodatkowe \ potrzebne do przejścia do \ i., Ponieważ \ i. Mają specjalne znaczenie w wyrażeniu regularnym, gdy występują samodzielnie):

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

Wyjaśnienie:

1. To wyrażenie regularne ma postać A | B | C | D | E | F, gdzie A, B, C, D, E, F same są wyrażeniami regularnymi, które się nie nakładają. Ogólnie rzecz biorąc, łatwiej mi zacząć od najprostszych możliwych dopasowań, A. Jeśli A nie trafia w dopasowania, które chcesz, stwórz B, które jest niewielką modyfikacją A i zawiera nieco więcej tego, czego chcesz. Następnie, w oparciu o B, utwórz C, które przechwytuje więcej itd. Łatwiej jest mi też tworzyć wyrażenia regularne, które się nie nakładają; łatwiej jest zrozumieć wyrażenie regularne z 20 prostymi nienakładającymi się wyrażeniami regularnymi połączonymi z operatorami OR, niż z kilkoma wyrażeniami regularnymi z bardziej złożonym dopasowaniem. Ale każdy do swojego!

2. A to (\ d) i odpowiada dokładnie jednemu z 0,1,2,3,4,5,6,7,8,9, co nie może być prostsze!

3. B to ([1-9] \ d +) i dopasowuje tylko liczby z 2 lub więcej cyframi, z których pierwsza nie obejmuje 0. B odpowiada dokładnie jednemu z 10,11,12, ... B nie zachodzi na A, ale jest małą modyfikacją A.

4. C to (. \ D +) i dopasowuje tylko cyfrę dziesiętną, po której następuje jedna lub więcej cyfr. C odpowiada dokładnie jednemu z: .0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .00 .01 .02 .... .23000 ... C umożliwia końcowe erosowanie po prawej stronie, co wolę: jeśli są to dane pomiarowe, liczba końcowych zer wskazuje poziom dokładności. Jeśli nie chcesz końcowych zer po prawej stronie, zmień (. \ D +) na (. \ D * [1-9]), ale to również wyklucza .0, które moim zdaniem powinno być dozwolone. C jest również małą modyfikacją A.

5. D to (\ d. \ D *), czyli A plus liczby dziesiętne z końcowymi zerami po prawej stronie. D dopasowuje tylko jedną cyfrę, po której następuje cyfra dziesiętna, po której następuje zero lub więcej cyfr. D odpowiada 0. 0.0 0.1 0.2 .... 0.01000 ... 9. 9.0 9.1..0.0230000 .... 9.9999999999 ... Jeśli chcesz wykluczyć „0” następnie zmień D na (\ d. \ d +). Jeśli chcesz wykluczyć końcowe zera po prawej stronie, zmień D na (\ d. \ D * [1-9]), ale to wyklucza 2.0, które moim zdaniem powinno zostać uwzględnione. D nie zachodzi na A, B lub C.

6. E to ([1-9] \ d +. \ D *), czyli B plus miejsca po przecinku z końcowymi zerami po prawej stronie. Jeśli chcesz na przykład wykluczyć „13”, zmień E na ([1-9] \ d +. \ D +). E nie zachodzi na A, B, C lub D. Dopasowanie E 10. 10.0 10.0100 .... 99.9999999999 ... Końcowe zera mogą być obsługiwane jak w 4. i 5.

7. F to ([1-9] \ d {0,2} (, \ d {3}) + (. \ D *)?) I dopasowuje tylko liczby z przecinkami i prawdopodobnie liczbami dziesiętnymi, zezwalając na zera końcowe po prawej stronie. Pierwsza grupa ([1-9] \ d {0,2}) dopasowuje niezerową cyfrę, po której następuje zero, jedna lub dwie więcej cyfr. Druga grupa (, \ d {3}) + pasuje do 4-znakowej grupy (przecinek, po którym następują dokładnie trzy cyfry) i ta grupa może pasować raz lub więcej razy (brak dopasowania oznacza brak przecinków!). Wreszcie (. \ D *)? nic nie pasuje lub pasuje. samodzielnie lub dopasowuje ułamek dziesiętny. po którym następuje dowolna liczba cyfr, prawdopodobnie żadna. Ponownie, aby wykluczyć rzeczy takie jak „1111.”, Zmień (. \ D *) na (. \ D +). Końcowe zera można obsługiwać tak, jak w 4. lub 5. F nie nakłada się na A, B, C, D lub E. Nie przychodziło mi do głowy łatwiejsze wyrażenie regularne dla F.

Daj mi znać, jeśli jesteś zainteresowany, a mogę edytować powyżej, aby obsłużyć końcowe zera po prawej stronie zgodnie z życzeniem.

Oto, co pasuje do wyrażenia regularnego, a co nie:

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 -------> granica słowa

\ d + ------> jeden lub cyfra

, --------> zawierające przecinki,

Na przykład:

sddsgg 70,000 sdsfdsf fdgfdg70,00

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

Będzie pasować:

70,

5,

44,

, 44

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

To pasowałoby do każdej małej lub dużej liczby, jak po przecinku lub bez

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

lub

1
100
1262
156262
1078999
123456789