python list根据嵌套中的对象排序

字典排序

    dict = {'a':21, 'b':5, 'c':3, 'd':54, 'e':74, 'f':0}
    new_dict = sorted(dict.iteritems(), key=lambda d:d[1], reverse =True)
    print new_dict

 

列表排序

    [{'businessname': '暂无', 'requestCount': 264, 'maxtime': '76.00', 'avgtime': '8.81', 'appname': 'wszx-svc', 'errRequest': 0, 'mintime': '4.00', 'interface':  'gov.etax.dzswj.xxzx.channel.IChannelAgent'}]

    ilist = sorted(ilist,key=lambda e:float(e.__getitem__('avgtime')))
    ilist = sorted(ilist,key=lambda e:float(e.__getitem__('avgtime')),reverse=True)

   多级排序,先按照score，再按照no排序
   new_s_2 = sorted(new_s,key = lambda e:(e.__getitem__('score'),e.__getitem__('no')))

实例代码

     handleSortChange1(sortobj)
      {
         this.sortColumn=sortobj.prop;
         let sortType=sortobj.order;
         if(sortType=="ascending")
         {
            this.sortType="asc";
         }
         else
         {
           this.sortType="desc";
         }
         this.currentPage = 1;
         this.getinferfaceCall();
      },
     getinferfaceCall()
     {
      this.tbflag=true;
      return this.$http.getInterfaceCall(
          {
            "pageIndex":this.currentPage,
            "pageSize":this.pageSize,
            "startTime":this.startTtime,
            "endTime":this.endTime,
            "sortColumn":this.sortColumn,
            "sortType":this.sortType
           },{notify:true})
         .then((data) => 
          {
            this.interfaceList=data.list;
            this.total=data.total;
          }).finally(() =>{
            this.tbflag=false;
          });
     }

    def getinterfacecall(self,startTime,endTime,pageIndex,pageSize,sortColumn,sortType):
        userChoiceTime_start = self.formartStartTime(startTime)
        userChoiceTime_end = self.formartEndTime(endTime)
        index_list_pattern=self.getindexes(startTime,endTime)
        pageIndex = int(pageIndex)
        pageSize = int(pageSize)

        body = {
            "size": 0,
            "query": {
                "filtered": {
                    "filter": {
                        "bool": {
                            "must": [
                                {
                                    "range": {
                                        "@timestamp": {
                                            "gte": tools.strtime_to_timestamp(userChoiceTime_start),
                                            "lte": tools.strtime_to_timestamp(userChoiceTime_end)
                                        }
                                    }
                                }
                            ]
                        }
                    }
                }
            },
            "aggs": {
              "appname": {
                 "terms": {
                     "field": "appname"
                 },
                 "aggs":  {
                   "res": {
                      "terms": {
                        "field": "interface"
                    },
                    "aggs": {
                        "avg_waste_time": {
                            "avg": {
                                "field": "waste_time"
                            }
                        },
                        "max_waste_time": {
                            "max": {
                                "field": "waste_time"
                            }
                        },
                        "min_waste_time": {
                            "min": {
                                "field": "waste_time"
                            }
                        },
                        "visit": {
                            "terms": {
                                "field": "success.keyword"
                            }
                        }
                    }
                }
               }
              }
            }
        }

        res = self.es.search(index=index_list_pattern,body=body)

        ilist=[]
        for app in res["aggregations"]["appname"]["buckets"]:
            appname = app["key"]
            appobj=AppName.objects.filter(appname=appname).first()
            businessname="暂无"
            if appobj and appobj.env:
                businessname=appobj.env.businessname
            for interface in app["res"]["buckets"]:
                wastetime = self.format_floatnumber(interface["avg_waste_time"]["value"])
                maxtime=self.format_floatnumber(interface["max_waste_time"]["value"])
                mintime=self.format_floatnumber(interface["min_waste_time"]["value"])
                requests = interface["doc_count"]
                err_express = [i["doc_count"] for i in interface["visit"]["buckets"] if i["key"] == "false"]
                errcount = err_express[0] if len(err_express) > 0 else 0
                ilist.append({"businessname":businessname,"appname":appname,"interface": interface["key"], "avgtime": wastetime, "requestCount": requests, "errRequest": errcount,"maxtime":maxtime,"mintime":mintime})

        reverse=False
        floatflag=False
        if sortType == "desc":
            reverse=True
        if sortColumn in ["avgtime","requestCount","errRequest","maxtime","mintime"]:
            floatflag=True
        if floatflag:
            ilist = sorted(ilist,key=lambda e:float(e.__getitem__(sortColumn)),reverse=reverse)
        else:
            ilist = sorted(ilist, key=lambda e: e.__getitem__(sortColumn), reverse=reverse)

        reslist=ilist[(pageIndex-1)*pageSize:pageIndex*pageSize]
        data = {'code': 'SUCCESS', 'message': '', 'data': {"total":len(ilist),"list":reslist}}
        return data