J'essaie de comprendre s'il est logique de prendre le contenu d'une liste et de l'ajouter à une autre liste.
J'ai la première liste créée par une fonction de boucle, qui extrait des lignes spécifiques d'un fichier et les sauvegarde dans une liste.
Ensuite, une seconde liste est utilisée pour enregistrer ces lignes et démarrer un nouveau cycle sur un autre fichier.
Mon idée était d’obtenir la liste une fois le cycle for terminé, de la vider dans la deuxième liste, puis de démarrer un nouveau cycle, de vider le contenu de la première liste dans la deuxième mais de l’ajouter, de sorte somme de tous les fichiers de liste plus petits créés dans ma boucle. La liste doit être ajoutée uniquement si certaines conditions sont remplies.
Cela ressemble à quelque chose de semblable à ceci:
# This is done for each log in my directory, i have a loop running
for logs in mydir:
for line in mylog:
#...if the conditions are met
list1.append(line)
for item in list1:
if "string" in item: #if somewhere in the list1 i have a match for a string
list2.append(list1) # append every line in list1 to list2
del list1 [:] # delete the content of the list1
break
else:
del list1 [:] # delete the list content and start all over
Cela a-t-il un sens ou devrais-je choisir un autre itinéraire?
J'ai besoin de quelque chose d'efficacité qui ne prendrait pas trop de cycles, car la liste des journaux est longue et chaque fichier texte est assez gros; alors j'ai pensé que les listes correspondraient à l'objectif.
Vous voulez probablement
list2.extend(list1)
au lieu de
list2.append(list1)
Voici la différence:
>>> a = range(5)
>>> b = range(3)
>>> c = range(2)
>>> b.append(a)
>>> b
[0, 1, 2, [0, 1, 2, 3, 4]]
>>> c.extend(a)
>>> c
[0, 1, 0, 1, 2, 3, 4]
Étant donné que list.extend()
accepte les valeurs itératives arbitraires, vous pouvez également remplacer
for line in mylog:
list1.append(line)
par
list1.extend(mylog)
Jetez un coup d'oeil à itertools.chain pour un moyen rapide de traiter de nombreuses petites listes comme une seule grande liste (ou au moins comme une seule grande liste itérable) sans copier les petites listes:
>>> import itertools
>>> p = ['a', 'b', 'c']
>>> q = ['d', 'e', 'f']
>>> r = ['g', 'h', 'i']
>>> for x in itertools.chain(p, q, r):
print x.upper()
Cela semble assez raisonnable pour ce que vous essayez de faire.
Une version légèrement plus courte qui s'appuie sur Python pour faire plus de gros travail pourrait être:
for logs in mydir:
for line in mylog:
#...if the conditions are met
list1.append(line)
if any(True for line in list1 if "string" in line):
list2.extend(list1)
del list1
....
Le (True for line in list1 if "string" in line)
itère sur list
et émet True
chaque fois qu'une correspondance est trouvée. any()
utilise l'évaluation de court-circuit pour renvoyer True
dès que le premier élément True
est trouvé. list2.extend()
ajoute le contenu de list1
à la fin.
Pour récapituler sur les réponses précédentes. Si vous avez une liste avec [0,1,2]
et une autre avec [3,4,5]
et que vous souhaitez les fusionner, elle devient donc [0,1,2,3,4,5]
, vous pouvez utiliser chaining
ou extending
et devez connaître les différences pour l'utiliser à bon escient.
En utilisant la méthode list
classes extend
, vous pouvez copier les éléments d’une liste sur une autre. Toutefois, cela entraînera une utilisation supplémentaire de la mémoire, ce qui devrait convenir dans la plupart des cas, mais peut poser problème si vous souhaitez optimiser la mémoire.
a = [0,1,2]
b = [3,4,5]
a.extend(b)
>>[0,1,2,3,4,5]
À l'inverse, vous pouvez utiliser itertools.chain
pour câbler de nombreuses listes, ce qui renverra une variable appelée iterator
pouvant être utilisée pour parcourir les listes. C'est plus efficace en termes de mémoire car il ne s'agit pas de copier des éléments mais simplement de pointer vers la liste suivante.
from itertools import chain
a = [0,1,2]
b = [3,4,5]
c = itertools.chain(a, b)
Créez un itérateur qui renvoie les éléments de la première itérable jusqu'à son épuisement, puis passe à la suivante, jusqu'à ce que tous les itérables soient épuisés. Utilisé pour traiter des séquences consécutives comme une seule séquence.
Utilisation des fonctions intégrées map()
et reduce()
def file_to_list(file):
#stuff to parse file to a list
return list
files = [...list of files...]
L = map(file_to_list, files)
flat_L = reduce(lambda x,y:x+y, L)
Minimal "pour la boucle" et élégant modèle de codage :)
Si nous avons la liste comme ci-dessous:
list = [2,2,3,4]
deux façons de le copier dans une autre liste.
1.
x = [list] # x =[] x.append(list) same
print("length is {}".format(len(x)))
for i in x:
print(i)
length is 1 [2, 2, 3, 4]
2.
x = [l for l in list]
print("length is {}".format(len(x)))
for i in x:
print(i)
length is 4 2 2 3 4
Vous pouvez également combiner deux listes (par exemple a, b) à l'aide de l'opérateur '+'. Par exemple,
a = [1,2,3,4]
b = [4,5,6,7]
c = a + b
Output:
>>> c
[1, 2, 3, 4, 4, 5, 6, 7]