Fractionner par virgule et supprimer les espaces en Python

J'ai du code python qui se divise en virgule, mais ne supprime pas l'espace blanc:

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

Je préfère me retrouver avec des espaces supprimés comme ceci:

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

Je suis conscient que je pourrais parcourir la liste et supprimer () chaque élément mais, comme il s'agit de Python, je suppose qu'il existe une manière plus rapide, plus facile et plus élégante de le faire.

Utilisez la compréhension de liste - plus simple et tout aussi facile à lire qu'une forboucle.

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

Voir: Documents Python sur la compréhension de liste
Une bonne explication de 2 secondes sur la compréhension de liste.

Fractionnez en utilisant une expression régulière. Remarque J'ai rendu le cas plus général avec des espaces de début. La compréhension de la liste consiste à supprimer les chaînes nulles à l'avant et à l'arrière.

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

Cela fonctionne même si ^\s+ne correspond pas:

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

Voici pourquoi vous avez besoin de ^ \ s +:

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

Voir les principaux espaces de bla?

Clarification: ci-dessus utilise l'interpréteur Python 3, mais les résultats sont les mêmes dans Python 2.

Je suis venu ajouter:

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

mais vu qu'il avait déjà été mentionné par Jason Orendorff dans un commentaire .

En lisant le commentaire de Glenn Maynard dans la même réponse suggérant des compréhensions de liste sur la carte, j'ai commencé à me demander pourquoi. Je supposais qu'il voulait dire pour des raisons de performance, mais bien sûr il aurait pu vouloir dire pour des raisons stylistiques, ou autre chose (Glenn?).

Un test rapide (éventuellement imparfait?) Sur ma box appliquant les trois méthodes en boucle a donc révélé:

[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

fabrication map(str.strip, string.split(',')) le gagnant, même s'il semble qu'ils sont tous dans le même stade.

Certes, la carte (avec ou sans lambda) ne doit pas nécessairement être exclue pour des raisons de performances, et pour moi, c'est au moins aussi clair qu'une compréhension de liste.

Éditer:

Python 2.6.5 sur Ubuntu 10.04

Supprimez simplement l'espace blanc de la chaîne avant de le diviser.

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

Je sais que cela a déjà été répondu, mais si vous arrêtez de faire beaucoup de choses, les expressions régulières peuvent être une meilleure façon de procéder:

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

Le \scorrespond à n'importe quel caractère d'espacement, et nous le remplaçons simplement par une chaîne vide ''. Vous pouvez trouver plus d'informations ici: http://docs.python.org/library/re.html#re.sub

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

cela fonctionne bien pour moi.

re (comme dans les expressions régulières) permet de diviser plusieurs caractères à la fois:

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

Cela ne fonctionne pas bien pour votre exemple de chaîne, mais fonctionne bien pour une liste séparée par des virgules. Pour votre exemple de chaîne, vous pouvez combiner la puissance re.split pour diviser les motifs regex pour obtenir un effet "split-on-this-or-that".

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

Malheureusement, c'est moche, mais filterça fera l'affaire:

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

Voila!

map(lambda s: s.strip(), mylist)serait un peu mieux qu'une boucle explicite. Ou pour le tout à la fois: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)]

Simplement, une virgule ou au moins un espace blanc avec / sans espaces blancs précédents / suivants.

S'il vous plaît essayez!

map(lambda s: s.strip(), mylist)serait un peu mieux qu'une boucle explicite.
Ou pour le tout à la fois:

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

C'est essentiellement tout ce dont vous avez besoin.