sorted lambda key suivant chaine

Bonjour,
J'ai un petit souci avec un tri.
Pour éviter un problème xyz, je présente l'origine de celui-ci.
J'ai deux fichiers excel dont un qui est à compléter car 3 colonnes manquantes.
J'ai ces colonnes manquantes mais le problème c'est que celles-ci sont un autre fichier excel dans lequel les nom/prénom sont classés par ordre alphabétiques.
Donc je veux remettre les colonnes manquantes dans l'ordre de mon premier fichier excel.

J'ai obtenu des listes pour chaque colonne de mes fichiers excel et j'essaie de reclasser mes listes. Peut-être n'est-ce pas une bonne option mais elle me paraît la plus à ma portée.
J'ai fait cela, sachant que je veux donc classer liste_nom_prenom_note_p en ayant pour clé les éléments de liste_nom_prenom

Code:

---

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

liste_nom = ["BG", "CZ", "AB", "BG", "FT"] liste_prenom = ["ab", "dt", "uy", "ir", "ml"]   liste_nom_prenom = zip(liste_nom, liste_prenom)   liste_nom_p = sorted(liste_nom) liste_prenom_p = sorted(liste_prenom) liste_nom_prenom_p = sorted(liste_nom_prenom) liste_n_p = [2,7,5,None,4] liste_nom_prenom_note_p = zip(liste_nom_prenom_p,liste_n_p)     print(liste_nom) print(liste_prenom) print(liste_nom_p) print(liste_prenom_p) print(liste_n_p) print("nom_prenom", list(liste_nom_prenom)) print(liste_nom_prenom_p) print(list(liste_nom_prenom_note_p)) liste_n=sorted(liste_nom_prenom_note_p,key=lambda x: x[liste_nom_prenom]) print(liste_n)

---

Je devrais peut-être commencer par élucider un mystère pour moi :

Code:

---

print("nom_prenom", list(liste_nom_prenom))

---

me renvoie une liste vide...

Bonjour,

"zip" est un itérateur. Il faut donc écrire:

Code:

---

liste_nom_prenom = list(zip(liste_nom, liste_prenom))

---

Qui donne:

Code:

---

[('BG', 'ab'), ('CZ', 'dt'), ('AB', 'uy'), ('BG', 'ir'), ('FT', 'ml')]

---

Salut,

Dans votre code, liste_nom_prenom est un generateur: zip(liste_nom, liste_prenom).
C'est un pistolet à un coup: vous ne pouvez l'exécuter qu'une seule fois... et les fois suivantes, çà retournera une liste vide (tous les items ayant été déjà consommés).

- W
grilled par tyrtamos.

ok, merci pour cette précision, itérateur est une notion difficile pour moi. Pour le reste, j'attends votre aide. :)

Bonjour

Citation:

---

Envoyé par marco056

itérateur est une notion difficile pour moi

---

Pas compliqué: prenons une fonction qui retourne 5 trucs. Un débutant pensera tout naturellement à les retourner d'un coup, soit en liste, soit en tuple (ma préférence quand l'ensemble n'est pas destiné à évoluer) => def fct(): return (1, 2, 3, 4, 5).

Toutefois il se trouve que dans 99% des cas, l'appelant lui, se servira de ce retour dans une itération pour traiter chaque valeur => for x in fct(): print(x). Et en plus il ne s'en servira qu'une seule fois. Dommage d'avoir donc consommé de la mémoire pour stocker 5 nombres alors qu'on n'en utilise qu'un seul.

Ok, admettons (c'est pas ça qui va plomber un code quoique... ça+ça+ça... mais ok). Toutefois arrive un autre souci inhérent avec la quantité de valeurs retournées par rapport au temps de traitement. Il est alors possible que la dernière valeur (ici 5) ait perdu sa pertinence du fait du temps de traitement des 4 précédentes.
Exemple

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

from datetime import * import time   def fct(x): ret=[] for i in range(x): ret.append(datetime.today().strftime("%H:%M:%S")) return ret   for (i, f) in enumerate(fct(5), 1): print(i, f) time.sleep(5)

---

Dans cet exemple qui prendra 25 secondes pour s'exécuter, on aura 5 fois la même heure. Il est évident que la dernière ligne n'aura pas de rapport avec la réalité (l'heure affichée ne sera plus celle de la réalité).

Donc on a un souci de "gaspilage" (stocker 5 valeurs pour n'en traiter qu'une seule) et de perte de pertinence à cause du temps de traitement entre la date de création de la valeur et sa date d'utilisation. Un client commande 50 trucs, le programme donne les références prises en bdd, puis un autre client achète le truc en boutique et quand l'employé va le chercher en rayon pour honorer la commande, il n'y est plus.

C'est là qu'entrent en jeux les générateurs. Ils permettent à la fonction de "générer" la valeur au moment où l'appelant en a réellement besoin. Cela se fait au travers du yield qui renvoie l'info demandée (comme un return) mais qui garde trace de la position du code. Et à l'appel suivant, il reprend de cette position pour générer et renvoyer la valeur suivante.

Exemple 1

Code:

---

1 2 3 4 5 6

def fct(): yield 1 yield 2 yield 3 yield 4 yield 5

---

Du côté appelant, rien ne change. Il peut parfaitement réécrire sa boucle for x in fct(): print(x). Au premier appel, la fonction retourne 1. Au second appel, elle repart du 1 pour continuer son travail et retourne 2 et etc.

Exemple 2

Code:

---

1 2 3 4 5 6 7 8 9 10

from datetime import * import time   def fct(x): for i in range(x): yield datetime.today().strftime("%H:%M:%S")   for (i, g) in enumerate(fct(5), 1): print(i, g) time.sleep(5)

---

Ici les heures affichées seront celles du moment réel de l'affichage. Le générateur a résolu tous nos problèmes tout en restant compatible avec l'appelant qui, lui, ne change pas sa façon de faire. Et ça c'est important.

Seul inconvénient, le générateur ne peut être consommé qu'une seule fois. Si on le stocke qqpart et qu'on tente deux boucles dessus, la seconde ne se fait pas (cela a été ton cas). Mais comme je l'ai dit, dans 99% des cas le générateur n'est utilisé qu'une seule fois et pour le 1% restant (ben toi quoi :aie:) il reste alors la solution de le transformer explicitement en tuple ce qui le fige en reproduisant alors le comportement initial qui n'est alors pas perdu.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

def fct1(): return (1, 2, 3, 4, 5)   def fct2(): yield 1 yield 2 yield 3 yield 4 yield 5   res1=fct1() res2=tuple(fct2()) print(res1, res2, res1 == res2)

---