Comment supprimer tous les espaces d'une chaîne

Comment supprimer tous les espaces dans une chaîne python? Par exemple, je veux qu'une chaîne strip my spacessoit transformée en stripmyspaces, mais je n'arrive pas à y parvenir avec strip():

>>> 'strip my spaces'.strip()
'strip my spaces'

Profitant du comportement de str.split sans paramètre sep:

>>> s = " \t foo \n bar "
>>> "".join(s.split())
'foobar'

Si vous souhaitez simplement supprimer des espaces au lieu de tous les espaces:

>>> s.replace(" ", "")
'\tfoo\nbar'

Optimisation prématurée

Même si l'efficacité n'est pas l'objectif principal - l'écriture de code clair l'est - voici quelques horaires initiaux:

$ python -m timeit '"".join(" \t foo \n bar ".split())'
1000000 loops, best of 3: 1.38 usec per loop
$ python -m timeit -s 'import re' 're.sub(r"\s+", "", " \t foo \n bar ")'
100000 loops, best of 3: 15.6 usec per loop

Notez que l'expression régulière est mise en cache, elle n'est donc pas aussi lente que vous l'imaginez. Le compiler au préalable en aide certains, mais cela n'aurait d'importance en pratique que si vous appelez cela plusieurs fois:

$ python -m timeit -s 'import re; e = re.compile(r"\s+")' 'e.sub("", " \t foo \n bar ")'
100000 loops, best of 3: 7.76 usec per loop

Même si re.sub est 11,3 fois plus lent, rappelez-vous que vos goulots d'étranglement sont assurément ailleurs. La plupart des programmes ne remarqueraient pas la différence entre ces 3 choix.

>>> import re
>>> re.sub(r'\s+', '', 'strip my spaces')
'stripmyspaces'

Gère également tous les caractères d'espaces auxquels vous ne pensez pas (croyez-moi, il y en a beaucoup).

Alternativement,

"strip my spaces".translate( None, string.whitespace )

Et voici la version Python3:

"strip my spaces".translate(str.maketrans('', '', string.whitespace))

Le plus simple est d'utiliser replace:

"foo bar\t".replace(" ", "").replace("\t", "")

Vous pouvez également utiliser une expression régulière:

import re
re.sub(r"\s", "", "foo bar\t")

Supprimer les espaces de départ en Python

string1="    This is Test String to strip leading space"
print string1
print string1.lstrip()

Supprimer les espaces de fin ou de fin en Python

string2="This is Test String to strip trailing space     "
print string2
print string2.rstrip()

Supprimez les whiteSpaces du début et de la fin de la chaîne en Python

string3="    This is Test String to strip leading and trailing space      "
print string3
print string3.strip()

Supprimez tous les espaces en python

string4="   This is Test String to test all the spaces        "
print string4
print string4.replace(" ", "")

Essayez une regex avec re.sub. Vous pouvez rechercher tous les espaces et les remplacer par une chaîne vide.

\sdans votre modèle correspondra aux caractères d'espacement - et pas seulement à un espace (tabulations, retours à la ligne, etc.). Vous pouvez en savoir plus à ce sujet dans le manuel .

import re
re.sub(' ','','strip my spaces')

Comme mentionné par Roger Pate, le code suivant a fonctionné pour moi:

s = " \t foo \n bar "
"".join(s.split())
'foobar'

J'utilise Jupyter Notebook pour exécuter le code suivant:

i=0
ProductList=[]
while i < len(new_list): 
   temp=''                            # new_list[i]=temp=' Plain   Utthapam  '
   #temp=new_list[i].strip()          #if we want o/p as: 'Plain Utthapam'
   temp="".join(new_list[i].split())  #o/p: 'PlainUtthapam' 
   temp=temp.upper()                  #o/p:'PLAINUTTHAPAM' 
   ProductList.append(temp)
   i=i+2

Les techniques standard pour filtrer une liste s'appliquent, bien qu'elles ne soient pas aussi efficaces que les méthodes split/joinou translate.

Nous avons besoin d'un ensemble d'espaces blancs:

>>> import string
>>> ws = set(string.whitespace)

L' filterintégré:

>>> "".join(filter(lambda c: c not in ws, "strip my spaces"))
'stripmyspaces'

Une liste de compréhension (oui, utilisez les crochets: voir référence ci-dessous):

>>> import string
>>> "".join([c for c in "strip my spaces" if c not in ws])
'stripmyspaces'

Un pli:

>>> import functools
>>> "".join(functools.reduce(lambda acc, c: acc if c in ws else acc+c, "strip my spaces"))
'stripmyspaces'

Référence:

>>> from timeit import timeit
>>> timeit('"".join("strip my spaces".split())')
0.17734256500003198
>>> timeit('"strip my spaces".translate(ws_dict)', 'import string; ws_dict = {ord(ws):None for ws in string.whitespace}')
0.457635745999994
>>> timeit('re.sub(r"\s+", "", "strip my spaces")', 'import re')
1.017787621000025

>>> SETUP = 'import string, operator, functools, itertools; ws = set(string.whitespace)'
>>> timeit('"".join([c for c in "strip my spaces" if c not in ws])', SETUP)
0.6484303600000203
>>> timeit('"".join(c for c in "strip my spaces" if c not in ws)', SETUP)
0.950212219999969
>>> timeit('"".join(filter(lambda c: c not in ws, "strip my spaces"))', SETUP)
1.3164566040000523
>>> timeit('"".join(functools.reduce(lambda acc, c: acc if c in ws else acc+c, "strip my spaces"))', SETUP)
1.6947649049999995

TL / DR

Cette solution a été testée avec Python 3.6

Pour supprimer tous les espaces d'une chaîne en Python3, vous pouvez utiliser la fonction suivante:

def remove_spaces(in_string: str):
    return in_string.translate(str.maketrans({' ': ''})

Pour supprimer des espaces ('\ t \ n \ r \ x0b \ x0c'), vous pouvez utiliser la fonction suivante:

import string
def remove_whitespace(in_string: str):
    return in_string.translate(str.maketrans(dict.fromkeys(string.whitespace)))

Explication

La str.translateméthode de Python est une méthode de classe intégrée de str, elle prend une table et retourne une copie de la chaîne avec chaque caractère mappé via la table de traduction passée. Documentation complète pour str.translate

Pour créer la table de traduction str.maketransest utilisé. Cette méthode est une autre méthode de classe intégrée de str. Ici, nous l'utilisons avec un seul paramètre, dans ce cas un dictionnaire, où les clés sont les caractères à remplacer mappés aux valeurs avec la valeur de remplacement des caractères. Il renvoie une table de traduction à utiliser avec str.translate. Documentation complète pour str.maketrans

Le stringmodule en python contient des opérations et des constantes de chaîne courantes. string.whitespaceest une constante qui renvoie une chaîne contenant tous les caractères ASCII considérés comme des espaces. Cela inclut l'espace de caractères, la tabulation, le saut de ligne, le retour, le saut de page et la tabulation verticale. Documentation complète pour la chaîne

Dans la deuxième fonction dict.fromkeysest utilisée pour créer un dictionnaire où les clés sont les caractères de la chaîne retournés par string.whitespacechacun avec valeur None. Documentation complète pour dict.fromkeys

Si des performances optimales ne sont pas une exigence et que vous voulez juste quelque chose de très simple, vous pouvez définir une fonction de base pour tester chaque caractère à l'aide de la méthode intégrée "isspace" de la classe de chaîne:

def remove_space(input_string):
    no_white_space = ''
    for c in input_string:
        if not c.isspace():
            no_white_space += c
    return no_white_space

Construire la no_white_spacechaîne de cette manière n'aura pas des performances idéales, mais la solution est facile à comprendre.

>>> remove_space('strip my spaces')
'stripmyspaces'

Si vous ne voulez pas définir une fonction, vous pouvez la convertir en quelque chose de vaguement similaire avec la compréhension de liste. Emprunter de la joinsolution de la meilleure réponse :

>>> "".join([c for c in "strip my spaces" if not c.isspace()])
'stripmyspaces'