Elegant Python function to convert CamelCase to snake case

Question

Example    gt  gt  gt  convert  CamelCase    camel case

User · Answer

Concise without regular expressions  but HTTPResponseCode   httpresponse code   def from camel name               ThisIsCamelCase    gt  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

User · Answer

So many complicated methods    Just find all  Titled  group and join its lower cased variant with underscore    gt  gt  gt  import re  gt  gt  gt  def camel to snake string           groups   re findall    A-z0-9  a-z      string          return     join  i lower   for i in groups        gt  gt  gt  camel to snake  ABCPingPongByTheWay2KWhereIsOurBorderlands3       a b c ping pong by the way 2 k where is our borderlands 3    If you don t want make numbers like first character of group or separate group - you can use   A-z  a-z0-9    mask

User · Answer

Avoiding libraries and regular expressions  def camel to snake s       return    join      c lower   if c isupper   else c for c in s   lstrip        gt  gt  gt  camel to snake  ThisIsMyString    this is my string

User · Answer

Here s something I did to change the headers on a tab-delimited file  I m omitting the part where I only edited the first line of the file  You could adapt it to Python pretty easily with the re library  This also includes separating out numbers  but keeps the digits together   I did it in two steps because that was easier than telling it not to put an underscore at the start of a line or tab   Step One   find uppercase letters or integers preceded by lowercase letters  and precede them with an underscore   Search     a-z     A-Z   0-9      Replacement    1  l 2    Step Two   take the above and run it again to convert all caps to lowercase   Search     A-Z     Replacement  that s backslash  lowercase L  backslash  one     l 1

User · Answer

I think this solution is more straightforward than previous answers   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     Which outputs   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   The regular expression matches three patterns     A-Z   a-z    Consecutive lower-case letters that optionally start with an upper-case letter   A-Z  2      A-Z  a-z   d  W     Two or more consecutive upper-case letters  It uses a lookahead to exclude the last upper-case letter if it is followed by a lower-case letter   d   Consecutive numbers    By using re findall we get a list of individual  words  that can be converted to lower-case and joined with underscores

User · Answer

This simple method should do the job   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      We look for capital letters that are precedeed by any number of  or zero  capital letters  and followed by any number of lowercase characters  An underscore is placed just before the occurence of the last capital letter found in the group  and one can be placed before that capital letter in case it is preceded by other capital letters  If there are trailing underscores  remove those  Finally  the whole result string is changed to lower case     taken from here  see working example online

User · Answer

Camel case to snake case import re  name    CamelCaseName  name   re sub r    lt        A-Z          name  lower   print name     camel case name  If you do this many times and the above is slow  compile the regex beforehand  pattern   re compile r    lt        A-Z     name   pattern sub      name  lower    To handle more advanced cases specially  this is not reversible anymore   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  Snake case to camel case name    snake case name  name      join word title   for word in name split       print name     SnakeCaseName

User · Answer

Using regexes may be the shortest  but this solution is way more readable   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

User · Answer

Very nice RegEx proposed on this site      lt        A-Z     If python have a String Split method  it should work     In Java   String s    loremIpsum   words   s split     amp  60        A-Z

User · Answer

I don t get idea why using both  sub   calls     I m not regex guru  but I simplified function to this one  which is suitable for my certain needs  I just needed a solution to convert camelCasedVars from POST request to vars with underscore    def myFunc         return re sub       A-Z  1     r  1  2    iTriedToWriteNicely   lower     It does not work with such names like getHTTPResponse  cause I heard it is bad naming convention  should be like getHttpResponse  it s obviously  that it s much easier memorize this form

User · Answer

This is not a elegant method  is a very  low level  implementation of a simple state machine  bitfield state machine   possibly the most anti pythonic mode to resolve this   however re module also implements a too complex state machine to resolve this simple task  so i think this is a good solution   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  amp  1                  yield s si ci                  si   ci             elif state  amp  2                  yield s si ci - 1                  si   ci - 1             state   4   8   16             ci    1          elif c isupper                if state  amp  4                  yield s si ci                  si   ci             if state  amp  32                  state   2   8   16   32             else                  state   8   16   32              ci    1          elif c isdigit                if state  amp  8                  yield s si ci                  si   ci             state   1   4   16             ci    1          else              if state  amp  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 can parses all case types  UpperSEQUENCEInterleaved  under score  BIG SYMBOLS and cammelCasedMethods  I hope it is useful

User · Answer

I don t know why these are all so complicating   for most cases  the simple expression   A-Z    will do the trick   gt  gt  gt  re sub    A-Z      r   1   CamelCase   lower     camel case     gt  gt  gt  re sub    A-Z      r   1   camelCase   lower    camel case   gt  gt  gt  re sub    A-Z      r   1   camel2Case2   lower    camel2 case2   gt  gt  gt  re sub    A-Z      r   1   camelCamelCase   lower    camel camel case   gt  gt  gt  re sub    A-Z      r   1   getHTTPResponseCode   lower    get httpresponse code    To ignore the first character simply add look behind         gt  gt  gt  re sub         A-Z      r   1   CamelCase   lower    camel case   gt  gt  gt  re sub         A-Z      r   1   CamelCamelCase   lower    camel camel case   gt  gt  gt  re sub         A-Z      r   1   Camel2Camel2Case   lower    camel2 camel2 case   gt  gt  gt  re sub         A-Z      r   1   getHTTPResponseCode   lower    get httpresponse code    If you want to separate ALLCaps to all caps and expect numbers in your string you still don t need to do two separate runs just use   This expression     lt   a-z0-9   A-Z        A-Z     a-z    can handle just about every scenario in the book   gt  gt  gt  a   re compile      lt   a-z0-9   A-Z        A-Z     a-z       gt  gt  gt  a sub r   1    getHTTPResponseCode   lower    get http response code   gt  gt  gt  a sub r   1    get2HTTPResponseCode   lower    get2 http response code   gt  gt  gt  a sub r   1    get2HTTPResponse123Code   lower    get2 http response123 code   gt  gt  gt  a sub r   1    HTTPResponseCode   lower    http response code   gt  gt  gt  a sub r   1    HTTPResponseCodeXYZ   lower    http response code xyz    It all depends on what you want so use the solution that best suits your needs as it should not be overly complicated   nJoy

User · Answer

join     c lower   if c isupper   else c for c in  DeathToCamelCase   strip      re sub       A-Z     r  1  2    DeathToCamelCase   lower

User · Answer

Not in the standard library  but I found this module that appears to contain the functionality you need

User · Answer

There s an inflection library in the package index that can handle these things for you  In this case  you d be looking for inflection underscore      gt  gt  gt  inflection underscore  CamelCase    camel case

User · Answer

Use  str capitalize   to convert first letter of the string  contained in variable str  to a capital letter and returns the entire string   Example  Command   hello  capitalize    Output  Hello

User · Answer

I have had pretty good luck with this one   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    This could obviously be optimized for speed a tiny bit if you want to   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

User · Answer

stringcase is my go-to library for this  e g     gt  gt  gt  from stringcase import pascalcase  snakecase  gt  gt  gt  snakecase  FooBarBaz    foo bar baz   gt  gt  gt  pascalcase  foo bar baz    FooBarBaz

User · Answer

I was looking for a solution to the same problem  except that I needed a chain  e g    CamelCamelCamelCase  - gt   Camel-camel-camel-case    Starting from the nice two-word solutions here  I came up with the following    -  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      Most of the complicated logic is to avoid lowercasing the first word   Here s a simpler version if you don t mind altering the first word    -  join x group 1  lower   for x in re finditer      A-Z    A-Z   A-Z       stringToSplit      Of course  you can pre-compile the regular expressions or join with underscore instead of hyphen  as discussed in the other solutions

User · Answer

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

User · Answer

Without any library    def camelify out       return     join      x lower   if i lt len out -1 and x isupper   and out i 1  islower            else x lower       if i lt len out -1 and x islower   and out i 1  isupper            else x lower   for i x in enumerate list out      lstrip      replace             A bit heavy  but  CamelCamelCamelCase - gt   camel camel camel case HTTPRequest         - gt   http request GetHTTPRequest      - gt   get http request getHTTPRequest      - gt   get http request

User · Answer

Here s my solution   def un camel text           Converts a CamelCase name into an under score name             gt  gt  gt  un camel  CamelCase            camel case           gt  gt  gt  un camel  getHTTPResponseCode            get http response code              result          pos   0     while pos  lt  len text           if text pos  isupper                if pos-1  gt  0 and text pos-1  islower   or pos-1  gt  0 and               pos 1  lt  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    It supports those corner cases discussed in the comments  For instance  it ll convert getHTTPResponseCode to get http response code like it should

User · Answer

Just in case someone needs to transform a complete source file  here is a script that will do it     Copy and paste your camel case code in the string below camelCaseCode          cv2 Matx33d ComputeZoomMatrix const cv2 Point2d  amp  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

User · Answer

Take a look at the excellent Schematics lib   https   github com schematics schematics  It allows you to created typed data structures that can serialize deserialize from python to Javascript flavour  eg   class MapPrice Model       price before vat   DecimalType serialized name  priceBeforeVat       vat rate   DecimalType serialized name  vatRate       vat   DecimalType       total price   DecimalType serialized name  totalPrice

User · Answer

def convert name       return reduce          lambda x  y  x        if y isupper   else       y           name       lower     And if we need to cover a case with already-un-cameled input   def convert name       return reduce          lambda x  y  x        if y isupper   and not x endswith      else       y           name       lower

User · Answer

Lightely adapted from https   stackoverflow com users 267781 matth who use generators   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

User · Answer

Personally I am not sure how anything using regular expressions in python can be described as elegant  Most answers here are just doing  code golf  type RE tricks  Elegant coding is supposed to be easily understood   def to snake case not snake case       final          for i in xrange len not snake case            item   not snake case i          if i  lt  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   gt  gt  gt  to snake case  RegularExpressionsAreFunky    regular expressions are funky    gt  gt  gt  to snake case  RegularExpressionsAre Funky    regular expressions are funky    gt  gt  gt  to snake case  RegularExpressionsAre Funky    regular expressions are funky

User · Answer

A horrendous example using regular expressions  you could easily clean this up        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     Works for getHTTPResponseCode though   Alternatively  using 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     EDIT  It should also be pretty easy to see that there s room for improvement for cases like  Test   because the underscore is unconditionally inserted

User · Answer

Wow I just stole this from django snippets  ref http   djangosnippets org snippets 585   Pretty elegant   camelcase to underscore   lambda str  re sub r    lt   a-z   A-Z   A-Z      A-Z     r   g lt 0 gt    str  lower   strip        Example   camelcase to underscore  ThisUser     Returns    this user    REGEX DEMO

User · Answer

For the fun of it    gt  gt  gt  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       gt  gt  gt  un camel  camel case    camel case   gt  gt  gt  un camel  CamelCase    camel case    Or  more for the fun of it    gt  gt  gt  un camel   lambda i  i 0  lower     str join            c lower   if c in  ABCDEFGHIJKLMNOPQRSTUVWXYZ  else c for c in i 1      gt  gt  gt  un camel  camel case    camel case   gt  gt  gt  un camel  CamelCase    camel case

[python] Elegant Python function to convert CamelCase to snake_case?

Examples related to python

Examples related to camelcasing