Verwenden von Regex zum Hinzufügen von führenden Nullen

Ich würde gerne hinzufügen einer bestimmten Anzahl führender Nullen (z.B. bis zu 3) alle zahlen einer Zeichenkette. Zum Beispiel:

Eingang: /2009/5/song 01 of 12

Ausgabe: /2009/0005/song 0001 of 0012

Was ist der beste Weg, dies zu tun mit regulären Ausdrücken?

Edit:

Nahm ich die erste richtige Antwort. Aber alle Antworten sind es Wert, gelesen zu werden.

InformationsquelleAutor der Frage hpique | 2010-04-17

language-agnostic regex

Etwas, das unterstützt einen Rückruf, so können Sie das match:

>>> r=re.compile(r'(?:^|(?<=[^0-9]))([0-9]{1,3})(?=$|[^0-9])')
>>> r.sub(lambda x: '%04d' % (int(x.group(1)),), 'dfbg345gf345', sys.maxint)
'dfbg0345gf0345'
>>> r.sub(lambda x: '%04d' % (int(x.group(1)),), '1x11x111x', sys.maxint)
'0001x0011x0111x'
>>> r.sub(lambda x: '%04d' % (int(x.group(1)),), 'x1x11x111x', sys.maxint)
'x0001x0011x0111x'

InformationsquelleAutor der Antwort Ignacio Vazquez-Abrams

28

In Perl:
```
s/([0-9]+)/sprintf('%04d',$1)/ge;
```
InformationsquelleAutor der Antwort Snowhare

Ein Beispiel:

>>> re.sub("(?<!\d)0*(\d{1,3})(?!\d)","000\\1","/2009/5/song 01 of 3")
'/2009/0005/song 0001 of 0003'

Hinweis:

Es funktioniert nur für zahlen 1 - 9 für jetzt
Es ist nicht gut, test noch

Ich kann nicht glauben, eine einzige regex-ohne Verwendung von callbacks für jetzt* (gibt es vielleicht einen Weg, es zu tun).

Hier sind zwei reguläre Ausdrücke zu verarbeiten, dass:

>>> x = "1/2009/5/song 01 of 3 10 100 010 120 1200 abcd"
>>>
>>> x = re.sub("(?<!\d)0*(\d{1,3})(?!\d)","000\\1",x)
#'0001/2009/0005/song 0001 of 0003 00010 000100 00010 000120 1200 abcd'
>>>
>>> re.sub("0+(\d{4})(?!\d)","\\1",x) #strip extra leading zeroes
'0001/2009/0005/song 0001 of 0003 0010 0100 0010 0120 1200 abcd'

InformationsquelleAutor der Antwort YOU

Mithilfe c#:

string result = Regex.Replace(input, @"\d+", me =>
{
    return int.Parse(me.Value).ToString("0000");
});

InformationsquelleAutor der Antwort Alex

Anderen Ansatz:

>>> x
'/2009/5/song 01 of 12'
>>> ''.join([i.isdigit() and i.zfill(4) or i for i in re.split("(?<!\d)(\d+)(?!\d)",x)])
'/2009/0005/song 0001 of 0012'
>>>

Oder:

>>> x
'/2009/5/song 01 of 12'
>>> r=re.split("(?<!\d)(\d+)(?!\d)",x)
>>> ''.join(a+b.zfill(4) for a,b in zip(r[::2],r[1::2]))
'/2009/0005/song 0001 of 0012'

InformationsquelleAutor der Antwort YOU

1

Wenn Ihr regulärer Ausdruck-Implementierung unterstützt nicht Blick-hinter-und/oder look-ahead-assertions, können Sie auch mit diesem regulären Ausdruck:
```
(^|\D)\d{1,3}(\D|$)
```
Und ersetzen Sie das Spiel mit $1 + padLeft($2, 4, "0") + $3 wo $1 ist das match von der ersten Gruppe und der padLeft(str, length, padding) ist eine Funktion, die Präfixe str mit padding bis die Länge length erreicht ist.

InformationsquelleAutor der Antwort Gumbo
1

^{<warning> Dies geht von akademischen Interesse, natürlich sollten Sie die Verwendung von Rückrufen zu tun, es klar und richtig </warning>}

Ich bin in der Lage, um den Missbrauch von regulären Ausdrücken zu haben zwei führenden Nullen (.NET-Geschmack):
```
s = Regex.Replace(s, @".(?=\b\d\b)|(?=\b\d{1,2}\b)", "$&0");
```
Es funktioniert nicht, wenn es eine Zahl am Anfang des Strings. Dies funktioniert durch Anpassung der Breite 0, bevor eine Zahl oder das Zeichen vor einer Nummer, und ersetzen Sie Sie mit 0.

Hatte ich kein Glück die Erweiterung auf drei führende Nullen, und schon gar nicht mehr.

InformationsquelleAutor der Antwort Kobi

Hier ist eine Perl-Lösung ohne callbacks oder Rekursion. Es nutzt die Perl-regex-Erweiterung des code-Ausführung anstelle des geraden substitution (die e - Schalter) dieser ist aber sehr leicht auf andere Sprachen erweitert, dass der Mangel, konstruieren.

#!/usr/bin/perl

while (<DATA>) {
   chomp;
   print "string:\t\t\t$_\n";
# uncomment if you care about 0000000 case:
#   s/(^|[^\d])0+([\d])/\1\2/g;
#   print "now no leading zeros:\t$_\n";    
   s/(^|[^\d]{1,3})([\d]{1,3})($|[^\d]{1,3})/sprintf "%s%04i%s",$1,$i=$2,$3/ge;
   print "up to 3 leading zeros:\t$_\n";
}
print "\n";

__DATA__
/2009/5/song 01 of 12
/2010/10/song 50 of 99
/99/0/song 1 of 1000
1
01
001
0001
/001/
"02"
0000000000

Ausgabe:

string:                /2009/5/song 01 of 12
up to 3 leading zeros:  /2009/0005/song 0001 of 0012
string:                /2010/10/song 50 of 99
up to 3 leading zeros:  /2010/0010/song 0050 of 0099
string:                /99/0/song 1 of 1000
up to 3 leading zeros:  /0099/0/song 0001 of 1000
string:                1
up to 3 leading zeros:  0001
string:                01
up to 3 leading zeros:  0001
string:                001
up to 3 leading zeros:  0001
string:                0001
up to 3 leading zeros:  0001
string:                /001/
up to 3 leading zeros:  /0001/
string:                "02"
up to 3 leading zeros:  "0002"
string:                0000000000
up to 3 leading zeros:  0000000000

InformationsquelleAutor der Antwort dawg

0

Kombiniert in Xcode:
```
targetName=[NSString stringWithFormat:@"%05d",number];
```
Gibt 00123) aufweisen für die Zahl 123

InformationsquelleAutor der Antwort Vincent
0

Gültiger Scala-Programm zu ersetzen, die alle Gruppen von n Ziffern 4. $$ entweicht die Zeilenende-char $weil wir mit StringContext (string Präfix von s).
```
  (f/:(1 to 3)){case (res,i) =>
     res.replaceAll(s"""(?<=[^\\d]|^)(\\d$i)(?=[^\\d]|$$)""", "0"*(4-i)+"$1")
  }
```
InformationsquelleAutor der Antwort Mikaël Mayer

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.