Discussion :

[racine carrée]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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).

[wiztricks]

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

[racine carrée]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ...

[YCL-1]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

[locals() for i in [1]]

[{'.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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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
))

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']

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.

[racine carrée]

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.