Elegante Python-Funktion zur Umwandlung von CamelCase in snake_case?

Question

Exemple :

>>> convert('CamelCase')
'camel_case'

Answer 1

Ich suchte nach einer Lösung für dasselbe Problem, nur dass ich eine Kette brauchte; z.B.

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

Ausgehend von den netten Zwei-Wort-Lösungen hier, habe ich mir folgendes ausgedacht:

"-".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"))

Der größte Teil der komplizierten Logik besteht darin, die Kleinschreibung des ersten Wortes zu vermeiden. Hier ist eine einfachere Version, wenn es Ihnen nichts ausmacht, das erste Wort zu ändern:

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

Natürlich können Sie die regulären Ausdrücke vorkompilieren oder mit einem Unterstrich anstelle eines Bindestrichs verbinden, wie in den anderen Lösungen beschrieben.

Answer 2

Prägnant ohne reguläre Ausdrücke, aber HTTPResponseCode=> 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())])

Answer 3

Wow, das habe ich gerade von django snippets geklaut. ref http://djangosnippets.org/snippets/585/

Ziemlich elegant

camelcase_to_underscore = lambda str: re.sub(r'(?<=[a-z])[A-Z]|[A-Z](?=[^A-Z])', r'_\g<0>', str).lower().strip('_')

Exemple :

camelcase_to_underscore('ThisUser')

Rückgabe:

'this_user'

REGEX DEMO

Answer 4

Hier ist etwas, das ich getan habe, um die Kopfzeilen in einer tabulatorgetrennten Datei zu ändern. Ich lasse den Teil weg, in dem ich nur die erste Zeile der Datei bearbeitet habe. Man könnte das mit der re-Bibliothek ziemlich einfach an Python anpassen. Dabei werden auch die Zahlen herausgetrennt (aber die Ziffern bleiben zusammen). Ich habe es in zwei Schritten gemacht, weil das einfacher war, als dem Programm zu sagen, dass es keinen Unterstrich an den Anfang einer Zeile oder einen Tabulator setzen soll.

Schritt Eins: Suchen Sie Großbuchstaben oder ganze Zahlen, denen Kleinbuchstaben vorangestellt sind, und stellen Sie ihnen einen Unterstrich voran:

Suche:

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

Ersetzen:

\1_\l\2/

Schritt zwei: Führen Sie das obige Programm erneut aus, um alle Großbuchstaben in Kleinbuchstaben umzuwandeln:

Suche:

([A-Z])

Ersetzung (Backslash, Kleinbuchstabe L, Backslash, Eins):

\l\1

Answer 5

Für den Fall, dass jemand eine komplette Quelldatei umwandeln muss, finden Sie hier ein Skript, das dies ermöglicht.

# 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))