Insertion d'un élément après chaque élément dans une liste (Python)

Question

Dire que j'ai une liste comme ceci:

a = [[1, 2, 3], [4, 5, 6]] 
filler = ['cat'] 

Comment pourrais-je obtenir

b = [[1 ,2 ,3], ['cat'], [4, 5, 6], ['cat']] 

En sortie?

Answer 1

est ici une idée:

import itertools 

a = [[1, 2, 3], [4, 5, 6]] 
filler = ['cat'] 
print list(itertools.chain.from_iterable(zip(a, [filler] * len(a)))) 

Sortie:

[[1, 2, 3], ['cat'], [4, 5, 6], ['cat']] 

Answer 2

Pas pythonique mais semble fonctionner.

list = [[1, 2, 3], [4, 5, 6]] 
result = [] 
for e in list: 
    result.append(e) 
    result.append(['cat']) 
result.pop() 

Trouvé à ce poste: Add an item between each item already in the list

Answer 3

a = [[1, 2, 3], [4, 5, 6]] 
filler = ['cat'] 
out = [] 

for i in a: 
    out.append(i) 
    out.append(filler) 

Answer 4

result = [si for i in zip(a, [filler]*len(a)) for si in i] 

Answer 5

Je préfère itertools utiliser pour des trucs comme ça:

>>> import itertools as it 
>>> a = [[1, 2, 3], [4, 5, 6]] 
>>> filler = ['cat'] 
>>> list(it.chain.from_iterable(it.izip(a, it.repeat(filler)))) 
[[1, 2, 3], ['cat'], [4, 5, 6], ['cat']] 

Answer 6

Essayez ceci, comme une doublure:

from operator import add 
a = [[1, 2, 3], [4, 5, 6]] 
filler = ['cat'] 

reduce(add, ([x, filler] for x in a)) 
> [[1, 2, 3], ['cat'], [4, 5, 6], ['cat']] 

Ou encore plus simple, sans utiliser reduce:

sum(([x, filler] for x in a), []) 
> [[1, 2, 3], ['cat'], [4, 5, 6], ['cat']] 

Les deux solutions font la même chose: d'abord, créez un générateur de [element, filler] et ensuite aplatissez le flux de paires résultant. Pour l'efficacité, la première étape est réalisée en utilisant des générateurs pour éviter les listes intermédiaires inutiles.

MISE À JOUR:

Ce poste est un exemple de manuel de savoir pourquoi un troll ne doit pas être alimenté dans un forum en ligne. Voir les commentaires pour voir ce que je veux dire. Il vaut mieux ignorer le troll.

Answer 7

quelque chose comme ceci en utilisant itertools.islice() et itertools.cycle():

cycle() est utilisé pour répéter un élément, et utilisé islice() réduire le nombre de repeatation à len(a), puis utilisez izip() ou simples zip() sur a et l'itérateur retourné par islice() , cela retournera la liste des tuples. Vous pouvez ensuite l'aplatir en utilisant itertools.chain().

In [72]: a 
Out[72]: [[1, 2, 3], [4, 5, 6]] 

In [73]: b 
Out[73]: ['cat'] 

In [74]: cyc=islice(cycle(b),len(a)) 

In [75]: lis=[] 

In [76]: for x in a: 
    lis.append(x) 
    lis.append([next(cyc)]) 
    ....:  

In [77]: lis 
Out[77]: [[1, 2, 3], ['cat'], [4, 5, 6], ['cat']] 

ou:

In [108]: a 
Out[108]: [[1, 2, 3], [4, 5, 6]] 

In [109]: b 
Out[109]: ['cat'] 

In [110]: cyc=islice(cycle(b),len(a)) 

In [111]: list(chain(*[(x,[y]) for x,y in izip(a,cyc)])) 
Out[111]: [[1, 2, 3], ['cat'], [4, 5, 6], ['cat']] 

Answer 8

J'aime les itertools solutions à base affichées ici, mais voici une approche qui ne nécessite pas de liste ou compréhensions itertools, et je parie que c'est super rapide.

new_list = [filler] * (len(a) * 2) 
new_list[0::2] = a 

Answer 9

python 3.2 

    a = [[1, 2, 3], [4, 5, 6]] 
    b = ['cat'] 
    _=[a.insert(x,b) for x in range(1,len(a)*2,2)]