Python 根据元组的值按不同顺序对元组列表进行排序

当我们想要对元组列表进行排序时，其中每个元组的长度都是3（都在增加），我们需要对以下代码进行修改

ts = [(7, 14, 5), (3, 12, 9), (20, 22, 8), (20, 23, 24), (3, 12, 8), (4, 5, 7), (4, 5, 6), (4, 22, 17)]
ts.sort(key=lambda t: (t[0], t[1], t[2]))

我的意思是，一开始比较零位置的元素，降低元组中的零元素，越接近开始。若两个元组在位置0处具有相同的值，则第二个元素较低的元素将更靠近左侧。如果两个元组具有相同的第二个元素，则考虑元组中的第三个元素

所以上面代码的输出是

Output: [(3, 12, 8), (3, 12, 9), (4, 5, 6), (4, 5, 7), (4, 22, 17), (7, 14, 5), (20, 22, 8), (20, 23, 24)]

但是，如果我想在某些情况下（不是所有情况下）反转排序，例如比较第一个元素，并且如果一个元组的第一个元素较小，那么它在排序列表中的较早位置该怎么办。但是，如果第一个元素相同，则第一个元素越大的tuple在列表中越早。如果元组中的第二个元素相同，则第一个元素越大的元组越早出现在列表中

这也可以描述为：

< P>首先考虑元组中的第一个元素，按递增顺序排序
• 如果元组中的第一个元素相同，则按降序排序

• 如果元组中的第二个元素相同，则按降序排序

所以，我提供的输入应该是

Output: [(3, 12, 9), (3, 12, 8), (4, 22, 17), (4, 5, 7), (4, 5, 6), (7, 14, 5), (20, 23, 24), (20, 22, 8)]

我想知道，这是否可以使用lambda函数来完成，或者必须有一个单独的方法来进行所需的排序

我们还可以将这个问题推广到长度为n的元组。如果我们有一个长度为n的列表呢

('increasing', 'decreasing', 'decreasing', ..., 'increasing', 'decreasing')

这意味着：

< P>首先考虑元组中的第一个元素，按递增顺序排序
• 如果元组中的第一个元素相同，则按降序排序

• 如果元组中的第二个元素相同，则按降序排序

• 如果元组中位于n-2位置的元素相同，则按递增顺序对它们进行排序

• 如果元组中位于n-1位置的元素相同，则按降序对它们进行排序

---

我很高兴看到长度为3的元组问题的解决方案，以及对广义问题的讨论，其中元组的长度为n。

您可以更改元组值中的符号以获得预期的行为：

ts.sort(key=lambda t: (t[0], -t[1], -t[2]))

print(ts)
# [(3, 12, 9), (3, 12, 8), (4, 22, 17), (4, 5, 7), (4, 5, 6), (7, 14, 5), 
#  (20, 23, 24), (20, 22, 8)]

对于一般情况，您可以将

递增“、”递减“…

列表映射到

键中的sings和
zip
每个元组，符号如下：

l = ('increasing', 'decreasing', 'decreasing')
d = {'increasing':1, 'decreasing':-1}
signs = [d[i] for i in l]
ts.sort(key = lambda x: tuple(i*sign for sign,i in zip(signs, x)))

这将产生与上述相同的结果：

print(ts)
# [(3, 12, 9), (3, 12, 8), (4, 22, 17), (4, 5, 7), (4, 5, 6), (7, 14, 5), 
#  (20, 23, 24), (20, 22, 8)]

您可以更改元组值中的符号以获得预期的行为：

ts.sort(key=lambda t: (t[0], -t[1], -t[2]))

print(ts)
# [(3, 12, 9), (3, 12, 8), (4, 22, 17), (4, 5, 7), (4, 5, 6), (7, 14, 5), 
#  (20, 23, 24), (20, 22, 8)]

对于一般情况，您可以将
递增“、”递减“…
列表映射到
键中的sings和
zip
每个元组，符号如下：

l = ('increasing', 'decreasing', 'decreasing')
d = {'increasing':1, 'decreasing':-1}
signs = [d[i] for i in l]
ts.sort(key = lambda x: tuple(i*sign for sign,i in zip(signs, x)))

这将产生与上述相同的结果：

print(ts)
# [(3, 12, 9), (3, 12, 8), (4, 22, 17), (4, 5, 7), (4, 5, 6), (7, 14, 5), 
#  (20, 23, 24), (20, 22, 8)]

您的第一个示例根本不需要，默认情况下元组按元素的顺序递增排序。请参阅和和其他示例您的第一个示例根本不需要，默认情况下元组按元素的顺序递增排序。请参阅和其他示例