एक स्ट्रिंग में प्रत्येक शब्द के पहले अक्षर को कैसे कैपिटल करें?

Question

s = 'the brown fox'

... यहाँ कुछ करो ...

s होना चाहिए :

'The Brown Fox'

ऐसा करने का सबसे आसान तरीका क्या है?

Answer 1

.title()एक स्ट्रिंग की विधि (या तो ASCII या यूनिकोड ठीक है) ऐसा करती है:

>>> "hello world".title()
'Hello World'
>>> u"hello world".title()
u'Hello World'

हालाँकि, एम्बेडेड apostrophes के साथ तार के लिए बाहर देखो, के रूप में डॉक्स में उल्लेख किया।

एल्गोरिथ्म एक शब्द की एक सरल भाषा-स्वतंत्र परिभाषा का उपयोग करता है जो लगातार अक्षरों के समूहों के रूप में होता है। परिभाषा कई संदर्भों में काम करती है, लेकिन इसका मतलब है कि संकुचन और संपत्ति में apostrophes शब्द सीमाएँ बनाते हैं, जो वांछित परिणाम नहीं हो सकता है:

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

Comments

मैं कुछ के साथ समस्याग्रस्त समस्या से " ".join(w.capitalize() for w in s.split())

— बचता हूं

यह अधिकांश तारों के लिए सुरक्षित नहीं है, क्योंकि प्रत्येक शब्द के पास भी अपरकेस मिलता है।

String.title () के साथ एक समस्या है। जब आप उपयोग करते हैं, उदाहरण के लिए, "e g 3b"वांछित परिणाम होगा "E G 3b"। हालांकि, "e g 3b".title()रिटर्न "E G 3B"।

— सोरेन

ध्यान रखें कि यह भी इसका कारण होगा:In [2]: 'tEst'.title() Out[2]: 'Test'

— जोनास लिब्रेब्रेच

महान जवाब, और टिप्पणियां इस बात पर प्रकाश डालती हैं कि अजगर में हर चीज उस तरीके का व्यवहार नहीं करती है जिसकी आपको आवश्यकता है, लेकिन इसे बनाने के लिए हमेशा सुविधाजनक तरीके हैं। सबसे सुविधाजनक तरीका अक्सर एक उद्देश्य-निर्मित पुस्तकालय आयात कर रहा है, जैसे कि अजगर-शीर्षक

— आरोन 3468

Answer 2

.title()विधि अच्छी तरह से काम नहीं कर सकते,

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

string.capwords()विधि का प्रयास करें ,

import string
string.capwords("they're bill's friends from the UK")
>>>"They're Bill's Friends From The Uk"

से capwords पर अजगर डॉक्स :

Str.split () का उपयोग करते हुए शब्दों में तर्क को विभाजित करें, str.capitalize () का उपयोग करके प्रत्येक शब्द को कैपिटल करें, और str.join () का उपयोग करके पूंजीकृत शब्दों में शामिल हों। यदि वैकल्पिक दूसरा तर्क एसईपी अनुपस्थित है या कोई भी नहीं है, तो व्हाट्सएप पात्रों के रन एक ही स्थान से बदल दिए जाते हैं और अग्रणी और अनुगामी व्हाट्सएप को हटा दिया जाता है, अन्यथा शब्दों को विभाजित करने और जुड़ने के लिए एसईपी का उपयोग किया जाता है।

Comments

Capwords की अभी भी कमी है और कुछ इस तरह से संभाल नहीं करता है "There once was a string with an 'that had words right after it and then closed'"। इस उदाहरण के thatसाथ उम्मीद के अनुसार सभी दुनिया को कैपिटल में रखा गया है। परिणाम"There Once Was A String With An 'that Had Words Right After It And Then Closed'"

— devonbleibtrey

फिर भी, यह title()सामान्य स्थितियों की तुलना में बेहतर काम करता है। मेरी स्थिति में, title()उच्चारण या डाइरेसिस के साथ नामों के लिए एक बुरा आउटपुट देता है, जबकि capwords()इसे सही तरीके से संभाला है।

— हॉकरोस

अच्छा है, लेकिन यह अभी भी "ब्रिटेन / ब्रिटेन" भेद को गड़बड़ करता है

— जॉननाथ पी

Answer 3

सिर्फ इसलिए कि इस तरह की बात मेरे लिए मजेदार है, यहां दो और समाधान हैं।

शब्दों में विभाजित करें, विभाजित समूहों से प्रत्येक शब्द को प्रारंभिक-कैप करें, और फिर से जोड़ दें। यह शब्दों को एक ही सफेद स्थान में अलग करने वाले सफेद स्थान को बदल देगा, चाहे वह कोई भी हो।

s = 'the brown fox'
lst = [word[0].upper() + word[1:] for word in s.split()]
s = " ".join(lst)

---

संपादित करें: मुझे याद नहीं है कि जब मैं उपरोक्त कोड लिखा था तब मैं क्या सोच रहा था, लेकिन एक स्पष्ट सूची बनाने की कोई आवश्यकता नहीं है; हम इसे आलसी फैशन में करने के लिए एक जनरेटर अभिव्यक्ति का उपयोग कर सकते हैं। तो यहाँ एक बेहतर समाधान है:

s = 'the brown fox'
s = ' '.join(word[0].upper() + word[1:] for word in s.split())

---

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

import re
s = 'the brown fox'

def repl_func(m):
    """process regular expression match groups for word upper-casing problem"""
    return m.group(1) + m.group(2).upper()

s = re.sub("(^|\s)(\S)", repl_func, s)


>>> re.sub("(^|\s)(\S)", repl_func, s)
"They're Bill's Friends From The UK"

मुझे खुशी है कि मैंने इस उत्तर पर शोध किया। मुझे पता नहीं था कि कोई re.sub()फंक्शन ले सकता है! आप re.sub()अंतिम परिणाम का उत्पादन करने के लिए अंदर प्रसंस्करण कर सकते हैं !

Comments

स्लाइस का उपयोग कर समाधान के लिए +1। मुझे कुछ ऐसी चीज़ों की ज़रूरत थी जो बाकी शब्दों के पूँजीकरण में बदलाव किए बिना पहले अक्षरों को बड़ा कर दे (जैसे फू फू बन जाता है, लेकिन FOO हो जाता है)। यह एकदम सही था।

— टॉमनीसेटवॉल्ड

पूंजीकृत अपने पहले चरित्र को बड़े पैमाने पर लौटाता है और बाकी को कम कर देता है

— वानुअन

@Vanuan, आप सही हैं! डॉक्टर स्ट्रिंग विवरण ने मुझे लगता है कि यह सब किया था पहले अक्षर को कैपिटलाइज़ किया गया था, लेकिन आप इसके बारे में सही हैं कि यह वास्तव में क्या करता है। मैं उत्तर संपादित करूँगा। सर ऊंचा रखने के लिए आपका आभार।

— चरणवेद

string.capwordsचेन होउवु के जवाब में प्रलेखन के अनुसार, ऐसा प्रतीत होता है ।

— एड्रियन कीस्टर

S.split () का उपयोग करने के बजाय उपरोक्त उत्तर में कुछ ध्यान दें, मुझे लगता है कि s.split ('') का उपयोग करना बेहतर है। ऐसा इसलिए है क्योंकि स्ट्रिंग में कुछ दोहरे स्थान हैं और आप जुड़ने पर उन दोहरे स्थानों को बनाए रखना चाहते हैं, s.plit ('') आपको स्पेस बनाए रखने में मदद करेगा, जबकि s.split () नहीं होगा

— manpikin

Answer 4

इसे करने के विभिन्न तरीकों का सारांश यहां दिया गया है, वे इन सभी इनपुटों के लिए काम करेंगे:

""           => ""       
"a b c"      => "A B C"             
"foO baR"    => "FoO BaR"      
"foo    bar" => "Foo    Bar"   
"foo's bar"  => "Foo's Bar"    
"foo's1bar"  => "Foo's1bar"    
"foo 1bar"   => "Foo 1bar"     

- सबसे सरल उपाय यह है कि वाक्य को शब्दों में विभाजित करें और पहले अक्षर को कैपिटल करें और फिर इसे एक साथ जोड़ दें:

# Be careful with multiple spaces, and empty strings
# for empty words w[0] would cause an index error, 
# but with w[:1] we get an empty string as desired
def cap_sentence(s):
  return ' '.join(w[:1].upper() + w[1:] for w in s.split(' ')) 

- यदि आप इनपुट स्ट्रिंग को पहले शब्दों में विभाजित नहीं करना चाहते हैं, और फैंसी जनरेटर का उपयोग कर रहे हैं:

# Iterate through each of the characters in the string and capitalize 
# the first char and any char after a blank space
from itertools import chain 
def cap_sentence(s):
  return ''.join( (c.upper() if prev == ' ' else c) for c, prev in zip(s, chain(' ', s)) )

- या आयात किए बिना itertools:

def cap_sentence(s):
  return ''.join( (c.upper() if i == 0 or s[i-1] == ' ' else c) for i, c in enumerate(s) )

- या आप स्टेपवे के उत्तर से नियमित अभिव्यक्ति का उपयोग कर सकते हैं :

# match the beginning of the string or a space, followed by a non-space
import re
def cap_sentence(s):
  return re.sub("(^|\s)(\S)", lambda m: m.group(1) + m.group(2).upper(), s)

---

अब, ये कुछ अन्य उत्तर हैं जो पोस्ट किए गए थे, और इनपुट जिनके लिए वे अपेक्षा के अनुरूप काम नहीं करते हैं यदि हम एक शब्द की परिभाषा का उपयोग वाक्य की शुरुआत या रिक्त स्थान के बाद कुछ भी कर रहे हैं:

  return s.title()

# Undesired outputs: 
"foO baR"    => "Foo Bar"       
"foo's bar"  => "Foo'S Bar" 
"foo's1bar"  => "Foo'S1Bar"     
"foo 1bar"   => "Foo 1Bar"      

---

  return ' '.join(w.capitalize() for w in s.split())    
  # or
  import string
  return string.capwords(s)

# Undesired outputs:
"foO baR"    => "Foo Bar"      
"foo    bar" => "Foo Bar"      

विभाजन के लिए '' का उपयोग करने से दूसरा आउटपुट ठीक हो जाएगा, लेकिन अभी भी पासवर्ड () पहले के लिए काम नहीं करेगा

  return ' '.join(w.capitalize() for w in s.split(' '))    
  # or
  import string
  return string.capwords(s, ' ')

# Undesired outputs:
"foO baR"    => "Foo Bar"      

---

कई रिक्त स्थानों के साथ सावधान रहें

  return ' '.join(w[0].upper() + w[1:] for w in s.split())
# Undesired outputs:
"foo    bar" => "Foo Bar"                 

Comments

एक व्यापक सारांश के लिए +1। मैं केवल एक संख्या (प्रत्येक शब्द नहीं) के बाद किसी शब्द को कैपिटलाइज़ करने का तरीका ढूंढ रहा हूं। क्या आप अपने उत्तर को जोड़ सकते हैं जो इसे प्रदर्शित करता है? ईजी lower 123 upperको वापस लौटना चाहिए lower 123 Upper, जहां upperयह संख्या के रूप में पूंजीकृत है। मुझे पता है कि यह ओपी के सवाल के दायरे से परे है लेकिन आपके पहले से ही व्यापक जवाब पर एक अच्छा ऐड है। अग्रिम में धन्यवाद।

— प्रोग्रामर

आप इस मामले में अपनी आवश्यकताओं के अनुरूप उपरोक्त कुछ तरीकों को संशोधित कर सकते हैं। हालाँकि, मैं इसे उत्तर के हिस्से के रूप में नहीं जोड़ूंगा क्योंकि यह वह नहीं है जो अधिकांश लोग खोज रहे हैं। मैं इसके लिए रेगेक्स संस्करण का उपयोग करूंगा, और "([0-9]+)(\s+.)"इसके स्थान पर "(^|\s)(\S)"(एक या अधिक संख्याओं का मिलान करूंगा , उसके बाद एक या एक से अधिक रिक्त स्थान, और किसी भी चार के बाद) का उपयोग कर "([0-9]+)(\s*.)"सकता हूं , या यदि आप 'शून्य या अधिक' रिक्त स्थान के बाद वर्ण को कैपिटल करना चाहते हैं। संख्या

— अलजगोम

मैं इस पर गौर करना सुनिश्चित करूंगा, जिसने एक और विशेष मामले के बारे में मेरा विचार बनाया: आप एक स्ट्रिंग, उदा WW1 - the great warऔर आउटपुट के WW1 - The Great Warबजाय ऊपर के स्निपेट्स को कैसे संशोधित करेंगे Ww1 ...। संक्षेप के साथ समस्या देखें? क्या आप इस मामले को प्रदर्शित करने के लिए कुछ जोड़ना चाहते हैं? मैं कुछ समय के लिए इस बारे में सोच रहा था और इसे करने का तरीका नहीं सोच सकता।

— प्रोग्रामर

ऊपर बताए गए पहले तरीके उन अक्षरों को नहीं बदलते हैं जो पहले से ही इनपुट स्ट्रिंग में कैपिटल थे, इसलिए WW1आउटपुट होगाWW1

— aljgom

Answer 5

कॉपी-पेस्ट-तैयार संस्करण @jibberia anwser:

def capitalize(line):
    return ' '.join(s[:1].upper() + s[1:] for s in line.split(' '))

Comments

सूची बनाने की आवश्यकता नहीं है। str.joinजनरेटर स्वीकार करता है।

— वारवरियुक

@warvariuc आप जेनरेटर का लाभ उठाने के लिए इस कोड को कैसे बदलेंगे?

— कॉन्सटेंटिन स्पिरिन

बस वर्ग कोष्ठक को हटा दें, जैसे कि यह यहाँ

— warvariuc

हालांकि @warvariuc उल्लेख करने में एकदम सही है कि joinजनरल एक्सप्रेशंस को स्वीकार करता है, str.joinविशेष रूप से, आमतौर पर यह एक सूची समझ का उपयोग करने के लिए पसंद किया जाता है। ऐसा इसलिए है क्योंकि joinतर्क पर दो बार पुनरावृत्त होता है, और इसलिए जनरेटर के बजाय रेडी-टू-गो सूची प्रदान करना तेज़ होता है।

— भार्गव राव

@BhargavRao str.joinको तर्क पर दो बार पुनरावृति की आवश्यकता क्यों होगी ? मैंने अभी-अभी जाँच की है। हालांकि छोटे अनुक्रमों की सूची की समझ वास्तव में तेज है।

— वार्वारिक

Answer 6

जब समाधान सरल और सुरक्षित है तो आप अपने जीवन को क्यों जोड़ते हैं और छोरों के लिए?

बस यह करें:

string = "the brown fox"
string[0].upper()+string[1:]

Comments

क्योंकि कई शब्द हो सकते हैं।

— अरनौद

हां, लेकिन अक्सर मैं केवल पहले अक्षर को भुनाना चाहता हूं। यह ऐसा करने का एक तरीका है।

— डेलेसेट

तुम तो बस का उपयोग नहीं करेंगे "the brown fox".capitalize()?

— १०:१६ को १२:०६

@luckydonald क्योंकि शायद मैं नहीं चाहता कि चालू करना चाहते हैं 'this is John'में 'This is john'।

— जनक

बस इसे करने का एक बेहतर तरीका नहीं है string.capitalize()(अनिवार्य रूप से @luckydonald echoing)

— हसन बेग

Answer 7

यदि str.title () आपके लिए काम नहीं करता है, तो अपने आप को बड़ा करें।

1. स्ट्रिंग को शब्दों की सूची में विभाजित करें
2. प्रत्येक शब्द के पहले अक्षर को कैपिटलाइज़ करें
3. शब्दों को एक स्ट्रिंग में शामिल करें

एक लाइन:

>>> ' '.join([s[0].upper() + s[1:] for s in "they're bill's friends from the UK".split(' ')])
"They're Bill's Friends From The UK"

स्पष्ट उदाहरण:

input = "they're bill's friends from the UK"
words = input.split(' ')
capitalized_words = []
for word in words:
    title_case_word = word[0].upper() + word[1:]
    capitalized_words.append(title_case_word)
output = ' '.join(capitalized_words)

Comments

इस समाधान के साथ रुचि का एक बिंदु यह है कि आप किसी विशेष व्हाट्सएप को खो देते हैं। संदर्भ के आधार पर महत्वपूर्ण नहीं हो सकता है।

— mklauber

Answer 8

यदि केवल आपको पहला अक्षर चाहिए:

>>> 'hello world'.capitalize()
'Hello world'

लेकिन प्रत्येक शब्द को भुनाने के लिए:

>>> 'hello world'.title()
'Hello World'

Comments

सावधान क्योंकि 'hello New York'.capitalize()है'Hello new york'

— user2314737

Answer 9

यदि आप [1:] का उपयोग करते हैं तो एक खाली स्ट्रिंग एक त्रुटि उठाएगी, इसलिए मैं उपयोग करूंगा:

def my_uppercase(title):
    if not title:
       return ''
    return title[0].upper() + title[1:]

केवल पहले अक्षर को अपरकेस करने के लिए।

Comments

क्या ऐसा नहीं है str.capitalize?

— यूजीन पखोमोव

@ यूजीन, हाँ, लेकिन दुर्भाग्य से, अन्य सभी पत्रों को कम कर देता है, जो वांछनीय नहीं हो सकते हैं। : /

— विम फिजेन

return title[:1].upper() + title[1:]उस समस्या का भी ध्यान रखेंगे क्योंकि खाली स्ट्रिंग को

— खिसकने से

Answer 10

जैसा कि मार्क ने बताया कि आपको उपयोग करना चाहिए .title():

"MyAwesomeString".title()

हालाँकि, यदि आप django टेम्पलेट के अंदर पहला अक्षर अपरकेस बनाना चाहते हैं, तो आप इसका उपयोग कर सकते हैं:

{{ "MyAwesomeString"|title }}

या एक चर का उपयोग कर:

{{ myvar|title }}

Answer 11

सुझाई गई विधि str.title () सभी मामलों में काम नहीं करती है। उदाहरण के लिए:

string = "a b 3c"
string.title()
> "A B 3C"

के बजाय "A B 3c"।

मुझे लगता है, इस तरह से कुछ करना बेहतर है:

def capitalize_words(string):
    words = string.split(" ") # just change the split(" ") method
    return ' '.join([word.capitalize() for word in words])

capitalize_words(string)
>'A B 3c'

Comments

हालाँकि, त्रुटि उत्पन्न हो सकती है यदि उन्हें अलग करने वाले रिक्त स्थान की संख्या 1. नहीं है। संदर्भ के लिए: हैकर्रानक समस्या

— दिवाकर राजेश

Answer 12

हालांकि सभी उत्तर पहले से ही संतोषजनक हैं, लेकिन मैं पिछले सभी मामलों के साथ 2 अतिरिक्त मामलों को कवर करने का प्रयास करूंगा।

यदि रिक्त स्थान एक समान नहीं हैं और आप समान बनाए रखना चाहते हैं

string = hello    world i  am    here.

यदि सभी स्ट्रिंग अक्षर से शुरू नहीं हो रहे हैं

string = 1 w 2 r 3g

यहां आप इसका उपयोग कर सकते हैं

def solve(s):
    a = s.split(' ')
    for i in range(len(a)):
        a[i]= a[i].capitalize()
    return ' '.join(a)

यह आपको देगा

output = Hello    World I  Am    Here
output = 1 W 2 R 3g

मुझे उम्मीद है कि यह बेमानी नहीं है।

Comments

गैर-समान स्थानों के मामले को उजागर करने के लिए धन्यवाद। उपरोक्त कुछ उत्तर s.split ('') के बजाय s.split () का उपयोग करते हैं। यह ध्यान रखना महत्वपूर्ण है कि गैर-समान स्थानों के लिए, s.split ('') का उपयोग करके यह सुनिश्चित किया जाएगा कि गैर-समान स्थान बनाए रखा जाए! धन्यवाद फिर से

— manpikin

यह पूरी तरह से असमान रिक्त स्थान वाले शब्दों या कुछ अंकों से शुरू होने वाले शब्दों के लिए काम करता है। धन्यवाद :)

— अमरेश गिरी

Answer 13

शब्दों को भुनाने के लिए ...

str = "this is string example....  wow!!!";
print "str.title() : ", str.title();

@ Gary02127 टिप्पणी, apostrophe के साथ समाधान कार्य शीर्षक के नीचे

import re

def titlecase(s):
    return re.sub(r"[A-Za-z]+('[A-Za-z]+)?", lambda mo: mo.group(0)[0].upper() + mo.group(0)[1:].lower(), s)

text = "He's an engineer, isn't he? SnippetBucket.com "
print(titlecase(text))

Comments

मौजूदा फ़ंक्शन का उपयोग करें अजगर में तेजी से निष्पादन देता है।

— तेजस टैंक

मैं शीर्षक का सुपर शौकीन नहीं हूँ (), क्योंकि यह एपोस्ट्रोफिस को संभालता नहीं है। "मैं नहीं कह सकता" .title () "I Can'T Say" देता है

— Gary02127

@ Gary02127 मैंने अद्यतन उत्तर दिया था, कृपया एक नज़र डालें, अपनी समस्या डोमेन के साथ भी सही काम किया

— तेजस टैंक

Answer 14

सफेद स्थान के संरक्षण को नजरअंदाज न करें। यदि आप संसाधित करना चाहते हैं 'fred flinstone'और आप 'Fred Flinstone'इसके बजाय प्राप्त करते हैं 'Fred Flinstone', तो आपने अपने सफेद स्थान को दूषित कर दिया है। उपरोक्त समाधानों में से कुछ सफेद स्थान खो देंगे। यहां एक समाधान है जो पायथन 2 और 3 के लिए अच्छा है और सफेद स्थान को संरक्षित करता है।

def propercase(s):
    return ''.join(map(''.capitalize, re.split(r'(\s+)', s)))

Answer 15

एक त्वरित कार्य पायथन 3 के लिए काम किया

Python 3.6.9 (default, Nov  7 2019, 10:44:02) 
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> capitalizeFirtChar = lambda s: s[:1].upper() + s[1:]
>>> print(capitalizeFirtChar('помните своих Предковъ. Сражайся за Правду и Справедливость!'))
Помните своих Предковъ. Сражайся за Правду и Справедливость!
>>> print(capitalizeFirtChar('хай живе вільна Україна! Хай живе Любовь поміж нас.'))
Хай живе вільна Україна! Хай живе Любовь поміж нас.
>>> print(capitalizeFirtChar('faith and Labour make Dreams come true.'))
Faith and Labour make Dreams come true.

Answer 16

गैर-समान स्थानों के साथ स्ट्रिंग कैपिटलाइज़ करें

ठीक है, मैं समझता हूं कि यह एक पुराना सवाल है और शायद उत्तर लगभग समाप्त हो गए होंगे, लेकिन मैं गैर-समान स्थानों पर @Amit गुप्ता के बिंदु को जोड़ना चाहूंगा। मूल प्रश्न से, हम स्ट्रिंग में प्रत्येक शब्द को कैपिटलाइज़ करना चाहेंगे s = 'the brown fox'। क्या होगा अगर स्ट्रिंग s = 'the brown fox'गैर-समान स्थानों के साथ थी ।

def solve(s):
    # if you want to maintain the spaces in the string, s = 'the brown      fox'
    # use s.split(' ') instead of s.split(). 
    # s.split() returns ['the', 'brown', 'fox']
    # while s.split(' ') returns ['the', 'brown', '', '', '', '', '', 'fox']
    capitalized_word_list = [word.capitalize() for word in s.split(' ')]
    return ' '.join(capitalized_word_list)

Comments

.. यदि आपका कोड भूरा और लोमड़ी के बीच नहीं

— व्हाट्सएप;

Answer 17

** मामले में आप को कम करना चाहते हैं **

 #Assuming you are opening a new file   
 with open(input_file) as file:
     lines = [x for x in reader(file) if x]
 #for loop to parse the file by line
 for line in lines:
           name = [x.strip().lower() for x in line if x]
           print(name) #check the result

Answer 18

मुझे वास्तव में यह उत्तर पसंद है:

कॉपी-पेस्ट-तैयार संस्करण @jibberia anwser:

def capitalize(line):
    return ' '.join([s[0].upper() + s[1:] for s in line.split(' ')])

लेकिन कुछ पंक्तियाँ जिन्हें मैं कुछ रिक्त '' वर्णों से अलग कर रहा था, जो s [1:] करने की कोशिश करते समय त्रुटियों का कारण बना। ऐसा करने के लिए शायद एक बेहतर तरीका है, लेकिन मुझे एक len (s)> 0 में जोड़ना था, जैसे कि

return ' '.join([s[0].upper() + s[1:] for s in line.split(' ') if len(s)>0])

Comments

यह बहुत जटिल है, wth आप भी लंबाई की जाँच के बारे में जाना ?! अक्षम।