Пример:
>>> convert('CamelCase')
'camel_case'
NotCamelCase
ноthisIs
Пример:
>>> convert('CamelCase')
'camel_case'
NotCamelCase
ноthisIs
Ответы:
import re
name = 'CamelCaseName'
name = re.sub(r'(?<!^)(?=[A-Z])', '_', name).lower()
print(name) # camel_case_name
Если вы делаете это много раз, а вышеприведенное медленно, скомпилируйте регулярное выражение заранее:
pattern = re.compile(r'(?<!^)(?=[A-Z])')
name = pattern.sub('_', name).lower()
Специально для обработки более сложных случаев (это уже необратимо):
def camel_to_snake(name):
name = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
return re.sub('([a-z0-9])([A-Z])', r'\1_\2', name).lower()
print(camel_to_snake('camel2_camel2_case')) # camel2_camel2_case
print(camel_to_snake('getHTTPResponseCode')) # get_http_response_code
print(camel_to_snake('HTTPResponseCodeXYZ')) # http_response_code_xyz
name = 'snake_case_name'
name = ''.join(word.title() for word in name.split('_'))
print(name) # SnakeCaseName
not_camel_case
в notCamelCase
и / или NotCamelCase
?
s2.replace('__', '_')
В индексе пакета есть библиотека перегибов, которая может обработать эти вещи для вас. В этом случае вы будете искать inflection.underscore()
:
>>> inflection.underscore('CamelCase')
'camel_case'
Я не знаю, почему все это так сложно.
в большинстве случаев простое выражение ([A-Z]+)
поможет
>>> 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'
Чтобы игнорировать первый символ, просто добавьте взгляд позади (?!^)
>>> 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'
Если вы хотите отделить ALLCaps от all_caps и ожидать чисел в вашей строке, вам все равно не нужно выполнять два отдельных запуска, просто используйте |
это выражение, которое ((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z]))
может обрабатывать практически все сценарии в книге
>>> 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'
Все зависит от того, что вы хотите, поэтому используйте решение, которое наилучшим образом соответствует вашим потребностям, поскольку оно не должно быть слишком сложным.
NJoy!
(?!^)
выражением, которое называли «оглядывающимся сзади». Если я чего-то не упустил, то, что мы действительно хотим здесь, это негативный взгляд, который должен быть выражен как (?<!^)
. По причинам, которые я не могу понять, твой негативный прогноз, (?!^)
похоже, тоже работает ...
"Camel2WARNING_Case_CASE"
становится "camel2_warning_case__case"
. Вы можете добавить (?<!_)
отрицательный взгляд назад, чтобы решить: re.sub('((?<=[a-z0-9])[A-Z]|(?!^)(?<!_)[A-Z](?=[a-z]))', r'_\1', "Camel2WARNING_Case_CASE").lower()
возвращение 'camel2_warning_case_case'
(?!^)
неправильно были названы «взглядом позади», и вместо этого должны были быть названы негативным прогнозом . Как показывает это приятное объяснение , негативные взгляды обычно появляются после искомого выражения. Таким образом, вы можете думать (?!^)
как «найти, ''
где <start of string>
не следует». В самом деле, отрицательный взгляд также работает: вы можете думать, (?<!^)
как «найти, ''
где <start of string>
не предшествует».
stringcase - моя библиотека для этого; например:
>>> from stringcase import pascalcase, snakecase
>>> snakecase('FooBarBaz')
'foo_bar_baz'
>>> pascalcase('foo_bar_baz')
'FooBarBaz'
Я предпочитаю избегать, re
если возможно:
def to_camelcase(s):
return ''.join(['_' + c.lower() if c.isupper() else c for c in s]).lstrip('_')
>>> to_camelcase("ThisStringIsCamelCase")
'this_string_is_camel_case'
re
библиотеку и не выполняет всю работу в одну строку, используя только встроенные методы str.methods! Это похоже на этот ответ , но избегает использования нарезки и дополнительных if ... else
, просто убирая потенциально добавленный «_» в качестве первого символа. Мне это нравится больше всего.
6.81 µs ± 22.5 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
но за этот ответ, 2.51 µs ± 25.5 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
который в 2,5 раза быстрее! Люблю это!
Лично я не уверен, что что-либо, использующее регулярные выражения в python, может быть описано как элегантное. Большинство ответов здесь просто делают трюки типа «Code Golf» типа RE. Предполагается, что элегантное кодирование легко понять.
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()
это в конце. Или в этом случае просто присоединитесь к нему с подчеркиванием ...
Я думаю, что это решение является более простым, чем предыдущие ответы:
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))
Какие выводы:
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
Регулярное выражение соответствует трем шаблонам:
[A-Z]?[a-z]+
Последовательные строчные буквы, которые необязательно начинаются с заглавной буквы.[A-Z]{2,}(?=[A-Z][a-z]|\d|\W|$)
: Две или более последовательных заглавных буквы. Он использует заглядывание, чтобы исключить последнюю заглавную букву, если за ней следует строчная буква.\d+
: Последовательные номера.Используя, re.findall
мы получаем список отдельных «слов», которые можно преобразовать в нижний регистр и объединить с подчеркиванием.
Я не понимаю, зачем использовать оба вызова .sub ()? :) Я не гуру регулярных выражений, но я упростил функцию до этой, которая подходит для моих определенных потребностей, мне просто нужно решение для преобразования camelCasedVars из запроса POST в vars_with_underscore:
def myFunc(...):
return re.sub('(.)([A-Z]{1})', r'\1_\2', "iTriedToWriteNicely").lower()
Он не работает с такими именами, как getHTTPResponse, потому что я слышал, что это плохое соглашение об именах (должно быть, как getHttpResponse, очевидно, что эту форму гораздо легче запомнить).
'HTTPConnectionFactory'
, ваш код производит 'h_tt_pconnection_factory'
, код из принятого ответа производит'http_connection_factory'
Вот мое решение:
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)
Это поддерживает те угловые случаи, обсужденные в комментариях. Например, он будет преобразован getHTTPResponseCode
в get_http_response_code
как надо.
Для удовольствия:
>>> 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'
Или, больше для удовольствия:
>>> 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'
str.join
осуждается целую вечность . Используйте ''.join(..)
вместо этого.
Использование регулярных выражений может быть самым коротким, но это решение более читабельно:
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
Так много сложных методов ... Просто найдите всю группу "Titled" и присоедините ее вариант в нижнем регистре с подчеркиванием.
>>> 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'
Если вы не хотите, чтобы цифры были похожи на первый символ группы или отдельной группы - вы можете использовать ([A-z][a-z0-9]*)
маску.
Не в стандартной библиотеке, но я обнаружил, что этот скрипт содержит необходимые вам функции.
Это не элегантный метод, это реализация очень низкого уровня простого конечного автомата (конечного автомата с битовым полем), возможно, наиболее анти-питонический режим для решения этой проблемы, однако модуль re также реализует слишком сложный конечный автомат для решения этого простого задача, так что я думаю, что это хорошее решение.
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 может анализировать все типы дел: UpperSEQUENCEInterleaved, under_score, BIG_SYMBOLS и cammelCasedMethods
Надеюсь это полезно
Легко адаптировано из https://stackoverflow.com/users/267781/matth, которые используют генераторы.
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()
Взгляните на превосходную библиотеку Schematics
https://github.com/schematics/schematics
Это позволяет вам создавать типизированные структуры данных, которые могут сериализовать / десериализовать от Python до Javascript, например:
class MapPrice(Model):
price_before_vat = DecimalType(serialized_name='priceBeforeVat')
vat_rate = DecimalType(serialized_name='vatRate')
vat = DecimalType()
total_price = DecimalType(serialized_name='totalPrice')
Этот простой метод должен сделать работу:
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()
(взято отсюда , см. рабочий пример онлайн )
Вау, я только что украл это из фрагментов Джанго. ссылка http://djangosnippets.org/snippets/585/
Довольно элегантно
camelcase_to_underscore = lambda str: re.sub(r'(?<=[a-z])[A-Z]|[A-Z](?=[^A-Z])', r'_\g<0>', str).lower().strip('_')
Пример:
camelcase_to_underscore('ThisUser')
Возвращает:
'this_user'
Ужасный пример с использованием регулярных выражений (это можно легко очистить :)):
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")
Работает для getHTTPResponseCode, хотя!
В качестве альтернативы, используя лямбду:
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")
РЕДАКТИРОВАТЬ: также должно быть довольно легко увидеть, что есть место для улучшений для таких случаев, как «Тест», потому что подчеркивание безоговорочно вставляется.
Вот что я сделал, чтобы изменить заголовки файла с разделителями табуляции. Я опускаю ту часть, где я редактировал только первую строку файла. Вы можете легко адаптировать его к Python с помощью библиотеки re. Это также включает в себя разделение чисел (но сохраняет цифры вместе). Я сделал это в два этапа, потому что это было проще, чем указывать не ставить подчеркивание в начале строки или табуляции.
Шаг первый ... найдите заглавные буквы или целые числа, перед которыми стоят строчные буквы, и поставьте перед ними подчеркивание:
Поиск:
([a-z]+)([A-Z]|[0-9]+)
Замена:
\1_\l\2/
Шаг второй ... возьмите приведенное выше и запустите его снова, чтобы преобразовать все заглавные буквы в нижний регистр:
Поиск:
([A-Z])
Замена (это обратный слеш, строчные буквы L, обратный слеш, один):
\l\1
Я искал решение той же проблемы, за исключением того, что мне нужна была цепочка; например
"CamelCamelCamelCase" -> "Camel-camel-camel-case"
Начав с хороших двухсловных решений, я придумал следующее:
"-".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"))
Большая часть сложной логики заключается в том, чтобы не допускать ввод первого слова в нижнем регистре. Вот более простая версия, если вы не против изменить первое слово:
"-".join(x.group(1).lower() for x in re.finditer("(^[^A-Z]+|[A-Z][^A-Z]+)", "stringToSplit"))
Конечно, вы можете предварительно скомпилировать регулярные выражения или объединить с подчеркиванием вместо дефиса, как обсуждалось в других решениях.
Кратко без регулярных выражений, но 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())])
Без какой-либо библиотеки:
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('__','_')
Немного тяжелый, но
CamelCamelCamelCase -> camel_camel_camel_case
HTTPRequest -> http_request
GetHTTPRequest -> get_http_request
getHTTPRequest -> get_http_request
Очень хороший RegEx предложил на этом сайте :
(?<!^)(?=[A-Z])
Если у python есть метод String Split, он должен работать ...
В Java:
String s = "loremIpsum";
words = s.split("(?<!^)(?=[A-Z])");
На случай, если кому-то понадобится преобразовать полный исходный файл, вот скрипт, который это сделает.
# 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))
Мне очень повезло с этим:
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)
Это может быть , очевидно , оптимизировано для скорости на крошечные немного , если вы хотите.
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)
Использование: str.capitalize()
для преобразования первой буквы строки (содержащейся в переменной str) в заглавную букву и возвращает всю строку.
Пример: Команда: "привет" .capitalize () Вывод: Привет