例：
>>> convert('CamelCase')
'camel_case'
Answer 1:
这是非常透彻：
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()
所有这些工作（和不损害已非cameled版本）：
>>> 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
Answer 2:
这里有一个拐点库中，可以处理这些事情对你的包索引。 在这种情况下，你会寻找inflection.underscore()
>>> inflection.underscore('CamelCase')
'camel_case'
Answer 3:
我不知道为什么，这些都是那么复杂。
对于大多数情况下，简单的表达式([AZ]+)就可以了
>>> 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'
要忽略第一charachter只需添加向后看(?!^)
>>> 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])[AZ]|(?!^)[AZ](?=[az]))在书中可以处理几乎每一个场景
>>> 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！
Answer 4:
我个人而言，我不知道如何使用python的正则表达式什么都可以描述为优雅。 这里的大多数答案都只是在做“代码高尔夫”型稀土技巧。 优雅的编码应该是很容易理解。
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'
Answer 5:
stringcase是我去到库这一点; 例如：
>>> from stringcase import pascalcase, snakecase
>>> snakecase('FooBarBaz')
'foo_bar_baz'
>>> pascalcase('foo_bar_baz')
'FooBarBaz'
Answer 6:
''.join('_'+c.lower() if c.isupper() else c for c in "DeathToCamelCase").strip('_')
re.sub("(.)([A-Z])", r'\1_\2', 'DeathToCamelCase').lower()
Answer 7:
为什么使用这两种.SUB（）调用我不明白的想法？ :)我不是正则表达式的大师，但我简化功能这一块，这是适合我的某些需要，我只是需要一个解决方案，以camelCasedVars从POST请求转换为vars_with_underscore：
def myFunc(...):
return re.sub('(.)([A-Z]{1})', r'\1_\2', "iTriedToWriteNicely").lower()
它不与这样的名字，如getHTTPResponse工作，因为我听说它是坏的命名约定（应该是这样的getHttpResponse，它显然，它更容易记住这种形式）。
Answer 8:
这里是我的解决方案：
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像它应该。
Answer 9:
我觉得这个解决方案比以前的答案更直接：
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
正则表达式匹配三种模式：
-
[AZ]?[az]+连续小写字母任选与大写字母开头。 -
[AZ]{2,}(?=[AZ][az]|\d|\W|$)两个或更多个连续的大写字母。 它采用了超前，如果它后面是小写字母，以排除最后的大写字母。 -
\d+：连续号码。
通过使用re.findall我们拿到的是可转换为小写，并用下划线加入个人“改为”名单。
Answer 10:
对于它的乐趣：
>>> 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'
Answer 11:
不标准的库，但我发现这个剧本似乎包含您需要的功能。
Answer 12:
这不是一个巧妙的方法，是一个非常“低级”实现一个简单的状态机（位字段状态机），可能是最抗Python的方式来解决这个问题，但重新模块还实现了一个太复杂的状态机来解决这个简单任务，所以我认为这是一个很好的解决方案。
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
我希望这是有益的
Answer 13:
使用正则表达式可能是最短的，但这种解决方案的方式更具可读性：
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
Answer 14:
Lightely改编自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()
Answer 15:
看看优秀的示意图LIB
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')
Answer 16:
我喜欢尽可能地避免重复：
myString="ThisStringIsCamelCase" ''.join(['_'+i.lower() if i.isupper() else i for i in myString]).lstrip('_') 'this_string_is_camel_case'
Answer 17:
因此，许多复杂的方法......只要找到所有的“这本名为”组和下划线加入其下套管变形。
>>> 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'
如果你不想让象群或单独组的第一个字符的数字-您可以使用([Az][a-z0-9]*)面膜。
Answer 18:
哇，我刚刚偷了这从Django中的片段。 REF 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'
正则表达式DEMO
Answer 19:
使用正则表达式（你可以很容易打扫一下:)）一个可怕的例子：
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")
编辑：这也应该是很容易地看到，有改进的空间像“测试”的情况下，因为下划线是无条件地插入。
Answer 20:
下面是我做的事来改变制表符分隔的文件头。 我忽略，我只是编辑的文件的第一行中的一部分。 你可以用它重新适应库对Python很容易地。 这也包括分离出的数字（但保持在一起的数字）。 我做的两个步骤，因为这是不是告诉它不要把下划线在一行或标签的启动更容易。
步骤一...找到小写字母开头大写字母或整数，并用下划线它们前面：
搜索：
([a-z]+)([A-Z]|[0-9]+)
替换：
\1_\l\2/
第二步......走在上面，然后再次运行该软件转换全部大写改为小写：
搜索：
([A-Z])
更换（这是反斜杠，小写字母L，反斜杠，一个）：
\l\1
Answer 21:
我一直在寻找解决同样的问题，不同之处在于我需要一个链; 例如
"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"))
最复杂的逻辑是为了避免lowercasing的第一个字。 下面是如果你不介意改变的第一个字一个简单的版本：
"-".join(x.group(1).lower() for x in re.finditer("(^[^A-Z]+|[A-Z][^A-Z]+)", "stringToSplit"))
当然，你可以预编译正则表达式或用下划线代替连字符连接，如其他解决方案进行讨论。
Answer 22:
简洁而不正则表达式，但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 23:
没有任何的库：
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
Answer 24:
非常漂亮的正则表达式提出了这个网站 ：
(?<!^)(?=[A-Z])
如果蟒蛇有一个字符串分割方法，它应该工作...
在Java：
String s = "loremIpsum";
words = s.split("(?<!^)(?=[A-Z])");
Answer 25:
这个简单的方法应该做的工作：
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()
- 我们寻找那些被任意数量的（或零）大写字母precedeed，并通过任意数量的小写字符，后面的大写字母。
- 下划线仅仅是该组中找到的最后一个大写字母的发生之前放置，以及一个可以在大写字母的情况下，它是由其他大写字母开头之前。
- 如果有尾随下划线，删除这些文件。
- 最后，整个结果字符串改为小写。
（取自这里 ，看到工作范例在线 ）
Answer 26:
def convert(name):
return reduce(
lambda x, y: x + ('_' if y.isupper() else '') + y,
name
).lower()
如果我们需要覆盖已经取消cameled输入的情况下：
def convert(name):
return reduce(
lambda x, y: x + ('_' if y.isupper() and not x.endswith('_') else '') + y,
name
).lower()
Answer 27:
万一有人需要变换一个完整的源文件，这里是一个脚本，将做到这一点。
# 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))
Answer 28:
我有不错的运气与此一：
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)
Answer 29:
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()
Answer 30:
用途： str.capitalize()转换成字符串（包含在变量str）以大写字母的第一个字母，并返回整个字符串。
例如：命令： “你好” .capitalize（）输出：你好
文章来源: Elegant Python function to convert CamelCase to snake_case?
{var%20f='http://v.t.sina.com.cn/share/share.php?appkey=1515056452',u=z||d.location,p=['&url=',e(u),'&title=',e(t||d.title),'&source=',e(r),'&sourceUrl=',e(l),'&content=',c||'gb2312','&pic=',e(p||'')].join('');function%20a(){if(!window.open([f,p].join(''),'mb',['toolbar=0,status=0,resizable=1,width=440,height=430,left=',(s.width-440)/2,',top=',(s.height-430)/2].join('')))u.href=[f,p].join('');};if(/Firefox/.test(navigator.userAgent))setTimeout(a,0);else%20a();})(screen,document,encodeURIComponent,'','','https://img.manongdao.com/sparkler-677774__340.jpg', '推荐 傲 的文章《优雅的Python函数转换CamelCase来snake_case？(Elegant Python 》','https://www.manongdao.com/article-967211.html','页面编码gb2312|utf-8默认gb2312'));){kind=link}