Cum să majusculă prima literă a fiecărui cuvânt într-un șir?

A .titlul() metoda de un șir de caractere (ASCII sau Unicode este bine) face acest lucru:

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

Cu toate acestea, uita-te pentru siruri de caractere cu încorporat apostroful, după cum sa menționat în documente.

algoritmul foloseste un limbaj simplu, independent de definiția unui cuvânt ca grupuri de litere consecutive. Definiția funcționează în multe contexte, dar aceasta înseamnă că apostroful în contracții și posesive formularul de limitele de cuvinte, care nu poate fi rezultatul dorit:

"ei're bill's prieteni din marea BRITANIE".titlul() "Ei'Re Bill'S Prieteni Din marea Britanie"

A .titlul() metoda poate't lucra bine,

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

Încerca șir de caractere.capwords() metoda,

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

De python-docs pe capwords:

Split argumentul în cuvinte, folosind str.split(), valorifica fiecare cuvânt folosind str.valorifica(), și să se alăture cuvinte capitalizate folosind str.join(). Dacă opționale de-al doilea argument sep este absent sau Nici unul, ruleaza de spațiu personajele sunt înlocuite printr-un singur spațiu și de conducere și la sfârșit spațiu sunt eliminate, în caz contrar sep este folosit pentru a împărți și să se alăture cuvinte.

Doar pentru că acest fel de lucru este distractiv pentru mine, aici sunt două soluții.

Împărțit în cuvinte, inițial-pac fiecare cuvânt din split grupuri, și să te întorci. Acest lucru se va schimba spațiu alb care separă cuvintele într-un singur spațiu alb, nu contează ce a fost.

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

EDIT: eu nu't amintesc la ce mă gândeam când am scris codul de mai sus, dar nu există nici o nevoie pentru a construi listă explicită; putem folosi un generator de exprimare să-l facă în lenes moda. Deci, aici este o soluție mai bună:

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

Utilizați o expresie regulată pentru a se potrivi la începutul șirului, sau spațiu alb de separare de cuvinte, plus un singur caracter non-spațiu; utilizați paranteze pentru a marca "a se potrivi grupuri". Scrieți o funcție care ia un obiect de meci, și returnează spațiu alb meci de grup neschimbată și caracter non-spațiu meci de grup în caz de sus. Apoi, utilizați re.sub() pentru a înlocui modele. Acesta nu avea semne de punctuație probleme de prima soluție, nici nu reface spațiul alb ca prima mea soluție. Aceasta produce cel mai bun rezultat.

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"

Am'm a bucur că am cercetat acest răspuns. Nu am avut nici o idee că re.sub () ar putea avea o funcție! Puteți face trivial prelucrare în interiorulre.sub()` pentru a produce rezultatul final!

Aici's un rezumat de moduri diferite de a face asta, ei vor lucra pentru toate aceste intrări:

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

- Cea mai simplă soluție este să împartă propoziția în cuvinte și majusculă prima literă, apoi se alăture din nou împreună:

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

- Dacă nu't doriți să împartă șir de intrare în cuvinte, în primul rând, și folosind generatoare de lux:

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

- Sau fără importul itertools:

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

- Sau puteți folosi expresii regulate, de steveha's a răspunde:

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

Acum, acestea sunt niste alte răspunsuri care au fost postate, și date de intrare pentru care ei nu't lucreze cum era de așteptat dacă suntem folosind definiția unui cuvânt fiind la început de propoziție sau ceva dupa un spațiu gol:

  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"      

folosind ' ' pentru split va stabili cea de-a doua ieșire, dar capwords() a câștigat încă't de lucru pentru prima

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

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

Fii atent cu mai multe spații goale

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

Copy-paste-versiune gata de @jibberia anwser:

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

De ce sa te complici cu se alătură și pentru bucle atunci când soluția este simplă și în condiții de siguranță??

Doar face acest lucru:

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

Dacă str.titlul() nu't de lucru pentru tine, nu-capitalizarea tine.

1. Split string într-o listă de cuvinte
2. Majusculă prima literă a fiecărui cuvânt
3. Alăturați-vă cuvintele într-un singur șir

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

Exemplu clar:

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)

Dacă vrei prima scrisoare: ``python

'salut lume'.valorifica() 'Salut lume' Dar pentru a valorifica fiecare cuvânt: python 'salut lume'.titlul() 'Salut Lume' ``

Un șir gol va ridica o Eroare dacă ai acces [1:], prin urmare mi-ar folosi:

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

la majuscule prima literă numai.

Ca Marca a subliniat că ar trebui să utilizați .titlul():

"MyAwesomeString".title()

Cu toate acestea, dacă ar dori să facă prima literă majusculă în interiorul unui șablon django, ai putea folosi asta:

{{ "MyAwesomeString"|title }}

sau, folosind o variabilă:

{{ myvar|title }}

Pentru a valorifica cuvinte...

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

@Gary02127 comentariu, mai jos, solutia de lucru titlul cu 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))

Metoda sugerată str.titlul() nu funcționează în toate cazurile. De exemplu:

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

în loc de"O B 3c"`.

Cred că este mai bine pentru a face ceva de genul asta:

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'

Don't au vedere la conservarea de spațiu alb. Dacă doriți pentru a procesa 'fred flinstone' și ai `'Fred Flinstone' "în loc de" 'Fred Flinstone', ar'am corupt spațiu alb. Unele dintre soluțiile de mai sus va pierde spațiu alb. Aici's o soluție care's bun pentru Python 2 și 3 și păstrează un spațiu alb.

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

În cazul în care doriți să reducă

 #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

Deși toate răspunsurile sunt deja satisfăcătoare, dar am'll încerca să acopere cele 2 cazuri în plus, împreună cu cazul precedent.

dacă spațiile nu sunt uniforme și doriți să mențină același

string = hello    world i  am    here.

dacă toate șir nu sunt incepand de alfabete

string = 1 w 2 r 3g

Aici puteți utiliza acest

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

acest lucru vă va oferi

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

Sper că acest lucru nu este redundantă.

Îmi place foarte mult acest răspuns:

Copy-paste-versiune gata de @jibberia anwser:

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

Dar unele dintre liniile pe care eu i-am trimis desprins unele blank '' personaje care au cauzat erori atunci când încearcă pentru a face s[1:]. Există, probabil, o modalitate mai bună de a face acest lucru, dar am avut de a adăuga într-o daca len(s)>0, ca în

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