精华内容
下载资源
问答
  • 今天小编就为大家分享一篇python对数组进行排序,并输出排序后对应的索引值方式,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 今天小编就为大家分享一篇python 实现多维数组(array)排序,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 这三个排序方法应对日常工作基本够用 先说一下三者的区别 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]]
    
    展开全文
  • argsort()函数是将x中的元素从小到大排列,提取其对应的index(索引) 当num>=0时,np.argsort()[num]就可以理解为y[num] 当num<0时,np.argsort()[num]就是把数组y的元素反向输出 import numpy as np x = np....

    argsort()函数是将x中的元素从小到大排列,提取其对应的index(索引)

    当num>=0时,np.argsort()[num]就可以理解为y[num]
    当num<0时,np.argsort()[num]就是把数组y的元素反向输出

    import numpy as np
    x = np.array([2,1,4,5,7,3,6]
    y = x.argsort()
    print (y[1], y[-1])
    

    、、、、、、、、、、、、、、、、、、、、、、、
    .argsort函数

    argsort函数返回的是数组值从小到大的索引值

    Examples
    --------
    

    One dimensional array:一维数组

    >>> x = np.array([3, 1, 2])
    >>> np.argsort(x)
    array([1, 2, 0])
    

    Two-dimensional array:二维数组

    '''
    遇到问题没人解答?小编创建了一个Python学习交流QQ群:857662006 
    寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
    '''
    >>> x = np.array([[0, 3], [2, 2]])
    >>> x
    array([[0, 3],
    [2, 2]])
    
    >>> np.argsort(x, axis=0) #按列排序
    array([[0, 1],
    [1, 0]])
    
    >>> np.argsort(x, axis=1) #按行排序
    array([[0, 1],
    [0, 1]])
    

    例1:

    '''
    遇到问题没人解答?小编创建了一个Python学习交流QQ群:857662006 
    寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
    '''
    >>> x = np.array([3, 1, 2])
    >>> np.argsort(x) #按升序排列
    array([1, 2, 0])
    >>> np.argsort(-x) #按降序排列
    array([0, 2, 1])
    
    >>> x[np.argsort(x)] #通过索引值排序后的数组
    array([1, 2, 3])
    >>> x[np.argsort(-x)]
    array([3, 2, 1])
    

    另一种方式实现按降序排序:

    >>> a = x[np.argsort(x)]
    >>> a
    array([1, 2, 3])
    >>> a[::-1]
    array([3, 2, 1]) 
    
    展开全文
  • python如何返回排序列表的索引

    万次阅读 多人点赞 2019-05-17 16:25:58
    >>> lis = [1,2,3,0,1,9,8] >>> sorted(range(len(lis)), key=lambda k: lis[k]) [3, 0, 4, 1, 2, 6, 5] >>>
    >>> lis = [1,2,3,0,1,9,8]
    >>> sorted(range(len(lis)), key=lambda k: lis[k])
    [3, 0, 4, 1, 2, 6, 5]
    >>>
    
    展开全文
  • Python数组排序

    2018-04-28 10:20:17
    #创建一个二维数组 data=np.sin(np.arange(20)).reshape(5,4) print("data:") print(data) # [[ 0. 0.84147098 0.90929743 0.14112001] # [-0.7568025 -0.95892427 -0.2794155 0.656986...
    
    import numpy as np
    #创建一个二维数组
    data=np.sin(np.arange(20)).reshape(5,4)
    print("data:")
    print(data)
    # [[ 0.          0.84147098  0.90929743  0.14112001]
    #  [-0.7568025  -0.95892427 -0.2794155   0.6569866 ]
    #  [ 0.98935825  0.41211849 -0.54402111 -0.99999021]
    #  [-0.53657292  0.42016704  0.99060736  0.65028784]
    #  [-0.28790332 -0.96139749 -0.75098725  0.14987721]]
    #按照列找除结果最大的索引,返回的是行号
    max_ind=data.argmax(axis=0)
    print(max_ind)
    # [2 0 3 1]
    #按照行找除结果最小的索引,返回的是列号
    min_ind=data.argmin(axis=1)
    print(min_ind)
    # [0 1 3 0 1]
    #找出最大值
    print(data[max_ind,range(data.shape[1])])
    #[0.98935825 0.84147098 0.99060736 0.6569866 ]
    #找出最小值
    print(data[range(data.shape[0]),min_ind])
    #[ 0.         -0.95892427 -0.99999021 -0.53657292 -0.96139749]
    #数组扩展
    a=np.arange(0,40,10)
    print(a)
    #[ 0 10 20 30]
    b=np.tile(a,(3,5))
    print(b)
    
    # [[ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
    #  [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
    #  [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]]
    
    #排序
    a=np.array([
        [14,32,15,7],
        [1,2,1,9],
        [12,3,1,9]
    ])
    print(a)
    # [[14 32 15  7]
    #  [ 1  2  1  9]
    #  [12  3  1  9]]
    
    print(np.sort(a,axis=0))
    # [[ 1  2  1  7]
    #  [12  3  1  9]
    #  [14 32 15  9]]
    print(np.argsort(a,axis=1))
    # [[3 0 2 1]
    #  [0 2 1 3]
    #  [2 1 3 0]]
    print(np.argsort(-a,axis=1))
    # [[1 2 0 3]
    #  [3 1 0 2]
    #  [0 3 1 2]]
    print(a.max())
    # 32
    展开全文
  • 针对数组中数字,如果想要获得前N小/大数字的索引 可进行如下操作 import numpy as np a = np.array([1,4,3,5,2]) b = np.argsort(a) print(b) 输出的结果是[0 4 2 1 3]从小到大排序 由此可以看出数组a中大小排布的...
  • 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=...
  • from numpy\core\fromnumeric.py @array_function_dispatch(_argsort_dispatcher) def argsort(a, axis=-1, kind=None, order=None): """ Returns the indices that would sort an ... 返回将对数组进行排序索引...
  • argsort()函数是将x中的元素从小到大排列,提取其对应的index(索引) 当num&amp;gt;=0时,np.argsort()[num]就可以理解为y[num] 当num&amp;lt;0时,np.argsort()[num]就是把数组y的元素反向输出 ...
  • python - 按列在NumPy中对数组进行排序如何在第n列中对NumPy中的数组进行排序?例如,a = array([[9, 2, 3],[4, 5, 6],[7, 0, 5]])我想按第二列对行进行排序,以便我回来:array([[7, 0, 5],[9, 2, 3],[4, 5, 6]])9...
  • python的numpy包有非常多好用的功能 比如sort函数可以一键排序 那么对于两个数组,让其中一个进行升序排列,如何让另一个数组保持和原来数组的对应关系也进行排列呢。比如如下两个数组: import numpy as np arr1 =...
  • (1)自定义方法 myList = [1, 2, 3, 100, 5] index_list=[i[0] for i in sorted(enumerate(myList)...enumerate(myList)返回一个包含(index,value)元组的列表 [(0, 1), (1, 2), (2, 3), (3, 100), (4, 5)] 通...
  • python数组使用(超级全面)

    万次阅读 多人点赞 2019-04-18 19:43:46
    1、Python数组分三种类型: (1) list 普通的链表,初始化后可以通过特定方法动态增加元素。 定义方式:arr = [元素] (2) Tuple 固定的数组,一旦定义后,其元素个数是不能再改变的。 定义方式:arr = (元素) (2) ...
  • python数组排名

    2020-08-10 20:52:27
    然后想起numpy里面有个argsort,可以返回数组排序后的索引 (然后我就以为argsort的返回值就是排名了。。。。。) 其实并不是!!!是索引!!! 如果要得到排名我自己写了一下: import numpy as np result = [2,4...
  • python 对数组进行排序并保留索引

    千次阅读 2018-08-01 16:22:00
    import numpy as np arr = [1, 3, 5, 2, 4, 6] arr = np.array(arr) print (np.argsort(arr)) # 正序输出 print (np.argsort(-arr)) # 逆序输出
  • s = [2, 3, 1, 4, 5] sorted(range(len(s)), key=lambda k: s[k]) [2, 0, 1, 3, 4]
  • https://blog.csdn.net/weixin_41824534/article/details/92411046
  • # Python中缩进规则 print(1) # print(2) # 无原因的缩进 unexpected idented #for i in range(5): #print(123) #for循环下面的一行如果没有缩进,则会有expected an indented block # List中相关方法 # 通过start...
  • python对数组进行排序,并输出排序后对应的索引

    万次阅读 多人点赞 2019-06-16 17:31:24
    # -*- coding: cp936 -*...#一维数组排序 arr = [1, 3, 5, 2, 4, 6] arr = np.array(arr) print arr print np.sort(arr)#或print np.sort(arr,axis=None) print (np.argsort(arr)) # 正序输出索引 print (np...
  • 常常需要找到一个列表中或者数组中最小的值并返回索引,经常用,经常忘,害。 1、list中返回索引 list.index() list1 = [1,2,3,2,1] print(list1.index(max(a))) #结果:2 list2 = [1,2,3,4] print(list2.index(min...
  • python数组的使用

    千次阅读 2018-07-07 12:22:38
    python数组的使用 python数组的使用 2010-07-28 17:17 1、Python的数组分三种类型:
  • #sa[i]表示排名为i的后缀的起始字符下标为... suffix[i] = s[sa[i]:] # suffix中存储的就是排序后的后缀数组 return suffix if __name__ == "__main__": s = "aabaaaab" suffix = get_suffix(s) print(suffix)
  • python】二维数组按照某行或某列排序(numpy lexsort)

    万次阅读 多人点赞 2018-12-17 20:40:41
    曾经以为排序只能使用list的sort函数,后来发现array的排序实现方法也有很多。 List 1、一维数组 2、二维数组 无论是一维数组还是二维数组都能通过 list 自带的 sort() 函数进行更新,或者直接调用sorted()方法...
  • python数组基本操作总结

    万次阅读 多人点赞 2018-06-19 18:26:42
     np.zeros( (2,4) ) #传入元祖,返回2*4数组   np.zeros( (2,4,5) )  #2*4*5  #  ones, empty方法使用方式类似    (3)arange方法:  np.arange(5) #默认从0开始,到4的整数数组,默认步长为1  np.array...
  • 有序数组其实就是数组的进化版,和数组唯一的区别就是“有序”这两个字,就是指在这个数组当中的所有数据,必须按照一定的顺序来排列,即便是插入新数据或者删除原有数据,仍然要按照既定规则来排序;而普通的数组是...
  • import numpy as np B=np.array([[4,2,3,55],[5,6,37,8],[-7,68,9,0]]) print('B:') print(B) #正序 #step1: print('') print('正序的时候') print('默认输出') ...这些索引值对应的元素是从小到大排序的。 #st
  • Python数组从小到大排序(选择排序)代码: #coding=utf-8 ‘’’ #选择排序 Created on 2019年12月8日 @author: LWJ ‘’’ def findSmallest(arr): smallest = arr[0] #存储最小的值 smallest_index ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 43,405
精华内容 17,362
关键字:

python数组排序返回索引

python 订阅