Conversión de caja de serpiente a caja de camello inferior (lowerCamelCase)

¿Cuál sería una buena manera de convertir de mayúsculas y minúsculas ( my_string) a mayúsculas y minúsculas (myString) en Python 2.7?

La solución obvia es dividir por subrayado, poner en mayúscula cada palabra excepto la primera y volver a unir.

Sin embargo, tengo curiosidad por conocer otras soluciones más idiomáticas o una forma de usar RegExppara lograr esto (¿con algún modificador de caso?)

def to_camel_case(snake_str):
    components = snake_str.split('_')
    # We capitalize the first letter of each component except the first one
    # with the 'title' method and join them together.
    return components[0] + ''.join(x.title() for x in components[1:])

Ejemplo:

In [11]: to_camel_case('snake_case')
Out[11]: 'snakeCase'

Aquí hay otra toma, que solo funciona en Python 3.5 y versiones posteriores:

def camel(snake_str):
    first, *others = snake_str.split('_')
    return ''.join([first.lower(), *map(str.title, others)])

Obligatorio one-liner:

import string

def to_camel_case(s):
    return s[0].lower() + string.capwords(s, sep='_').replace('_', '')[1:] if s else s

>>> snake_case = "this_is_a_snake_case_string"
>>> l = snake_case.split("_")
>>> print l[0] + "".join(map(str.capitalize, l[1:]))
'thisIsASnakeCaseString'

otro trazador de líneas

def to_camel_case(snake_string):
    return snake_string.title().replace("_", "")

Un poco tarde para esto, pero encontré esto en / r / python hace un par de días:

pip install pyhumps

y luego puedes hacer:

import humps

humps.camelize('jack_in_the_box')  # jackInTheBox
# or
humps.decamelize('rubyTuesdays')  # ruby_tuesdays
# or
humps.pascalize('red_robin')  # RedRobin

Sobre la base de la respuesta de Steve, esta versión debería funcionar:

def to_camel_case(snake_case_string):
    titleCaseVersion =  snake_case_string.title().replace("_", "")
    camelCaseVersion = titleCaseVersion[0].lower() + titleCaseVersion[1:]
    return camelCaseVersion

Aquí hay una solución que usa expresiones regulares:

import re

def snake_to_camel(text):
    return re.sub('_([a-zA-Z0-9])', lambda m: m.group(1).upper(), text)

def to_camel_case(snake_str):
    components = snake_str.split('_')
    return reduce(lambda x, y: x + y.title(), components[1:], components[0])

Sin usar listas por comprensión:

def snake_to_camel_case(text_snake):
    return '{}{}'.format(
        text_snake[:1].lower(),
        text_snake.title().replace('_', '')[1:],
    )

Así que necesitaba convertir un archivo completo con un montón de parámetros de caso de serpiente en caso de camello. La solución de Mathieu Rodic funcionó mejor. Gracias.

Aquí hay un pequeño script para usarlo en archivos.

import re

f = open("in.txt", "r")
words = f.read()

def to_camel_case3(s):
    return re.sub(r'_([a-z])', lambda x: x.group(1).upper(), s)

f = open("out.txt", "w")
f.write(to_camel_case3(words))

def toCamel(snake)
    return ''.join( word.capitalize()
                    for word in snake.split('_') )

Permita que el subrayado sea escapado por un subrayado anterior (por ejemplo, 'Escaped__snake' se convertiría en 'Escaped_Snake', mientras que 'usual_snake' se convierte en 'UsualSnake'. Incluya la prueba ternaria para espacios en blanco.

def toCamel(escaped_snake)
    return ''.join( (word.capitalize(), '_')[word=='')
                    for word in escaped_snake.split('_') )

No use mayúsculas en el primer segmento (es decir, 'tHERE_is_a_snake' se convierte en 'thereIsASnake')

def toCamel(esCAPed_snake)
    words = esCAPed_snake.split('_')
    return words[0].lower() + ''.join( (word.capitalize(), '_')[word=='')
                                       for word in words[1:] )

También se tocamelcasepuede convertir fácilmente de estuche de serpiente a estuche de camello.

Instalar en pc

$ pip install tocamelcase

y luego puedes usarlo así:

import tocamelcase

print(tocamelcase.convert("non_camel_case"))
# -> non_camel_case → NonCamelCase

También existe decamelizela inversa de este módulo.