Python split pour les listes

Si nous avons un list de strings en python et que vous voulez créer des sous-listes basées sur certains string comment devrions-nous le faire?

Par exemple:

l = ["data","more data","","data 2","more data 2","danger","","date3","lll"]
p = split_special(l,"")

générerait:

p = [["data","more data"],["data 2","more data 2","danger"],["date3","lll"]]
Pourquoi la programmation fonctionnelle tag?
pour obtenir une réponse fonctionnelle à l'aide de méthodes de programmation en python

OriginalL'auteur ppaulojr | 2013-01-25

  1. 25

    itertools.groupby est une approche (comme c'est souvent le cas):

    >>> l = ["data","more data","","data 2","more data 2","danger","","date3","lll"]
>>> from itertools import groupby
>>> groupby(l, lambda x: x == "")
<itertools.groupby object at 0x9ce06bc>
>>> [list(group) for k, group in groupby(l, lambda x: x == "") if not k]
[['data', 'more data'], ['data 2', 'more data 2', 'danger'], ['date3', 'lll']]

    On peut même tricher un peu à cause de ce cas particulier:

    >>> [list(group) for k, group in groupby(l, bool) if k]
[['data', 'more data'], ['data 2', 'more data 2', 'danger'], ['date3', 'lll']]
    nice triche! pour le lambda, il peut être amélioré comme lambda x: not x ou tout simplement operator.not_

    OriginalL'auteur DSM

  2. 4

    Une possible mise en œuvre à l'aide de itertools

    >>> l
['data', 'more data', '', 'data 2', 'more data 2', 'danger', '', 'date3', 'lll']
>>> it_l = iter(l)
>>> from itertools import takewhile, dropwhile
>>> [[e] + list(takewhile(lambda e: e != "", it_l)) for e in it_l if e != ""]
[['data', 'more data'], ['data 2', 'more data 2', 'danger'], ['date3', 'lll']]

    Note*

    C'est aussi rapide que d'utiliser groupby

    >>> stmt_dsm = """
[list(group) for k, group in groupby(l, lambda x: x == "") if not k]
"""
>>> stmt_ab = """
it_l = iter(l)
[[e] + list(takewhile(lambda e: e != "", it_l)) for e in it_l if e != ""]
"""
>>> t_ab = timeit.Timer(stmt = stmt_ab, setup = "from __main__ import l, dropwhile, takewhile")
>>> t_dsm = timeit.Timer(stmt = stmt_dsm, setup = "from __main__ import l, groupby")
>>> t_ab.timeit(100000)
1.6863486541265047
>>> t_dsm.timeit(100000)
1.5298066765462863
>>> t_ab.timeit(100000)
1.735611326163962
>>>
    Pourquoi êtes-vous y compris le purement pour exemple groupby(l, lambda x: x ="") ligne? Il ne fait rien. En outre, [list(group) for k, group in groupby(l, bool) if k] devrait être de 10%+ rapide.
    J'ai eu tort de l'ajouter, mais en enlevant ce n'est pas beaucoup de distance. Btw, comme vous l'avez mentionné, de la même manière, [list(takewhile(bool, it_l)) for e in it_l if e != ""] doivent aussi être plus rapide, mais je me sens encore, la différence est négligeable et comparables.

    OriginalL'auteur Abhijit

  3. 2

    réduction vient à l'esprit:

    def split(iterable, where):
    def splitter(acc, item, where=where):
        if item == where:
            acc.append([])
        else:
            acc[-1].append(item)
        return acc
    return reduce(splitter, iterable, [[]])


data = ["data","more data","","data 2","more data 2","danger","","date3","lll"]
print split(data, '')

    Résultat:

    [['data', 'more data'], ['data 2', 'more data 2', 'danger'], ['date3', 'lll']]
    Une chose à noter est que reduce en python est en fait foldl dans CS termes - le CS reduce doit être utilisé sur une fonction qui ne se soucient pas dans quel ordre les entrées venir. Cela peut vous causer des ennuis si vous essayez de reduce dans d'autres langues.

    OriginalL'auteur pillmuncher

  4. 1

    Je ne suis pas sûr que c'est le plus "pythonic" façon de le résoudre.

    def split_seq(seq, sep):
    start = 0
    while start < len(seq):
        try:
           stop = start + seq[start:].index(sep)
           yield seq[start:stop]
           start = stop + 1
        except ValueError:
           yield seq[start:]
           break

ll = ["data","more data","","data 2","more data 2","danger","","date3","lll"]
p = [i for i in split_seq(ll,"")]
    +1: C'est probablement le plus rapide. Btw, au lieu de LC vous pourriez avoir simple fait list(split_seq(ll,"")

    OriginalL'auteur ppaulojr

  5. 1

    Heres une idée. 🙂

    def spec_split(seq,sep):
    # Ideally this separator will never be in your list
    odd_sep = "!@#$%^&*()"

    # Join all the items with the odd separator and split
    # anywhere the odd separator + separator + odd seperator meet
    # This makes a list of items broken by the separator
    jumble = odd_sep.join(seq).split(odd_sep+sep+odd_sep)

    # split the remaining items broken by odd separators into sublists
    return [item.split(odd_sep) for item in jumble]

    OriginalL'auteur Paul Seeb