用两个键对Python列表进行排序，但只按相反顺序对一个键进行排序

我想知道用两个键对元组列表进行排序的python方法是什么，其中使用一个键（并且只有一个键）进行排序的顺序是相反的，而使用另一个键进行排序的顺序是不区分大小写的。 更具体地说，我有一个包含元组的列表，如：

myList = [(ele1A, ele2A),(ele1B, ele2B),(ele1C, ele2C)]

我可以使用以下代码使用两个键对其进行排序：

sortedList = sorted(myList, key = lambda y: (y[0].lower(), y[1]))

要按相反的顺序排序，我可以使用

sortedList = sorted(myList, key = lambda y: (y[0].lower(), y[1]), reverse = True)

但这将以两个键的相反顺序排序

---

非常感谢您的提示。

当我们需要使用两个约束对列表进行排序时，将使用两个键，一个按升序排序，另一个按降序排序，在同一列表或任意列表中
在您的示例中，

sortedList=sorted（myList，key=lambda y:（y[0].lower（），y[1]）

只能按一个顺序对整个列表进行排序
您可以尝试这些并检查发生了什么

sortedList = sorted(myList, key = lambda y: (y[0].lower(), -y[1]))
sortedList = sorted(myList, key = lambda y: (-y[0].lower(), y[1]))
sortedList = sorted(myList, key = lambda y: (-y[0].lower(), -y[1]))

---

希望您能理解；）

有时除了使用比较器函数外，几乎没有其他选择。在2.4版的介绍中，有一个

cmp

参数指向

sorted

，但它被从Python 3中删除，取而代之的是更高效的

key

函数。在3.2中，

cmp_to_key

被添加到

functools

；它通过将原始对象包装到一个比较函数基于

cmp

函数的对象中，从原始对象创建关键帧。（您可以在

在您的情况下，由于下套管相对昂贵，您可能需要进行以下组合：

class case_insensitive_and_2nd_reversed:
    def __init__(self, obj, *args):
        self.first = obj[0].lower()
        self.second = obj[1]
    def __lt__(self, other):
        return self.first < other.first or self.first == other.first and other.second < self.second
    def __gt__(self, other):
        return self.first > other.first or self.first == other.first and other.second > self.second
    def __le__(self, other):
        return self.first < other.first or self.first == other.first and other.second <= self.second
    def __ge__(self, other):
        return self.first > other.first or self.first == other.first and other.second >= self.second
    def __eq__(self, other):
        return self.first == other.first and self.second == other.second
    def __ne__(self, other):
        return self.first != other.first and self.second != other.second

sortedList = sorted(myList, key = case_insensitive_and_2nd_reversed)

class case\u不区分大小写\u和第二个\u颠倒：
定义初始化（self，obj，*args）：
self.first=obj[0]。lower（）
self.second=obj[1]
定义（自身、其他）：
返回self.firstother.first或self.first==other.first和other.second>self.second
定义（自我、其他）：
返回self.first=self.second
定义（自身、其他）：
返回self.first==other.first和self.second==other.second
定义（自身、其他）：
返回self.first！=other.first和self.second！=other.second
sortedList=已排序（myList，key=不区分大小写和倒序）

方法1 一个简单但可能不是最有效的解决方案是排序两次：第一次使用第二个元素，第二次使用第一个元素：

sortedList = sorted(sorted(myList, key=lambda (a,b):b, reverse=True), key=lambda(a,b):a)

或细分：

tempList = sorted(myList, key=lambda (a,b):b, reverse=True)
sortedList = sorted(tempList, key=lambda(a,b):a))

方法2 如果你的元素是数字，你可以作弊一点：

sorted(myList, key=lambda(a,b):(a,1.0/b))

方法3 另一种方法是在比较元素时交换元素：

def compare_func(x, y):
    tup1 = (x[0], y[1])
    tup2 = (x[1], y[0])
    if tup1 == tup2:
        return 0
    elif tup1 > tup2:
        return 1
    else:
        return -1

sortedList = sorted(myList, cmp=compare_func)

或者，使用lambda避免写入函数：

sortedList = sorted(
    myList,
    cmd=lambda (a1, b1), (a2, b2): 0 if (a1, b2) == (a2, b1) else 1 if (a1, b2) > (a2, b1) else -1
    )

---

我建议不要使用这种方法，因为它很混乱，而且Python 3中没有

cmd

关键字一种方法是创建一个reversor类，并使用它来装饰有问题的键。该类可用于反转任何具有可比性的字段

class reversor:
    def __init__(self, obj):
        self.obj = obj

    def __eq__(self, other):
        return other.obj == self.obj

    def __lt__(self, other):
        return other.obj < self.obj

---

也许优雅但不是有效的方式：

reverse_key=functools.cmp_to_key（lambda，b：（ab））
sortedList=sorted（myList，key=lambda y:（反向键（y[0].lower（）），y[1]））

此解决方案可用于字符串或其他对象。它比标记为最佳解决方案的解决方案更干净。最好使用

functools来装饰此解决方案。total_ordering

：total ordering不必用作排序函数中的关键参数。您只需==和

sortedList = sorted(myList, key=lambda(y): (y[0].lower(), reversor(y[1]))