Hoe kan ik de eerste letter van elk woord in een tekenreeks met een hoofdletter schrijven?

…doe hier iets…

smoet zijn:

'The Brown Fox'

Wat is de gemakkelijkste manier om dit te doen?

Antwoord 1, autoriteit 100%

De .title()methode van een string (ofwel ASCII of Unicode is prima) doet dit:

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

Let echter op tekenreeksen met ingesloten apostrofs, zoals vermeld in de documenten.

Het algoritme gebruikt een eenvoudige taalonafhankelijke definitie van een woord als groepen opeenvolgende letters. De definitie werkt in veel contexten, maar het betekent dat apostrofs in samentrekkingen en bezittelijke woorden woordgrenzen vormen, wat misschien niet het gewenste resultaat is:

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

Antwoord 2, autoriteit 18%

De .title()methode kan niet goed werken,

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

Probeer string.capwords()methode,

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

van de python documentatie op capwords :

Splits het argument in woorden met behulp van str.split (), kapitaal elk woord met str.capitalize () en sluit u aan bij de geactiveerde woorden met str.join (). Als het optionele tweede argument september afwezig is of geen, worden runs van witruimtekens vervangen door een enkele ruimte en zijn leidende en trailing whitespace verwijderd, anders wordt SEP gebruikt om te splitsen en deel te nemen aan de woorden.

Antwoord 3, Autoriteit 10%

Alleen omdat dit soort dingen leuk voor me is, hier zijn nog twee oplossingen.

Splitsen in woorden, initiaal-dop elk woord uit de splitgroepen en rejoin. Dit zal de witte ruimte veranderen die de woorden in een enkele witte ruimte scheiden, ongeacht wat het was.

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

EDIT: Ik weet het niet meer wat ik achterdacht toen ik de bovenstaande code schreef, maar het is niet nodig om een ​​expliciete lijst te bouwen; We kunnen een generatoruitdrukking gebruiken om het op luie manier te doen. Dus hier is een betere oplossing:

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

Gebruik een reguliere expressie om overeen te komen met het begin van de tekenreeks, of spaties die woorden scheiden, plus een enkel niet-witruimteteken; gebruik haakjes om “overeenkomstgroepen” te markeren. Schrijf een functie waaraan een match-object moet doorgegeven worden en die de matchgroep voor witruimte ongewijzigd en de matchgroep zonder witruimte in hoofdletters teruggeeft. Gebruik vervolgens re.sub()om de patronen te vervangen. Deze heeft niet de interpunctieproblemen van de eerste oplossing, en doet de witruimte ook niet opnieuw zoals mijn eerste oplossing. Deze geeft het beste resultaat.

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"

Ik ben blij dat ik dit antwoord heb onderzocht. Ik had geen idee dat re.sub()een functie kon aannemen! U kunt niet-triviale bewerkingen uitvoeren binnen re.sub()om het eindresultaat te produceren!

Antwoord 4, autoriteit 3%

Hier is een samenvatting van verschillende manieren om dit te doen, ze zullen werken voor al deze invoer:

""           => ""       
"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"     

– De eenvoudigste oplossing is om de zin in woorden te splitsen en de eerste letter in hoofdletters te zetten en deze vervolgens weer samen te voegen:

# 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(' ')) 

– Als u de invoerreeks niet eerst in woorden wilt splitsen en fancy generators wilt gebruiken:

# 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)) )

– Of zonder itertools te importeren:

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

– Of u kunt reguliere expressies gebruiken, van steveha’s antwoord:

# 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)

Dit zijn enkele andere antwoordendie zijn gepost, en invoer waarvoor ze niet werken zoals verwacht als we de definitie gebruiken dat een woord het begin van de zin is of iets daarna een lege ruimte:

 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"      

Gebruik ” voor de splitsing bevestigen de tweede uitvoer, maar capwords () werkt nog steeds niet voor de eerste

 return ' '.join(w.capitalize() for w in s.split(' '))    
  # or
  import string
  return string.capwords(s, ' ')
# Undesired outputs:
"foO baR"    => "Foo Bar"      

Wees voorzichtig met meerdere lege ruimtes

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

Antwoord 5

Copy-Paste-Ready-versie van @jibberia Anwser:

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

Antwoord 6

Waarom compliceer je je leven met joins en voor loops wanneer de oplossing eenvoudig en veilig is ??

doe dit gewoon:

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

Antwoord 7

als str.title () niet voor u werkt, doe de kapitalisatie zelf.

1. split de tekenreeks in een lijst met woorden
2. Kapitaliseer de eerste letter van elk woord
3. Word lid van de woorden in een enkele string

ONE-LINER:

>>> ' '.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"

Duidelijk voorbeeld:

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)

Antwoord 8

Als je alleen de eerste letter wilt:

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

Maar om elk woord met een hoofdletter te schrijven:

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

Antwoord 9

Een lege string geeft een foutmelding als je [1:] opent. Daarom zou ik gebruiken:

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

alleen de eerste letter in hoofdletters.

Antwoord 10

Hoewel alle antwoorden al bevredigend zijn, zal ik proberen om de twee extra gevallen samen met alle voorgaande gevallen te behandelen.

als de ruimtes niet uniform zijn en je wilt hetzelfde behouden

string = hello    world i  am    here.

als niet alle tekenreeksen beginnen met alfabetten

string = 1 w 2 r 3g

Hier kun je dit gebruiken:

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

Hiermee geeft u:

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

Antwoord 11

De voorgestelde methode str.title () werkt niet in alle gevallen.
Bijvoorbeeld:

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

in plaats van "A B 3c".

Ik denk, het is beter om zoiets te doen:

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'

Antwoord 12

Als Mark aangegeven, moet u .title():

"MyAwesomeString".title()

Indien echter de eerste letter hoofdletter in een Django-sjabloon , zou kunnen gebruiken, kunt u dit gebruiken:

{{ "MyAwesomeString"|title }}

of gebruik een variabele:

{{ myvar|title }}

Antwoord 13

om woorden te kapitaliseren …

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

@ Gary02127 Commentaar, de onderstaande oplossing werkt met titel met apostrof

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))

Antwoord 14

Kijk niet over het behoud van de witte ruimte. Als u 'fred flinstone'wilt verwerken en u krijgt 'Fred Flinstone'in plaats van 'fred flinstone', hebt u uw wit beschadigd ruimte. Sommige van de bovenstaande oplossingen verliezen witte ruimte. Hier is een oplossing die goed is voor Python 2 en 3 en witte ruimte behoudt.

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

Antwoord 15

Een snelle functie werkte voor Python 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.

Antwoord 16

Knop met niet-uniforme ruimtes

Ik wil graag toevoegen aan @amit Gupta’s punt van niet-uniforme ruimtes:

Van de oorspronkelijke vraag willen we elk woord in de tekenreeks s = 'the brown fox'met een hoofdletter schrijven. Wat als de string s = 'the brown fox'was met niet-uniforme spaties.

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)

Antwoord 17

De methode .title() werkt niet in alle testgevallen, dus het samen gebruiken van .capitalize(), .replace() en .split() is de beste keuze om de eerste letter van elk woord met een hoofdletter te schrijven.

p>

bijvoorbeeld: def caps(y):

    k=y.split()
     for i in k:
        y=y.replace(i,i.capitalize())
     return y

Antwoord 18

Je kunt dit proberen. eenvoudig en netjes.

def cap_each(string):
    list_of_words = string.split(" ")
    for word in list_of_words:
        list_of_words[list_of_words.index(word)] = word.capitalize()
    return " ".join(list_of_words)

Antwoord 19

In het geval u wilt inkrimpen

# 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

Antwoord 20

Gemakkelijkste oplossing voor uw vraag, het werkte in mijn geval:

import string
def solve(s):
    return string.capwords(s,' ') 
s=input()
res=solve(s)
print(res)

Antwoord 21

Ik vind dit antwoord erg leuk:

Kopiëren-plakken-klare versie van @jibberia anwser:

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

Maar sommige regels die ik stuurde, splitsten een paar lege ”-tekens af die fouten veroorzaakten bij het uitvoeren van s[1:]. Er is waarschijnlijk een betere manier om dit te doen, maar ik moest een if len(s)>0 toevoegen, zoals in

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