Come rimuovere tutto lo spazio dalla stringa

Come posso rimuovere tutti gli spazi in una stringa Python? Ad esempio, voglio che una stringa simile strip my spacesvenga trasformata in stripmyspaces, ma non riesco a farlo con strip():

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

Sfruttando il comportamento di str.split senza parametro sep:

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

Se vuoi solo rimuovere gli spazi anziché tutti gli spazi bianchi:

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

Ottimizzazione prematura

Anche se l'efficienza non è l'obiettivo principale - la scrittura di un codice chiaro è - ecco alcuni tempi iniziali:

$ 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

Nota che regex è memorizzato nella cache, quindi non è così lento come immagini. Compilarlo in anticipo aiuta alcuni, ma importerebbe in pratica solo se lo chiamate molte volte:

$ 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

Anche se re.sub è 11.3x più lento, ricorda che i tuoi colli di bottiglia sono sicuramente altrove. La maggior parte dei programmi non noterebbe la differenza tra nessuna di queste 3 scelte.

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

Gestisce anche tutti gli spazi bianchi a cui non stai pensando (credimi, ce ne sono molti).

In alternativa,

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

Ed ecco la versione di Python3:

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

Il più semplice è usare sostituire:

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

In alternativa, usa un'espressione regolare:

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

Rimuovi gli spazi di partenza in Python

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

Rimuovi gli spazi finali o finali in Python

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

Rimuovi gli spazi bianchi da Inizio e fine della stringa in Python

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

Rimuovi tutti gli spazi in Python

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

Prova una regex con re.sub. Puoi cercare tutti gli spazi bianchi e sostituirli con una stringa vuota.

\snel tuo modello corrisponderà ai caratteri degli spazi bianchi e non solo uno spazio (tabulazioni, nuove righe, ecc.). Puoi leggere di più a riguardo nel manuale .

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

Come menzionato da Roger Pate, il seguente codice ha funzionato per me:

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

Sto usando Jupyter Notebook per eseguire il seguente codice:

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

Si applicano le tecniche standard per filtrare un elenco, sebbene non siano efficienti come i metodi split/joino translate.

Abbiamo bisogno di una serie di spazi bianchi:

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

Il filterbuiltin:

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

Una comprensione dell'elenco (sì, utilizzare le parentesi: vedere il punto di riferimento sotto):

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

Una piega:

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

Prova delle prestazioni:

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

Questa soluzione è stata testata utilizzando Python 3.6

Per rimuovere tutti gli spazi da una stringa in Python3 puoi usare la seguente funzione:

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

Per rimuovere qualsiasi carattere di spazio ('\ t \ n \ r \ x0b \ x0c') puoi usare la seguente funzione:

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

Spiegazione

Il str.translatemetodo di Python è un metodo di classe incorporato di str, prende una tabella e restituisce una copia della stringa con ogni carattere mappato attraverso la tabella di traduzione passata. Documentazione completa per str.translate

Per creare la tabella di traduzione str.maketransviene utilizzato. Questo metodo è un altro metodo di classe incorporato di str. Qui lo usiamo con un solo parametro, in questo caso un dizionario, in cui le chiavi sono i caratteri da sostituire mappati ai valori con il valore di sostituzione dei caratteri. Restituisce una tabella di traduzione da utilizzare con str.translate. Documentazione completa per str.maketrans

Il stringmodulo in Python contiene alcune operazioni e costanti di stringa comuni. string.whitespaceè una costante che restituisce una stringa contenente tutti i caratteri ASCII considerati spazi bianchi. Ciò include lo spazio dei caratteri, la scheda, l'avanzamento di riga, il ritorno, l'avanzamento del modulo e la scheda verticale. Documentazione completa per stringa

Nella seconda funzione dict.fromkeysviene utilizzato per creare un dizionario in cui le chiavi sono i caratteri nella stringa restituiti da string.whitespaceciascuno con valore None. Documentazione completa per dict.fromkeys

Se le prestazioni ottimali non sono un requisito e vuoi semplicemente qualcosa di estremamente semplice, puoi definire una funzione di base per testare ogni carattere usando il metodo "isspace" della classe stringa:

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

Costruire la no_white_spacestringa in questo modo non avrà prestazioni ideali, ma la soluzione è facile da capire.

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

Se non si desidera definire una funzione, è possibile convertirla in qualcosa di vagamente simile con la comprensione dell'elenco. Prendendo in prestito dalla soluzione della risposta migliore join:

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