Modifier liste2 en fonction des modifications apportées a liste1

Version imprimable

22/04/2021, 15h58
Jma06

Modifier liste2 en fonction des modifications apportées a liste1
Bonjour,

J'ai besoin d'un coup de pouce car je sens bien que je cherche... mal... et me noie dans un verre d'eau :-/

Pour deux listes l1 et l2 ayant le même nombre d'éléments:
Code:

1 2 l1 = ["a","b","c","d","e","f"] l2 = [2,5,1,9,7,3]
Comment faire pour modifier l1 en fonction de la modification sorted(l2)

Le résultat attendu ici serait:
sorted(l2) => [1,2,3,5,7,9],
l1 deviendrait => ["c","a","f","b","e","d"].

Merci pour votre temps.
Jma

Salut,

rapidement je peux te proposer quelque chose du genre:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
l1 = ["a","b","c","d","e","f"]
l2 = [2,5,1,9,7,3]
l3 = []
 
for l in sorted(l2):
    for z1, z2 in zip(l1, l2):
        if l == z2:
            l3.append(z1)
 
print(l3)
 
>>> ['c', 'a', 'f', 'b', 'e', 'd']

22/04/2021, 17h17
Jma06

Oh super! merci beaucoup :)

salut,

une alternative :

Code:

1
2
3
4
>>> l1 = ["a","b","c","d","e","f"]
>>> l2 = [2,5,1,9,7,3]
>>> [i for i,j in sorted(zip(l1,l2), key=lambda x:x[1])]
['c', 'a', 'f', 'b', 'e', 'd']

23/04/2021, 10h24
Jma06

Merci BufferBob ! ,
Super aussi cette alternative.
Pour être sur de "bien la comprendre" (entre guillemets car je ne suis jamais sur de bien comprendre en fait.. débutant oblige)

Code:

.. key = lambda x:x[1] )

sert bien a récupérer la valeur d'index [1] du tuple de l'iterateur créé par zip()?

(donc la valeur qui était dans la liste l2 lors de l'itération sur l1 et l2.. et du coup on peut ensuite placer cette valeur dans la liste en compréhension..)

J'ai bon?
En tous cas expression élégante et zip bien utile je trouve :)
Merci à vous deux zancrows et BufferBob !
23/04/2021, 11h01
Sve@r

Bonjour

Citation:

Envoyé par Jma06

Pour être sur de "bien la comprendre" (entre guillemets car je ne suis jamais sur de bien comprendre en fait.. débutant oblige) .. key = lambda x:x[1] ) sert bien a récupérer la valeur d'index [1] du tuple de l'iterateur créé par zip()?
(donc la valeur qui était dans la liste l2 lors de l'itération sur l1 et l2.. et du coup on peut ensuite placer cette valeur dans la liste en compréhension..)

J'ai bon?

Exact. Chaque "item" du truc à trier sera filtré par la fonction lambda. Cette fonction recevant un item composé dans ce cas précis d'un couple issu d'un tuple l1+l2, elle renverra l'élément [1] (donc le second car il ne faut pas oublier que les indices commencent à 0) donc la partie qui vient de l2. C'est donc cette partie qui servira de clef de tri.
Au final le tri fournit tous les couples (l1+l2) triés sur chaque l2 et l'expression "en comprehension" extrait de ce tri le seul élément l1.

Citation:

Envoyé par Jma06

et zip bien utile je trouve

Ah oui. zip, enumerate, map, any, all, min, max, sum, filter, reduce, il y a beaucoup d'outils pour manipuler les itérables (reduce ayant toutefois déménagé dans le module "functools" depuis Python3).

Citation:
Envoyé par BufferBob
salut,

une alternative :
Code:

1 2 3 4 >>> l1 = ["a","b","c","d","e","f"] >>> l2 = [2,5,1,9,7,3] >>> [i for i,j in sorted(zip(l1,l2), key=lambda x:x[1])] ['c', 'a', 'f', 'b', 'e', 'd']
l'argument key est inutile si on construit - via zip - des tuples inversés qui, eux, se trient "naturellement" :
Code:

1 2 >>> [car for no, car in sorted(zip(l2, l1))] ['c', 'a', 'f', 'b', 'e', 'd']

23/04/2021, 11h36
BufferBob

Citation:

Envoyé par plxpy

(...) tuples inversés qui, eux, se trient "naturellement"

bien vu ! 8-)
23/04/2021, 12h09
Jma06

Ha .. ben oui.. interessant ce zip().
Du coup c'est l1 en 1er argument de zip(l1,l2) qui sera "sorted" et la seconde (l2) qui "suivra" la première..
et il suffit donc de placer la liste que l'on trie en premier et de récupérer les éléments de la seconde... ce qui explique que vous avez placé l2 (la liste que l'on classe) en premier argument de zip() c'est ça?

Salut,

Ici, on peut aussi faire sans zip:

Code:

1
2
3
4
5
>>> l1 = ["a","b","c","d","e","f"]
>>> l2 = [2,5,1,9,7,3]
>>> sorted(l1, key=lambda x: l2[l1.index(x)])
['c', 'a', 'f', 'b', 'e', 'd']
>>>

- W

25/04/2021, 09h47
Jma06

joliiii -W :)

Vous assurez tous vraiment fort!
Merci encore pour ce fil de discussion devenu si complet et compréhensible grâce à vous tous.
25/04/2021, 14h34
wiztricks
Citation:

Envoyé par Jma06

joliiii -W :)

non parce que tel que, côté performances, c'est pas top... mais on peut l'améliorer:
Code:

1 2 3 >>> [ z[1] for z in sorted(enumerate(l1), key=lambda x: l2[x[0]])] ['c', 'a', 'f', 'b', 'e', 'd'] >>>
Et se rendre compte que sorted et zip "militent" pour des regroupements de données explicites (on fabrique des tuples contenant des données liées entre elles) plutôt qu'implicites (2 tableaux où l'index matérialise la relation entre...).
Et si on fait çà, c'est parce qu'on est dans une logique "objet".
Dit autrement, quant on écrit:
Code:

1 2 >>> l1 = ["a","b","c","d","e","f"] >>> l2 = [2,5,1,9,7,3]
on a 2 entités (à priori) indépendantes au sens où c'est dans le code qu'il va falloir câbler cette dépendance (si j'aoute un item à l1, il ne faudra pas oublier de faire de même pour l2).
Si dès le départ, on câble la relation:
Code:

1 2 3 4 >>> L = list(zip(l1, l2)) >>> L [('a', 2), ('b', 5), ('c', 1), ('d', 9), ('e', 7), ('f', 3)] >>>
on sait que les items de L sont des tuples à 2 éléments et ajouter ou retirer un élément à L pourvu qu'il ressemble aux autres (un objet semblable) est simple.

Pas besoin de zip pour appliquer sorted, et si on veut afficher les premiers éléments de chaque tuples, c'est juste une présentation des données.

Et vous voyez que dans cette histoire, il y a matière a se poser des questions sur comment on met en forme (informatique vient de là) les données pour qu'elles aient une certaine orthogonalité avec les opérations qu'on va pouvoir faire "naturellement" dessus.

- W

et avec une autre structure,

Code:

1
2
3
d = {2: "a", 5: "b", 1: "c", 9: "d", 7: "e", 3: "f"}
l = [d[key] for key in sorted(d)]
print(l)