Dans cet article, vous apprendrez la réponse ultime à la question suivante :
Comment éliminer tous les espaces blancs d'une chaîne - aux deux extrémités et entre les mots ?
Résumé : Utilisez les méthodes de chaîne join() , split() , strip() , rstrip() , lstrip() et ou replace() - dans des combinaisons spécifiques - pour supprimer tout espace dans une chaîne donnée. Le moyen le plus simple de supprimer tous les espaces blancs dans une chaîne est d'utiliser le split() pour créer une liste de mots sans espace, puis regrouper les mots dans la liste fractionnée.
Le site Web officiel de Python propose une brève explication de ces méthodes et d'autres méthodes de chaîne pour référence ultérieure.
Remarque :Toutes les solutions fournies ci-dessous ont été vérifiées avec Python 3.8.5
Problème
Étant donné la variable de chaîne suivante :
sentence = '\t\t hello world \n'
Sortie souhaitée
Manipulez-le pour fournir la sortie suivante :
>>> 'helloworld'
Contexte
En Python, comme dans de nombreux autres langages de programmation populaires, les chaînes sont simplement des tableaux d'octets qui représentent des caractères unicode. Semblable aux types de données de base tels que Booléens , entiers et flottants, chaînes sont l'un des types de données les plus importants du langage de programmation Python. Python fournit une pléthore de méthodes d'assistance telles que join() , split() , strip() , rstrip() , lstrip() et replace() , pour manipuler des objets chaîne. L'utilisation de telles méthodes de chaîne sera explorée ci-dessous, pour résoudre le problème décrit ci-dessus.
Méthode 1 :string.split() et string.join()
Une méthode concise en une seule ligne pour supprimer les espaces en double dans une chaîne est illustrée ci-dessous :
sentence = '\t\t hello world \n'
Remarque : Si l'on coupe et colle ce qui précède et obtient une erreur de syntaxe en Python, c'est probablement parce que le ' (c'est-à-dire cocher) le caractère unicode a été modifié par Google. Il faut donc s'assurer que le bon ' (cocher) ou " (guillemet) est utilisé.
Pour supprimer les caractères d'espacement en double, utilisez str.split() et str.join() comme suit :
‘’.join(sentence.split())
Le code exécuté dans un shell Python ressemble à ceci :
>>> sentence = '\t\t hello world \n' >>> ''.join(sentence.split()) 'helloworld'
Que se passe-t-il ici ?
Par défaut, le str.split() , sans aucun argument, considérera et utilisera des séries consécutives de caractères d'espacement comme un seul séparateur. Si la chaîne a des espaces de début ou de fin, le fractionnement sera effectué de telle sorte qu'il n'y ait pas de chaînes vides au début ou à la fin de l'objet chaîne. Ainsi, ce qui suit se produit lorsque l'on utilise le str.split() méthode sur la variable chaîne sentence avec des arguments par défaut (c'est-à-dire None ou rien).
>>> sentence.split() ['hello', 'world']
Notez comment tous les caractères d'espacement ont été éliminés autour des mots hello et monde . Notez également que les mots ont été mis dans une liste itérable. Cette liste résultante itérable est maintenant transmise au str.join(iterable) méthode, qui concaténera toutes les chaînes dans iterable et renvoie un objet chaîne. Notez que l'objet chaîne (par exemple, la variable s2 ou '' , ci-dessous), sur lequel opère la méthode join, sera utilisé comme séparateur, pour joindre toutes les chaînes de la liste iterable .
Considérez l'extrait de code suivant pour lier le tout.
>>> sentence # This is the original string. '\t\t hello world \n' >>> s1 = sentence.split() #s1 is the resulting list iterable from the split method >>> s1 ['hello', 'world'] >>> s2 = '' # s2 is the dummy separator (i.e. an empty string) >>> s2 '' >>> s3 = s2.join(s1) # s3 is the desired result from joining elements in >>> s3 # the s1 list iterable, using string s2 as a seperator 'helloworld' >>>
Voyons ensuite si cette solution fonctionne sur une chaîne plus grande et plus élaborée :
>>> sentence = ''' ... ## This is a curious case. Since the step is a -ve number all the indexing ... ## is done from the right side of the list. The start index is beyond the ... ## list, so the last letter '!' is included, the end index is a -ve number ... ## so the counting for the end index begins from the right side of the list. ... ## So the end of the list is the letter to the right of index -5 i.e. 'a'. ... ## Note that end index is excluded, so answer is '!ssa' ... ''' >>> >>> sentence "\n## This is a curious case. Since the step is a -ve number all the indexing\n## is done from the right side of the list. The start index is beyond the\n## list, so the last letter '!' is included, the end index is a -ve number\n## so the counting for the end index begins from the right side of the list.\n## So the end of the list is the letter to the right of index -5 i.e. 'a'.\n## Note that end index is excluded, so answer is '!ssa'\n" >>> >>> s2 '' >>> s3 = s2.join(sentence.split()) >>> >>> s3 "##Thisisacuriouscase.Sincethestepisa-venumberalltheindexing##isdonefromtherightsideofthelist.Thestartindexisbeyondthe##list,sothelastletter'!'isincluded,theendindexisa-venumber##sothecountingfortheendindexbeginsfromtherightsideofthelist.##Sotheendofthelististhelettertotherightofindex-5i.e.'a'.##Notethatendindexisexcluded,soansweris'!ssa'" >>>
On voit ici encore que la solution fonctionne parfaitement sur une corde plus longue aussi. Il s'est débarrassé de tous les espaces blancs dans la variable de chaîne sentence . Notez ici que la variable de chaîne sentence est une chaîne multiligne, créée à l'aide du ''' ...''' (c'est-à-dire triple-tic).
Les explications suivantes montrent d'autres méthodes plus fastidieuses pour supprimer les espaces. Elles sont efficaces mais pas aussi pratiques que la Méthode 1 , pour le problème spécifique en cours. Les étapes sont cependant génériques et peuvent être appliquées ailleurs, pour d'autres substitutions.
Méthode 2 :string.replace()
Une façon plus élaborée et fastidieuse de supprimer les espaces en double dans une chaîne consiste à utiliser le str.replace(old, new) méthode, comme indiqué ci-dessous.
Le code exécuté dans un shell Python ressemble à ceci :
>>> sentence = '\t\t hello world \n'
>>> sentence
'\t\t hello world \n'
>>>
>>> s1 = sentence.replace(' ', '')
>>> s1
'\t\thelloworld\n'
>>> s1.replace('\t', '')
'helloworld\n'
>>> s1
'\t\thelloworld\n'
>>> s2 = s1.replace('\t', '')
>>> s2
'helloworld\n'
>>> s3 = s2.replace('\n', '')
>>> s3
'helloworld'
>>>
Que se passe-t-il ici ?
Le str.replace(old, new) la méthode remplacera toutes les occurrences de la sous-chaîne old avec la chaîne nouveau et renvoie une copie modifiée de l'objet chaîne d'origine. Voyons comment cela a fonctionné dans l'extrait de code ci-dessus.
Dans Méthode 2 , la variable chaîne sentence est façonné une étape à la fois, pour obtenir le résultat souhaité. Dans la première étape, la chaîne " " (c'est-à-dire l'espace caractère) est éliminé en le remplaçant par "" (c'est-à-dire rien). Notez que l'onglet (c'est-à-dire \t ) et la nouvelle ligne (c'est-à-dire \n ) continuent d'exister dans la variable de chaîne s1 .
>>> sentence = '\t\t hello world \n'
>>> sentence
'\t\t hello world \n'
>>>
>>> s1 = sentence.replace(' ', '')
>>> s1
'\t\thelloworld\n'
À l'étape suivante, le "\t" (c'est-à-dire l'onglet caractère) est éliminé en le remplaçant par "" (c'est-à-dire rien, encore une fois). Notez que la nouvelle ligne (c'est-à-dire \n ) continue d'exister dans la variable de chaîne s2 .
>>> s1
'\t\thelloworld\n'
>>> s2 = s1.replace('\t', '')
>>> s2
'helloworld\n'
Dans la dernière étape, le "\n" (c'est-à-dire la nouvelle ligne caractère) est éliminé en le remplaçant par "" (c'est-à-dire rien, encore une fois). Cette dernière étape donne maintenant le résultat souhaité dans la variable de chaîne s3 .
>>> s2
'helloworld\n'
>>> s3 = s2.replace('\n', '')
>>> s3
'helloworld'
>>>
Voyons ensuite si cette solution fonctionne sur une chaîne plus grande et plus élaborée :
>>> sentence = '''
... ## This is a curious case. Since the step is a -ve number all the indexing
... ## is done from the right side of the list. The start index is beyond the
... ## list, so the last letter '!' is included, the end index is a -ve number
... ## so the counting for the end index begins from the right side of the list.
... ## So the end of the list is the letter to the right of index -5 i.e. 'a'.
... ## Note that end index is excluded, so answer is '!ssa'
... '''
>>> sentence
"\n## This is a curious case. Since the step is a -ve number all the indexing\n## is done from the right side of the list. The start index is beyond the\n## list, so the last letter '!' is included, the end index is a -ve number\n## so the counting for the end index begins from the right side of the list.\n## So the end of the list is the letter to the right of index -5 i.e. 'a'.\n## Note that end index is excluded, so answer is '!ssa'\n"
>>>
>>> s1 = sentence.replace(' ', '')
>>> s1
"\n##Thisisacuriouscase.Sincethestepisa-venumberalltheindexing\n##isdonefromtherightsideofthelist.Thestartindexisbeyondthe\n##list,sothelastletter'!'isincluded,theendindexisa-venumber\n##sothecountingfortheendindexbeginsfromtherightsideofthelist.\n##Sotheendofthelististhelettertotherightofindex-5i.e.'a'.\n##Notethatendindexisexcluded,soansweris'!ssa'\n"
>>> s2 = s1.replace('\t', '')
>>> s2
"\n##Thisisacuriouscase.Sincethestepisa-venumberalltheindexing\n##isdonefromtherightsideofthelist.Thestartindexisbeyondthe\n##list,sothelastletter'!'isincluded,theendindexisa-venumber\n##sothecountingfortheendindexbeginsfromtherightsideofthelist.\n##Sotheendofthelististhelettertotherightofindex-5i.e.'a'.\n##Notethatendindexisexcluded,soansweris'!ssa'\n"
>>> s3 = s2.replace('\n', '')
>>> s3
"##Thisisacuriouscase.Sincethestepisa-venumberalltheindexing##isdonefromtherightsideofthelist.Thestartindexisbeyondthe##list,sothelastletter'!'isincluded,theendindexisa-venumber##sothecountingfortheendindexbeginsfromtherightsideofthelist.##Sotheendofthelististhelettertotherightofindex-5i.e.'a'.##Notethatendindexisexcluded,soansweris'!ssa'"
>>>
On voit là encore que même si la solution est fastidieuse, par rapport à la Méthode 1 , il continue de fonctionner parfaitement sur une corde plus longue également. Il s'est débarrassé de tous les espaces blancs dans la variable de chaîne sentence .
Méthode 3 :replace(), lstrip() et rstrip()
Cette dernière méthode est purement pédagogique. Il montre encore une autre façon élaborée et fastidieuse de supprimer les espaces en double dans une chaîne en utilisant le str.replace(old, new) , le str.lstrip([chars]) et le str.rstrip([chars]) méthodes, comme indiqué ci-dessous.
Le code exécuté dans un shell Python ressemble à ceci :
>>> sentence = '\t\t hello world \n'
>>> sentence
'\t\t hello world \n'
>>>
>>> s1 = sentence.replace(" ", "")
>>> s1
'\t\thelloworld\n'
>>>
>>> s2 = s1.lstrip()
>>> s2
'Helloworld\n'
>>>
>>> s3 = s2.rstrip()
>>> s3
'helloworld'
>>>
Que se passe-t-il ici ?
Le str.lstrip([chars]) la méthode renvoie une copie modifiée de l'objet chaîne str avec les premiers caractères supprimés. Les caractères supprimés sont spécifiés dans l'ensemble représenté par la chaîne chars . Les espaces blancs sont supprimés, par défaut, si chars n'est pas spécifié ou est None .
De même, le str.rstrip([chars]) la méthode renvoie une copie modifiée de l'objet chaîne str avec les caractères de fin supprimés. Les caractères supprimés sont spécifiés dans l'ensemble représenté par la chaîne chars . Les espaces blancs sont supprimés, par défaut, si chars n'est pas spécifié ou est None .
Dans la méthode 3, la variable de chaîne phrase est façonné une étape à la fois pour obtenir le résultat souhaité (c'est-à-dire similaire à la méthode 2). Dans la première étape, la chaîne " " (c'est-à-dire l'espace caractère) est éliminé en le remplaçant par "" (c'est-à-dire rien). Notez que l'onglet (c'est-à-dire \t ) et la nouvelle ligne (c'est-à-dire \n ) continuent d'exister dans la variable de chaîne s1 .
>>> sentence = '\t\t hello world \n'
>>> sentence
'\t\t hello world \n'
>>>
>>> s1 = sentence.replace(" ", "")
>>> s1
'\t\thelloworld\n'
À l'étape suivante, le "\t" (c'est-à-dire l'onglet caractère) est éliminé en le supprimant du préfixe (c'est-à-dire str.lstrip() ). Notez que la nouvelle ligne (c'est-à-dire \n ) continue d'exister dans la variable de chaîne s2 .
>>> s1 '\t\thelloworld\n' >>> >>> s2 = s1.lstrip() >>> s2 'Helloworld\n'
Dans la dernière étape, le "\n" (c'est-à-dire la nouvelle ligne caractère) est éliminé en supprimant le suffixe (c'est-à-dire str.rstrip() ). Cette dernière étape donne maintenant le résultat souhaité dans la variable de chaîne s3 .
>>> s2 'Helloworld\n' >>> >>> s3 = s2.rstrip() >>> s3 'helloworld'
Académie Finxter
Ce blog vous a été présenté par Girish , un étudiant de Finxter Academy. Vous pouvez trouver son profil Upwork ici.
Référence
Toutes les recherches pour cet article de blog ont été effectuées à l'aide de documents Python et de la base de connaissances partagée des communautés Stack Overlfow et Finxter Academy.
