CODEWITHSUNDEEP
pythonregexcamelcasing
Dexter
Dexter

Reputation: 11841

Check for camel case in Python

I would like to check if a string is a camel case or not (boolean). I am inclined to use a regex but any other elegant solution would work. I wrote a simple regex 

(?:[A-Z])(?:[a-z])+(?:[A-Z])(?:[a-z])+

Would this be correct? Or am I missing something?

Edit

I would like to capture names in a collection of text documents of the format 

McDowell
O'Connor
T.Kasting

Edit2

I have modified my regex based on the suggestion in the comments

(?:[A-Z])(?:\S?)+(?:[A-Z])(?:[a-z])+

Upvotes: 11

Views: 22258

Answers (8)

Thingamabobs
Thingamabobs

Reputation: 8057

CamelCase

is the practice of writing phrases without spaces or punctuation, indicating the separation of words with a single capitalized letter

def iscamelcase(string):
    non_alpha = [i for i in string if not i.isalpha()]
    substrings= string.translate({ord(i): ' ' for i in non_alpha}).split(' ')
    for string in substrings:
        if not all(char.isupper() for char in string):
            for idx,i in enumerate(string):
                if i.isupper() and idx > 0:
                    return True
    return False
  1. search the string for other signs than charackters and store in non_alpha
  2. replace all non_alpha signs with empty space and split them by empty space to create substrings
  3. Check all substrings to be not fully uppercase and if not the index of the uppercase cant be >0

Output

camel False
camelCase True
CamelCase True
CAMELCASE False
camelcase False
Camelcase False
Case False
camel_case False

Upvotes: 0

Tobias P. G.
Tobias P. G.

Reputation: 820

This regex solution worked for my use case ([A-Z][a-z\S]+)([A-Z][a-z]+)

Upvotes: 0

user3064538
user3064538

Reputation:

Convert your string to camel case using a library like inflection. If it doesn't change, it must've already been camel case.

from inflection import camelize

def is_camel_case(s):
    # return True for both 'CamelCase' and 'camelCase'
    return camelize(s) == s or camelize(s, False) == s

Upvotes: 2

Chidi
Chidi

Reputation: 991

if you do not want strings starting with upper-case e.g Case and Camelcase to pass True. edit @william's answer:

def is_camel_case(s):
  if s != s.lower() and s != s.upper() and "_" not in s and sum(i.isupper() for i in s[1:-1]) == 1:
      return True
  return False



tests = [
"camel",
"camelCase",
"CamelCase",
"CAMELCASE",
"camelcase",
"Camelcase",
"Case",
"camel_case",
]

for test in tests:
   print(test, is_camel_case(test))

the results:

camel False
camelCase True
CamelCase True
CAMELCASE False
camelcase False
Camelcase False
Case False
camel_case False

Upvotes: 3

William Bettridge-Radford
William Bettridge-Radford

Reputation: 2602

You could check if a string has both upper and lowercase.

def is_camel_case(s):
    return s != s.lower() and s != s.upper() and "_" not in s


tests = [
    "camel",
    "camelCase",
    "CamelCase",
    "CAMELCASE",
    "camelcase",
    "Camelcase",
    "Case",
    "camel_case",
]

for test in tests:
    print(test, is_camel_case(test))

Output:

camel False
camelCase True
CamelCase True
CAMELCASE False
camelcase False
Camelcase True
Case True
camel_case False

Upvotes: 19

Santosh Magadum
Santosh Magadum

Reputation: 39

sub_string= 'hiSantyWhereAreYou'  `Change the string here and try`
index=[x for x,y in enumerate(list(sub_string)) if(y.isupper())] `Finding the index 
of caps`
camel_=[]
temp=0
for m in index:
    camel_.append(sub_string[temp:m])
    temp=m
if(len(index)>0):
    camel_.append(sub_string[index[-1]::])
    print('The individual camel case words are', camel_) `Output is in list`
else:
    camel_.append(sub_string)
    print('The given string is not camel Case')

Upvotes: 0

Ben
Ben

Reputation: 673

I think you might get away with just checking that the string has a capital with a lower case letter before it if(line =~ m/[a-z][A-Z]/). Just checking lower and upper fails on the given examples. ~Ben

Upvotes: 0

Qtax
Qtax

Reputation: 33908

You probably want something more like:

(?:[A-Z][a-z]*)+

Altho that would allow all caps. You could avoid that with:

(?:[A-Z][a-z]+)+

Anchor the expression with ^ and $ or \z if required.

Upvotes: 3

Related Questions