pointeur de liste

Bonjour à tous,
pour les listes définies en compréhension, quel est le pointeur de la liste que l'on est en train de créer ? Je m'explique:
Voilà un code qui permet d'ajouter des éléments à une liste si ces éléments ne sont pas déjà dans celle-ci:

Code:

---

1 2 3 4 5

l=['moto', 'omto', 'otmo', 'otom', 'mtoo', 'tmoo', 'tomo', 'toom', 'mtoo', 'tmoo', 'tomo', 'toom', 'moot', 'omot', 'oomt', 'ootm', 'moot', 'omot', 'oomt', 'ootm', 'moto', 'omto', 'otmo', 'otom'] L=[] for k in l: if k not in L: L.append(k)

---

je voudrais trouver un équivalent en compréhension à ce code du style:

Code:

---

L=[k for k in l if k not in self]

---

où self serait une référence vers la liste que l'on est en train de créer, mais je ne sais pas quoi mettre à la place de self (cette liste n'a pas de nom puisqu'on ne l'a pas encore créée).

Salut,

Il y a peut être des hacks qui traînent sur Internet mais une compréhension de liste est une écriture condensée pour des cas simples. Une boucle "for" pour les autres cas fonctionne bien aussi.
Ceci dit dans votre cas, vous pourriez construire un set (ce qui va gérer les doublons) puis en faire une liste: L = list(set(l)).

- W

En fait c'est un exo dans le cadre de la prepa, et on n'a pas le droit d'utiliser les dictionnaires ni les sets.
On devait faire une fonction anagramme récursive, et je m'étais donné comme objectifs de la faire en une seule ligne.
Du coup j'ai réussi à faire:

Code:

---

anag=lambda mot: [mot] if len(mot)==1 else [mot[k]+i for k in range(len(mot)) for i in anag(mot[:k]+mot[k+1:])]

---

qui marche bien mais renvoie des doublons quand on cherche les anagrammes d'un mot contenant plusieurs fois la même lettre.
On a pas le droits d'utiliser {}, sinon j'aurais fait le code suivant:

Code:

---

anag=lambda mot: {mot} if len(mot)==1 else {mot[k]+i for k in range(len(mot)) for i in anag(mot[:k]+mot[k+1:])}

---

.
J'ai donc rajouté une fonction lambda qui supprime tous les doublons au moment de renvoyer la liste:

Code:

---

anag=lambda mot: [mot] if len(mot)==1 else (lambda l: [l[k] for k in range(len(l)) if l[k] not in l[:k]])([mot[k]+i for k in range(len(mot)) for i in anag(mot[:k]+mot[k+1:])])

---

mais ça rallonge pas mal le temps de recherche, du coup je voulais trouver une solution pour tester si un élément est déjà dans la liste créée au moment de le rajouter, plutôt que de mettre tous les éléments et de supprimer ensuite ceux qui sont en trop.
ça donnerait donc un code du style:

Code:

---

anag=lambda mot: [mot] if len(mot)==1 else [mot[k]+i for k in range(len(mot)) if (mot[k]+i for k in range(len(mot))) not in self for i in anag(mot[:k]+mot[k+1:])]

---

Mais je crains que ce ne soit possible ...

Bonsoir,

il y a une possibilité en utilisant locals() qui retourne toutes les déclarations locales d'une fonction.

Testé sur Python 3.7 : La comprehension list va créer une variable ".0"

Code:

---

[locals() for i in [1]]

---

Citation:

---

[{'.0': <tuple_iterator object at 0x000000000303AEB8>, 'i': 1}]

---

Ça génère un itérateur mais du coup on ne peut pas interroger l'itérateur sans le modifier.

Le seul moyen est de copier l'itérateur avec (copy.copy) mais ça rallonge sacrément le temps d’exécution :

Code:

---

1 2	from copy import copy [i for i in [3, 2, 1, 2, 1] if i not in copy(locals()['.0'])] # Retourne [3, 2, 1]

---

Et le comportement est curieux :

Code:

---

[i for i in [3, 2, 1, 2, 1, 3] if i not in copy(locals()['.0'])] # Retourne [2, 1, 3]

---

Code:

---

[i for i in [3, 2, 1, 2, 1, 3, 2] if i not in copy(locals()['.0'])] # Retourne [1, 3, 2]

---

Il semble garder le dernier doublon plutôt que le premier

Et question timing c'est clairement pas une solution à utiliser :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

import timeit from copy import copy   l=['moto', 'omto', 'otmo', 'otom', 'mtoo', 'tmoo', 'tomo', 'toom', 'mtoo', 'tmoo', 'tomo', 'toom', 'moot', 'omot', 'oomt', 'ootm', 'moot', 'omot', 'oomt', 'ootm', 'moto', 'omto', 'otmo', 'otom']   methode1 = """ L = [] for k in l:     if k not in L:         L.append(k) """   methode2 = """[k for k in l if k not in copy(locals()['.0'])]"""   nb_test = int(100e3) print("methode1") t = timeit.timeit(methode1, setup="from __main__ import l", number=nb_test) print("Temps d'éxecution : total: {:.02f} s, moyen : {:.02f} µs".format( t, (t / nb_test) * 1e6 )) print("methode2") t = timeit.timeit(methode2, setup="from __main__ import l, copy", number=nb_test) print("Temps d'exécution : total: {:.02f} s, moyen : {:.02f} µs".format( t, (t / nb_test) * 1e6 ))

---

Citation:

---

methode1 :
Temps d’exécution : total: 0.38 s, moyen : 3.77 µs

['moto', 'omto', 'otmo', 'otom', 'mtoo', 'tmoo', 'tomo', 'toom', 'moot', 'omot', 'oomt', 'ootm']

---

Citation:

---

methode2:
Temps d'exécution : total: 10.77 s, moyen : 107.69 µs

['mtoo', 'tmoo', 'tomo', 'toom', 'moot', 'omot', 'oomt', 'ootm', 'moto', 'omto', 'otmo', 'otom']

---

Je me demande si j'utilise la bonne fonction pour copier l'itérateur car on dirait qu'il perd l'ordre.

Merci beaucoup,
j'aurai au moins appris comment on utilise timeit (je ne savais pas qu'on pouvait envoyer comme ça du code sous forme de chaine de caractères à une fonction.)
Sinon tant pis pour la méthode sur une seule ligne, car c'était un objectif que je m'étais donné pour m'amuser.