Jak usunąć wszystkie białe znaki z łańcucha

Jak usunąć wszystkie spacje w ciągu znaków Pythona? Na przykład chcę, aby struna podobna była strip my spacesdo przekształcenia stripmyspaces, ale nie mogę tego osiągnąć za pomocą strip():

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

Wykorzystując zachowanie str.split bez parametru sep:

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

Jeśli chcesz tylko usunąć spacje zamiast wszystkich białych znaków:

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

Przedwczesna optymalizacja

Chociaż wydajność nie jest głównym celem - pisanie przejrzystego kodu jest - oto kilka początkowych terminów:

$ 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

Zwróć uwagę, że wyrażenie regularne jest buforowane, więc nie jest tak wolne, jak można by sobie wyobrazić. Skompilowanie go wcześniej pomaga niektórym, ale w praktyce będzie miało znaczenie tylko wtedy, gdy wywołasz to wiele razy:

$ 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

Mimo że re.sub jest 11,3 razy wolniejsze, pamiętaj, że wąskie gardła są z pewnością gdzie indziej. Większość programów nie zauważyłaby różnicy między którąkolwiek z tych 3 opcji.

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

Obsługuje również wszystkie białe znaki, o których nie myślisz (wierz mi, jest ich mnóstwo).

Alternatywnie,

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

A oto wersja Pythona3:

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

Najprościej jest użyć zamiany:

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

Alternatywnie użyj wyrażenia regularnego:

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

Usuń spacje początkowe w Pythonie

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

Usuń końcowe lub końcowe spacje w Pythonie

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

Usuń białe spacje z początku i końca ciągu w Pythonie

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

Usuń wszystkie spacje w Pythonie

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

Wypróbuj wyrażenie regularne z re.sub. Możesz wyszukać wszystkie białe znaki i zastąpić je pustym ciągiem.

\sw twoim wzorcu dopasują białe znaki - a nie tylko spacje (tabulatory, nowe linie itp.). Więcej na ten temat przeczytasz w instrukcji .

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

Jak wspomniał Roger Pate, zadziałał dla mnie następujący kod:

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

Używam Notatnika Jupyter do uruchomienia następującego kodu:

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

Stosowane są standardowe techniki filtrowania listy, chociaż nie są one tak wydajne jak metody split/joinlub translate.

Potrzebujemy zestawu białych znaków:

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

filterWbudowane:

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

Zrozumienie listy (tak, użyj nawiasów: patrz punkt odniesienia poniżej):

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

Krotnie:

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

Reper:

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

To rozwiązanie zostało przetestowane przy użyciu Pythona 3.6

Aby usunąć wszystkie spacje z ciągu w Pythonie3, możesz użyć następującej funkcji:

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

Aby usunąć wszelkie białe znaki ('\ t \ n \ r \ x0b \ x0c'), możesz użyć następującej funkcji:

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

Wyjaśnienie

str.translateMetoda Pythona jest wbudowaną metodą klasową str, pobiera tabelę i zwraca kopię ciągu z każdym znakiem odwzorowanym w przekazanej tabeli translacji. Pełna dokumentacja dla str.translate

Do stworzenia tabeli tłumaczeń str.maketranssłuży. Ta metoda jest kolejną wbudowaną metodą klasy str. Tutaj używamy go tylko z jednym parametrem, w tym przypadku ze słownikiem, w którym klucze to znaki, które mają być zastąpione, odwzorowane na wartości z wartością zastępującą znaki. Zwraca tabelę tłumaczeń do użycia z str.translate. Pełna dokumentacja dla str.maketrans

stringModuł w Pythonie zawiera kilka wspólnych operacji łańcuchowych i stałe. string.whitespacejest stałą, która zwraca łańcuch zawierający wszystkie znaki ASCII, które są uważane za białe znaki. Obejmuje to spację znaków, tabulator, wysuw wiersza, powrót, wysuw formularza i tabulator pionowy. Pełna dokumentacja dla stringów

W drugiej funkcji dict.fromkeyssłuży do tworzenia słownika, w którym kluczami są znaki w ciągu zwracane przez string.whitespacekażdy z wartością None. Pełna dokumentacja dla dict.fromkeys

Jeśli optymalna wydajność nie jest wymagana, a po prostu chcesz czegoś martwego prostego, możesz zdefiniować podstawową funkcję do testowania każdego znaku za pomocą wbudowanej metody "isspace" klasy string:

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

Budowanie no_white_spacestruny w ten sposób nie zapewni idealnej wydajności, ale rozwiązanie jest łatwe do zrozumienia.

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

Jeśli nie chcesz definiować funkcji, możesz przekonwertować ją na coś nieco podobnego za pomocą rozumienia list. Pożyczanie z rozwiązania u góry odpowiedzi join:

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