J'ai une fonction qui trie une liste de listes par la première liste. Quand j'utilise la fonction avec les variables comme ceci:
OUT = sort_lists(data_sort[idx] for idx in range(len(IN[0])))
cela fonctionne parfaitement. Bien que, comme je ne sais pas combien de listes mon entrée contient, je souhaite utiliser ceci comme variable:
def sort_lists(*args):
zipped_list= zip(*sorted(zip(*args)))
return [list(l) for l in zipped_list]
OUT = sort_lists(data_sort[0],data_sort[1],data_sort[2])
Bien que cela renvoie un tri d'une liste (la superliste ). Pourquoi y a-t-il une différence entre ces variables, et comment puis-je améliorer le code?
Voici la fonction si décisive (ici IN [0] est l'entrée avec un certain nombre de sous-listes):
sort_lists(IN[idx] for idx in range(len(IN)))
Je souhaite utiliser cette sortie:
sort_lists(IN[0],IN[1],IN[2])
3 Réponses :
Changez simplement la fonction pour accepter la liste des listes, est-ce un problème? Ce morceau de code:
IN[idx] for idx in range(len(IN))
renvoie à nouveau la liste des listes
Comment feriez-vous cela? Toutes mes excuses, mais je suis nouveau sur Python.
Deux choses à comprendre ici:
* args vous donnera tous les paramètres de fonction en tant que tuple IN [idx] pour idx dans la plage (len (IN)) est un expression du générateur Vous pouvez voir en quoi vos entrées sont différentes si vous ajoutez simplement l'instruction print dans votre fonction:
>>> sort_lists(*lists) [[1, 2, 3], [3, 1, 4], [4, 5, 2]]
Laissez l'entrée liste des listes: lists = [[2, 1, 3], [1, 3, 4], [5, 4, 2]] .
def sort_lists(arg):
zipped_list= zip(*sorted(zip(*arg)))
return [list(l) for l in zipped_list]
sort_lists(lists[idx] for idx in range(len(lists)))
# [[1, 2, 3], [3, 1, 4], [4, 5, 2]]
Oh wow. Merci d'avoir répondu! Je viens de déballer mes listes dans la sortie et cela fonctionne comme je le voulais maintenant.
Comme l'a souligné Georgy, la différence réside dans le fait que les arguments sont un générateur ou une liste. Je tiens également à souligner que c'est l'occasion d'utiliser et de pratiquer la méthode map . map applique la même fonction à chaque entrée d'une liste. La fonction peut être intégrée comme sorted.
[[1, 2, 3], [1, 3, 4], [2, 4, 5]]
Returns:
list_a = [[2, 1, 3], [1, 3, 4], [5, 4, 2]] sorted_list_a = list(map(sorted, list_a)) # sorted is the python built-in function print(sorted_list_a)
Vous remarquerez que vous devrez passer votre carte à la fonction liste car map renvoie un objet cartographique, vous devez donc le transformer en liste .
La documentation de la carte est ici . Et un bon exemple est ici .
p >
C'est la différence entre les arguments:
foo (a, b, c)et un argument qui est une liste:foo ([a, b, c]). Cependant, vous utilisez déjà* args- savez-vous ce qu'il fait?@ Ry- Je sais que * args me permet d'avoir un nombre non donné d'arguments comme entrée. Bien que comment puis-je utiliser cela dans ma sortie?
Je ne suis pas tout à fait sûr de ce que vous essayez de faire avec votre fonction. Pouvez-vous donner un exemple pour IN et le OUT attendu correspondant? Mais comme @ Ry- déjà mentionné, la première fois que vous passez 3 listes séparées, et la deuxième fois, vous donnez essentiellement un objet générateur comme seul argument de la fonction.
@DocDriven Ce que je veux faire (et que je peux faire maintenant avec un nombre connu d'entrées) est de trier un certain nombre de listes selon le modèle de tri de la première liste. Disons que j'ai un IN [0] = [2,4,3,1], et un in IN [1] = ["two", "four", "three", "one"]. Ma sortie est OUT = [1,2,3,4], ["un", "deux", "trois", "quatre"].