In Python durch Komma und Leerzeichen trennen

Ich habe Python-Code, der durch Komma geteilt wird, aber das Leerzeichen nicht entfernt:

>>> string = "blah, lots  ,  of ,  spaces, here "
>>> mylist = string.split(',')
>>> print mylist
['blah', ' lots  ', '  of ', '  spaces', ' here ']

Ich würde lieber Leerzeichen wie folgt entfernen:

['blah', 'lots', 'of', 'spaces', 'here']

Ich bin mir bewusst, dass ich die Liste durchlaufen und jedes Element entfernen () kann, aber da dies Python ist, gibt es vermutlich eine schnellere, einfachere und elegantere Möglichkeit, dies zu tun.

Verwenden Sie das Listenverständnis - einfacher und genauso einfach zu lesen wie eine forSchleife.

my_string = "blah, lots  ,  of ,  spaces, here "
result = [x.strip() for x in my_string.split(',')]
# result is ["blah", "lots", "of", "spaces", "here"]

Siehe: Python-Dokumente zum Listenverständnis
Eine gute 2-Sekunden-Erklärung zum Listenverständnis.

Mit einem regulären Ausdruck teilen. Hinweis: Ich habe den Fall mit führenden Leerzeichen allgemeiner gestaltet. Das Listenverständnis besteht darin, die Nullzeichenfolgen vorne und hinten zu entfernen.

>>> import re
>>> string = "  blah, lots  ,  of ,  spaces, here "
>>> pattern = re.compile("^\s+|\s*,\s*|\s+$")
>>> print([x for x in pattern.split(string) if x])
['blah', 'lots', 'of', 'spaces', 'here']

Dies funktioniert auch dann, wenn ^\s+es nicht übereinstimmt:

>>> string = "foo,   bar  "
>>> print([x for x in pattern.split(string) if x])
['foo', 'bar']
>>>

Hier ist, warum Sie ^ \ s + benötigen:

>>> pattern = re.compile("\s*,\s*|\s+$")
>>> print([x for x in pattern.split(string) if x])
['  blah', 'lots', 'of', 'spaces', 'here']

Sehen Sie die führenden Räume in bla?

Erläuterung: Oben wird der Python 3-Interpreter verwendet, die Ergebnisse in Python 2 sind jedoch dieselben.

Ich kam, um hinzuzufügen:

map(str.strip, string.split(','))

aber sah, dass es bereits von Jason Orendorff in einem Kommentar erwähnt worden war .

Als ich Glenn Maynards Kommentar in derselben Antwort las, in der Listenverständnisse über die Karte vorgeschlagen wurden, begann ich mich zu fragen, warum. Ich nahm an, dass er aus Performancegründen meinte, aber natürlich könnte er aus stilistischen Gründen gemeint sein oder etwas anderes (Glenn?).

Ein schneller (möglicherweise fehlerhafter?) Test auf meiner Box, bei dem die drei Methoden in einer Schleife angewendet wurden, ergab:

[word.strip() for word in string.split(',')]
$ time ./list_comprehension.py 
real    0m22.876s

map(lambda s: s.strip(), string.split(','))
$ time ./map_with_lambda.py 
real    0m25.736s

map(str.strip, string.split(','))
$ time ./map_with_str.strip.py 
real    0m19.428s

machen map(str.strip, string.split(','))den Sieger, obwohl es scheint , sie sind alle in derselben Liga.

Natürlich sollte eine Karte (mit oder ohne Lambda) aus Leistungsgründen nicht unbedingt ausgeschlossen werden, und für mich ist sie mindestens so klar wie ein Listenverständnis.

Bearbeiten:

Python 2.6.5 unter Ubuntu 10.04

Entfernen Sie einfach den Leerraum aus der Zeichenfolge, bevor Sie ihn teilen.

mylist = my_string.replace(' ','').split(',')

Ich weiß, dass dies bereits beantwortet wurde, aber wenn Sie dies häufig beenden, sind reguläre Ausdrücke möglicherweise der bessere Weg:

>>> import re
>>> re.sub(r'\s', '', string).split(',')
['blah', 'lots', 'of', 'spaces', 'here']

Das \sentspricht jedem Leerzeichen, und wir ersetzen es einfach durch eine leere Zeichenfolge ''. Weitere Informationen finden Sie hier: http://docs.python.org/library/re.html#re.sub

import re
result=[x for x in re.split(',| ',your_string) if x!='']

Das funktioniert gut für mich.

re (wie in regulären Ausdrücken) ermöglicht das Aufteilen auf mehrere Zeichen gleichzeitig:

$ string = "blah, lots  ,  of ,  spaces, here "
$ re.split(', ',string)
['blah', 'lots  ', ' of ', ' spaces', 'here ']

Dies funktioniert nicht gut für Ihre Beispielzeichenfolge, aber gut für eine durch Kommas getrennte Liste. Für Ihre Beispielzeichenfolge können Sie die re.split-Leistung kombinieren, um Regex-Muster zu teilen , um einen "Split-on-this-or-that" -Effekt zu erzielen.

$ re.split('[, ]',string)
['blah',
 '',
 'lots',
 '',
 '',
 '',
 '',
 'of',
 '',
 '',
 '',
 'spaces',
 '',
 'here',
 '']

Leider ist das hässlich, aber ein filterWille macht den Trick:

$ filter(None, re.split('[, ]',string))
['blah', 'lots', 'of', 'spaces', 'here']

Voila!

map(lambda s: s.strip(), mylist)wäre ein bisschen besser als explizite Schleifen. Oder für das Ganze auf einmal:map(lambda s:s.strip(), string.split(','))

s = 'bla, buu, jii'

sp = []
sp = s.split(',')
for st in sp:
    print st

import re
mylist = [x for x in re.compile('\s*[,|\s+]\s*').split(string)]

Einfach Komma oder mindestens ein Leerzeichen mit / ohne vorhergehende / nachfolgende Leerzeichen.

Bitte versuche!

map(lambda s: s.strip(), mylist)wäre ein bisschen besser als explizite Schleifen.
Oder für das Ganze auf einmal:

map(lambda s:s.strip(), string.split(','))

Das ist im Grunde alles was Sie brauchen.