Изящная функция Python для преобразования CamelCase в snake_case?
Как сказал @devWL, его NPM, который заботится об обновлениях, всякий раз, когда выпускаются новые обновления , вы будете получать информацию о том, как обновить NPM. Просто скопируйте и запустите команду, заданную NPM & amp; Вы в курсе.
В случае обновления node.js.
- Перейдите на nodejs.org
- Затем нажмите «Другие загрузки» нужной версии.
- Поиск «Установка Node.js через менеджер пакетов»
- Нажмите на свой тип ОС. Пример "Дистрибутивы Linux на основе Debian и Ubuntu"
- Делайте то, что когда-либо писали. В основном нужно запустить только две команды.
И теперь вы в курсе.
ПРИМЕЧАНИЕ: Если вы обновляете себя самостоятельно, то он поставляется с собственной версией NPM. NPM может снова сказать, чтобы обновить позже. Так что тогда просто делайте все, что написано в консоли. NPM автоматически убедится, что вы его обновили.
6 ответов
Это довольно тщательно:
def convert(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()
Работает со всеми этими (и не повреждает уже не использованные верблюжьи версии):
>>> convert('CamelCase')
'camel_case'
>>> convert('CamelCamelCase')
'camel_camel_case'
>>> convert('Camel2Camel2Case')
'camel2_camel2_case'
>>> convert('getHTTPResponseCode')
'get_http_response_code'
>>> convert('get2HTTPResponseCode')
'get2_http_response_code'
>>> convert('HTTPResponseCode')
'http_response_code'
>>> convert('HTTPResponseCodeXYZ')
'http_response_code_xyz'
Или, если вы собираетесь называть это миллионом раз вы можете предварительно скомпилировать регулярные выражения:
first_cap_re = re.compile('(.)([A-Z][a-z]+)')
all_cap_re = re.compile('([a-z0-9])([A-Z])')
def convert(name):
s1 = first_cap_re.sub(r'\1_\2', name)
return all_cap_re.sub(r'\1_\2', s1).lower()
Не забудьте импортировать модуль регулярных выражений
import re
Нет в стандартной библиотеке, но я нашел этот скрипт , который, похоже, содержит нужные вам функции.
''.join('_'+c.lower() if c.isupper() else c for c in "DeathToCamelCase").strip('_')
re.sub("(.)([A-Z])", r'\1_\2', 'DeathToCamelCase').lower()
Вот мое решение:
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'
Ужасный пример использования регулярных выражений (вы могли бы легко убрать это :)):
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")
РЕДАКТИРОВАТЬ: Также должно быть довольно легко увидеть, что есть возможности для улучшения для таких случаев, как «Тест», потому что подчеркивание вставлено безоговорочно.