Insérer un élément dans la liste Python après chaque nième élément

Dire que j'ai une liste Python comme ceci:

letters = ['a','b','c','d','e','f','g','h','i','j']

Je veux insérer un " x " après chaque nième élément, disons trois personnages dans cette liste. Le résultat devrait être:

letters = ['a','b','c','x','d','e','f','x','g','h','i','x','j']

Je comprends que je peux le faire avec le bouclage et de l'insertion. Ce que je suis à la recherche de est un Pythonish-chemin, un one-liner peut-être?

InformationsquelleAutor Hasan Iqbal | 2015-06-25

13

J'en ai deux revêtements un.

Donné:
```
>>> letters = ['a','b','c','d','e','f','g','h','i','j']
```
1. Utilisation enumerate pour obtenir l'index, ajoutez 'x' chaque 3^rd la lettre, par exemple: mod(n, 3) == 2, puis concaténer en chaîne et list() il.
```
>>> list(''.join(l + 'x' * (n % 3 == 2) for n, l in enumerate(letters)))

['a', 'b', 'c', 'x', 'd', 'e', 'f', 'x', 'g', 'h', 'i', 'x', 'j']
```
  Mais comme @sancho.s souligne cela ne fonctionne pas si l'un des éléments de plus d'une lettre.
2. Imbriquer des compréhensions pour aplatir une liste de listes^a, coupés en groupes de 3 avec 'x' ajouté si moins de 3 à partir de la fin de la liste.
```
>>> [x for y in (letters[i:i+3] + ['x'] * (i < len(letters) - 2) for
     i in xrange(0, len(letters), 3)) for x in y]

['a', 'b', 'c', 'x', 'd', 'e', 'f', 'x', 'g', 'h', 'i', 'x', 'j']
```
(a) [item for subgroup in groups for item in subgroup] aplatit dentelés liste de listes.
- Le premier ne fonctionne pas si des éléments ne sont pas de simples caractères. Il se termine par une liste avec chaque élément d'un seul caractère (fractionnement des chaînes de caractères).
InformationsquelleAutor Mark Mikofski
8

Essayer cette
```
i = n
while i < len(letters):
    letters.insert(i, 'x')
    i += (n+1)
```
où n est après combien d'éléments que vous souhaitez insérer 'x'.

Cela fonctionne par l'initialisation d'une variable i et définir égal à n. Vous pouvez ensuite mettre en place un while boucle qui s'exécute pendant que i est inférieure à la longueur de letters. Vous pouvez ensuite insérer 'x' à l'index i dans letters. Ensuite, vous devez ajouter la valeur de n+1 à i. La raison pour laquelle vous devez le faire n+1 au lieu de simplement n est parce que lorsque vous insérez un élément de letters, il augmente la longueur de la liste par un.

Avec votre exemple où n est 3 et que vous souhaitez insérer 'x', il devrait ressembler à ceci
```
letters = ['a','b','c','d','e','f','g','h','i','j']
i = 3
while i < len(letters):
    letters.insert(i, 'x')
    i += 4

print letters
```
qui permettrait d'imprimer
```
['a', 'b', 'c', 'x', 'd', 'e', 'f', 'x', 'g', 'h', 'i', 'x', 'j']
```
qui est le résultat escompté.
- C'est inutilement quadratique, ce qui peut ou ne peut pas d'importance dans ce cas.
- Comment est-ce quadratique? Je pense que c'est linéaire? (ne pas essayer de vous contredire, juste très mauvais avec le temps, complexité)
- lui-même prend O(n), utilisé à l'intérieur d'un while boucle quadratique. Voici le wiki affichant le temps de la complexité de chaque opération.
- Oh, je ne savais pas insert est O(n). Merci 🙂
- Dans la Fpo exemple, ceci étant quadratique n'a pas beaucoup d'importance, si elles ne le garder aussi simple que cela, alors il n'a pas d'importance, mais que la liste est plus longue et plus, le temps va commencer à jouer un rôle
- Je préfère facilement compréhensible et moins-code performant, plus difficiles à lire le code avec la haute performance. +1
InformationsquelleAutor michaelpri
4

Bien que l'utilisation de list.insert() dans un for boucle semble être plus efficace en terme de mémoire, dans l'ordre de le faire en une seule ligne, vous pouvez aussi ajouter de la valeur donnée à la fin de chaque divisé de manière égale des morceaux de split sur chaque nth index de la liste.
```
>>> from itertools import chain

>>> n = 2
>>> ele = 'x'
>>> lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> list(chain(*[lst[i:i+n] + [ele] if len(lst[i:i+n]) == n else lst[i:i+n] for i in xrange(0, len(lst), n)]))
[0, 1, 'x', 2, 3, 'x', 4, 5, 'x', 6, 7, 'x', 8, 9, 'x', 10]
```
- +1 pour itertools.chain de la méthode, rend un objet iterable [item for subgroup in group for item in subgroup] qui est toujours aussi difficile à retenir. Aussi +1 pour l'utilisation de ternaire dans une liste de compréhension; pour une raison que je n'avais pas pensé à ça, génial!
InformationsquelleAutor ozgur

Une jolie méthode simple:

>>> letters = ['a','b','c','d','e','f','g','h','i','j']
>>> new_list = []
>>> n = 3
>>> for start_index in range(0, len(letters), n):
...     new_list.extend(letters[start_index:start_index+n])
...     new_list.append('x')
... 
>>> new_list.pop()
'x'
>>> new_list
['a', 'b', 'c', 'x', 'd', 'e', 'f', 'x', 'g', 'h', 'i', 'x', 'j']

Vous pouvez également utiliser le grouper recette de la itertools de la documentation pour le chunking.

Que faire si new_list.pop() pop une valeur qui est en fait censé être là?
il soulève la dernière valeur, qui a été le 'x' j'ai ajouté en dernier.

InformationsquelleAutor Mike Graham

1

Je veux ajouter un nouvel élément par élément.

Comment à ce sujet ?
```
a=[2,4,6]
for b in range (0,len(a)):
    a.insert(b*2,1)
```
un est maintenant
```
[1, 2, 1, 4, 1, 6]
```
InformationsquelleAutor Tim Seed
1

C'est un vieux sujet, mais il manque le plus facile, le plus "pythonic" de la solution, de l'omi. Il n'est plus qu'une extension à la partie 2 de Marque Mikofski's accepté de répondre à que l'on améliore la lisibilité (et donc le rend plus pythonic).
```
>>> letters = ['a','b','c','d','e','f','g','h','i','j']
>>> [el for y in [[el, 'x'] if idx % 3 == 2 else el for 
     idx, el in enumerate(letters)] for el in y]

['a', 'b', 'c', 'x', 'd', 'e', 'f', 'x', 'g', 'h', 'i', 'x', 'j']
```
InformationsquelleAutor John Paper

Tout Marque Mikofski's réponse fonctionne, il y a une solution plus rapide par l'attribution de tranches:

import string
# The longer the list the more speed up for list3
# letters = ['a','b','c','d','e','f','g','h','i','j']
letters = list(string.ascii_letters)
print("org:", letters)
# Use enumerate to get index, add 'x' every 3rd letter, eg: mod(n, 3) == 2, then concatenate into string and list() it.
list1 = list(''.join(l + 'x' * (n % 3 == 2) for n, l in enumerate(letters)))
print("list1:", list1)
%timeit list(''.join(l + 'x' * (n % 3 == 2) for n, l in enumerate(letters)))
# But as @sancho.s points out this doesn't work if any of the elements have more than one letter.
# Use nested comprehensions to flatten a list of lists(a), sliced in groups of 3 with 'x' added if less than 3 from end of list.
list2 = [x for y in (letters[i:i+3] + ['x'] * (i < len(letters) - 2) for i in range(0, len(letters), 3)) for x in y]
print("list2:", list2)
%timeit [x for y in (letters[i:i+3] + ['x'] * (i < len(letters) - 2) for i in range(0, len(letters), 3)) for x in y]
# Use list slice assignments
len_letters = len(letters)
len_plus_x = ll // 3
list3 = [None for _ in range(len_letters + len_plus_x)]
list3[::4] = letters[::3]
list3[2::4] = letters[2::3]
list3[1::4] = letters[1::3]
list3[3::4] = ['x' for _ in range(len_plus_x)]
print("list3:", list3)
%timeit ll = len(letters); lp = ll//3; new_letters = [None for _ in range(ll + lp)]; new_letters[::4] = letters[::3]; new_letters[2::4] = letters[2::3]; new_letters[1::4] = letters[1::3]; new_letters[3::4] = ['x' for _ in range(lp)]

produit (à l'aide de jupyter ordinateur portable)

org: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
list1: ['a', 'b', 'c', 'x', 'd', 'e', 'f', 'x', 'g', 'h', 'i', 'x', 'j', 'k', 'l', 'x', 'm', 'n', 'o', 'x', 'p', 'q', 'r', 'x', 's', 't', 'u', 'x', 'v', 'w', 'x', 'x', 'y', 'z', 'A', 'x', 'B', 'C', 'D', 'x', 'E', 'F', 'G', 'x', 'H', 'I', 'J', 'x', 'K', 'L', 'M', 'x', 'N', 'O', 'P', 'x', 'Q', 'R', 'S', 'x', 'T', 'U', 'V', 'x', 'W', 'X', 'Y', 'x', 'Z']
13 µs ± 1.09 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)
list2: ['a', 'b', 'c', 'x', 'd', 'e', 'f', 'x', 'g', 'h', 'i', 'x', 'j', 'k', 'l', 'x', 'm', 'n', 'o', 'x', 'p', 'q', 'r', 'x', 's', 't', 'u', 'x', 'v', 'w', 'x', 'x', 'y', 'z', 'A', 'x', 'B', 'C', 'D', 'x', 'E', 'F', 'G', 'x', 'H', 'I', 'J', 'x', 'K', 'L', 'M', 'x', 'N', 'O', 'P', 'x', 'Q', 'R', 'S', 'x', 'T', 'U', 'V', 'x', 'W', 'X', 'Y', 'x', 'Z']
13.7 µs ± 336 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
list3: ['a', 'b', 'c', 'x', 'd', 'e', 'f', 'x', 'g', 'h', 'i', 'x', 'j', 'k', 'l', 'x', 'm', 'n', 'o', 'x', 'p', 'q', 'r', 'x', 's', 't', 'u', 'x', 'v', 'w', 'x', 'x', 'y', 'z', 'A', 'x', 'B', 'C', 'D', 'x', 'E', 'F', 'G', 'x', 'H', 'I', 'J', 'x', 'K', 'L', 'M', 'x', 'N', 'O', 'P', 'x', 'Q', 'R', 'S', 'x', 'T', 'U', 'V', 'x', 'W', 'X', 'Y', 'x', 'Z']
4.86 µs ± 35.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

InformationsquelleAutor ChrisFreeman

-2
```
l = ['a','b','c','d','e','f','g','h','i','j']
[ l.insert(n+(n+1)*i, 'x') for i in range(len(l)/n) ]
print l
```
- L'exécution de ce programme renvoie une erreur
- Désolé, c'est un bug. Je l'ai corrigé.
InformationsquelleAutor hongshuning

Vous devez vous connecter pour publier un commentaire.