Comment capitaliser la première lettre de chaque mot dans une chaîne (Python)?

Le .title() méthode ne peut pas bien fonctionner,

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

Essayer string.capwords() la méthode,

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

De la python docs sur capwords :

Split l'argument en mots à l'aide str.split (), capitaliser chaque mot en utilisant str.capitaliser (), et joindre les mots en majuscules en utilisant str.rejoindre.)( Si le second argument optionnel sep est absent ou Aucun, les séries de caractères blancs sont remplacés par un espace unique et les espaces blancs menant et traînant sont supprimés, sinon sep est utilisé pour diviser et joindre les mots.

juste parce que ce genre de chose est amusant pour moi, voici deux autres solutions.

divisé en mots, initialiser chaque mot des groupes de scission, et de rejoindre. Cela changera l'espace blanc séparant les mots en un seul espace blanc, peu importe ce qu'il était.

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

EDIT: je ne me souviens pas de ce que je pensais quand j'ai écrit le code ci-dessus, mais il n'est pas nécessaire de construire une liste explicite; nous pouvons utilisez une expression de générateur pour le faire de façon paresseuse. Voici donc une meilleure solution:

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

utilisez une expression régulière pour faire correspondre le début de la chaîne, ou l'espace blanc séparant les mots, plus un caractère unique non-Espace; utilisez des parenthèses pour marquer"match groups". Ecrire une fonction qui prend un objet match, et renvoie le groupe de match espace blanc inchangé et le groupe de match caractère non-espace en majuscules. Ensuite, utilisez re.sub() pour remplacer les motifs. Celui-ci n'a pas les problèmes de ponctuation de la première solution, et il ne refait pas l'espace blanc comme ma première solution. Ce que l'on produit le meilleur résultat.

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"

je suis content d'avoir cherché cette réponse. Je ne savais pas que re.sub() pouvait prendre une fonction! Vous pouvez faire un traitement non trivial à l'intérieur de re.sub() pour produire le résultat final!

version prête à copier-coller de @jibberia anwser:

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

pourquoi compliquez-vous votre vie avec des jointures et pour des boucles alors que la solution est simple et sûre??

faites Simplement ceci:

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

Si str.titre () ne fonctionne pas pour vous, faites la capitalisation vous-même.

1. divise la chaîne en une liste de mots
2. capitaliser la première lettre de chaque mot
3. Joignez-vous aux mots dans une chaîne unique

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"

exemple clair:

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)

Voici un résumé des différentes façons de le faire:

la solution la plus simple est de diviser la phrase en mots et de capitaliser la première lettre puis de la joindre à nouveau ensemble.

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

si vous ne voulez pas diviser la chaîne d'entrée en mots d'abord, et en utilisant des générateurs de fantaisie:

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

ou sans importation d'outils itératifs

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

ou vous pouvez utiliser expressions régulières, de réponse de steveha

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

ceux-ci fonctionneront pour toutes ces entrées:

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

maintenant, ce sont quelques autres réponses qui ont été affichés, et les entrées pour lesquelles ils ne fonctionnent pas comme prévu si nous utilisons la définition d'un mot étant le début de la phrase ou quelque chose après un espace vide:

  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"      

en utilisant '' pour le split fixera la deuxième sortie, mais capwords () ne fonctionnera toujours pas pour la première

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

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

faites attention avec plusieurs espaces vides

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

une chaîne vide va soulever une erreur si vous accédez [1:], donc j'utiliserais:

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

pour majuscules la première lettre seulement.

comme Mark a indiqué que vous devez utiliser .title() :

"MyAwesomeString".title()

cependant, si vous souhaitez faire la première lettre majuscule à l'intérieur d'un modèle django , vous pouvez utiliser ceci:

{{ "MyAwesomeString"|title }}

ou en utilisant une variable:

{{ myvar|title }}

La méthode suggérée str.titre() ne fonctionne pas dans tous les cas. Par exemple:

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

au lieu de "A B 3c" .

je pense que c'est mieux de faire quelque chose comme ça:

def capitalize_words(string):
    words = string.split()
    return ' '.join([word.capitalize() for word in words])

capitalize_words(string)
>'A B 3c'

pour capitaliser les mots...

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

@Gary02127 commentaire, ci-dessous la solution de travail titre avec 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))

ne négligez pas la préservation de l'espace blanc. Si vous voulez traiter 'fred flinstone' et que vous obtenez 'Fred Flinstone' au lieu de 'Fred Flinstone' , vous avez corrompu votre espace blanc. Certaines de ces solutions vont perdre de l'espace blanc. Voici une solution qui est bonne pour Python 2 et 3 et préserve l'espace blanc.

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

si seulement vous voulez la première lettre: 'bonjour le monde'.capitaliser() Sortie: Bonjour tout le monde

mais pour capitaliser chaque mot: 'bonjour le monde'.intitulé() Sortie: Bonjour tout le monde

**Dans le cas où vous souhaitez réduire la taille de **

 #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

j'aime vraiment cette réponse:

version prête à copier-coller de @jibberia anwser:

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

mais certaines des lignes que j'envoyais séparaient des caractères Vierges qui causaient des erreurs en essayant de faire s[1:]. Il y a probablement une meilleure façon de le faire, mais j'ai dû ajouter un if len (s)>0, comme dans

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