Python使用sort和class实现的多级排序功能示例

本文实例讲述了Python使用sort和class实现的多级排序功能。分享给大家供大家参考,具体如下:

# -*- coding:utf-8 -*-
import random
class Temp:
  def __init__(self, a, b, c):
    self.a = a
    self.b = b
    self.c = c
  def __str__(self):
    return ( ('[a: %d b: %d c: %d]' % (self.a, self.b, self.c)))
def cmp1(temp1, temp2):
  if (temp1.a > temp2.a):
    return 1;
  elif(temp1.a == temp2.a):
    if (temp1.b>temp2.b):
      return 1;
    elif(temp1.b == temp2.b):
      return 0;
    else:
      return -1;
  else:
    return -1;
def cmp2(temp1):
  return temp1.a
temp = []
for i in range(200):
  a = random.randint(1, 100)
  b = random.randint(1, 100)
  c = random.randint(1, 100)
  temp.append(Temp(a,b,c))
# for i in range(10):
#   print(temp[i])
#
print
print
# for i in sorted(temp,cmp = cmp1):
#   print(temp[i])
temp.sort(cmp1)
for i in range(200):
  print(temp[i])

运行结果:

[a: 1 b: 61 c: 91]
[a: 1 b: 62 c: 4]
[a: 1 b: 66 c: 6]
[a: 1 b: 73 c: 8]
[a: 2 b: 24 c: 100]
[a: 2 b: 26 c: 26]
[a: 2 b: 52 c: 90]
[a: 4 b: 69 c: 36]
[a: 4 b: 100 c: 66]
[a: 7 b: 59 c: 10]
[a: 7 b: 97 c: 24]
[a: 8 b: 32 c: 84]
[a: 8 b: 49 c: 90]
[a: 9 b: 13 c: 22]
[a: 9 b: 29 c: 99]
[a: 10 b: 52 c: 11]
[a: 11 b: 2 c: 62]
[a: 11 b: 20 c: 56]
[a: 11 b: 38 c: 17]
[a: 11 b: 72 c: 2]
[a: 12 b: 13 c: 48]
[a: 15 b: 39 c: 24]
[a: 15 b: 64 c: 84]
[a: 16 b: 31 c: 89]
[a: 16 b: 60 c: 15]
[a: 16 b: 68 c: 33]
[a: 17 b: 44 c: 97]
[a: 17 b: 82 c: 41]
[a: 17 b: 96 c: 4]
[a: 19 b: 47 c: 22]
[a: 19 b: 97 c: 91]
[a: 20 b: 35 c: 87]
[a: 20 b: 45 c: 71]
[a: 20 b: 58 c: 45]
[a: 21 b: 5 c: 29]
[a: 21 b: 12 c: 1]
[a: 21 b: 24 c: 84]
[a: 21 b: 27 c: 41]
[a: 21 b: 34 c: 4]
[a: 21 b: 44 c: 38]
[a: 21 b: 63 c: 60]
[a: 21 b: 88 c: 60]
[a: 22 b: 15 c: 39]
[a: 23 b: 6 c: 90]
[a: 23 b: 45 c: 36]
[a: 23 b: 95 c: 92]
[a: 24 b: 44 c: 48]
[a: 24 b: 79 c: 86]
[a: 25 b: 40 c: 24]
[a: 25 b: 80 c: 46]
[a: 25 b: 100 c: 40]
[a: 26 b: 34 c: 74]
[a: 26 b: 79 c: 23]
[a: 27 b: 6 c: 51]
[a: 27 b: 8 c: 8]
[a: 27 b: 28 c: 86]
[a: 27 b: 71 c: 48]
[a: 28 b: 5 c: 9]
[a: 29 b: 11 c: 91]
[a: 29 b: 42 c: 17]
[a: 29 b: 47 c: 21]
[a: 31 b: 80 c: 86]
[a: 32 b: 18 c: 24]
[a: 32 b: 30 c: 29]
[a: 32 b: 81 c: 55]
[a: 33 b: 33 c: 10]
[a: 33 b: 36 c: 83]
[a: 34 b: 11 c: 27]
[a: 34 b: 60 c: 52]
[a: 34 b: 62 c: 45]
[a: 34 b: 72 c: 37]
[a: 35 b: 81 c: 50]
[a: 35 b: 88 c: 3]
[a: 36 b: 11 c: 64]
[a: 36 b: 57 c: 93]
[a: 36 b: 92 c: 2]
[a: 38 b: 58 c: 83]
[a: 39 b: 39 c: 66]
[a: 39 b: 47 c: 15]
[a: 40 b: 13 c: 3]
[a: 40 b: 50 c: 66]
[a: 40 b: 99 c: 71]
[a: 41 b: 14 c: 48]
[a: 42 b: 23 c: 38]
[a: 42 b: 26 c: 30]
[a: 42 b: 32 c: 60]
[a: 42 b: 33 c: 61]
[a: 43 b: 27 c: 53]
[a: 43 b: 66 c: 69]
[a: 43 b: 69 c: 81]
[a: 43 b: 71 c: 51]
[a: 44 b: 8 c: 60]
[a: 44 b: 20 c: 7]
[a: 44 b: 48 c: 51]
[a: 44 b: 59 c: 45]
[a: 45 b: 55 c: 95]
[a: 47 b: 45 c: 25]
[a: 47 b: 79 c: 16]
[a: 48 b: 10 c: 32]
[a: 48 b: 17 c: 17]
[a: 48 b: 80 c: 63]
[a: 49 b: 90 c: 32]
[a: 49 b: 93 c: 54]
[a: 50 b: 14 c: 95]
[a: 50 b: 21 c: 75]
[a: 50 b: 41 c: 24]
[a: 50 b: 54 c: 98]
[a: 50 b: 81 c: 70]
[a: 51 b: 33 c: 62]
[a: 52 b: 53 c: 87]
[a: 53 b: 68 c: 68]
[a: 53 b: 70 c: 74]
[a: 53 b: 74 c: 96]
[a: 54 b: 33 c: 16]
[a: 55 b: 80 c: 74]
[a: 55 b: 88 c: 99]
[a: 55 b: 95 c: 44]
[a: 56 b: 14 c: 81]
[a: 56 b: 70 c: 87]
[a: 57 b: 29 c: 21]
[a: 57 b: 81 c: 51]
[a: 58 b: 79 c: 11]
[a: 58 b: 80 c: 87]
[a: 60 b: 78 c: 100]
[a: 61 b: 82 c: 48]
[a: 62 b: 35 c: 64]
[a: 62 b: 65 c: 24]
[a: 62 b: 99 c: 100]
[a: 63 b: 7 c: 61]
[a: 64 b: 24 c: 86]
[a: 64 b: 41 c: 52]
[a: 64 b: 42 c: 40]
[a: 64 b: 63 c: 92]
[a: 66 b: 9 c: 51]
[a: 66 b: 68 c: 78]
[a: 66 b: 78 c: 30]
[a: 66 b: 94 c: 74]
[a: 67 b: 75 c: 41]
[a: 67 b: 78 c: 78]
[a: 68 b: 39 c: 91]
[a: 68 b: 42 c: 19]
[a: 68 b: 42 c: 63]
[a: 69 b: 15 c: 89]
[a: 69 b: 34 c: 86]
[a: 69 b: 37 c: 11]
[a: 69 b: 44 c: 87]
[a: 69 b: 95 c: 68]
[a: 70 b: 44 c: 98]
[a: 70 b: 79 c: 61]
[a: 71 b: 28 c: 95]
[a: 71 b: 81 c: 38]
[a: 72 b: 92 c: 1]
[a: 74 b: 34 c: 74]
[a: 74 b: 67 c: 72]
[a: 75 b: 4 c: 70]
[a: 76 b: 79 c: 90]
[a: 77 b: 71 c: 73]
[a: 78 b: 19 c: 28]
[a: 79 b: 5 c: 17]
[a: 79 b: 84 c: 100]
[a: 79 b: 89 c: 2]
[a: 79 b: 99 c: 33]
[a: 81 b: 17 c: 70]
[a: 81 b: 95 c: 97]
[a: 83 b: 47 c: 51]
[a: 84 b: 22 c: 68]
[a: 84 b: 45 c: 35]
[a: 84 b: 49 c: 63]
[a: 84 b: 90 c: 89]
[a: 85 b: 41 c: 78]
[a: 85 b: 60 c: 19]
[a: 85 b: 61 c: 84]
[a: 86 b: 37 c: 12]
[a: 86 b: 63 c: 17]
[a: 87 b: 5 c: 7]
[a: 87 b: 53 c: 25]
[a: 87 b: 79 c: 38]
[a: 88 b: 4 c: 90]
[a: 89 b: 8 c: 34]
[a: 89 b: 59 c: 21]
[a: 90 b: 1 c: 5]
[a: 90 b: 50 c: 87]
[a: 91 b: 93 c: 63]
[a: 92 b: 81 c: 47]
[a: 92 b: 89 c: 27]
[a: 92 b: 94 c: 51]
[a: 94 b: 37 c: 71]
[a: 95 b: 25 c: 15]
[a: 95 b: 39 c: 56]
[a: 95 b: 59 c: 39]
[a: 96 b: 9 c: 64]
[a: 96 b: 50 c: 20]
[a: 97 b: 12 c: 45]
[a: 97 b: 24 c: 95]
[a: 97 b: 36 c: 72]
[a: 97 b: 41 c: 40]
[a: 97 b: 80 c: 7]
[a: 99 b: 33 c: 23]
[a: 99 b: 56 c: 16]
[a: 100 b: 51 c: 66]

几点需要说明的:

  1. sort接受三个默认的参数,一定要理解cmp函数的含义。我的理解:当a>b时,return 1;意思越大的值越往后排
  2. cmp1()函数中一定要用return a-b,而前往不要return a>b.因为在Python中,有a==b的时候的判断,感觉和c++不太一样

PS:这里再为大家推荐一款关于排序的演示工具供大家参考:

在线动画演示插入/选择/冒泡/归并/希尔/快速排序算法过程工具:
http://tools.jb51.net/aideddesign/paixu_ys

更多关于Python相关内容感兴趣的读者可查看本站专题:《Python数据结构与算法教程》、《Python列表(list)操作技巧总结》、《Python编码操作技巧总结》、《Python函数使用技巧总结》、《Python字符串操作技巧汇总》及《Python入门与进阶经典教程》

希望本文所述对大家Python程序设计有所帮助。

(0)

相关推荐

  • python使用sorted函数对列表进行排序的方法

    本文实例讲述了python使用sorted函数对列表进行排序的方法.分享给大家供大家参考.具体如下: python提供了sorted函数用于对列表进行排序,并且可以按照正序或者倒序进行排列 #创建一个数字组成的列表 numbers = [5, 1, 4, 3, 2, 6, 7, 9] #输出排序后的数字数组 print sorted(numbers) #输出原始数组,并未被改变 print numbers my_string = ['aa', 'BB', 'zz', 'CC', 'dd', "E

  • Python实现二维数组按照某行或列排序的方法【numpy lexsort】

    本文实例讲述了Python实现二维数组按照某行或列排序的方法.分享给大家供大家参考,具体如下: lexsort支持对数组按指定行或列的顺序排序:是间接排序,lexsort不修改原数组,返回索引. (对应lexsort 一维数组的是argsort a.argsort()这么使用就可以:argsort也不修改原数组, 返回索引) 默认按最后一行元素有小到大排序, 返回最后一行元素排序后索引所在位置. 设数组a, 返回的索引ind,ind返回的是一维数组 对于一维数组, a[ind]就是排序后的数组.

  • python sort、sorted高级排序技巧

    Python list内置sort()方法用来排序,也可以用python内置的全局sorted()方法来对可迭代的序列排序生成新的序列. 1)排序基础 简单的升序排序是非常容易的.只需要调用sorted()方法.它返回一个新的list,新的list的元素基于小于运算符(__lt__)来排序. 复制代码 代码如下: >>> sorted([5, 2, 3, 1, 4]) [1, 2, 3, 4, 5] 你也可以使用list.sort()方法来排序,此时list本身将被修改.通常此方法不如s

  • Python使用sorted对字典的key或value排序

    sorted函数 sorted(iterable,key,reverse) iterable 待排序的可迭代对象 key 对应的是个函数, 该函数用来决定选取用哪些值来进行排序 reverse 反转排序 对key排序 d: dict = {"p": 59, "o": 9, "s": 5, "a": 20, "z": 18} li: list = sorted(d.keys()) print(li) 执行结果

  • 详解python中sort排序使用

    1.前言 昨天一学妹问我一个关于python的问题,当时在外忙碌,没时间细看.今天看一下,咋一看我还真的不知道这个问题,bookinfo.sort(reverse=True ,key=lambda x:(x[1],x[1]/x[2]))是如何排序的.但是我猜测应该是按照第二个元素排序,如果第二个元素相同,就按照第二个元素和第三个元素的比值排序.猜测归猜测,自己就去测试了一下.过程如下. 2.环境准备 系统:win10 python版本:3.6 3.程序实现 为了满足实验要求,就设置几个第二个元素

  • Python 列表排序方法reverse、sort、sorted详解

    python语言中的列表排序方法有三个:reverse反转/倒序排序.sort正序排序.sorted可以获取排序后的列表.在更高级列表排序中,后两中方法还可以加入条件参数进行排序. reverse()方法 将列表中元素反转排序,比如下面这样 >>> x = [1,5,2,3,4] >>> x.reverse() >>> x [4, 3, 2, 5, 1] reverse列表反转排序:是把原列表中的元素顺序从左至右的重新存放,而不会对列表中的参数进行排序

  • 基于python list对象中嵌套元组使用sort时的排序方法

    在list中嵌套元组,在进行sort排序的时候,产生的是原数组的副本,排序过程中,先根据第一个字段进行从小到大排序,如果第一个字段相同的话,再根据第二个字段进行排序,依次类推,当涉及到字母的时候,是按照字典序进行排序. 如下: a = [(1, 'B'), (1, 'A'), (1, 'C'), (1, 'AC'), (2, 'B'), (2, 'A'), (1, 'ABC')] a a.sort() a 输出结果为: [(1, 'B'), (1, 'A'), (1, 'C'), (1, 'AC

  • 在Python中使用sort()方法进行排序的简单教程

    sort()方法排序列表中的对象,比较使用func(如果给定). 语法 以下是sort()方法的语法: list.sort([func]) 参数 func -- 这是一个可选参数,如果有将使用该函数,对列表中的对象进行排序 返回值 此方法不返回任何值,但是从列表中给定的对象进行排序 例子 下面的例子显示了sort()方法的使用 #!/usr/bin/python aList = [123, 'xyz', 'zara', 'abc', 'xyz']; aList.sort(); print "Li

  • Python使用sort和class实现的多级排序功能示例

    本文实例讲述了Python使用sort和class实现的多级排序功能.分享给大家供大家参考,具体如下: # -*- coding:utf-8 -*- import random class Temp: def __init__(self, a, b, c): self.a = a self.b = b self.c = c def __str__(self): return ( ('[a: %d b: %d c: %d]' % (self.a, self.b, self.c))) def cmp

  • Python利用operator模块实现对象的多级排序详解

    前言 最近在工作中碰到一个小的排序问题,需要按嵌套对象的多个属性来排序,于是发现了Python里的operator模块和sorted函数组合可以实现这个功能.本文介绍了Python用operator模块实现对象的多级排序的相关内容,分享出来供大家参考学习,下面来看看详细的介绍: 比如我有如下的类关系,A对象引用了一个B对象, class A(object): def __init__(self, b): self.b = b def __str__(self): return "[%s, %s,

  • Python简单实现阿拉伯数字和罗马数字的互相转换功能示例

    本文实例讲述了Python实现阿拉伯数字和罗马数字的互相转换功能.分享给大家供大家参考,具体如下: 前面一篇介绍了<Java实现的求解经典罗马数字和阿拉伯数字相互转换问题>,这里来看看Python的实现方法. 题目很简单,如果之前也做过这种题目的话,相信对于什么是罗马数字就不会很陌生了,罗马数字是很古老的计数方法,现在的一些地方还有见到它的使用,下面简单贴两张维基百科的图片简单回顾一下罗马数字: 今天简单实现一下,阿拉伯数字和罗马数字之间的相互转化问题,很简单就不多说了,下面是具体的实现: #

  • Python网络编程基于多线程实现多用户全双工聊天功能示例

    本文实例讲述了Python网络编程基于多线程实现多用户全双工聊天功能.分享给大家供大家参考,具体如下: 在前面一篇<Python网络编程使用select实现socket全双工异步通信功能>中,我们实现了1对1的异步通信,在文章结尾,给出了多对多通信的思路. 既然说了,咱就动手试一试,本次用的是多线程来实现,正好练练手- 首先讲一下思路: 我们将服务器做为中转站来处理信息,一方面与客户端互动,另一方面进行消息转发. 大体思路确定下来后,需要确定一些通信规则: 1. 客户端与服务器建立连接后,需要

  • python 实现 hive中类似 lateral view explode的功能示例

    背景:加入现在有这样的数据,可能一条ocr代表两个label,并且label通过","分隔.我们想把数据转换成下面的. 原始数据: label ocr 日常行车服务,汽车资讯 去加油站,加完油后直接离开?最开心的可能是加油站的工作人员 社会民生 已致2死20伤 !景区突遭尘卷风袭击,孩子被卷上天!现场画面曝光 目标数据: label ocr 日常行车服务 去加油站,加完油后直接离开?最开心的可能是加油站的工作人员 汽车资讯 去加油站,加完油后直接离开?最开心的可能是加油站的工作人员 社

  • Python实现的多进程拷贝文件并显示百分比功能示例

    本文实例讲述了Python实现的多进程拷贝文件并显示百分比功能.分享给大家供大家参考,具体如下: centos7下查看cup核数: # 总核数 = 物理CPU个数 X 每颗物理CPU的核数 # 总逻辑CPU数 = 物理CPU个数 X 每颗物理CPU的核数 X 超线程数 # 查看物理CPU个数 cat /proc/cpuinfo| grep "physical id"| sort| uniq| wc -l # 查看每个物理CPU中core的个数(即核数) cat /proc/cpuinf

  • Python使用修饰器执行函数的参数检查功能示例

    本文实例讲述了Python使用修饰器执行函数的参数检查功能.分享给大家供大家参考,具体如下: 参数检查:1. 参数的个数:2. 参数的类型:3. 返回值的类型. 考虑如下的函数: import html def make_tagged(text, tag): return '<{0}>{1}</{0}>'.format(tag, html.escape(text)) 显然我们希望传递进来两个参数,且参数类型/返回值类型均为str,再考虑如下的函数: def repeat(what,

  • Python实现快速排序和插入排序算法及自定义排序的示例

    一.快速排序 快速排序(Quicksort)是对冒泡排序的一种改进.由C. A. R. Hoare在1962年提出.它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列. 快速排序,递归实现 def quick_sort(num_list): """ 快速排序 """ if num_li

  • Python实现的手机号归属地相关信息查询功能示例

    本文实例讲述了Python实现的手机号归属地相关信息查询功能.分享给大家供大家参考,具体如下: 根据指定的手机号码,查询其归属地等相关信息,Python实现: 手机号文件:test.txt 13693252552 13296629989 13640810839 15755106631 15119622732 13904446048 18874791953 13695658500 13695658547 15950179080 15573462779 15217624651 15018485989

  • Python数据结构与算法之常见的分配排序法示例【桶排序与基数排序】

    本文实例讲述了Python数据结构与算法之常见的分配排序法.分享给大家供大家参考,具体如下: 箱排序(桶排序) 箱排序是根据关键字的取值范围1~m,预先建立m个箱子,箱排序要求关键字类型为有限类型,可能会有无限个箱子,实用价值不大,一般用于基数排序的中间过程. 桶排序是箱排序的实用化变种,其对数据集的范围,如[0,1) 进行划分为n个大小相同的子区间,每一个子区间为一个桶,然后将n非记录分配到各桶中.因为关键字序列是均匀分布在[0,1)上的,所以一般不会有很多记录落入同一个桶中. 以下的桶排序方

随机推荐