Python之列表和字典排序

Python之列表和字典排序

文章目录


在Python中，对列表（list）和字典（dictionary）进行排序是很常见的操作。

列表排序

列表排序可以使用 sort() 方法或 sorted() 函数。

使用 sort() 方法：

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
my_list.sort()
print(my_list)


#打印结果：
#[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

或者使用 sorted() 函数：

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_list = sorted(my_list)
print(sorted_list)


#打印结果：
#[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

默认情况下，它们都是按照升序排序。如果你想按照降序排序，可以设置 reverse=True：

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
my_list.sort(reverse=True)
print(my_list)


#打印结果：
#[9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

或者：

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_list = sorted(my_list, reverse=True)
print(sorted_list)


#打印结果：
#[9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

还可以通过 key 参数指定一个函数，来按照特定的条件进行排序。例如，如果你有一个字符串列表，你可以按照字符串的长度进行排序：

my_list = ['apple', 'banana', 'cherry', 'date']
my_list.sort(key=len)
print(my_list)


#打印结果：
#['date', 'apple', 'banana', 'cherry']

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

字典排序

字典排序稍微复杂一些，因为字典是无序的。要排序字典，你需要将字典转换为列表，然后对列表进行排序。

例如，如果你有一个字典，并且想要按照键（key）进行排序：

my_dict = {'apple': 10, 'banana': 5, 'cherry': 20}
sorted_dict = sorted(my_dict.items(), key=lambda item: item[0])  # 按键排序
print(sorted_dict)


#打印结果：
#[('apple', 10), ('banana', 5), ('cherry', 20)]

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

如果你想要按照值（value）进行排序：

my_dict = {'apple': 10, 'banana': 5, 'cherry': 20}
sorted_dict = sorted(my_dict.items(), key=lambda item: item[1])  # 按值排序
print(sorted_dict)


#打印结果：
#[('banana', 5), ('apple', 10), ('cherry', 20)]

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

《AUTOSAR谱系分解(ETAS工具链)》之总目录

id="article_content" class="article_content clearfix"> id="content_views" class="markdown_views prism-atom-one-dark">
在Java中，我们Stream时，会使用到sorted() 方法 进行排序处理
/**
     * Returns a stream consisting of the elements of this stream, sorted
     * according to the provided {@code Comparator}.
     *
     * 
For ordered streams, the sort is stable.  For unordered streams, no
     * stability guarantees are made.
     *
     * 
This is a stateful
     * intermediate operation.
     *
     * @param comparator a non-interfering,
     *                   stateless
     *                   {@code Comparator} to be used to compare stream elements
     * @return the new stream
     */
    Stream<T> sorted(Comparator<? super T> comparator);
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
class="hide-preCode-box">
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

sorted()需要传入一个Comparator比较器，常用的就是Comparator.comparing(), 当然还有Comparator.comparingInt()、Comparator.comparingLong()、Comparator.comparingDouble() 等常用类型值比较器；

在进行单字段排序时，默认就是使用指定字段值升序进行排序， 如果加上reversed()则是进行降序排序。
但是，我们在日常开发中难免会遇到使用元素的多个属性值进行排序，对于后端开发人员来说，因为习惯 SQL 的排序方式后
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
  • 1
  • 2
-- COLUMN_SORT1_NAME 按降序，(COLUMN_SORT1_NAME相同时) COLUMN_SORT2_NAME 按升序 
SELECT * FROM TABLE_NAME WHERE COLUMN_NAME = VALUE ORDER BY COLUMN_SORT1_NAME DESC, COLUMN_SORT2_NAME ASC
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
会误认为sorted()中的多字段排序相同。
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
下面我们用示例来说明

定义一个类：

@Data
public class TestComparatorComparingMultiple{
    private String sort1; //排序字段1
    private String sort2; //排序字段2

    public TestComparatorComparingMultiple(String sort1, String sort2){
        this.sort1 = sort1;
        this.sort2 = sort2;
    }
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

初始化一个集合：

public static void main(String[] args) {

        List<TestComparatorComparingMultiple> bs = new ArrayList<>();
        bs.add(new TestComparatorComparingMultiple("555","222"));
        bs.add(new TestComparatorComparingMultiple("222","555"));
        bs.add(new TestComparatorComparingMultiple("111","666"));
        bs.add(new TestComparatorComparingMultiple("444","333"));
        bs.add(new TestComparatorComparingMultiple("222","444"));
        bs.add(new TestComparatorComparingMultiple("666","333"));
        bs.add(new TestComparatorComparingMultiple("333","333"));
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

初始顺序： 在这里插入图片描述
通过不同场景来分析排序：

//场景一
List<TestComparatorComparingMultiple> sortResult1 = bs.stream()
                .sorted(Comparator.comparing(TestComparatorComparingMultiple::getSort1)
                        .thenComparing(TestComparatorComparingMultiple::getSort2)
                )
                .collect(Collectors.toList());
 //场景二            
List<TestComparatorComparingMultiple> sortResult2 = bs.stream()
        .sorted(Comparator.comparing(TestComparatorComparingMultiple::getSort1)
                .thenComparing(TestComparatorComparingMultiple::getSort2).reversed()
        )
        .collect(Collectors.toList());
//场景三
List<TestComparatorComparingMultiple> sortResult3 = bs.stream()
        .sorted(Comparator.comparing(TestComparatorComparingMultiple::getSort1).reversed()
                .thenComparing(TestComparatorComparingMultiple::getSort2)
        )
        .collect(Collectors.toList());
//场景四
List<TestComparatorComparingMultiple> sortResult4 = bs.stream()
        .sorted(Comparator.comparing(TestComparatorComparingMultiple::getSort1).reversed()
                .thenComparing(TestComparatorComparingMultiple::getSort2).reversed()
        )
        .collect(Collectors.toList());
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}"> class="hide-preCode-box">

运行以上得到结果：
场景一：
在这里插入图片描述
结果: sort1 升序 、 sort2 升序
没有reversed()时,第一个字段升序 ,第一个字段相同时 第二个字段按升序

场景二：
在这里插入图片描述
结果: sort1 降序 、 sort2 降序
reversed()在最后一个字段时,第一个字段降序 ,第一个字段相同时 第二个字段按降序 (相当于就是场景一取反)

场景三：
在这里插入图片描述
结果: sort1 降序 、 sort2 升序
reversed()在一个字段时 第一个字段降序 ，第一个字段相同时，第二个字段按升序

场景四：
在这里插入图片描述
结果: sort1 升序、 sort2 降序
reversed()两个字段时，第一个字段升序 ， 第一个字段相同时 第二个字段按降序 (相当于就是场景三取反)

综上结果得到：
当reversed()在最后一个字段时，就会将之前的所有排序规则取反(区别SQL中的指定字段排序)。

通过reversed()方法的源码，去理解该逻辑。

 /**
	 * 返回一个该顺序相反比较器
     * Returns a comparator that imposes the reverse ordering of this
     * comparator.
     *
     * @return a comparator that imposes the reverse ordering of this
     *         comparator.
     * @since 1.8
     */
    default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

避坑，避坑…
当然 Collections.sort() , java.util.List 下的 sort(Comparator c)，也可以排序；

>>
注：本文转载自blog.csdn.net的PlutoZuo的文章"https://blog.csdn.net/PlutoZuo/article/details/134259590"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！