Einfache Möglichkeit, mehrere Leerzeichen in einer Zeichenfolge zu entfernen?

Nehme an, dies ist die Zeichenfolge:

The   fox jumped   over    the log.

Resultieren würde:

The fox jumped over the log.

Was ist die einfachste, 1-2 liner, die dies tun können? Ohne splitting und gehen in Listen...

InformationsquelleAutor der Frage TIMEX | 2009-10-09

  1. 292
    >>> import re
>>> re.sub(' +',' ','The     quick brown    fox')
'The quick brown fox'

    InformationsquelleAutor der Antwort Josh Lee

  2. 352

    foo ist dein string:

    " ".join(foo.split())

    Werden Sie gewarnt, wenn diese entfernt alle whitespace-Zeichen (Leerzeichen, Tabulator, newline, return, formfeed)". (Dank an hhsaffarsiehe Kommentare) ie "this is \t a test\n" effektiv am Ende als "this is a test"

    InformationsquelleAutor der Antwort Taylor Leese

  3. 71
    import re
s = "The   fox jumped   over    the log."
re.sub("\s\s+" , " ", s)

    oder

    re.sub("\s\s+", " ", s)

    da der Raum vor dem Komma aufgeführt ist als Hauptärgernis in PEP8, wie erwähnt, durch die Elche in die Kommentare.

    InformationsquelleAutor der Antwort Nasir

  4. 44

    Mit regexes mit "\s" und es tut sich einfach string.split () - 's wird auch entfernen Sie andere whitespace-Zeichen wie Zeilenumbrüche, Zeilenschaltungen, Tabulatoren. Es sei denn, dies ist erwünscht, um nur tun mehrere Räumepräsentiere ich diese Beispiele.

    EDIT: Da bin ich gar nicht zu tun, ich schlief, und neben der Korrektur eines Tippfehlers auf die letzten Ergebnisse (v3.3.3 @ 64-bit, nicht 32-bit), der offensichtliche hit me: der test-string war eher trivial.

    So, ich habe ... 11 Absätze, 1000 Worte, 6665 bytes von Lorem Ipsum mehr zu bekommen-realistische Zeit-tests. Ich habe dann Hinzugefügt, random-Länge extra-Raum in:

    original_string = ''.join(word + (' ' * random.randint(1, 10)) for word in lorem_ipsum.split(' '))

    Ich auch korrigiert, die "richtige join"; wenn man sich darum kümmert, die one-liner im wesentlichen einen Streifen von führenden/nachgestellten Leerzeichen, diese korrigierte version bewahrt einen führenden/nachgestellten Leerzeichen (aber nur EINE ;-). (Ich fand dies, weil Sie die zufällig angeordneten lorem_ipsum habe extra Leerzeichen am Ende und so konnte die assert.)

    # setup = '''

import re

def while_replace(string):
    while '  ' in string:
        string = string.replace('  ', ' ')

    return string

def re_replace(string):
    return re.sub(r' {2,}' , ' ', string)

def proper_join(string):
    split_string = string.split(' ')

    # To account for leading/trailing spaces that would simply be removed
    beg = ' ' if not split_string[ 0] else ''
    end = ' ' if not split_string[-1] else ''

    # versus simply ' '.join(item for item in string.split(' ') if item)
    return beg + ' '.join(item for item in split_string if item) + end

original_string = """Lorem    ipsum        ... no, really, it kept going...          malesuada enim feugiat.         Integer imperdiet    erat."""

assert while_replace(original_string) == re_replace(original_string) == proper_join(original_string)

#'''
    # while_replace_test
new_string = original_string[:]

new_string = while_replace(new_string)

assert new_string != original_string
    # re_replace_test
new_string = original_string[:]

new_string = re_replace(new_string)

assert new_string != original_string
    # proper_join_test
new_string = original_string[:]

new_string = proper_join(new_string)

assert new_string != original_string

    HINWEIS: Die "while version" machte eine Kopie der original_stringwie ich glaube, einmal geändert, auf dem ersten Lauf aufeinander folgende Läufe schneller gehen würde (wenn auch nur ein bisschen). Da dies fügt Zeit, ich habe diese Zeichenfolge kopieren, um die beiden anderen so, dass die Zeiten zeigten, das Unterschied nur in der Logik. Beachten Sie, dass die Haupt - stmt auf timeit - Instanzen wird nur dann ausgeführt werden, wenn; der ursprüngliche Weg, ich Tat dies, die while Schleife gearbeitet, auf dem selben label, original_string somit den zweiten Lauf, es wäre nichts zu tun. So, wie es jetzt eingerichtet, eine Funktion aufrufen, mit zwei verschiedenen Etiketten, das ist kein problem. Ich habe assert Aussagen zu den Arbeitern, um zu überprüfen, ändern wir etwas, was jeder iteration (für diejenigen, die möglicherweise zweifelhafte). E. g., ändern sich diese, und es bricht:

    # while_replace_test
new_string = original_string[:]

new_string = while_replace(new_string)

assert new_string != original_string # will break the 2nd iteration

while '  ' in original_string:
    original_string = original_string.replace('  ', ' ')
    Tests run on a laptop with an i5 processor running Windows 7 (64-bit).

timeit.Timer(stmt = test, setup = setup).repeat(7, 1000)

test_string = 'The   fox jumped   over\n\t    the log.' # trivial

Python 2.7.3, 32-bit, Windows
                test |      minum |    maximum |    average |     median
---------------------+------------+------------+------------+-----------
  while_replace_test |   0.001066 |   0.001260 |   0.001128 |   0.001092
     re_replace_test |   0.003074 |   0.003941 |   0.003357 |   0.003349
    proper_join_test |   0.002783 |   0.004829 |   0.003554 |   0.003035

Python 2.7.3, 64-bit, Windows
                test |      minum |    maximum |    average |     median
---------------------+------------+------------+------------+-----------
  while_replace_test |   0.001025 |   0.001079 |   0.001052 |   0.001051
     re_replace_test |   0.003213 |   0.004512 |   0.003656 |   0.003504
    proper_join_test |   0.002760 |   0.006361 |   0.004626 |   0.004600

Python 3.2.3, 32-bit, Windows
                test |      minum |    maximum |    average |     median
---------------------+------------+------------+------------+-----------
  while_replace_test |   0.001350 |   0.002302 |   0.001639 |   0.001357
     re_replace_test |   0.006797 |   0.008107 |   0.007319 |   0.007440
    proper_join_test |   0.002863 |   0.003356 |   0.003026 |   0.002975

Python 3.3.3, 64-bit, Windows
                test |      minum |    maximum |    average |     median
---------------------+------------+------------+------------+-----------
  while_replace_test |   0.001444 |   0.001490 |   0.001460 |   0.001459
     re_replace_test |   0.011771 |   0.012598 |   0.012082 |   0.011910
    proper_join_test |   0.003741 |   0.005933 |   0.004341 |   0.004009
    test_string = lorem_ipsum
# Thanks to http://www.lipsum.com/
# "Generated 11 paragraphs, 1000 words, 6665 bytes of Lorem Ipsum"

Python 2.7.3, 32-bit
                test |      minum |    maximum |    average |     median
---------------------+------------+------------+------------+-----------
  while_replace_test |   0.342602 |   0.387803 |   0.359319 |   0.356284
     re_replace_test |   0.337571 |   0.359821 |   0.348876 |   0.348006
    proper_join_test |   0.381654 |   0.395349 |   0.388304 |   0.388193    

Python 2.7.3, 64-bit
                test |      minum |    maximum |    average |     median
---------------------+------------+------------+------------+-----------
  while_replace_test |   0.227471 |   0.268340 |   0.240884 |   0.236776
     re_replace_test |   0.301516 |   0.325730 |   0.308626 |   0.307852
    proper_join_test |   0.358766 |   0.383736 |   0.370958 |   0.371866    

Python 3.2.3, 32-bit
                test |      minum |    maximum |    average |     median
---------------------+------------+------------+------------+-----------
  while_replace_test |   0.438480 |   0.463380 |   0.447953 |   0.446646
     re_replace_test |   0.463729 |   0.490947 |   0.472496 |   0.468778
    proper_join_test |   0.397022 |   0.427817 |   0.406612 |   0.402053    

Python 3.3.3, 64-bit
                test |      minum |    maximum |    average |     median
---------------------+------------+------------+------------+-----------
  while_replace_test |   0.284495 |   0.294025 |   0.288735 |   0.289153
     re_replace_test |   0.501351 |   0.525673 |   0.511347 |   0.508467
    proper_join_test |   0.422011 |   0.448736 |   0.436196 |   0.440318

    Dem trivialen string, es würde scheinen, dass eine while-Schleife ist die Schnellste, gefolgt von der Pythonic string-split/join, und regex hochziehen der Rückseite.

    Für nicht-triviale Zeichenfolgenscheint es etwas mehr zu beachten. 32-bit-Version 2.7? Es ist regex ist die Rettung! 2.7 64-bit? Ein while Schleife ist am besten, durch eine anständige Marge. 32-bit-3.2, gehen mit der "richtigen" join. 64-bit 3.3, gehen Sie für eine while Schleife. Wieder.

    In das Ende kann man die Leistung verbessern wenn/wo/Wann benötigtaber es ist immer am besten,denken Sie daran das mantra:

    1. Damit Es Funktioniert
    2. Recht Machen
    3. Es Schnell

    IANAL, YMMV, Caveat Emptor!

    InformationsquelleAutor der Antwort pythonlarry

  5. 27

    Muss Zustimmen, Paul McGuire ' s Kommentar oben. Zu mir, 

             ' '.join(the_string.split())

    ist weit vorzuziehen, bewegt sich ein regex. Meine Messungen (Linux, Python 2.5) zeigen die split-dann-Verknüpfung ist fast 5 mal schneller als der re.sub(...)", und immer noch 3 mal schneller, wenn Sie precompile den regex einmal und der Vorgang mehrere Male. Und es ist in jeder Hinsicht einfacher zu verstehen -- viel mehr pythonic.

    InformationsquelleAutor der Antwort Kevin Little

  6. 10

    Ähnlich zu den vorherigen Lösungen, aber mehr spezifisch: ersetzen Sie zwei oder mehr Leerzeichen mit einem:

    >>> import re
>>> s = "The   fox jumped   over    the log."
>>> re.sub('\s{2,}', ' ', s)
'The fox jumped over the log.'

    InformationsquelleAutor der Antwort Peter

  7. 7

    Einem einfachen soultion nutzen

    >>> import re
>>> s="The   fox jumped   over    the log."
>>> print re.sub('\s+',' ', s)
The fox jumped over the log.

    InformationsquelleAutor der Antwort HMS

  8. 2

    Andere alternative

    >>> import re
>>> str = 'this is a            string with    multiple spaces and    tabs'
>>> str = re.sub('[ \t]+' , ' ', str)
>>> print str
this is a string with multiple spaces and tabs

    InformationsquelleAutor der Antwort Kreshnik

  9. 2

    Eine Zeile code zu entfernen Sie alle zusätzlichen Leerzeichen vor, nach und innerhalb von einem Satz: 

    sentence = "  The   fox jumped   over    the log.  "
sentence = ' '.join(filter(None,sentence.split(' ')))

    Erklärung:

    1. Split gesamte Zeichenfolge in der Liste.
    2. Filter leeren Elemente aus der Liste.
    3. Wieder restlichen Elemente* mit Leerzeichen

    *Die restlichen Elemente sollten Wörter oder Wörter mit Satzzeichen, etc. Ich habe nicht testen Sie dies ausgiebig, aber dies sollte ein guter Ausgangspunkt. Alle die besten!!!

    InformationsquelleAutor der Antwort gabchan

  10. 2
    import re
string =  re.sub('[ \t\n]+', ' ', 'The     quick brown                \n\n             \t        fox')

    Dies wird entfernen Sie alle Register, neue Zeilen und mehrere Leerzeichen mit einzelnen weißen Raum.

    InformationsquelleAutor der Antwort Rakesh Kumar

  11. 1

    Dieser scheint auch zu funktionieren:

    while "  " in s:
    s=s.replace("  "," ")

    Wo die variable s repräsentiert den string.

    InformationsquelleAutor der Antwort Anakimi

  12. 1
    def unPretty(S):
   # given a dictionary, json, list, float, int, or even a string.. 
   # return a string stripped of CR, LF replaced by space, with multiple spaces reduced to one.
   return ' '.join( str(S).replace('\n',' ').replace('\r','').split() )

    InformationsquelleAutor der Antwort jw51

  13. 0

    Wenn es Leerzeichen, die Sie beschäftigen sich mit splitting auf None nicht leerer string im Rückgabewert.

    https://docs.python.org/2/library/stdtypes.html#str.split

    InformationsquelleAutor der Antwort jsnklln

  14. 0
    string='This is a             string full of spaces          and taps'
string=string.split(' ')
while '' in string:
    string.remove('')
string=' '.join(string)
print(string)

    Ergebnisse:

    Dies ist ein string voller Leerzeichen und tippt

    InformationsquelleAutor der Antwort Hassan Abdul-Kareem

  15. 0

    Zum entfernen des weißen Bereichs, unter Berücksichtigung führende, nachfolgende und zusätzliche Leerzeichen zwischen Wörtern verwenden:

    (?<=\s) +|^ +(?=\s)| (?= +[\n\0])

    den ersten oder beschäftigt sich mit führenden Leerzeichen, das zweite oder beschäftigt sich mit dem start der Zeichenkette führende Leerzeichen, und der Letzte befasst sich mit nachgestellten Leerzeichen

    für den Nachweis der Verwendung dieser link wird Ihnen mit einem test.

    https://regex101.com/r/meBYli/4

    lassen Sie mich wissen, wenn Sie finden einen Eingang, der bricht diesen regex code.

    AUCH - dies ist mit der re.split-Funktion

    InformationsquelleAutor der Antwort CameronE

  16. 0

    In einigen Fällen ist es wünschenswert, ersetzen Sie hintereinander alle whitespace-Zeichen mit einer einzigen Instanz von dass Charakter. Würde man einen regulären Ausdruck verwenden, mit Rückverweise zu tun.

    (\s)\1{1,} entspricht einem beliebigen whitespace-Zeichen, gefolgt von einem oder mehr vorkommen des Charakters. Nun, alles, was Sie tun müssen, ist geben Sie die erste Gruppe (\1) als Ersatz für das match.

    Wickeln diese in eine Funktion:

    import re

def normalize_whitespace(string):
    return re.sub(r'(\s)\1{1,}', r'\1', string)
    >>> normalize_whitespace('The   fox jumped   over    the log.')
'The fox jumped over the log.'
>>> normalize_whitespace('First    line\t\t\t \n\n\nSecond    line')
'First line\t \nSecond line'

    InformationsquelleAutor der Antwort vaultah

  17. 0

    Ich habe nicht viel gelesen in den anderen Beispielen, aber ich habe gerade erstellt diese Methode für die Konsolidierung von mehreren aufeinanderfolgenden Leerzeichen.

    Es verwendet keine Bibliotheken, und während es ist relativ lang in Bezug auf die Skript-Längen es ist nicht eine komplexe Umsetzung

    def spaceMatcher(command):
    """
    function defined to consolidate multiple whitespace characters in 
    strings to a single space
    """
    #initiate index to flag if more than 1 consecutive character 
    iteration
    space_match = 0
    space_char = ""
    for char in command:
      if char == " ":
          space_match += 1
          space_char += " "
      elif (char != " ") & (space_match > 1):
          new_command = command.replace(space_char, " ")
          space_match = 0
          space_char = ""
      elif char != " ":
          space_match = 0
          space_char = ""
   return new_command

command = None
command = str(input("Please enter a command ->"))
print(spaceMatcher(command))
print(list(spaceMatcher(command)))

    InformationsquelleAutor der Antwort Scott Anderson

  18. 0

    Schnellsten bekommen Sie für user-generierte Zeichenfolgen ist:

        if '  ' in text:
        while '  ' in text:
            text = text.replace('  ', ' ')

    Dem Kurzschluss ist es etwas schneller als pythonlarry die umfassende Antwort. Gehen Sie für diese, wenn Sie nach Effizienz, und sind streng auf der Suche, um Unkraut aus extra Leerzeichen der einzige Raum Vielfalt.

    InformationsquelleAutor der Antwort Hassan Baig

  19. 0

    Können Sie auch verwenden, die string-splitting-Technik in ein Pandas DataFrame ohne zu verwenden .gelten(..), die ist nützlich, wenn Sie brauchen, um den Betrieb schnell auf einer großen Anzahl von strings. Hier ist es auf einer Zeile:

    df['message'] = (df['message'].str.split()).str.join(' ')

    InformationsquelleAutor der Antwort devinbost

Schreibe einen Kommentar