Étant donné deux listes:
if list1[i] == list2[0]: IndexError: list index out of range
avec l'hypothèse len (list2) == 2 ,
Je me demandais comment obtenir un sortie comme ceci:
l = len(list1)
for i in range(0,l-1):
if list1[i] == list2[0]:
if list1[i+1] == list2[1]:
a = i
b = i+1
list1[a:b+1] = [''.join(list1[a:b+1])]
l = l - 1
print(list1)
Essentiellement, toute instance de list2 dans list1 (dans cet ordre), devrait concaténer dans la liste d'origine1 et la sortie (après avoir vérifié toutes les possibilités). p >
Ce que j'ai essayé jusqu'à présent:
['a', 'bc', 'd', 'e', 'f', 'bc', 'b', 'd', 'f', 'c', 'b', 'e']
Mais continuez à recevoir une erreur:
list1 = ["a","b","c","d","e","f","b","c","b","d","f","c","b","e"] list2 = ["b","c"]
7 Réponses :
Il s'agit d'une approche utilisant le découpage de liste.
Ex:
['a', 'bc', 'd', 'e', 'f', 'bc', 'b', 'd', 'f', 'c', 'b', 'e']
Résultat: p >
list1 = ["a","b","c","d","e","f","b","c","b","d","f","c","b","e"]
list2 = ["b","c"]
l = len(list2)
result = []
skip = 0
for i, v in enumerate(list1):
if skip:
skip -= 1
continue
if list1[i:l+i] == list2: #Check for sub-element
result.append("".join(list2))
skip = l-1 #Skip flag
else:
result.append(v)
print(result)
Vraiment sympa! Je me demandais si vous pouviez essayer n'importe quelle longueur de list2!
Essayez ceci:
['a', 'bc', 'd', 'e', 'f', 'bc', 'b', 'd', 'f', 'c', 'b', 'e']
O / P:
list1 = ["a","b","c","d","e","f","b","c","b","d","f","c","b","e"]
list2 = ["b","c"]
l = len(list1)
new_list = []
last_merge = False
for i in range(0,l):
# match list1 index i element with list2 first element
if list1[i] == list2[0]:
# match list1 index i+1 element with list2 second element
if i+1 <= l and list1[i+1] == list2[1]:
# merge and append list1 index i and i+1 element
new_list.append(list1[i]+list1[i+1])
# mark merge as true
last_merge = True
else:
# append list1 index i element
new_list.append(list1[i])
else:
# check list index i element is merge with last element then mark last_merge as False and continue iterate list
if last_merge is True:
last_merge = False
continue
# append list1 index i element
new_list.append(list1[i])
print(new_list)
Version avec une longueur arbitraire de list2:
def sublist_concatenate(list1, list2):
N = len(list2)
fullset = ''.join(list2)
outlist = []
i = 0 # counts the number of matches so far
for el in list1:
if el == list2[i]: # hold matching elements so far
i += 1
if i == N: # we have matched N times, so we have the whole set
outlist.append(fullset)
i = 0
else: # not a match for the next position
outlist += list2[0:i] # add all previously-passed elements
# check whether it is a match for the first position though
if el == list2[0]:
i = 1
else:
outlist.append(el)
i = 0
return outlist
l1 = ["a", "b", "b", "c", "d", "e", "f",
"b", "c", "b", "d", "f", "c", "b", "e"]
l2 = ["b", "c"]
print sublist_concatenate(l1, l2)
# ['a', 'b', 'bc', 'd', 'e', 'f', 'bc', 'b', 'd', 'f', 'c', 'b', 'e']
EDIT: code corrigé par commentaires, en ajoutant la branche if el == list2 [0] .
échec de l'entrée l1 = ["a", "b", "b", "c", "d", "e", "f", "b", "c", "b", " d "," f "," c "," b "," e "]
Bonne prise (la raison est que "b", "b" fait échouer la logique). Essayera de le réparer.
vous devez réinitialiser i = 0 lorsque l'élément suivant ne correspond pas
En supposant que la question est de savoir pourquoi vous obtenez une erreur, cette ligne
if list[i] == list2[0]:
modifie list1 et la raccourcit en fait. Ainsi, lorsque vous bouclez sur une plage de la longueur de la liste 1, raccourcir la liste signifie que le compteur de boucle i sera finalement hors de portée, car les éléments de la liste que vous vouliez trouver avec l'index sont partis.
Vous devez également vous rappeler que les listes sont indexées de 0 à n - 1 , où n est la longueur du list, donc cette instruction
if list1[i+1] == list2[1]:
semble vraiment devoir être
list1[a:b+1] = [''.join(list1[a:b+1])]
La boucle externe est également basée sur range (0, l - 1) signifie qu'il passera en boucle à travers tous les index sauf le dernier. Donc, à moins que vous ne vouliez vraiment éviter de regarder le dernier élément de la liste, ce que je ne pense pas faire en fonction de vos besoins, vous utiliseriez range (l) , qui produit des index à partir de 0 à l - 1 .
['a', 'b', 'bc', 'e', 'f', 'bc', 'd', 'f', 'c', 'b', 'e']
Essayez ceci, cela devrait fonctionner pour n'importe quelle longueur de list2 :
>>> result ['a', 'bc', 'd', 'e', 'f', 'bc', 'b', 'd', 'f', 'c', 'b', 'e']
vérification du résultat :
split_pattern = ''.join(list2)
chunks = ''.join(list1).split(split_pattern)
result = list(chunks[0])
for c in chunks[1:] :
result.append( split_pattern )
result.extend( list(c) )
Je voudrais suggérer cette méthode qui renvoie un générateur:
res = join_if_ref(list1, list2) print(list(res)) #=> ['a', 'bcd', 'e', 'f', 'b', 'c', 'b', 'd', 'f', 'c', 'bcd', 'k', 's']
Dans ce cas:
list1 = ["a","b","c","d","e","f","b","c","b","d","f","c","b","c","d","k","s"] list2 = ["b","c","d"]
Il renvoie:
def join_if_ref(main_list, ref_list):
n, s = len(ref_list), "".join(ref_list)
i, size = 0, len(main_list)
while i < size-n+1:
j = "".join(main_list[i:i+n])
if j == s:
yield j
i += n - 1
else:
yield main_list[i]
if i < size: i += 1
for k in range(size-i):
yield(main_list[k+i])
Encore un cas de test: list1 = ["a", "b", "c", "d", "e", "f", "b", "c", "b", "d", "f "," c "," b "," c "]
Juste une hypothèse: dans votre liste 1, le nombre est de 14 et lorsque vous manipulez les données pour votre sortie, le nombre de tableaux est de 12. Veuillez vérifier si c'est le problème?