Jak zrobić CamelCase split w Pythonie

Użyj re.sub() i split()

import re

name = 'CamelCaseTest123'
splitted = re.sub('(?!^)([A-Z][a-z]+)', r' \1', name).split()

Wynik

['Camel', 'Case', 'Test123']

W większości przypadków, gdy nie trzeba sprawdzać formatu ciągu, globalne badanie jest prostsze niż podział (dla tego samego wyniku):

re.findall(r'[A-Z](?:[a-z]+|[A-Z]*(?=[A-Z]|$))', 'CamelCaseXYZ')

Zwraca

['Camel', 'Case', 'XYZ']

Do czynienia z dromedary zbyt, można użyć:

re.findall(r'[A-Z]?[a-z]+|[A-Z]+(?=[A-Z]|$)', 'camelCaseXYZ')

Uwaga: (?=[A-Z]|$) można skrócić za pomocą podwójnej negacji (negatywnego spojrzenia z negowaną klasą znaków): (?![^A-Z])

Dokumentacja dla Pythona re.split mówi:

Zauważ, że split nigdy nie podzieli łańcucha na puste dopasowanie wzorca.

Widząc to:

>>> re.findall("(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])", "CamelCaseXYZ")
['', '']

Staje się jasne, dlaczego podział nie działa zgodnie z oczekiwaniami. Moduł reznajduje puste dopasowania, tak jak jest to zamierzone przez wyrażenie regularne.

Ponieważ dokumentacja stwierdza, że nie jest to błąd, ale raczej zamierzone zachowanie, musisz obejść to, próbując stworzyć wielbłąda podział przypadku:

def camel_case_split(identifier):
    matches = finditer('(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])', identifier)
    split_string = []
    # index of beginning of slice
    previous = 0
    for match in matches:
        # get slice
        split_string.append(identifier[previous:match.start()])
        # advance index
        previous = match.start()
    # get remaining string
    split_string.append(identifier[previous:])
    return split_string

Natknąłem się na tę sprawę i napisałem Wyrażenie regularne, aby ją rozwiązać. To powinno zadziałać dla każdej grupy słów.

RE_WORDS = re.compile(r'''
    # Find words in a string. Order matters!
    [A-Z]+(?=[A-Z][a-z]) |  # All upper case before a capitalized word
    [A-Z]?[a-z]+ |  # Capitalized words / all lower case
    [A-Z]+ |  # All upper case
    \d+  # Numbers
''', re.VERBOSE)

Kluczem jest lookahead w pierwszym możliwym przypadku. Dopasuje (i zachowa) wielkie słowa przed wielkimi literami:

assert RE_WORDS.findall('FOOBar') == ['FOO', 'Bar']

Oto inne rozwiązanie, które wymaga mniej kodu i nie wymaga skomplikowanych wyrażeń regularnych:

def camel_case_split(string):
    bldrs = [[string[0].upper()]]
    for c in string[1:]:
        if bldrs[-1][-1].islower() and c.isupper():
            bldrs.append([c])
        else:
            bldrs[-1].append(c)
    return [''.join(bldr) for bldr in bldrs]

Edytuj

Powyższy kod zawiera optymalizację, która pozwala uniknąć przebudowy całego ciągu Z Każdym dołączonym znakiem. Pomijając tę optymalizację, prostsza wersja (z komentarzami) może wyglądać tak:

def camel_case_split2(string):
    # set the logic for creating a "break"
    def is_transition(c1, c2):
      return c1.islower() and c2.isupper()

    # start the builder list with the first character
    # enforce upper case
    bldr = [string[0].upper()]
    for c in string[1:]:
        # get the last character in the last element in the builder
        # note that strings can be addressed just like lists
        previous_character = bldr[-1][-1]
        if is_transition(previous_character, c):
            # start a new element in the list
            bldr.append(c)
        else:
            # append the character to the last string
            bldr[-1] += c
    return bldr

Myślę, że poniżej jest optimim

Def count_word(): Powrót (re.findall ('[a-Z]?[A-z]+', input ('please enter your string'))

Print (count_word ())