例子：
>>> convert('CamelCase')
'camel_case'
问问题
255788 次
30 回答
1002
骆驼案到蛇案
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
还要添加带有两个或更多下划线的大小写：
def to_snake_case(name):
name = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
name = re.sub('__([A-Z])', r'_\1', name)
name = re.sub('([a-z0-9])([A-Z])', r'\1_\2', name)
return name.lower()
蛇案到骆驼案
name = 'snake_case_name'
name = ''.join(word.title() for word in name.split('_'))
print(name) # SnakeCaseName
于 2009-07-24T06:25:13.860 回答
255
包索引中有一个变形库可以为您处理这些事情。在这种情况下，您会寻找inflection.underscore()：
>>> inflection.underscore('CamelCase')
'camel_case'
于 2013-06-26T19:34:34.923 回答
137
我不知道为什么这些都这么复杂。
在大多数情况下，简单的表达式([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'
这完全取决于您想要什么，因此请使用最适合您需求的解决方案，因为它不应该过于复杂。
开心！
于 2012-10-12T21:17:16.130 回答
44
避免库和正则表达式：
def camel_to_snake(s):
return ''.join(['_'+c.lower() if c.isupper() else c for c in s]).lstrip('_')
>>> camel_to_snake('ThisIsMyString')
'this_is_my_string'
于 2017-07-07T11:13:58.527 回答
33
stringcase是我的首选库；例如：
>>> from stringcase import pascalcase, snakecase
>>> snakecase('FooBarBaz')
'foo_bar_baz'
>>> pascalcase('foo_bar_baz')
'FooBarBaz'
于 2017-04-05T23:42:51.750 回答
10
就我个人而言，我不确定在 python 中使用正则表达式的任何东西如何被描述为优雅。这里的大多数答案只是在做“代码高尔夫”类型的 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'
于 2013-11-12T22:05:05.353 回答
10
我认为这个解决方案比以前的答案更直接：
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，我们得到了一个单独的“单词”列表，这些单词可以转换为小写并用下划线连接。
于 2017-09-29T17:11:56.757 回答
7
''.join('_'+c.lower() if c.isupper() else c for c in "DeathToCamelCase").strip('_')
re.sub("(.)([A-Z])", r'\1_\2', 'DeathToCamelCase').lower()
于 2009-07-24T01:48:27.700 回答
5
我不明白为什么要同时使用 .sub() 调用？:) 我不是正则表达式大师，但我简化了这个函数，这适合我的某些需求，我只需要一个解决方案来将 camelCasedVars 从 POST 请求转换为 vars_with_underscore：
def myFunc(...):
return re.sub('(.)([A-Z]{1})', r'\1_\2', "iTriedToWriteNicely").lower()
它不适用于像 getHTTPResponse 这样的名称，因为我听说它的命名约定不好（应该像 getHttpResponse，很明显，它更容易记住这种形式）。
于 2012-11-13T15:39:08.303 回答
4
这是我的解决方案：
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应有的样子。
于 2009-07-24T02:09:28.967 回答
3
为了它的乐趣：
>>> 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'
于 2009-07-24T01:20:40.153 回答
3
使用正则表达式可能是最短的，但这个解决方案更具可读性：
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
于 2015-02-27T21:39:18.967 回答
2
这不是一个优雅的方法，是一个简单状态机（位域状态机）的非常“低级”的实现，可能是解决这个问题的最反 Python 模式，但是 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 可以解析所有 case 类型：UpperSEQUENCEInterleaved、under_score、BIG_SYMBOLS 和 cammelCasedMethods
我希望它有用
于 2013-02-16T17:58:52.753 回答
2
这么多复杂的方法......只需找到所有“标题”组并用下划线加入其小写变体。
>>> 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]*)掩码。
于 2018-05-01T12:41:24.533 回答
1
一个使用正则表达式的可怕例子（你可以很容易地清理它:)）：
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！
或者，使用 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")
编辑：也应该很容易看出像“测试”这样的情况还有改进的空间，因为下划线是无条件插入的。
于 2009-07-24T02:05:16.663 回答
1
这个简单的方法应该可以完成这项工作：
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()
- 我们查找前面有任意数量（或零个）大写字母，后跟任意数量小写字符的大写字母。
- 下划线放置在该组中最后一个大写字母的出现之前，并且可以在该大写字母之前放置一个下划线，以防它前面有其他大写字母。
- 如果有尾随下划线，请将其删除。
- 最后，整个结果字符串变为小写。
于 2015-11-04T08:06:03.690 回答
1
改编自 使用生成器的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()
于 2015-12-08T14:57:20.970 回答
1
看看优秀的 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')
于 2016-04-01T13:30:43.327 回答
0
哇，我刚刚从 django 片段中偷了这个。参考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'
于 2011-03-18T19:05:44.833 回答
0
在这个网站上提出了非常好的正则表达式：
(?<!^)(?=[A-Z])
如果 python 有一个 String Split 方法，它应该可以工作......
在 Java 中：
String s = "loremIpsum";
words = s.split("(?<!^)(?=[A-Z])");
于 2011-09-29T07:19:31.850 回答
0
这是我为更改制表符分隔文件的标题所做的事情。我省略了我只编辑文件第一行的部分。你可以很容易地使用 re 库来适应 Python。这还包括分离数字（但将数字保持在一起）。我分两步完成，因为这比告诉它不要在行或制表符的开头放置下划线要容易。
第一步...找到前面有小写字母的大写字母或整数，并在它们前面加上下划线：
搜索：
([a-z]+)([A-Z]|[0-9]+)
替换：
\1_\l\2/
第二步...执行上述操作并再次运行以将所有大写字母转换为小写：
搜索：
([A-Z])
替换（即反斜杠，小写 L，反斜杠，一）：
\l\1
于 2011-12-09T22:41:32.203 回答
0
我一直在寻找解决同一问题的方法，只是我需要一条链条；例如
"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"))
当然，您可以预编译正则表达式或使用下划线而不是连字符连接，如其他解决方案中所述。
于 2013-01-31T20:55:29.483 回答
0
简洁没有正则表达式，但是 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())])
于 2014-05-09T09:29:04.170 回答
0
没有任何图书馆：
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
于 2015-08-27T14:27:01.313 回答
0
以防万一有人需要转换完整的源文件，这里有一个脚本可以做到。
# 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))
于 2018-03-18T15:29:31.950 回答
-1
不在标准库中，但我发现这个模块似乎包含您需要的功能。
于 2009-07-24T00:27:58.027 回答
-1
我在这个方面运气不错：
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)
于 2012-06-11T18:17:16.580 回答
-1
def convert(name):
return reduce(
lambda x, y: x + ('_' if y.isupper() else '') + y,
name
).lower()
如果我们需要覆盖一个已经没有骆驼的输入的案例：
def convert(name):
return reduce(
lambda x, y: x + ('_' if y.isupper() and not x.endswith('_') else '') + y,
name
).lower()
于 2017-07-13T08:52:54.483 回答
-2
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()
于 2018-01-06T05:18:27.950 回答
-5
用途：str.capitalize()将字符串的第一个字母（包含在变量 str 中）转换为大写字母并返回整个字符串。
示例：命令：“hello”.capitalize() 输出：Hello
于 2015-08-18T06:07:33.170 回答