Wie kann man den ersten Buchstaben jedes Wortes in einer Zeichenfolge groß schreiben?

s = 'the brown fox'

... hier etwas tun ...

s sollte sein :

'The Brown Fox'

Was ist der einfachste Weg, dies zu tun?

Die .title()Methode einer Zeichenfolge (entweder ASCII oder Unicode ist in Ordnung) führt Folgendes aus:

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

Achten Sie jedoch auf Zeichenfolgen mit eingebetteten Apostrophen, wie in den Dokumenten angegeben.

Der Algorithmus verwendet eine einfache sprachunabhängige Definition eines Wortes als Gruppen aufeinanderfolgender Buchstaben. Die Definition funktioniert in vielen Zusammenhängen, bedeutet jedoch, dass Apostrophe in Kontraktionen und Possessiven Wortgrenzen bilden, die möglicherweise nicht das gewünschte Ergebnis sind:

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

Die .title()Methode kann nicht gut funktionieren,

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

Versuchen Sie string.capwords()Methode,

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

Aus den Python-Dokumenten zu Capwords :

Teilen Sie das Argument mit str.split () in Wörter auf, schreiben Sie jedes Wort mit str.capitalize () groß und verbinden Sie die großgeschriebenen Wörter mit str.join (). Wenn das optionale zweite Argument sep fehlt oder None ist, werden Läufe von Leerzeichen durch ein einzelnes Leerzeichen ersetzt und führende und nachfolgende Leerzeichen entfernt. Andernfalls wird sep verwendet, um die Wörter zu teilen und zu verbinden.

Nur weil mir so etwas Spaß macht, gibt es hier zwei weitere Lösungen.

In Wörter aufteilen, jedes Wort aus den aufgeteilten Gruppen mit einem Anfangsbuchstaben versehen und wieder verbinden. Dadurch wird der Leerraum, der die Wörter trennt, in einen einzelnen Leerraum geändert, unabhängig davon, um was es sich handelt.

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

EDIT: Ich erinnere mich nicht, was ich gedacht habe, als ich den obigen Code geschrieben habe, aber es besteht keine Notwendigkeit, eine explizite Liste zu erstellen. Wir können einen Generatorausdruck verwenden, um dies auf faule Weise zu tun. Also hier ist eine bessere Lösung:

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

Verwenden Sie einen regulären Ausdruck, der mit dem Anfang der Zeichenfolge übereinstimmt, oder Leerzeichen, die Wörter trennen, sowie ein einzelnes Nicht-Leerzeichen. Verwenden Sie Klammern, um "Übereinstimmungsgruppen" zu markieren. Schreiben Sie eine Funktion, die ein Übereinstimmungsobjekt verwendet und die Übereinstimmungsgruppe für Leerzeichen unverändert und die Übereinstimmungsgruppe für Nicht-Leerzeichen in Großbuchstaben zurückgibt. Verwenden Sie dann re.sub(), um die Muster zu ersetzen. Dieser hat weder die Interpunktionsprobleme der ersten Lösung, noch wiederholt er den Leerraum wie meine erste Lösung. Dieser liefert das beste Ergebnis.

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"

Ich bin froh, dass ich diese Antwort recherchiert habe. Ich hatte keine Ahnung, dass re.sub()das eine Funktion übernehmen könnte! Sie können im Inneren eine nicht triviale Verarbeitung durchführenre.sub() , um das Endergebnis zu erzielen!

Hier ist eine Zusammenfassung der verschiedenen Möglichkeiten, sie funktionieren für alle diese Eingaben:

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

- Die einfachste Lösung besteht darin, den Satz in Wörter aufzuteilen, den ersten Buchstaben groß zu schreiben und ihn dann wieder zusammenzufügen:

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

- Wenn Sie die Eingabezeichenfolge nicht zuerst in Wörter aufteilen und ausgefallene Generatoren verwenden möchten:

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

- Oder ohne itertools zu importieren:

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

- Oder Sie können reguläre Ausdrücke aus Steveas Antwort verwenden :

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

Dies sind einige andere Antworten , die veröffentlicht wurden, und Eingaben, für die sie nicht wie erwartet funktionieren, wenn wir die Definition eines Wortes als Satzanfang oder irgendetwas nach einem Leerzeichen verwenden:

  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"      

Wenn Sie '' für die Aufteilung verwenden, wird die zweite Ausgabe korrigiert, aber capwords () funktioniert für die erste immer noch nicht

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

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

Seien Sie vorsichtig mit mehreren Leerzeichen

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

Copy-Paste-Ready-Version von @jibberia antwort:

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

Warum erschweren Sie Ihr Leben mit Joins und for-Loops, wenn die Lösung einfach und sicher ist?

Mach das einfach:

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

Wenn str.title () für Sie nicht funktioniert, führen Sie die Großschreibung selbst durch.

1. Teilen Sie die Zeichenfolge in eine Liste von Wörtern
2. Großschreiben Sie den ersten Buchstaben jedes Wortes
3. Verbinden Sie die Wörter zu einer einzigen Zeichenfolge

Einzeiler:

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

Klares Beispiel:

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)

Wenn Sie nur den ersten Buchstaben wollen:

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

Aber um jedes Wort groß zu schreiben:

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

Eine leere Zeichenfolge löst einen Fehler aus, wenn Sie auf [1:] zugreifen. Daher würde ich Folgendes verwenden:

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

nur den ersten Buchstaben in Großbuchstaben schreiben.

Wie Mark betonte, sollten Sie verwenden .title():

"MyAwesomeString".title()

Wenn Sie jedoch den ersten Buchstaben in einer Django-Vorlage in Großbuchstaben schreiben möchten , können Sie Folgendes verwenden:

{{ "MyAwesomeString"|title }}

oder mit einer Variablen:

{{ myvar|title }}

Die vorgeschlagene Methode str.title () funktioniert nicht in allen Fällen. Zum Beispiel:

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

anstatt "A B 3c" .

Ich denke, es ist besser, so etwas zu tun:

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'

Obwohl alle Antworten bereits zufriedenstellend sind, werde ich versuchen, die 2 zusätzlichen Fälle zusammen mit allen vorherigen Fällen abzudecken.

wenn die Leerzeichen nicht einheitlich sind und Sie diese beibehalten möchten

string = hello    world i  am    here.

wenn nicht alle Zeichenfolgen von Alphabeten ausgehen

string = 1 w 2 r 3g

Hier können Sie dies verwenden

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

das wird dir geben

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

Ich hoffe das ist nicht überflüssig.

Wörter groß schreiben ...

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

@ Gary02127 Kommentar, unten Lösungsarbeitstitel mit Apostroph

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

Übersehen Sie nicht die Erhaltung des Leerraums. Wenn Sie verarbeiten möchten 'fred flinstone'und 'Fred Flinstone'stattdessen erhalten 'Fred Flinstone', haben Sie Ihren Leerraum beschädigt. Einige der oben genannten Lösungen verlieren Leerraum. Hier ist eine Lösung, die für Python 2 und 3 gut ist und Leerzeichen bewahrt.

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

Eine schnelle Funktion funktionierte für 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.

Großschreibung von Zeichenfolgen mit ungleichmäßigen Leerzeichen

Nun, ich verstehe, dass dies eine alte Frage ist und wahrscheinlich die Antworten fast erschöpft sind, aber ich möchte @Amit Guptas Punkt ungleichmäßiger Räume ergänzen. Von der ursprünglichen Frage möchten wir jedes Wort in der Zeichenfolge groß schreiben s = 'the brown fox'. Was wäre, wenn die Zeichenfolge s = 'the brown fox'ungleichmäßige Leerzeichen hätte ?

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)

** Falls Sie verkleinern möchten **

 #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

Diese Antwort gefällt mir sehr gut:

Copy-Paste-Ready-Version von @jibberia antwort:

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

Aber einige der Zeilen, die ich gesendet habe, haben einige leere Zeichen abgespalten, die beim Versuch, s [1:] auszuführen, Fehler verursacht haben. Es gibt wahrscheinlich einen besseren Weg, dies zu tun, aber ich musste ein if len (s)> 0 hinzufügen, wie in

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