精华内容
下载资源
问答
  • 今天小编就为大家分享一篇python 实现多维数组(array)排序,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 数组productlist中存储的是自定义类Product,Product有一个方法是返回商品的价格,于是对productlist按照Product的价格从低到高进行排序,仅需要如此简单的一行代码即可实现。 Python真的是一门简洁而强大的语言,...
  • 主要介绍了Python实现二维数组按照某行或列排序的方法,结合具体实例形式分析了Python使用numpy模块的lexsort方法针对二维数组进行排序的常用操作技巧,需要的朋友可以参考下
  • 数组排序-Py 流行数组排序算法的 Python 实现和基准测试
  • 这三个排序方法应对日常工作基本够用 先说一下三者的区别 sort, sorted 是用在 list 数据类型中的排序方法 argsort 是用在 numpy 数据类型中的排序方法( numpy 里也有一个 sort 方法,下面会讲) sort 和 sorted ...

    这三个排序方法应对日常工作基本够用

    先说一下三者的区别
    sort, sorted 是用在 list 数据类型中的排序方法
    argsort 是用在 numpy 数据类型中的排序方法( numpy 里也有一个 sort 方法,下面会讲)

    sort 和 sorted 的区别如下👇
    先看两个简单的升序排序,分别使用 sorted 和 sort 方法

    # sorted 
    num_list = [1, 8, 2, 3, 10, 4, 5]
    ordered_list = sorted(num_list)
    print(ordered_list)    # [1, 2, 3, 4, 5, 8, 10]
    
    # sort
    num_list = [1, 8, 2, 3, 10, 4, 5]
    num_list.sort()
    print(num_list)    # [1, 2, 3, 4, 5, 8, 10]
    

    可以看出 sorted 并没有修改原来的数组,而是将排序的结果作为参数传递给一个新的数组,而 sort 则在原数组上直接进行了排序
    区别就是 sorted 需要一个变量接收排序结果,sort不用
    建议使用 sorted,因为 sort 虽然代码更简洁,但是会修改原数组,这样不灵活,如果你有多个地方同时使用了这个数组,那么经过 sort 操作之后的数组就已经不是原来那个数组了,debug的时候很麻烦


    说完了区别,来具体讲讲使用方法

    1.升序排序

    # sorted 升序排序
    num_list = [1, 8, 2, 3, 10, 4, 5]
    ordered_list = sorted(num_list)
    print(ordered_list)    # [1, 2, 3, 4, 5, 8, 10]
    
    # sort 升序排序
    num_list = [1, 8, 2, 3, 10, 4, 5]
    num_list.sort()
    print(num_list)    # [1, 2, 3, 4, 5, 8, 10]
    

    2.降序排序

    # sorted 降序排序
    num_list = [1, 8, 2, 3, 10, 4, 5]
    ordered_list = sorted(num_list, reverse=True)
    print(ordered_list)    # [1, 2, 3, 4, 5, 8, 10]
    
    # sort 降序排序
    num_list = [1, 8, 2, 3, 10, 4, 5]
    num_list.sort(reverse=True)
    print(num_list)    # [1, 2, 3, 4, 5, 8, 10]
    

    3.如果不想要排序后的值,想要排序后的索引,可以这样做

    num_list = [1, 8, 2, 3, 10, 4, 5]
    ordered_list = sorted(range(len(num_list)), key=lambda k: num_list[k])
    print(ordered_list)    # [0, 2, 3, 5, 6, 1, 4]
    

    4.字符串类型排序

    # 字符串类型排序
    str_list = ['1', '8', '2', '3', '10', '4', '5']
    ordered_list = sorted(str_list)
    print(ordered_list)  # ['1', '10', '2', '3', '4', '5', '8']
    
    str_list = ['A', 'D', 'B', 'N', 'C', 'R', 'V']
    ordered_list = sorted(str_list)
    print(ordered_list)  # ['A', 'B', 'C', 'D', 'N', 'R', 'V']
    

    5.二维数组排序

    book_list = [
        ['北大马克思主义研究', '9787509728529', 2011],
        ['人的解放', '9787215064003', 2014],
        ['西方经典悦读 资本论', '9787200092882', 2012],
        ['列宁的一生', '9787501319343', 2013],
    ]
    
    # sorted 按出版年升序排序
    ordered_list = sorted(book_list, key=lambda book: book[2])
    print(ordered_list)    # [['北大马克思主义研究', '9787509728529', 2011], ['西方经典悦读 资本论', '9787200092882', 2012], ['列宁的一生', '9787501319343', 2013], ['人的解放', '9787215064003', 2014]]
    
    # sort 按出版年降序排序
    book_list.sort(key=lambda book: book[2], reverse=True)
    print(book_list)    # [['人的解放', '9787215064003', 2014], ['列宁的一生', '9787501319343', 2013], ['西方经典悦读 资本论', '9787200092882', 2012], ['北大马克思主义研究', '9787509728529', 2011]]
    

    6.二维数组获取排序后的索引

    # sorted 获取排序后的索引
    book_list = [
        ['北大马克思主义研究', '9787509728529', 2011],
        ['人的解放', '9787215064003', 2014],
        ['西方经典悦读 资本论', '9787200092882', 2012],
        ['列宁的一生', '9787501319343', 2013],
    ]
    ordered_list = sorted(range(len(book_list)), key=lambda k: book_list[k][2])
    print(ordered_list)  # [0, 2, 3, 1]
    

    7.字典数组排序

    book_list = [
        {'name': '北大马克思主义研究', 'isbn': '9787509728529', 'publish_year': 2011},
        {'name': '人的解放', 'isbn': '9787215064003', 'publish_year': 2014},
        {'name': '西方经典悦读 资本论', 'isbn': '9787200092882', 'publish_year': 2012},
        {'name': '列宁的一生', 'isbn': '9787501319343', 'publish_year': 2013},
    ]
    # sorted 按出版年降序排序
    ordered_list = sorted(book_list, key=lambda book: book['publish_year'], reverse=True)
    print(ordered_list)    # [{'name': '人的解放', 'isbn': '9787215064003', 'publish_year': 2014}, {'name': '列宁的一生', 'isbn': '9787501319343', 'publish_year': 2013}, {'name': '西方经典悦读 资本论', 'isbn': '9787200092882', 'publish_year': 2012}, {'name': '北大马克思主义研究', 'isbn': '9787509728529', 'publish_year': 2011}]
    # sort 按出版年升序排序
    book_list.sort(key=lambda book: book['publish_year'])
    print(book_list)    # [{'name': '北大马克思主义研究', 'isbn': '9787509728529', 'publish_year': 2011}, {'name': '西方经典悦读 资本论', 'isbn': '9787200092882', 'publish_year': 2012}, {'name': '列宁的一生', 'isbn': '9787501319343', 'publish_year': 2013}, {'name': '人的解放', 'isbn': '9787215064003', 'publish_year': 2014}]
    

    8.字典数组获取排序后的索引

    book_list = [
        {'name': '北大马克思主义研究', 'isbn': '9787509728529', 'publish_year': 2011},
        {'name': '人的解放', 'isbn': '9787215064003', 'publish_year': 2014},
        {'name': '西方经典悦读 资本论', 'isbn': '9787200092882', 'publish_year': 2012},
        {'name': '列宁的一生', 'isbn': '9787501319343', 'publish_year': 2013},
    ]
    ordered_list = sorted(range(len(book_list)), key=lambda k: book_list[k]['publish_year'])
    print(ordered_list)  # [0, 2, 3, 1]
    

    9.对象排序

    class Book(object):
        def __init__(self, name, isbn, publish_year):
            self.name = name
            self.isbn = isbn
            self.publish_year = publish_year
        def __repr__(self):
            return repr((self.name, self.isbn, self.publish_year))
    book_list = [
        Book('北大马克思主义研究', '9787509728529', 2011),
        Book('人的解放', '9787215064003', 2014),
        Book('西方经典悦读 资本论', '9787200092882', 2012),
        Book('列宁的一生', '9787501319343', 2013),
    ]
    # sorted 按出版年降序排序
    ordered_list = sorted(book_list, key=lambda book: book.publish_year, reverse=True)
    print(ordered_list)  # [('人的解放', '9787215064003', 2014), ('列宁的一生', '9787501319343', 2013), ('西方经典悦读 资本论', '9787200092882', 2012), ('北大马克思主义研究', '9787509728529', 2011)]
    # sort 按出版年升序排序
    book_list.sort(key=lambda book: book.publish_year)
    print(book_list)  # [('北大马克思主义研究', '9787509728529', 2011), ('西方经典悦读 资本论', '9787200092882', 2012), ('列宁的一生', '9787501319343', 2013), ('人的解放', '9787215064003', 2014)]
    

    10.对象排序获取排序后的索引

    book_list = [
        Book('北大马克思主义研究', '9787509728529', 2011),
        Book('人的解放', '9787215064003', 2014),
        Book('西方经典悦读 资本论', '9787200092882', 2012),
        Book('列宁的一生', '9787501319343', 2013),
    ]
    ordered_list = sorted(range(len(book_list)), key=lambda k: book_list[k].publish_year)
    print(ordered_list)  # [0, 2, 3, 1]
    

    11.一维数组排序【numpy】

    numpy 只有 sort 没有 sorted,且 numpy 的 sort 方法 和 list 的 sorted 方法使用起来类似

    import numpy as np
    
    # 一维数组
    num_list = np.array([1, 8, 2, 3, 10, 4, 5])
    index_list = np.sort(num_list)
    print(index_list)    # [ 1  2  3  4  5  8 10]
    

    12.一维数组获取排序后的索引【numpy】

    num_list = np.array([1, 8, 2, 3, 10, 4, 5])
    index_list = np.argsort(num_list)
    print(index_list)    # [0 2 3 5 6 1 4]
    

    13.一维数组降序排序【numpy】

    # # 降序排序
    num_list = np.array([1, 8, 2, 3, 10, 4, 5])
    index_list = np.argsort(-num_list)    # 加负号按降序排序
    print(index_list)  # [4 1 6 5 3 2 0]
    

    14.二维数组排序【numpy】

    num_list = np.array([
        [1, 8, 2, 9],
        [8, 2, 4, 5],
        [2, 3, 7, 4],
        [1, 2, 3, 5]
    ])
    ordered_list = np.sort(num_list, axis=0)    # axis=0 是按列排序
    print(ordered_list)
    # [[1 2 2 4]
    #  [1 2 3 5]
    #  [2 3 4 5]
    #  [8 8 7 9]]
    
    ordered_list = np.sort(num_list, axis=1)     # axis=1 是按行排序
    print(ordered_list)
    # [[1 2 8 9]
    #  [2 4 5 8]
    #  [2 3 4 7]
    #  [1 2 3 5]]
    

    15.二维数组获取排序后的索引【numpy】

    num_list = np.array([
        [1, 8, 2, 9],
        [8, 2, 4, 5],
        [2, 3, 7, 4],
        [1, 2, 3, 5]
    ])
    ordered_list = np.argsort(num_list, axis=0)   # axis=0 是按列排序
    print(ordered_list)
    # [[0 1 0 2]
    #  [3 3 3 1]
    #  [2 2 1 3]
    #  [1 0 2 0]]
    ordered_list = np.argsort(num_list, axis=1)  # axis=1 是按行排序
    print(ordered_list)
    # [[0 2 1 3]
    #  [1 2 3 0]
    #  [0 1 3 2]
    #  [0 1 2 3]]
    
    展开全文
  • 数组排序(python)

    千次阅读 2019-07-30 18:41:50
     按照这种规则依次给整个数组排序,并将排序过程打印到控制台。 比如给出一组数据4,1,3,5,2,排序过程如下: 最后得到结果:1 2 3 4 5 class Task : def sort ( self , xlist ) : # *******...

    本关挑战任务是对一个数组进行排序,排序需要遵守一些规则:

       先对数组从左到右,相邻元素进行比较,如果第一个比第二个大,就交换它们,进行一个升序排序;

       再对数组从右到左,相邻元素进行比较,如果第一个比第二个小,就交换它们,进行一个降序排序;

       以此类推,持续的、依次的改变排序的方向,并不断缩小没有排序的数组范围;

       按照这种规则依次给整个数组排序,并将排序过程打印到控制台。

    比如给出一组数据4,1,3,5,2,排序过程如下:

    在这里插入图片描述
    最后得到结果:1 2 3 4 5

    class Task:
    
        def sort(self, xlist):
            # ********* Begin *********#
    
            if sorted(xlist) == xlist:
                xlist1 = list(map(str, xlist))
                print(' '.join(xlist1))
            else:
                for i in range(int(len(xlist)/2)):
    
                    for i in range(len(xlist) - 1):
                        if xlist[i] > xlist[i + 1]:
                            xlist[i],xlist[i+1] = xlist[i+1],xlist[i]
    
                            xlist1 = list(map(str, xlist))
                            print(' '.join(xlist1))
    
                    for i in range(len(xlist) - 1, 0, -1):
                        if xlist[i] < xlist[i-1]:
                            xlist[i], xlist[i-1] = xlist[i-1], xlist[i]
                            xlist1 = list(map(str, xlist))
                            print(' '.join(xlist1))
    
    
    
        # ********* End *********#
    

    思路:

    • 1、首先利用python自带的sorted()判断是否已经是排序好的
    • 2、利用map函数将数组里面的int转化为str,然后转化为list.
    • 3、利用jion()函数,将数组内的字符串进行拼接
    • 4、xlist[i],xlist[i+1] = xlist[i+1],xlist[i]
            等价于利用temp中间变量进行交换。
    展开全文
  • 数组排序 sort() 和 sorted() 相对于sort()来说,sorted的应用更加广泛 sorted() 作用于任意可迭代的对象 而 sort() 一般作用于列表 sort(): x = [4, 6, 2, 1, 7, 9] x.sort() print(x) 打印结果为 [1, 2, 4, ...

    数组的排序

    sort() 和 sorted()
    相对于sort()来说,sorted的应用更加广泛
    sorted() 作用于任意可迭代的对象
    而 sort() 一般作用于列表

    sort():

    x = [4, 6, 2, 1, 7, 9]
    x.sort()
    print(x)
    
    打印结果为 [1, 2, 4, 6, 7, 9] 从小到大排序
    

    sort()提供了两个可选参数,分别是 key和reverse

    • key在使用时必须提供一个排序过程总调用的函数:
     - x = ["WW","WWW","W","WW","WWWW","WW","W","WWWWW"]
    x.sort(key=len)
    print(x)
    打印结果为:['W', 'W', 'WW', 'WW', 'WW', 'WWW', 'WWWW', 'WWWWW'](以字符串长度进行排序)
    
    • reverse实现降序排序,反转功能:
     x = ["WW","WWW","W","WW","WWWW","WW","W","WWWWW"]
    x.sort(reverse=True)
    print(x)
    打印结果为:['WWWWW', 'WWWW', 'WWW', 'WW', 'WW', 'WW', 'W', 'W']
    

    sorted():

    sorted()可以对列表、元组、字典、集合、字符串、range对象以及其他可迭代对象进行排序,返回排序后的列表,支持使用key参数指定排序规则,支持reverse参数指定升序或者降序。

    x = (4, 6, 2, 1, 7, 9)
    print(type(x)) #打印为元组<class 'tuple'>
    print(sorted(x))
    打印结果:<class 'tuple'>
    		[1, 2, 4, 6, 7, 9]
    

    如果这个例子中针对元组使用 sort() 方法会抛出 AttributeError,而使用 sorted() 函数则 没有这个问题。

    当排序对象为列表的时候两者适合的场景不同
    sorted() 函数会返回一个排序后的列表,原有列表保持不变
    而 sort() 函数会直接修改原有列表

    例子: 输入数组、最大的与第一个元素交换、最小的与最后一个元素交换、输出数组。

    l = input('请输入一个数组:')
    z = l.strip('[').strip(']').split(',')
    x = []
    for i in z:
        x.append(int(i))
    k = (max(x))
    x.remove(k)
    h = (min(x))
    x.remove(h)
    x.insert(0,k)
    x.append(h)
    print(x)
    
                      ——————————————————感谢观看——————————————————————
    
    展开全文
  • 这个比较简单,从网上搜索了sort函数的用法 代码实现 class Solution: def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None: """ Do not return anything, modify nums1 in-place ...

    这个比较简单,从网上搜索了sort函数的用法
    代码实现

    class Solution:
        def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
            """
            Do not return anything, modify nums1 in-place instead.
            """
            j=0
            i=m
            while j <n:
                nums1[i]=nums2[j]
                j+=1
                i+=1
            nums1.sort()

    在这里插入图片描述

    展开全文
  • 有时候会遇到将B数组按照A数组进行排序的情况,尤其是在写程序统计频率的时候。之前遇到过一次,然后情急之下是采用的冒泡排序算法,后进行关联排序。这样效率太低了。今天有幸看到了一位博主的解法,就是用ZIP来...
  • Python数组排序

    2020-03-16 14:47:55
    适用于Python数组排序的方法有很多,这里只介绍一种目前比较推荐的排序方法,即 list.sort(key=None,reverse=False)。 函数的两个参数: key: 选定比较的元素,可以设置多个参数,依次比较,一般使用lambda表达式来...
  • 使用二分查找的思想,解决《33. 搜索旋转排序数组》问题
  • Python3】数组排序

    万次阅读 2018-05-15 19:56:49
    1、数组排序 a = [3,1,4,6] a.sort() print(a) 执行结果: 2、多维数组排 a = [['5.1.5.40580', 29], ['5.0.8.14000', 11], ['5.0.8.14999', 59], ['5.1.4.37882', 4]] a.sort(key=lambda x:x[1],reverse=...
  • 研究排序问题的时候常常需要生成随机数组来验证自己排序算法的正确性和性能,今天把Python生成随机数组的方法稍作总结,以备以后查看使用。 一、使用random模块生成随机数组 python的random模块中有一些生成随机数字...
  • >>> l = [[1, 2, 3], [2, 3, 4], [2, 1, 3]] >>> sorted(l, key=lambda l: l[1], reverse=True) [[2, 3, 4], [1, 2, 3], [2, 1, 3]] >... sorted(l, key=lambda l: l[1]) [[2, 1, 3], [1, 2, 3], ...
  • python的numpy包有非常多好用的功能 比如sort函数可以一键排序 那么对于两个数组,让其中一个进行升序排列,如何让另一个数组保持和原来数组的对应关系也进行排列呢。比如如下两个数组: import numpy as np arr1 =...
  • Python sorted() 函数 配合lambda用法 https://blog.csdn.net/weixin_42280517/article/details/80500632?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-8.add_param_isCf&...
  • Python 二维数组排序问题

    千次阅读 2017-12-25 14:13:43
    希望一个二维数组,先按第二列排序,再按第一列排序,网上找了一圈没找到,后来不停尝试终于找到一个方法,代码如下:a = [[2,3,4], [2,4,5],[3,3,4]] sorted(a, key=lambda x: (x[1], x[0]))输出结果为:[[2, 3, 4]...
  • python 多维数组排序

    千次阅读 2017-08-12 18:12:35
    python 多维数组排序
  • 由于Python没有内置的数组功能,因此通常使用列表执行数组操作。在列表中存储对象列表为在方括号[]里定义的以逗号分隔的数据序列类型,例如:图1注意,在示例的最后一行中,列表包含了不同的数据类型。并且,在列表...
  • 排序前 {'code': 'X001', 'shptype': '航空运输', 'quantity': 4, 'pkgcode': epcm.package(1,), 'avastart': datetime.date(2020, 12, 27), 'avaend': datetime.date(2021, 6, 1)} {'code': 'X002', 'shptype': '...
  • python二维数组自定义排序

    千次阅读 2020-07-29 21:18:42
    二维数组排序python二维数组自定义排序基础二维数组排序二维数组自定义排序 python二维数组自定义排序 基础二维数组排序 y = sorted(x, key = lambda x:(x[0],-x[1])) # 按照一维升序,二维降序 输入:[(264.0, 8, 0...
  • 合并K个已排序数组Python

    千次阅读 2018-09-03 12:08:38
    将K个已排序数组合并成一个数组,如merge([[2,4,5],[1,3,9],[6,7,8]]) = [1,2,3,4,5,6,7,8,9] 代码思路: 本题采用归并算法较为简单清晰。归并法的实现简单来说就是分治法的实现,讲一个大问题不停拆解,最后在将...
  • python 多维数组(array)排序

    千次阅读 2018-07-18 18:15:19
    python 多维数组(array)排序 关于多维数组如何复合排序 如数组: &gt;&gt;&gt; import numpy as np &gt;&gt;&gt; data = np.array([[2,2,5],[2,1,3],[1,2,3],[3,1...
  • 在用Matplotlib库绘制折线图的时候遇到一个问题,当定义一个x轴数组时,plot绘制折线图时,x轴并不会按照我们定义的数组的顺序去排列显示,例如: import matplotlib.pyplot as plt colums_x = ['aa','bc','ad','bd...
  • Python 二维数组排序

    千次阅读 2018-09-25 23:56:58
    多维数组排序 之前在matlab上面想了好久。 用python实现很简单: a = [[2,3,4], [2,4,5],[3,3,4]] sorted(a, key=lambda x: (x[1], x[0])) print(a) [[2, 3, 4], [2, 4, 5], [3, 3, 4]] ...
  • 今天小编就为大家分享一篇python对数组进行排序,并输出排序后对应的索引值方式,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 96,103
精华内容 38,441
关键字:

数组排序python

python 订阅