Metindeki sayıları virgül ve ondalık sayılarla eşleştirmek için normal ifade

Question 1

Bir metin gövdesindeki tüm sayıları bulmaya ve değiştirmeye çalışıyorum. Neredeyse sorunu çözen birkaç örnek normal ifade buldum, ancak hiçbiri henüz mükemmel değil. Sahip olduğum sorun, metnimdeki sayıların ondalık ve virgül içerip içermeyeceğidir. Örneğin:

"5000 lb. tilki 99.999.99998713 fitlik bir çitin üzerinden atladı."

Normal ifade " 5000" ve " 99,999.99998713" döndürmelidir . Örnekler, virgüldeki sayıları kırdığım veya iki ondalık basamakla sınırlı olduğunu buldum. Normal ifadenin bazı örneklerin neden iki ondalık basamakla sınırlı olduğunu anlamak için yeterli olduğunu anlamaya başlıyorum, ancak bunun üstesinden nasıl geleceğimi henüz öğrenmedim ve tüm diziyi elde etmek için virgül ekledim.

İşte en son sürümüm:

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

Yukarıdaki metin için " 5000", " 99,99", " 9.99" ve " 998713" döndürür .

Question 2

DÜZENLEME: Bu çok fazla görüntülendiğinden, Google'da aradıkları şeyi herkese vererek başlayayım:

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

Artık bu yoldan çıktığına göre, aşağıdakilerin çoğu, onunla akıllı olmaya çalışırsanız, normal ifadenin ne kadar karmaşık olabileceği ve neden alternatifler aramanız gerektiği hakkında yorum anlamına geliyor. Riski size ait olmak üzere okuyun.

Bu çok yaygın bir iştir, ama ben şimdiye kadar burada gördüğünüz tüm cevaplar gibi sayı biçiminizi eşleşmeyen girişi, kabul edecek ,111, 9,9,9hatta .,,.. Numaralar başka bir metne gömülü olsa bile, bunu düzeltmek için yeterince basit. 1,234.56 ve 1234- çekmeye başarısız IMHO şey ve sadece bu numaralar arasında -kasa abc22 1,234.56 9.9.9.9 def 1234yanlış cevaptır.

Her şeyden önce, hepsini tek bir normal ifadede yapmanız gerekmiyorsa, yapmayın. İki farklı sayı biçimi için tek bir normal ifadenin, başka bir metne gömülü olmasalar bile bakımı zordur. Gerçekten yapmanız gereken şey, her şeyi beyaz alana bölmek, ardından sonuçlarda iki veya üç küçük normal ifade çalıştırmaktır. Bu sizin için bir seçenek değilse okumaya devam edin.

Temel desen

Verdiğiniz örnekler göz önüne alındığında, işte hemen hemen her tam sayıya veya ondalık 0000biçime izin veren ve diğer her şeyi engelleyen basit bir normal ifade :

^\d*\.?\d+$

İşte 0,000format gerektiren bir tane :

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

Bunları bir araya getirin ve tutarlı oldukları sürece virgüller isteğe bağlı hale gelir:

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

Gömülü numaralar

Yukarıdaki desenler, tüm girdinin bir sayı olmasını gerektirir. Metne gömülü sayılar arıyorsunuz, bu yüzden o kısmı gevşetmelisiniz. Öte yandan, catch2222 sayısını görmesini ve bulmasını istemezsiniz. Geriye bakma desteği olan bir şey kullanıyorsanız (.NET gibi), bu oldukça kolaydır: ^ile (?<!\S)ve $ile değiştirin (?!\S)ve iyisiniz gitmek:

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

JavaScript veya Ruby veya başka bir şeyle çalışıyorsanız, işler daha karmaşık görünmeye başlar:

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

Yakalama gruplarını kullanmanız gerekecek; Arkamdan destek olmadan bir alternatif düşünemiyorum. İstediğiniz sayılar Grup 1'de olacaktır (tüm maçın Grup 0 olduğu varsayılarak).

Doğrulama ve daha karmaşık kurallar

Sanırım bu, sorunuzu kapsıyor, bu yüzden ihtiyacınız olan tek şey buysa, şimdi okumayı bırakın. Daha meraklı olmak istiyorsanız, işler çok hızlı bir şekilde çok karmaşık bir hal alır. Durumunuza bağlı olarak, aşağıdakilerden herhangi birini veya tümünü engellemek isteyebilirsiniz:

Boş giriş
Baştaki sıfırlar (ör. 000123)
Sondaki sıfırlar (ör. 1.2340000)
Ondalık noktayla başlayan ondalık sayılar (ör. 0,001 yerine 0,001)

Sadece cehennem olsun, ilk 3'ü bloke etmek, ancak sonuncusuna izin vermek istediğinizi varsayalım. Ne yapmalısın? Size ne yapmanız gerektiğini söyleyeceğim, her kural için farklı bir normal ifade kullanmalı ve eşleşmelerinizi aşamalı olarak daraltmalısınız. Ancak zorluk uğruna, işte hepsini tek bir dev modelde nasıl yapacağınız:

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

Ve bunun anlamı şu:

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

Burada test edildi: http://rextester.com/YPG96786

Bu, aşağıdaki gibi şeylere izin verecektir:

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

Aşağıdaki gibi şeyleri engelleyecektir:

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

Bu normal ifadeyi daha basit ve daha kısa hale getirmenin birkaç yolu vardır, ancak kalıbı değiştirmenin sayı olarak gördüğü şeyi gevşeteceğini anlayın.

Çoğu normal ifade motoru (örneğin, JavaScript ve Ruby) olumsuz geriye bakmayı desteklemediğinden, bunu doğru bir şekilde yapmanın tek yolu yakalama grupları kullanmaktır:

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

Aradığınız numaralar yakalama grubu 1'de olacaktır.

Burada test edildi: http://rubular.com/r/3HCSkndzhT

Son bir not

Açıkçası, bu çok büyük, karmaşık, neredeyse okunamayan bir normal ifadedir. Zorluktan hoşlandım, ancak bunu bir üretim ortamında gerçekten kullanmak isteyip istemediğinizi düşünmelisiniz. Her şeyi tek bir adımda yapmaya çalışmak yerine, bunu ikide yapabilirsiniz: sayı olabilecek herhangi bir şeyi yakalamak için bir normal ifade, sonra sayı olmayan her şeyi ayıklamak için bir diğeri . Ya da bazı temel işlemler yapabilir, ardından dilinizin yerleşik sayı ayrıştırma işlevlerini kullanabilirsiniz. Senin seçimin.

Question 3

Birkaç gün önce, sondaki sıfırları bir sayı dizisinden çıkarma sorunu üzerinde çalıştım .

Bu problemin sürekliliğinde, bunu ilginç buluyorum çünkü problemi virgül içeren sayılara genişletir.

Önceki problemde yazdığım regex kalıbını aldım ve sayıları virgülle bu soruna cevap olarak ele alabilmesi için geliştirdim.

Coşkum ve normal ifadelerden hoşlanmama kapıldım. Sonuç tam olarak Michael Prescott tarafından ifade edilen ihtiyaca uygun mu bilmiyorum. Normal ifademde fazla veya eksik olan noktaları bilmek ve sizin için daha uygun hale getirmek için düzeltmekle ilgilenirim.

Şimdi, bu normal ifade üzerinde uzun bir çalışma seansından sonra, beynimde bir çeşit ağırlık var, bu yüzden pek çok açıklama yapacak kadar zinde değilim. Eğer noktalar belirsizse ve yeterince ilgilenen varsa, lütfen bana sorun.

Normal ifade, 2E10 numaralı bilimsel gösterimde ve hatta 5,22,454.12E-00.0478'de ifade edilen sayıları tespit edebilmesi için oluşturulmuştur ve bu sayıların iki bölümündeki gereksiz sıfırları da kaldırır. Bir üs sıfıra eşitse, sayı, daha fazla üs olmayacak şekilde değiştirilir.

Bazı özel durumların eşleşmemesi için kalıba bir miktar doğrulama ekledim , örneğin '12 ..57 ' eşleşmeyecek. Ama içinde ', 111' dizesi '111' maçları önceki virgül virgül bir sayı ama cümlenin virgül olmama kabul edilir çünkü.

Virgül yönetiminin iyileştirilmesi gerektiğini düşünüyorum, çünkü bana Hindistan numaralandırmasında virgül arasında sadece 2 rakam varmış gibi geliyor. Düzeltmek zor olmayacak, sanırım

Aşağıda normal ifademin nasıl çalıştığını gösteren bir kod var. İki işlev tek sayılar istiyorsa göre vardır ' 0,1245' transforme edilmesi '0.1245' ya da değil. Bazı sayı dizgileri durumları için hatalar veya istenmeyen eşleşmeler veya eşleşmemeler kalırsa şaşırmam; Eksikliği anlamak ve düzeltmek için bu vakaları bilmek istiyorum.

Python'da yazılan bu kod için özür dilerim, ancak normal ifadeler dil ötesi ve bence herkes reex'in kalıbını anlayabilecek

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

sonuç

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

Question 4

Aşağıdaki normal ifade, örneğinizdeki her iki sayıyla eşleşecektir.

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

İhtiyaçlarınıza uygun olarak 5000 ve 99,999.99998713 döndürür.

Question 5

Gereksinimler konusunda belirli bir özgürlük almak, arıyorsun

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

Ancak bunun örneğin 11,11,1 ile eşleşeceğine dikkat edin

Question 6

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

Bu, virgül veya ondalık sayılardan önce veya sonra her zaman en az bir rakam olduğunu varsayar ve ayrıca en fazla bir ondalık sayı olduğunu ve tüm virgüllerin ondalıktan önce geldiğini varsayar.

Question 7

Bu normal ifade:

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

Dizedeki her sayıyla eşleşti:

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

Question 8

İşte bir normal ifade:

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

sayıları kabul eden:

boşluksuz ve / veya ondalıksız, ör. 123456789,123.123
binlik ayırıcı ve / veya ondalık sayı olarak virgül veya boşluk içeren, ör. 123 456 789, 123 456 789.100, 123,456,3,232,300,000.00

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

Question 9

İşte en basit sayı biçimiyle başlayan ve ardından çakışmayan bir şekilde aşamalı olarak daha karmaşık sayı biçimleri ekleyen başka bir yapı:

Java kaydı:

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

Bir Java Dizesi olarak (\ ve. Beri \ ve. Kendi başlarına bir regexp içinde özel bir anlama sahip \ ve.

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

Açıklama:

Bu normal ifade, A | B | C | D | E | F biçimindedir; burada A, B, C, D, E, F kendilerinin çakışmayan normal ifadelerdir. Genel olarak, mümkün olan en basit eşleşmelerle, yani A ile başlamayı daha kolay buluyorum. A, istediğiniz eşleşmeleri kaçırırsa, A'nın küçük bir değişikliği olan ve istediğinizden biraz daha fazlasını içeren bir B oluşturun. Sonra, B'ye dayalı olarak, daha fazlasını yakalayan bir C oluşturun, vb. Üst üste binmeyen normal ifadeler oluşturmayı da daha kolay buluyorum; Daha karmaşık eşlemeli birkaç normal ifade yerine, OR'lerle bağlantılı 20 basit, çakışmayan, çakışmayan regexp içeren bir regexp'i anlamak daha kolaydır. Ama her biri kendi başına!
A (\ d) 'dir ve 0,1,2,3,4,5,6,7,8,9'dan biriyle tam olarak eşleşir ki bu daha basit olamaz!
B ([1-9] \ d +) 'dır ve yalnızca 2 veya daha fazla basamaklı sayılarla eşleşir, ilki 0 hariç. B, 10,11,12'den biriyle tam olarak eşleşir ... B, A ile örtüşmez, ancak A'nın küçük bir modifikasyonudur.
C (. \ D +) 'dır ve yalnızca bir ondalık sayı ve ardından gelen bir veya daha fazla rakamla eşleşir. C, .0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .00 .01 .02 .... .23000 ... C, tercih ettiğim sağda takip eden eroslara izin veriyor: eğer bu ölçüm verisi ise, takip eden sıfırların sayısı hassasiyet seviyesini gösterir. Sağdaki sondaki sıfırları istemiyorsanız, (. \ D +) 'yı (. \ D * [1-9]) olarak değiştirin, ancak buna izin verilmesi gerektiğini düşündüğüm .0 da hariç tutulur. C ayrıca A'nın küçük bir modifikasyonudur.
D, (\ d. \ D *) 'dır, bu da A artı ondalık sayıdır ve sonunda sıfırlar vardır. D yalnızca tek bir rakamla, ardından bir ondalık ve ardından sıfır veya daha fazla rakamla eşleşir. D, 0 ile eşleşir. 0,0 0,1 0,2 .... 0,01000 ... 9. 9.0 9.1..0.0230000 .... 9.9999999999 ... "0" ı hariç tutmak istiyorsanız sonra D'yi (\ d. \ d +) olarak değiştirin. Sağdaki sondaki sıfırları hariç tutmak istiyorsanız, D'yi (\ d. \ D * [1-9]) olarak değiştirin, ancak bu, dahil edilmesi gerektiğini düşündüğüm 2.0'ı hariç tutar. D, A, B veya C ile örtüşmez.
E, ([1-9] \ d +. \ D *) 'dir, bu da B artı ondalık sayıdır ve sonunda sıfırlar vardır. Örneğin "13" ü hariç tutmak istiyorsanız, E'yi ([1-9] \ d +. \ D +) olarak değiştirin. E, A, B, C veya D ile örtüşmez. E, 10. 10.0 10.0100 .... 99.9999999999 ile eşleşir ... Sondaki sıfırlar 4. ve 5'te olduğu gibi ele alınabilir.
F ([1-9] \ d {0,2} (, \ d {3}) + (. \ D *)?) 'Dır ve yalnızca virgül içeren sayılarla eşleşir ve muhtemelen sağdaki sondaki sıfırlara izin veren ondalık sayılarla eşleşir. İlk grup ([1-9] \ d {0,2}), sıfır olmayan bir basamakla ve ardından sıfır, bir veya iki basamakla eşleşir. İkinci grup (, \ d {3}) +, 4 karakterli bir grupla eşleşir (virgül ve ardından tam üç basamak) ve bu grup bir veya daha fazla kez eşleşebilir (eşleşme olmaması, virgül olmaması anlamına gelir!) Son olarak, (. \ D *)? hiçbir şeyle eşleşmez veya eşleşir. tek başına veya ondalık sayı ile eşleşir. ardından herhangi bir sayıda basamak, muhtemelen hiçbiri. Yine, "1,111." Gibi şeyleri hariç tutmak için, (. \ D *) yerine (. \ D +) değiştirin. Sondaki sıfırlar 4. veya 5.'deki gibi ele alınabilir. F, A, B, C, D veya E ile örtüşmez. F. için daha kolay bir normal ifade düşünemedim.

İlgilenip ilgilenmediğinizi bana bildirin ve sağdaki sondaki sıfırları istediğiniz gibi işlemek için yukarıda düzenleme yapabilirim.

Normal ifadeyle neyin eşleşip eşleşmediği aşağıda açıklanmıştır:

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

Question 10

\b\d+,

\ b -------> kelime sınırı

\ d + ------> bir veya rakam

, --------> virgül içeren,

Örneğin:

sddsgg 70.000 sdsfdsf fdgfdg70,00

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

Eşleşecek:

70,

5,

44,

, 44

Question 11

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

Bu, virgülle veya virgül olmadan aşağıdaki gibi küçük veya büyük sayılarla eşleşir

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

veya