Elegancka funkcja Pythona do konwersji CamelCase na Snake case?

W indeksie pakietów znajduje się biblioteka fleksyjna, która może obsłużyć te rzeczy za Ciebie. W tym przypadku szukałbyś inflection.underscore():

>>> inflection.underscore('CamelCase')
'camel_case'

Nie wiem, dlaczego to wszystko jest takie skomplikowane.

W większości przypadków proste wyrażenie ([A-Z]+) wykona sztuczkę

>>> re.sub('([A-Z]+)', r'_\1','CamelCase').lower()
'_camel_case'  
>>> re.sub('([A-Z]+)', r'_\1','camelCase').lower()
'camel_case'
>>> re.sub('([A-Z]+)', r'_\1','camel2Case2').lower()
'camel2_case2'
>>> re.sub('([A-Z]+)', r'_\1','camelCamelCase').lower()
'camel_camel_case'
>>> re.sub('([A-Z]+)', r'_\1','getHTTPResponseCode').lower()
'get_httpresponse_code'

Aby zignorować pierwszy charachter wystarczy dodać look behind (?!^)

>>> re.sub('(?!^)([A-Z]+)', r'_\1','CamelCase').lower()
'camel_case'
>>> re.sub('(?!^)([A-Z]+)', r'_\1','CamelCamelCase').lower()
'camel_camel_case'
>>> re.sub('(?!^)([A-Z]+)', r'_\1','Camel2Camel2Case').lower()
'camel2_camel2_case'
>>> re.sub('(?!^)([A-Z]+)', r'_\1','getHTTPResponseCode').lower()
'get_httpresponse_code'

Jeśli chcesz oddzielić ALLCaps od all_caps i oczekiwać liczb w ciągu znaków, nadal nie musisz robić dwóch oddzielnych uruchomień, użyj {[5] } to wyrażenie ((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z])) może obsłużyć prawie każdy scenariusz w książce

>>> a = re.compile('((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z]))')
>>> a.sub(r'_\1', 'getHTTPResponseCode').lower()
'get_http_response_code'
>>> a.sub(r'_\1', 'get2HTTPResponseCode').lower()
'get2_http_response_code'
>>> a.sub(r'_\1', 'get2HTTPResponse123Code').lower()
'get2_http_response123_code'
>>> a.sub(r'_\1', 'HTTPResponseCode').lower()
'http_response_code'
>>> a.sub(r'_\1', 'HTTPResponseCodeXYZ').lower()
'http_response_code_xyz'

Wszystko zależy od tego, co chcesz, więc użyj rozwiązanie, które najlepiej pasuje do Twoich potrzeb, ponieważ nie powinno być zbyt skomplikowane.

Osobiście nie jestem pewien, jak cokolwiek używając wyrażeń regularnych w Pythonie można opisać jako eleganckie. Większość odpowiedzi tutaj są po prostu robi "kod golf" Typ RE sztuczki. Eleganckie kodowanie ma być łatwo zrozumiałe.

def to_snake_case(not_snake_case):
    final = ''
    for i in xrange(len(not_snake_case)):
        item = not_snake_case[i]
        if i < len(not_snake_case) - 1:
            next_char_will_be_underscored = (
                not_snake_case[i+1] == "_" or
                not_snake_case[i+1] == " " or
                not_snake_case[i+1].isupper()
            )
        if (item == " " or item == "_") and next_char_will_be_underscored:
            continue
        elif (item == " " or item == "_"):
            final += "_"
        elif item.isupper():
            final += "_"+item.lower()
        else:
            final += item
    if final[0] == "_":
        final = final[1:]
    return final

>>> to_snake_case("RegularExpressionsAreFunky")
'regular_expressions_are_funky'

>>> to_snake_case("RegularExpressionsAre Funky")
'regular_expressions_are_funky'

>>> to_snake_case("RegularExpressionsAre_Funky")
'regular_expressions_are_funky'

''.join('_'+c.lower() if c.isupper() else c for c in "DeathToCamelCase").strip('_')
re.sub("(.)([A-Z])", r'\1_\2', 'DeathToCamelCase').lower()

Stringcase jest moją biblioteką do tego; np.:

>>> from stringcase import pascalcase, snakecase
>>> snakecase('FooBarBaz')
'foo_bar_baz'
>>> pascalcase('foo_bar_baz')
'FooBarBaz'

Nie rozumiem, po co używać obu .wywołania sub ()? :) Nie jestem guru regex, ale uprościłem funkcję do tej, która jest odpowiednia dla moich pewnych potrzeb, po prostu potrzebowałem rozwiązania do konwersji camelCasedVars z żądania POST na vars_with_underscore:

def myFunc(...):
  return re.sub('(.)([A-Z]{1})', r'\1_\2', "iTriedToWriteNicely").lower()

To nie działa z takimi nazwami jak getHTTPResponse, bo słyszałem, że to zła konwencja nazewnictwa(powinno być jak getHttpResponse, to oczywiście, że o wiele łatwiej zapamiętać ten formularz).

Oto moje rozwiązanie:

def un_camel(text):
    """ Converts a CamelCase name into an under_score name. 

        >>> un_camel('CamelCase')
        'camel_case'
        >>> un_camel('getHTTPResponseCode')
        'get_http_response_code'
    """
    result = []
    pos = 0
    while pos < len(text):
        if text[pos].isupper():
            if pos-1 > 0 and text[pos-1].islower() or pos-1 > 0 and \
            pos+1 < len(text) and text[pos+1].islower():
                result.append("_%s" % text[pos].lower())
            else:
                result.append(text[pos].lower())
        else:
            result.append(text[pos])
        pos += 1
    return "".join(result)

Wspiera te narożne sprawy omówione w komentarzach. Na przykład konwertuje getHTTPResponseCode na get_http_response_code tak, jak powinno.

Myślę, że to rozwiązanie jest prostsze niż poprzednie odpowiedzi:

import re

def convert (camel_input):
    words = re.findall(r'[A-Z]?[a-z]+|[A-Z]{2,}(?=[A-Z][a-z]|\d|\W|$)|\d+', camel_input)
    return '_'.join(map(str.lower, words))


# Let's test it
test_strings = [
    'CamelCase',
    'camelCamelCase',
    'Camel2Camel2Case',
    'getHTTPResponseCode',
    'get200HTTPResponseCode',
    'getHTTP200ResponseCode',
    'HTTPResponseCode',
    'ResponseHTTP',
    'ResponseHTTP2',
    'Fun?!awesome',
    'Fun?!Awesome',
    '10CoolDudes',
    '20coolDudes'
]
for test_string in test_strings:
    print(convert(test_string))

Które wyjście:

camel_case
camel_camel_case
camel_2_camel_2_case
get_http_response_code
get_200_http_response_code
get_http_200_response_code
http_response_code
response_http
response_http_2
fun_awesome
fun_awesome
10_cool_dudes
20_cool_dudes

Wyrażenie regularne pasuje do trzech wzorców:

1. [A-Z]?[a-z]+: kolejne małe litery, które opcjonalnie zaczynają się od wielkiej litery.
2. [A-Z]{2,}(?=[A-Z][a-z]|\d|\W|$): dwie lub więcej kolejnych wielkich liter. Używa lookahead, aby wykluczyć ostatnią wielką literę, jeśli po niej następuje mała litera.
3. \d+: konsekutywne liczby.

Za pomocą re.findall otrzymujemy listę pojedynczych "słów", które można przekonwertować na małe litery i połączyć z podkreślnikami.

Dla Zabawy:

>>> def un_camel(input):
...     output = [input[0].lower()]
...     for c in input[1:]:
...             if c in ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'):
...                     output.append('_')
...                     output.append(c.lower())
...             else:
...                     output.append(c)
...     return str.join('', output)
...
>>> un_camel("camel_case")
'camel_case'
>>> un_camel("CamelCase")
'camel_case'

Lub, bardziej dla Zabawy:

>>> un_camel = lambda i: i[0].lower() + str.join('', ("_" + c.lower() if c in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" else c for c in i[1:]))
>>> un_camel("camel_case")
'camel_case'
>>> un_camel("CamelCase")
'camel_case'

Nie w bibliotece standardowej, ale znalazłem Ten skrypt , który wydaje się zawierać funkcje, których potrzebujesz.

Nie jest to elegancka metoda, jest bardzo' niskopoziomową ' implementacją prostej maszyny stanowej (bitfield state machine), prawdopodobnie najbardziej anty pythonicznym trybem do rozwiązania tego problemu, jednak moduł re implementuje również zbyt złożoną maszynę stanową, aby rozwiązać to proste zadanie, więc myślę, że jest to dobre rozwiązanie.

def splitSymbol(s):
    si, ci, state = 0, 0, 0 # start_index, current_index 
    '''
        state bits:
        0: no yields
        1: lower yields
        2: lower yields - 1
        4: upper yields
        8: digit yields
        16: other yields
        32 : upper sequence mark
    '''
    for c in s:

        if c.islower():
            if state & 1:
                yield s[si:ci]
                si = ci
            elif state & 2:
                yield s[si:ci - 1]
                si = ci - 1
            state = 4 | 8 | 16
            ci += 1

        elif c.isupper():
            if state & 4:
                yield s[si:ci]
                si = ci
            if state & 32:
                state = 2 | 8 | 16 | 32
            else:
                state = 8 | 16 | 32

            ci += 1

        elif c.isdigit():
            if state & 8:
                yield s[si:ci]
                si = ci
            state = 1 | 4 | 16
            ci += 1

        else:
            if state & 16:
                yield s[si:ci]
            state = 0
            ci += 1  # eat ci
            si = ci   
        print(' : ', c, bin(state))
    if state:
        yield s[si:ci] 


def camelcaseToUnderscore(s):
    return '_'.join(splitSymbol(s)) 

Splitsymbol może parsować wszystkie typy przypadków: UpperSEQUENCEInterleaved, under_score, BIG_SYMBOLS i cammelCasedMethods

Mam nadzieję, że się przyda

Właśnie ukradłem to z fragmentów django. ref http://djangosnippets.org/snippets/585/

Pretty elegant

camelcase_to_underscore = lambda str: re.sub('(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))', '_\\1', str).lower().strip('_')

Przykład:

camelcase_to_underscore('ThisUser')

Zwraca:

'this_user'

Używanie wyrażeń regularnych może być najkrótsze, ale to rozwiązanie jest o wiele bardziej czytelne:

def to_snake_case(s):
    snake = "".join(["_"+c.lower() if c.isupper() else c for c in s])
    return snake[1:] if snake.startswith("_") else snake

Lekka adaptacja z https://stackoverflow.com/users/267781/matth którzy używają generatorów.

def uncamelize(s):
    buff, l = '', []
    for ltr in s:
        if ltr.isupper():
            if buff:
                l.append(buff)
                buff = ''
        buff += ltr
    l.append(buff)
    return '_'.join(l).lower()

Spójrz na doskonałe Schematy lib

Https://github.com/schematics/schematics

Pozwala na tworzenie typowanych struktur danych, które mogą serializować/deserializować z Pythona do Javascript, np:

class MapPrice(Model):
    price_before_vat = DecimalType(serialized_name='priceBeforeVat')
    vat_rate = DecimalType(serialized_name='vatRate')
    vat = DecimalType()
    total_price = DecimalType(serialized_name='totalPrice')

Wolę unikać re, jeśli to możliwe:

myString="ThisStringIsCamelCase" ''.join(['_'+i.lower() if i.isupper() else i for i in myString]).lstrip('_') 'this_string_is_camel_case'

Tyle skomplikowanych metod... Po prostu znajdź całą grupę "zatytułowaną" i dołącz jej wariant w dolnej obudowie z podkreśleniem.

>>> import re
>>> def camel_to_snake(string):
...     groups = re.findall('([A-z0-9][a-z]*)', string)
...     return '_'.join([i.lower() for i in groups])
...
>>> camel_to_snake('ABCPingPongByTheWay2KWhereIsOurBorderlands3???')
'a_b_c_ping_pong_by_the_way_2_k_where_is_our_borderlands_3'

Jeśli nie chcesz tworzyć liczb takich jak pierwszy znak grupy lub oddzielna grupa-możesz użyć maski ([A-z][a-z0-9]*).

Horrendalny przykład użycia wyrażeń regularnych (możesz łatwo to wyczyścić:)):

def f(s):
    return s.group(1).lower() + "_" + s.group(2).lower()

p = re.compile("([A-Z]+[a-z]+)([A-Z]?)")
print p.sub(f, "CamelCase")
print p.sub(f, "getHTTPResponseCode")

Działa jednak dla getHTTPResponseCode!

Alternatywnie, używając lambda:

p = re.compile("([A-Z]+[a-z]+)([A-Z]?)")
print p.sub(lambda x: x.group(1).lower() + "_" + x.group(2).lower(), "CamelCase")
print p.sub(lambda x: x.group(1).lower() + "_" + x.group(2).lower(), "getHTTPResponseCode")

EDIT: powinno być również dość łatwo zauważyć, że jest miejsce na poprawę w przypadku takich przypadków jak "Test", ponieważ podkreślenie jest bezwarunkowo wstawiane.

Oto coś, co zrobiłem, aby zmienić nagłówki w pliku rozdzielanym tabulatorami. Pomijam część, w której edytowałem tylko pierwszą linię pliku. Możesz łatwo dostosować go do Pythona za pomocą biblioteki re. Obejmuje to również oddzielanie liczb (ale utrzymuje cyfry razem). Zrobiłem to w dwóch krokach, ponieważ było to łatwiejsze niż mówienie mu, aby nie umieszczał podkreślenia na początku linii lub tabulacji.

Szukaj:

([a-z]+)([A-Z]|[0-9]+)

Zamiennik:

\1_\l\2/

Szukaj:

([A-Z])

Zamiennik (to odwrotny ukośnik, małe litery L, odwrotny ukośnik, jeden):

\l\1

Szukałem rozwiązania tego samego problemu, poza tym, że potrzebowałem łańcucha; np.

"CamelCamelCamelCase" -> "Camel-camel-camel-case"

Zaczynając od ładnych dwu wyrazowych rozwiązań tutaj, wymyśliłem co następuje:

"-".join(x.group(1).lower() if x.group(2) is None else x.group(1) \
         for x in re.finditer("((^.[^A-Z]+)|([A-Z][^A-Z]+))", "stringToSplit"))

Większość skomplikowanej logiki polega na unikaniu małych liter pierwszego słowa. Oto prostsza wersja, jeśli nie masz nic przeciwko zmianie pierwszego słowa:

"-".join(x.group(1).lower() for x in re.finditer("(^[^A-Z]+|[A-Z][^A-Z]+)", "stringToSplit"))

Oczywiście, można wstępnie skompilować wyrażenia regularne lub połączyć z podkreśleniem zamiast myślnika, jak omówiono w drugim rozwiązania.

Zwięzły bez wyrażeń regularnych, ale Httpresponse_code=>httpresponse_code:

def from_camel(name):
    """
    ThisIsCamelCase ==> this_is_camel_case
    """
    name = name.replace("_", "")
    _cas = lambda _x : [_i.isupper() for _i in _x]
    seq = zip(_cas(name[1:-1]), _cas(name[2:]))
    ss = [_x + 1 for _x, (_i, _j) in enumerate(seq) if (_i, _j) == (False, True)]
    return "".join([ch + "_" if _x in ss else ch for _x, ch in numerate(name.lower())])

Bez biblioteki:

def camelify(out):
    return (''.join(["_"+x.lower() if i<len(out)-1 and x.isupper() and out[i+1].islower()
         else x.lower()+"_" if i<len(out)-1 and x.islower() and out[i+1].isupper()
         else x.lower() for i,x in enumerate(list(out))])).lstrip('_').replace('__','_')

Trochę ciężki, ale

CamelCamelCamelCase ->  camel_camel_camel_case
HTTPRequest         ->  http_request
GetHTTPRequest      ->  get_http_request
getHTTPRequest      ->  get_http_request

Bardzo ładny RegEx zaproponowany na tej stronie :

(?<!^)(?=[A-Z])

Jeśli python ma metodę String Split, powinna ona działać...

W Języku Java:

String s = "loremIpsum";
words = s.split("(?<!^)(?=[A-Z])");

Ta prosta metoda powinna wykonać zadanie:

import re

def convert(name):
    return re.sub(r'([A-Z]*)([A-Z][a-z]+)', lambda x: (x.group(1) + '_' if x.group(1) else '') + x.group(2) + '_', name).rstrip('_').lower()

• szukamy wielkich liter, które są poprzedzone dowolną liczbą (lub zerem) wielkich liter, a następnie dowolną liczbą małych znaków.
• podkreślenie jest umieszczane tuż przed wystąpieniem ostatniej wielkiej litery znalezionej w grupie, i można je umieścić przed tą wielką literą, jeśli jest poprzedzona innymi wielkimi literami.
• jeśli są końcowe podkreślniki, usuń je.
• Wreszcie, cały łańcuch wyniku zostanie zmieniony na małe litery.

(zaczerpnięte z tutaj , Zobacz przykład pracy online )

def convert(name):
    return reduce(
        lambda x, y: x + ('_' if y.isupper() else '') + y, 
        name
    ).lower()

A jeśli chcemy przykryć sprawę z już-nie-cameled input:

def convert(name):
    return reduce(
        lambda x, y: x + ('_' if y.isupper() and not x.endswith('_') else '') + y, 
        name
    ).lower()

def convert(camel_str):
    temp_list = []
    for letter in camel_str:
        if letter.islower():
            temp_list.append(letter)
        else:
            temp_list.append('_')
            temp_list.append(letter)
    result = "".join(temp_list)
    return result.lower()

Na wypadek, gdyby ktoś musiał przekształcić kompletny plik źródłowy, oto skrypt, który to zrobi.

# Copy and paste your camel case code in the string below
camelCaseCode ="""
    cv2.Matx33d ComputeZoomMatrix(const cv2.Point2d & zoomCenter, double zoomRatio)
    {
      auto mat = cv2.Matx33d::eye();
      mat(0, 0) = zoomRatio;
      mat(1, 1) = zoomRatio;
      mat(0, 2) = zoomCenter.x * (1. - zoomRatio);
      mat(1, 2) = zoomCenter.y * (1. - zoomRatio);
      return mat;
    }
"""

import re
def snake_case(name):
    s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
    return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()

def lines(str):
    return str.split("\n")

def unlines(lst):
    return "\n".join(lst)

def words(str):
    return str.split(" ")

def unwords(lst):
    return " ".join(lst)

def map_partial(function):
    return lambda values : [  function(v) for v in values]

import functools
def compose(*functions):
    return functools.reduce(lambda f, g: lambda x: f(g(x)), functions, lambda x: x)

snake_case_code = compose(
    unlines ,
    map_partial(unwords),
    map_partial(map_partial(snake_case)),
    map_partial(words),
    lines
)
print(snake_case_code(camelCaseCode))

[[2]}miałem z tym całkiem sporo szczęścia:

import re
def camelcase_to_underscore(s):
    return re.sub(r'(^|[a-z])([A-Z])',
                  lambda m: '_'.join([i.lower() for i in m.groups() if i]),
                  s)

To oczywiście może być zoptymalizowane dla prędkości a mały bit, jeśli chcesz.

import re

CC2US_RE = re.compile(r'(^|[a-z])([A-Z])')

def _replace(match):
    return '_'.join([i.lower() for i in match.groups() if i])

def camelcase_to_underscores(s):
    return CC2US_RE.sub(_replace, s)

Użyj: str.capitalize() Aby przekonwertować pierwszą literę łańcucha (zawartą w zmiennej str) na wielką literę i zwraca cały łańcuch.

Przykład: Polecenie: "Witam".kapitalizuj() Wyjście: Hello