पायथन में टाइटल केस में स्ट्रिंग कैसे कन्वर्ट करें?

Question

उदाहरण:

HILO -> Hilo
new york -> New York
SAN FRANCISCO -> San Francisco

क्या इस कार्य को करने के लिए कोई पुस्तकालय या मानक तरीका है?

Comments

यह "कैमलकेस" नहीं है, यह "कैपिटलाइज़" है; तुम्हें कौनसा चाहिए?

— एंड्रयू मार्शल

camelCase यह है।

— जोनाथन एम

आपके उदाहरण PascalCase का उपयोग करते हैं।

— डेविड बेट्ज़

Answer 1

titleडॉक्स से राइट का उपयोग क्यों न करें :

>>> "they're bill's friends from the UK".title()
"They'Re Bill'S Friends From The Uk"

यदि आप वास्तव में पास्कलकेस चाहते थे तो आप इसका उपयोग कर सकते हैं:

>>> ''.join(x for x in 'make IT pascal CaSe'.title() if not x.isspace())
'MakeItPascalCase'

Comments

मुझे लगता है कि "आर" में "वे" कम मामले होना चाहिए। और "बिल" में 'एस' निश्चित रूप से कम मामला होना चाहिए।

— डेनियल फिशर

@ डैनियल - उस मुद्दे के लिए डॉक्स में नोट किया गया है title: "एल्गोरिथ्म एक साधारण भाषा-स्वतंत्र परिभाषा का उपयोग करता है, जो लगातार अक्षरों के समूहों के रूप में होता है। परिभाषा कई संदर्भों में काम करती है, लेकिन इसका मतलब है कि संकुचन और अधिकार शब्द सीमाओं में एपोस्ट्रोफ्स। जो वांछित परिणाम नहीं हो सकता है ”। एक संभव समाधान होगा रेगेक्स के साथ लॉरेंस के जवाब का उपयोग r"['\w]+"करना ताकि एपोस्ट्रोफ एक मैच समाप्त न हो (अतिरिक्त विराम चिह्न आवश्यकतानुसार जोड़ा जा सके)।

— एंड्रयू क्लार्क

रिकॉर्ड के लिए, पिछले CamelCase उदाहरण के लिए एक शून्य तरीका है 'make IT camel CaSe'.title().replace(' ', '')।

— हेनरी गोमरसेल

अगर किसी और को लगता है कि वे पागल गोलियों पर हैं - यह पास्कलकेस है, न कि कैमलकेस।

— रॉब

अच्छा कोड है, लेकिन camelCase एक CAPITAL के साथ शुरू नहीं होता है। इसे def toCamel(s): ret = ''.join(x for x in s.title() if not x.isspace()) return ret[0].lower() + ret[1:] toCamel("WRITE this in camelcase") 'writeThisInCamelcase'

— आजमाइए

Answer 2

यह हमेशा लोअरकेस के साथ शुरू होता है, और गैर अल्फ़ान्यूमेरिक वर्णों को भी स्ट्रिप करता है:

def camelCase(st):
    output = ''.join(x for x in st.title() if x.isalnum())
    return output[0].lower() + output[1:]

Answer 3

def capitalizeWords(s):
  return re.sub(r'\w+', lambda m:m.group(0).capitalize(), s)

re.sub"प्रतिस्थापन" के लिए एक फ़ंक्शन ले सकता है (केवल एक स्ट्रिंग के बजाय, जिसका उपयोग अधिकांश लोगों को परिचित लगता है)। इस उत्तर फ़ंक्शन को re.Matchपैटर्न के प्रत्येक मैच के लिए एक ऑब्जेक्ट के साथ बुलाया जाएगा , और परिणाम (जो एक स्ट्रिंग होना चाहिए) का उपयोग उस मैच के प्रतिस्थापन के रूप में किया जाएगा।

एक ही बात का एक लंबा संस्करण:

WORD_RE = re.compile(r'\w+')

def capitalizeMatch(m):
  return m.group(0).capitalize()

def capitalizeWords(s):
  return WORD_RE.sub(capitalizeMatch, s)

यह पूर्व पैटर्न (आमतौर पर अच्छा रूप माना जाता है) को संकलित करता है और लैम्बडा के बजाय नामित फ़ंक्शन का उपयोग करता है।

Comments

यह बहुत साफ-सुथरा है, मैं अपने सिर को लंबोदर कार्यों के आसपास लाने की कोशिश कर रहा हूं, मदद करने के लिए धन्यवाद

— दिवास्वप्न

@JohnMachin मैंने सिर्फ इसलिए पूछा क्योंकि मुझे लगा कि कुछ स्पष्टीकरण जोड़ने से आपका उत्तर अधिक पूर्ण और बेहतर हो जाएगा।

— एनएन

@ लॉरेंस गोंसाल्वेस यहां लंबा क्या कर रहा है?

— सिय्योन

लंबोदर यहां क्या कर रहा है? wha से मैं समझ सकता हूँ और आप से स्पष्टीकरण। यह वही है जो मुझे समझ में आया। जब आप re.sub में फ़ंक्शन का उपयोग करते हैं, तो प्रत्येक matchफ़ंक्शन को दिया जाएगा? और चूंकि matchesनियमित अभिव्यक्तियों में समूह होते हैं। यह लाइन क्यों मौजूद है lambda m:m.group(0).capitalize()?

— Zion

@ जय हो। जब re.subकॉल करने योग्य (जैसे: एक फ़ंक्शन) को "प्रतिस्थापन" के रूप में दिया जाता है, तो यह उस कॉल करने योग्य के लिए मैच ऑब्जेक्ट को पास करता है, और एक स्ट्रिंग वापस पाने की उम्मीद करता है जो वास्तव में प्रतिस्थापन के रूप में उपयोग करता है। यदि आप लैम्ब्डा को भ्रमित करते हुए पाते हैं, तो "अधिक लंबा संस्करण" बिल्कुल वैसी ही क्रिया को अधिक क्रियात्मक तरीके से करता है।

— लॉरेंस गोंसाल्वेस

Answer 4

एक क्यों नहीं लिखा? ऐसा कुछ आपकी आवश्यकताओं को पूरा कर सकता है:

def FixCase(st):
    return ' '.join(''.join([w[0].upper(), w[1:].lower()]) for w in st.split())

Comments

धन्यवाद, कि पूरी तरह से मदद की। मेरा बुरा, मैं पहली जगह में एक लिखने के लिए नहीं सोचा था

— दिन में

Answer 5

नोट: मैं अभी तक एक और उत्तर क्यों प्रदान कर रहा हूं? यह उत्तर प्रश्न के शीर्षक पर आधारित है और यह धारणा कि ऊंट को परिभाषित किया गया है: शब्दों की एक श्रृंखला जिसे समाप्‍त नहीं किया गया है (कोई रिक्त स्थान नहीं!) जैसे कि मूल शब्दों में से प्रत्येक एक बड़े अक्षर से शुरू होता है (शेष लोअरकेस होता है) श्रृंखला के पहले शब्द को छोड़कर (जो पूरी तरह से लोअरकेस है)। यह भी माना जाता है कि "सभी तार" ASCII वर्ण सेट को संदर्भित करता है; यूनिकोड इस समाधान के साथ काम नहीं करेगा)।

सरल

उपरोक्त परिभाषा को देखते हुए, यह फ़ंक्शन

import re
word_regex_pattern = re.compile("[^A-Za-z]+")

def camel(chars):
  words = word_regex_pattern.split(chars)
  return "".join(w.lower() if i is 0 else w.title() for i, w in enumerate(words))

, जब कहा जाता है, इस तरीके से परिणाम होगा

camel("San Francisco")  # sanFrancisco
camel("SAN-FRANCISCO")  # sanFrancisco
camel("san_francisco")  # sanFrancisco

कम सरल

ध्यान दें कि यह विफल हो जाता है जब एक पहले से ही ऊंट आवरण स्ट्रिंग के साथ प्रस्तुत किया जाता है!

camel("sanFrancisco")   # sanfrancisco  <-- noted limitation

और भी कम सरल

ध्यान दें कि यह कई यूनिकोड स्ट्रिंग्स के साथ विफल हो जाता है

camel("México City")    # mXicoCity     <-- can't handle unicode

मेरे पास इन मामलों के लिए कोई समाधान नहीं है (या कुछ रचनात्मकता के साथ पेश किया जा सकता है)। तो, जैसा कि सभी चीजों में है, जो तार के साथ करना है, अपने स्वयं के किनारे के मामलों को कवर करें और यूनिकोड के साथ शुभकामनाएं!

Comments

आप यह कैसे निर्धारित कर सकते हैं कि वाक्य का अर्थ जाने बिना एक स्ट्रिंग ऊंट का मामला है? आपके "कम सरल" उदाहरण में, "sanfRancisco" ऊंट का मामला है और साथ ही साथ "itSnotcaMelcAn" भी है।

— पैट्रिस बर्नसोला जूल

मैं अनुमान लगा रहा हूं कि आपके इनपुट में एपोस्टोग्राफ या अन्य विराम चिह्न थे? मुझे अन्य विफल इनपुट पर ध्यान देना चाहिए। निश्चित रूप से एक अच्छा कैच। आपके द्वारा प्रदान किया गया इनपुट क्या था?

— मार्क

मेरा मतलब है कि अंतरिक्ष के बिना वर्णों के अनुक्रम को 1 शब्द के रूप में माना जाना चाहिए। आप वाक्य का अर्थ जाने बिना उससे काम नहीं निकाल सकते। Camello () के इनपुट के रूप में "sanfRancisco" या "itSnotcaMelcAse" डालें और आप देखेंगे कि आउटपुट समान होगा।

— पैट्रिस बर्नसोला

ओह, मैं देख रहा हूँ - हाँ, मुझे लगता है कि तुम सही हो। मैं समाधान से आगे निकल गया। मैं इसे अपडेट करूंगा।

— मार्क

Answer 6

संभावित पुस्तकालय: https://pypi.org/project/stringcase/

उदाहरण:

import stringcase
stringcase.camelcase('foo_bar_baz') # => "fooBarBaz"

हालांकि यह संदेहास्पद है कि क्या यह रिक्त स्थान छोड़ देगा। (उदाहरण यह दिखाते हैं कि यह अंतरिक्ष को हटा रहा है, लेकिन एक बग ट्रैकर मुद्दा है कि यह उन्हें अंदर छोड़ देता है।)

Comments

धत्त हां। पैकेज की तलाश में था। इस पैकेज में snakecase और अन्य रूपांतरण फ़ंक्शन भी हैं।

— s2t2

Answer 7

बस .title () का उपयोग करें, और यह राजधानी के हर शब्द के पहले अक्षर को बदल देगा, बाकी छोटे में:

>>> a='mohs shahid ss'
>>> a.title()
'Mohs Shahid Ss'
>>> a='TRUE'
>>> b=a.title()
>>> b
'True'
>>> eval(b)
True

Answer 8

मैं इस पोस्ट में अपना थोड़ा योगदान जोड़ना चाहूंगा:

def to_camelcase(str):
  return ' '.join([t.title() for t in str.split()])

Comments

दरअसल, str.title () एक ही है और आप कम्प्यूटेशनल लागत बचा रहे हैं।

— आउरोस 132

Answer 9

def camelCase(st):
    s = st.title()
    d = "".join(s.split())
    d = d.replace(d[0],d[0].lower())
    return d