s = 'the brown fox'
...face ceva aici...
"s" ar fi :
'The Brown Fox'
Ce's cel mai simplu mod de a face acest lucru?
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"
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 interiorul
re.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"
Dacă str.titlul() nu't de lucru pentru tine, nu-capitalizarea tine.
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)
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])