Comment trier une liste de tuples par leur premier élément?

J'ai une liste de tuples:

self.gridKeys = self.gridMap.keys() # The keys of the instance of the GridMap (It returns the product of every possible combination of positions in the specified grid, in tuples.)
print self.gridKeys

auto.gridKeys:

[(7, 3), (6, 9), (0, 7), (1, 6), (3, 7), (2, 5), (8, 5), (5, 8), (4, 0), (9, 0), (6, 7), (5, 5), (7, 6), (0, 4), (1, 1), (3, 2), (2, 6), (8, 2), (4, 5), (9, 3), (6, 0), (7, 5), (0, 1), (3, 1), (9, 9), (7, 8), (2, 1), (8, 9), (9, 4), (5, 1), (7, 2), (1, 5), (3, 6), (2, 2), (8, 6), (4, 1), (9, 7), (6, 4), (5, 4), (7, 1), (0, 5), (1, 0), (0, 8), (3, 5), (2, 7), (8, 3), (4, 6), (9, 2), (6, 1), (5, 7), (7, 4), (0, 2), (1, 3), (4, 8), (3, 0), (2, 8), (9, 8), (8, 0), (6, 2), (5, 0), (1, 4), (3, 9), (2, 3), (1, 9), (8, 7), (4, 2), (9, 6), (6, 5), (5, 3), (7, 0), (6, 8), (0, 6), (1, 7), (0, 9), (3, 4), (2, 4), (8, 4), (5, 9), (4, 7), (9, 1), (6, 6), (5, 6), (7, 7), (0, 3), (1, 2), (4, 9), (3, 3), (2, 9), (8, 1), (4, 4), (6, 3), (0, 0), (7, 9), (3, 8), (2, 0), (1, 8), (8, 8), (4, 3), (9, 5), (5, 2)]

Après le tri:

self.gridKeys = self.gridMap.keys() # The keys of the instance of the GridMap (It returns the product of every possible combination of positions in the specified grid, in tuples.)
self.gridKeys.sort() # They're dicts, so they need to be properly ordered for further XML-analysis.
print self.gridKeys

auto.gridKeys:

[(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9)]

Le premier élément de chaque tuple est le "x", et le second le "y". Je suis de déplacer des objets dans une liste par itération et à l'aide de ces touches (Donc, si je veux changer quelque chose dans l'axe des x, je dois passer par toute la colonne, et qui pourrait être la cause d'un horrible problème que je suis de ne pas être en mesure de résoudre).

Comment puis-je trier les n-uplets de cette façon?:

[(1, 0), (2, 0), (3, 0), (4, 0), (5, 0), ...]
  • Mais ce n'est pas de tri par son premier élément, c'est le tri par leur deuxième élément, puis leur première. Est-ce que vous vouliez dire?
  • Je pense que l'OP signifiait first element être element at index 1
  • Je voulais dire le premier index de chaque n-uplet (Maintenant, je suis un peu confus, mais la liste définitive là-bas est le "tri" que je veux atteindre).
  • self.gridKeys.sort(key=lambda x: x[1])
InformationsquelleAutor Ericson Willians | 2014-04-05
  1. 17

    Vous pouvez utiliser le key paramètre de la sort fonction, pour trier les n-uplets. La fonction de key paramètre est à venir avec une valeur qui doit être utilisé pour comparer deux objets. Donc, dans votre cas, si vous voulez la sort à utiliser uniquement le premier élément du tuple, vous pouvez faire quelque chose comme ceci

    self.gridKeys.sort(key=lambda x: x[0])

    Si vous souhaitez utiliser uniquement le deuxième élément du tuple, puis

    self.gridKeys.sort(key=lambda x: x[1])

    sort fonction va passer chaque élément de la liste pour la fonction lambda vous passez en paramètre à key et il utilisera la valeur qu'elle renvoie, pour comparer deux objets dans la liste. Donc, dans votre cas, disons que vous avez deux éléments dans la liste comme cela

    data = [(1, 3), (1, 2)]

    et si vous souhaitez trier par le deuxième élément, alors vous feriez

    data.sort(key=lambda x: x[1])

    D'abord il passe (1, 3) pour le lambda de la fonction qui retourne l'élément à l'index 1, qui est 3 et qui représentera cette tuple lors de la comparaison. De la même façon, 2 sera utilisé pour la deuxième tuple.

    InformationsquelleAutor thefourtheye
  2. 3

    Cela devrait faire l'affaire

    import operator
self.gridKeys.sort(key=operator.itemgetter(1))
    InformationsquelleAutor inspectorG4dget
  3. 2

    Tout thefourtheye la solution est correcte dans le sens strict que c'est exactement ce que vous avez demandé dans le titre. Il ne peut pas être ce que vous voulez. Il peut être préférable de le prendre un peu plus loin via le tri par l'inverse de la tuple à la place.

    self.gridKeys.sort(key=lambda x:tuple(reversed(x)))

    Cela vous oblige à avoir une commande comme:

    [(0, 0), (1, 0), (2, 0), (3, 0), (4, 0), ...]

    Plutôt que d'avoir le premier élément non ordonnée comme:

    [(4, 0), (9, 0), (6, 0), (1, 0), (3, 0), ...]

    Qui est ce que j'obtiens lors de l'utilisation:

    self.gridKeys.sort(key=lambda x: x[1])

    Par défaut de Python fait un tri lexicographique de gauche à droite. L'inversion de la n-uplet fait de Python ne le vocabulaire de la sorte, de droite à gauche.

    • J'ai trouvé que sa réponse n'était pas exactement ce que je voulais, mais j'ai compris comment l'utiliser.. en Utilisant à la fois [0] et [1]. auto.gridKeys.sort(key=lambda x: x[0]) self.gridKeys.sort(key=lambda x: x[1]), je vais analyser votre version, merci :).
    • J'ai trouvé ta version plus élégante que d'utiliser à la fois [0] et [1], et je l'utilise :).
    InformationsquelleAutor Nuclearman