Wyszukiwanie UUID w tekście za pomocą wyrażenia regularnego

Szukam UUID w blokach tekstu za pomocą wyrażenia regularnego. Obecnie opieram się na założeniu, że wszystkie UUID będą miały wzór 8-4-4-4-12 cyfr szesnastkowych.

Czy ktoś może pomyśleć o przypadku użycia, w którym to założenie byłoby nieważne i spowodowałoby, że przegapiłem niektóre UUID?

Zgadzam się, że z definicji wyrażenie regularne nie zawiera żadnego identyfikatora UUID. Warto jednak zauważyć, że jeśli szukasz szczególnie unikatowych identyfikatorów globalnych (GUID) firmy Microsoft, istnieje pięć równoważnych ciągów znaków dla identyfikatora GUID:

"ca761232ed4211cebacd00aa0057b223" 

"CA761232-ED42-11CE-BACD-00AA0057B223" 

"{CA761232-ED42-11CE-BACD-00AA0057B223}" 

"(CA761232-ED42-11CE-BACD-00AA0057B223)" 

"{0xCA761232, 0xED42, 0x11CE, {0xBA, 0xCD, 0x00, 0xAA, 0x00, 0x57, 0xB2, 0x23}}" 

Wyrażenie regularne dla uuid to:

\b[0-9a-f]{8}\b-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-\b[0-9a-f]{12}\b

@ivelin: UUID może mieć wielkie litery. Musisz albo toLowerCase () napis lub użyć:

[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}

Po prostu skomentowałbym to, ale za mało rep :)

Identyfikatory UUID w wersji 4 mają postać xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx, gdzie x to dowolna cyfra szesnastkowa, ay to jeden z 8, 9, A lub B. np. F47ac10b-58cc-4372-a567-0e02b2c3d479.

źródło: http://en.wikipedia.org/wiki/Uuid#Definition

Dlatego jest to technicznie bardziej poprawne:

/[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}/

Jeśli chcesz sprawdzić lub sprawdzić konkretną wersję UUID , oto odpowiednie wyrażenia regularne.

Zauważ, że jedyną różnicą jest numer wersji , który wyjaśniono w 4.1.3. Versionrozdziale UUID 4122 RFC .

Numer wersji to pierwszy znak trzeciej grupy [VERSION_NUMBER][0-9A-F]{3}:

• UUID v1:

  /^[0-9A-F]{8}-[0-9A-F]{4}-[1][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i

• UUID v2:

  /^[0-9A-F]{8}-[0-9A-F]{4}-[2][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i

• UUID v3:

  /^[0-9A-F]{8}-[0-9A-F]{4}-[3][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i

• UUID v4:

  /^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i

• UUID v5:

  /^[0-9A-F]{8}-[0-9A-F]{4}-[5][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i

/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89AB][0-9a-f]{3}-[0-9a-f]{12}$/i

Wyrażenie regularne Gajusa odrzuca UUID V1-3 i 5, nawet jeśli są poprawne.

[\w]{8}(-[\w]{4}){3}-[\w]{12} pracował dla mnie w większości przypadków.

Lub jeśli chcesz być naprawdę konkretny [\w]{8}-[\w]{4}-[\w]{4}-[\w]{4}-[\w]{12}.

W Python Re można rozciągać od alfabetu na duże litery. Więc..

import re
test = "01234ABCDEFGHIJKabcdefghijk01234abcdefghijkABCDEFGHIJK"
re.compile(r'[0-f]+').findall(test) # Bad: matches all uppercase alpha chars
## ['01234ABCDEFGHIJKabcdef', '01234abcdef', 'ABCDEFGHIJK']
re.compile(r'[0-F]+').findall(test) # Partial: does not match lowercase hex chars
## ['01234ABCDEF', '01234', 'ABCDEF']
re.compile(r'[0-F]+', re.I).findall(test) # Good
## ['01234ABCDEF', 'abcdef', '01234abcdef', 'ABCDEF']
re.compile(r'[0-f]+', re.I).findall(test) # Good
## ['01234ABCDEF', 'abcdef', '01234abcdef', 'ABCDEF']
re.compile(r'[0-Fa-f]+').findall(test) # Good (with uppercase-only magic)
## ['01234ABCDEF', 'abcdef', '01234abcdef', 'ABCDEF']
re.compile(r'[0-9a-fA-F]+').findall(test) # Good (with no magic)
## ['01234ABCDEF', 'abcdef', '01234abcdef', 'ABCDEF']

To sprawia, że ​​najprostsze wyrażenie regularne UUID w Pythonie:

re_uuid = re.compile("[0-F]{8}-([0-F]{4}-){3}[0-F]{12}", re.I)

Zostawię to jako ćwiczenie dla czytelnika, aby użyć timeit do porównania ich wydajności.

Cieszyć się. Keep it Pythonic ™!

UWAGA: Te zakresy również będą pasować, :;<=>?@'więc jeśli podejrzewasz, że może to dać fałszywe alarmy, nie bierz skrótu. (Dziękuję Oliverowi Aubertowi za wskazanie tego w komentarzach.)

Z definicji UUID składa się z 32 cyfr szesnastkowych, oddzielonych w 5 grupach łącznikami, tak jak opisano. Nie powinieneś przegapić żadnego z wyrażeniem regularnym.

http://en.wikipedia.org/wiki/Uuid#Definition

Tak więc, myślę, że Richard Bronosky rzeczywiście ma najlepszą jak do tej pory odpowiedź, ale myślę, że możesz zrobić trochę, aby uczynić to nieco prostszym (lub przynajmniej krótszym):

re_uuid = re.compile(r'[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}', re.I)

Wariant dla C ++:

#include <regex>  // Required include

...

// Source string    
std::wstring srcStr = L"String with GIUD: {4d36e96e-e325-11ce-bfc1-08002be10318} any text";

// Regex and match
std::wsmatch match;
std::wregex rx(L"(\\{[A-F0-9]{8}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{12}\\})", std::regex_constants::icase);

// Search
std::regex_search(srcStr, match, rx);

// Result
std::wstring strGUID       = match[1];

W przypadku identyfikatora UUID wygenerowanego w systemie OS X za uuidgenpomocą wzorca wyrażenia regularnego jest

[A-F0-9]{8}-[A-F0-9]{4}-4[A-F0-9]{3}-[89AB][A-F0-9]{3}-[A-F0-9]{12}

Zweryfikuj za pomocą

uuidgen | grep -E "[A-F0-9]{8}-[A-F0-9]{4}-4[A-F0-9]{3}-[89AB][A-F0-9]{3}-[A-F0-9]{12}"

$UUID_RE = join '-', map { "[0-9a-f]{$_}" } 8, 4, 4, 4, 12;

BTW, dopuszczenie tylko 4 na jednej pozycji jest ważne tylko dla UUIDv4. Ale v4 nie jest jedyną istniejącą wersją UUID. W mojej praktyce spotkałem również v1.

Jeśli używasz wyrażenia regularnego Posix ( grep -E, MySQL itp.), Może to być łatwiejsze do odczytania i zapamiętania:

[[:xdigit:]]{8}(-[[:xdigit:]]{4}){3}-[[:xdigit:]]{12}

Do bash:

grep -E "[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}"

Na przykład:

$> echo "f2575e6a-9bce-49e7-ae7c-bff6b555bda4" | grep -E "[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}"
f2575e6a-9bce-49e7-ae7c-bff6b555bda4