my_stringपाइथन 2.7 में साँप के मामले ( ) को कम ऊँट के मामले (myString) से बदलने का एक अच्छा तरीका क्या होगा ?
स्पष्ट समाधान अंडरस्कोर द्वारा विभाजित करना है, पहले एक को छोड़कर प्रत्येक शब्द को कैपिटल करें और वापस एक साथ जुड़ें।
हालांकि, मैं अन्य, अधिक मुहावरेदार समाधान या RegExpइसे प्राप्त करने के लिए उपयोग करने का एक तरीका (कुछ मामले संशोधक के साथ) के लिए उत्सुक हूं ?
जवाबों:
def to_camel_case(snake_str):
components = snake_str.split('_')
# We capitalize the first letter of each component except the first one
# with the 'title' method and join them together.
return components[0] + ''.join(x.title() for x in components[1:])
उदाहरण:
In [11]: to_camel_case('snake_case')
Out[11]: 'snakeCase'
to_camel_caseसुनिश्चित करने की जिम्मेदारी नहीं है कि इनपुट एक स्ट्रिंग है, यह कॉलिंग कोड की जिम्मेदारी है। एक गैर-स्ट्रिंग पास करना एक अपवाद को बढ़ाएगा, जो अच्छा है। यही अपवाद हैं।
None। आप किसी एक त्रुटि को रोक नहीं सकते। यदि आप इसे आजमाते हैं तो आप केवल इसके स्रोत को ही समाप्त कर देंगे। वह पायथन है, जावा नहीं। आपको अपवादों से बचना नहीं है, आपको उनका इलाज करना होगा।
_barबनने की उम्मीद barकरते हैं Bar, तो थोड़ा components = snake_str.lstrip('_').split('_')
यहाँ अभी तक एक और टेक है, जो केवल पायथन 3.5 और उच्चतर में काम करता है:
def camel(snake_str):
first, *others = snake_str.split('_')
return ''.join([first.lower(), *map(str.title, others)])
join(...)से बेहतर है join([...]), क्योंकि यह सूची बनाए बिना काम करता है)।
joinविधि को जो पारित किया गया है वह एक समझ नहीं बल्कि एक नियमित सूची है। यदि आप इन-मेमरी लिस्ट बनाने से बचना चाहते हैं, जिसका आप उपयोग कर सकते हैं itertools.chain, लेकिन तब अगर आप सांप को ऊँट के मामले में परिवर्तित करते समय मेमोरी फुटप्रिंट के बारे में चिंतित हैं तो आपको बहुत बड़ी समस्याएं हैं। ;-)
अनिवार्य एक-लाइनर:
import string
def to_camel_case(s):
return s[0].lower() + string.capwords(s, sep='_').replace('_', '')[1:] if s else s
return re.sub(r'_([a-z])', lambda x: x.group(1).upper(), name) (यहां देखें)
इसमें थोड़ी देर हो गई, लेकिन मैंने कुछ दिन पहले इस पर / आर / अजगर को पाया:
pip install pyhumps
और फिर आप बस कर सकते हैं:
import humps
humps.camelize('jack_in_the_box') # jackInTheBox
# or
humps.decamelize('rubyTuesdays') # ruby_tuesdays
# or
humps.pascalize('red_robin') # RedRobin
यहाँ नियमित अभिव्यक्ति का उपयोग कर एक समाधान है:
import re
def snake_to_camel(text):
return re.sub('_([a-zA-Z0-9])', lambda m: m.group(1).upper(), text)
def to_camel_case(snake_str):
components = snake_str.split('_')
return reduce(lambda x, y: x + y.title(), components[1:], components[0])
सूची समझ का उपयोग किए बिना:
def snake_to_camel_case(text_snake):
return '{}{}'.format(
text_snake[:1].lower(),
text_snake.title().replace('_', '')[1:],
)
इसलिए मुझे सांप के मामले के मापदंडों के साथ एक पूरी फाइल को ऊंट मामले में बदलने की जरूरत थी। मैथ्यू रोडिक के समाधान ने सबसे अच्छा काम किया। धन्यवाद।
यहाँ फ़ाइलों पर इसका उपयोग करने के लिए एक छोटी स्क्रिप्ट है।
import re
f = open("in.txt", "r")
words = f.read()
def to_camel_case3(s):
return re.sub(r'_([a-z])', lambda x: x.group(1).upper(), s)
f = open("out.txt", "w")
f.write(to_camel_case3(words))
def toCamel(snake)
return ''.join( word.capitalize()
for word in snake.split('_') )
पूर्ववर्ती अंडरस्कोर से बचने के लिए अंडरस्कोर की अनुमति दें (जैसे 'Escaped__snake' 'Escaped_Snake' बन जाएगा, जबकि 'normal_snake' 'UsualSnake' बन जाता है। रिक्त के लिए टेनरी परीक्षण शामिल करें।
def toCamel(escaped_snake)
return ''.join( (word.capitalize(), '_')[word=='')
for word in escaped_snake.split('_') )
1 सेगमेंट को कैपिटल न करें (यानी, 'tHERE_is_a_snake' बन जाता है 'उसके बाद')
def toCamel(esCAPed_snake)
words = esCAPed_snake.split('_')
return words[0].lower() + ''.join( (word.capitalize(), '_')[word=='')
for word in words[1:] )
tocamelcaseसांप के मामले से ऊंट मामले में आसानी से परिवर्तित होने के लिए भी है।
$ pip install tocamelcase
और फिर आप इसे इस तरह से उपयोग कर सकते हैं:
import tocamelcase
print(tocamelcase.convert("non_camel_case"))
# -> non_camel_case → NonCamelCase
वहाँ भी है decamelizeकि इस मॉड्यूल का उलटा है।