GVKun编程网logo

按两个字段对Python列表进行排序（按两个字段对python列表进行排序的方法）

11

对于按两个字段对Python列表进行排序感兴趣的读者，本文将提供您所需要的所有信息，我们将详细讲解按两个字段对python列表进行排序的方法，并且为您提供关于Javascript按两个字段对数组进行排

对于按两个字段对Python列表进行排序感兴趣的读者，本文将提供您所需要的所有信息，我们将详细讲解按两个字段对python列表进行排序的方法，并且为您提供关于Javascript按两个字段对数组进行排序、PHP按两个字段值对数组进行排序、python - 如何按两列或多列对python pandas中的dataFrame进行排序？、python – 基于两个词典对列表进行排序的宝贵知识。

本文目录一览：

按两个字段对Python列表进行排序（按两个字段对python列表进行排序的方法）

按两个字段对Python列表进行排序（按两个字段对python列表进行排序的方法）

我有一个从排序的csv创建的以下列表

list1 = sorted(csv1, key=operator.itemgetter(1))

我实际上想按两个条件对列表进行排序：首先按字段1中的值，然后按字段2中的值。我该怎么做？

答案1

小编典典

像这样：

import operatorlist1 = sorted(csv1, key=operator.itemgetter(1, 2))

答案2

小编典典

使用lambda函数时无需导入任何内容。
以下list按第一个元素排序，然后按第二个元素排序。

sorted(list, key=lambda x: (x[0], -x[1]))

Javascript按两个字段对数组进行排序

Javascript按两个字段对数组进行排序

如何解决Javascript按两个字段对数组进行排序？

| 
grouperArray.sort(function (a,b) {
    var aSize = a.gsize;
    var bSize = b.gsize;
    var aLow = a.glow;
    var bLow = b.glow;
    console.log(aLow + \" | \" + bLow);      
    return (aSize < bSize) ? -1 : (aSize > bSize) ? 1 : 0;
});
因此，以上代码按gsize（最小到最大）对数组进行了排序。效果很好。 但是，如果gsize相同，那么我希望它按辉光排序。 谢谢。     

解决方法

grouperArray.sort(function (a,b) {
    var aSize = a.gsize;
    var bSize = b.gsize;
    var aLow = a.glow;
    var bLow = b.glow;
    console.log(aLow + \" | \" + bLow);

    if(aSize == bSize)
    {
        return (aLow < bLow) ? -1 : (aLow > bLow) ? 1 : 0;
    }
    else
    {
        return (aSize < bSize) ? -1 : 1;
    }
});
    ,
grouperArray.sort(function (a,b) {   
    return a.gsize - b.gsize || a.glow - b.glow;
});
短版     ,
grouperArray.sort((a,b) => a.gsize - b.gsize || a.glow - b.glow);
使用箭头语法的更短版本！     ,我意识到这是在一段时间前提出的，但是我想我会添加我的解决方案。 此函数动态生成排序方法。只需提供每个可排序的子属性名称，并在其前面加上+/-即可表示升序或降序。超级可重用，并且不需要了解您放在一起的数据结构的任何信息。可以做为白痴证明-但似乎没有必要。 
function getSortMethod(){
    var _args = Array.prototype.slice.call(arguments);
    return function(a,b){
        for(var x in _args){
            var ax = a[_args[x].substring(1)];
            var bx = b[_args[x].substring(1)];
            var cx;

            ax = typeof ax == \"string\" ? ax.toLowerCase() : ax / 1;
            bx = typeof bx == \"string\" ? bx.toLowerCase() : bx / 1;

            if(_args[x].substring(0,1) == \"-\"){cx = ax; ax = bx; bx = cx;}
            if(ax != bx){return ax < bx ? -1 : 1;}
        }
    }
}
用法示例： items.sort（getSortMethod（\''-price \''，\''+ priority \''，\''+ name \''））;; 这将首先以最低的
price
排序
items
，并以最高的ѭ7item排序。 
name
打破了其他纽带 项目是一个数组，如： 
var items = [
    { name: \"z - test item\",price: \"99.99\",priority: 0,reviews: 309,rating: 2 },{ name: \"z - test item\",price: \"1.99\",reviews: 11,rating: 0.5 },{ name: \"y - test item\",priority: 1,reviews: 99,rating: 1 },price: \"0\",reviews: 394,rating: 3.5 },{ name: \"x - test item\",priority: 2,reviews: 249,rating: 0.5 } ...
];
现场演示：http：//gregtaff.com/misc/multi_field_sort/ 编辑：修复了Chrome的问题。     ,我希望三元运算符
((aSize < bSize) ? -1 : (aSize > bSize) ? 1 : 0;)
让您感到困惑。您应该查看链接以更好地理解它。 在此之前，如果/否则，这就是您的代码。 
grouperArray.sort(function (a,b) {
    if (a.gsize < b.gsize)
    {
        return -1;
    }
    else if (a.gsize > b.gsize)
    {
        return 1;
    }
    else
    {
        if (a.glow < b.glow)
        {
            return -1;
        }
        else if (a.glow > b.glow)
        {
            return 1;
        }
        return 0;
    }
});
    ,对于那些可能需要更通用的东西，可以在任何数量的字段中使用的人来说，这是一个实现。 
Array.prototype.sortBy = function (propertyName,sortDirection) {

    var sortArguments = arguments;
    this.sort(function (objA,objB) {

        var result = 0;
        for (var argIndex = 0; argIndex < sortArguments.length && result === 0; argIndex += 2) {

            var propertyName = sortArguments[argIndex];
            result = (objA[propertyName] < objB[propertyName]) ? -1 : (objA[propertyName] > objB[propertyName]) ? 1 : 0;

            //Reverse if sort order is false (DESC)
            result *= !sortArguments[argIndex + 1] ? 1 : -1;
        }
        return result;
    });

}
基本上，您可以指定任意数量的属性名称/排序方向： 
var arr = [{
  LastName: \"Doe\",FirstName: \"John\",Age: 28
},{
  LastName: \"Doe\",FirstName: \"Jane\",{
  LastName: \"Foo\",Age: 30
}];

arr.sortBy(\"LastName\",true,\"FirstName\",\"Age\",false);
//Will return Jane Doe / John Doe / John Foo

arr.sortBy(\"Age\",false,\"LastName\",false);
//Will return John Foo / John Doe / Jane Doe
    ,
grouperArray.sort(function (a,b) {
  var aSize = a.gsize;
  var bSize = b.gsize;
  var aLow = a.glow;
  var bLow = b.glow;
  console.log(aLow + \" | \" + bLow);      
  return (aSize < bSize) ? -1 : (aSize > bSize) ? 1 : ( (aLow < bLow ) ? -1 : (aLow > bLow ) ? 1 : 0 );
});
    ,
grouperArray.sort(function (a,b) {
     var aSize = a.gsize;     
     var bSize = b.gsize;     
     var aLow = a.glow;
     var bLow = b.glow;
     console.log(aLow + \" | \" + bLow);
     return (aSize < bSize) ? -1 : (aSize > bSize) ? 1 : (aLow < bLow) ? -1 : (aLow > bLow) ? 1 : 0); });
    ,这是一个使用递归对从1到无限的任意数量的排序字段进行排序的实现。您将结果数组（它是要排序的结果对象的数组）和结果数组（它是定义排序的排序对象的数组）传递给它。每个排序对象必须具有一个用于排序的键名称的“ select”键和一个“ order”键，该键是一个表示“升序”或“降序”的字符串。 
sortMultiCompare = (a,b,sorts) => {
    let select = sorts[0].select
    let order = sorts[0].order
    if (a[select] < b[select]) {
        return order == \''ascending\'' ? -1 : 1
    } 
    if (a[select] > b[select]) {
        return order == \''ascending\'' ? 1 : -1
    }
    if(sorts.length > 1) {
        let remainingSorts = sorts.slice(1)
        return this.sortMultiCompare(a,remainingSorts)
    }
    return 0
}

sortResults = (results,sorts) => {
    return results.sort((a,b) => {
        return this.sortMultiCompare(a,sorts)
    })
}

// example inputs
const results = [
    {
        \"LastName\": \"Doe\",\"FirstName\": \"John\",\"MiddleName\": \"Bill\"
    },{
        \"LastName\": \"Doe\",\"FirstName\": \"Jane\",{
        \"LastName\": \"Johnson\",\"FirstName\": \"Kevin\",\"MiddleName\": \"Bill\"
    }
]

const sorts = [
    {
        \"select\": \"LastName\",\"order\": \"ascending\"
    },{
        \"select\": \"FirstName\",{
        \"select\": \"MiddleName\",\"order\": \"ascending\"
    }    
]

// call the function like this:
let sortedResults = sortResults(results,sorts)
    ,当您具有优先级排序键（某些特定项目中可能不存在）时，这是这种情况的解决方案，因此您必须按备用键进行排序。 输入数据示例（id2是优先级排序键）： 
const arr = [
    {id: 1},{id: 2,id2: 3},{id: 4},{id: 3},{id: 10,id2: 2},{id: 7},{id: 6,id2: 1},{id: 5},{id: 9,{id: 8},];
输出应为： 
[ { id: 6,id2: 1 },{ id: 9,id2: 2 },{ id: 10,{ id: 2,id2: 3 },{ id: 1 },{ id: 3 },{ id: 4 },{ id: 5 },{ id: 7 },{ id: 8 } ]
比较器功能将类似于： 
arr.sort((a,b) => {
  if(a.id2 || b.id2) {
    if(a.id2 && b.id2) {
      if(a.id2 === b.id2) {
        return a.id - b.id;
      }
      return a.id2 - b.id2;
    }
    return a.id2 ? -1 : 1;
  }
  return a.id - b.id
});
附言如果.id2的.id可以为零，请考虑使用
typeof
。     ,
grouperArray.sort(
  function(a,b){return a.gsize == b.gsize ? a.glow - b.glow : a.gsize - b.gsize}
);
    ,
grouperArray.sort(function (a,b) {
    var aSize = a.gsize;
    var bSize = b.gsize;
    if (aSize !== aSize)
        return aSize - bSize;
    return a.glow - b.glow;
});
尚未测试，但我认为应该可以。     ,这就是我用的 
function sort(a,b) {
    var _a = \"\".concat(a.size,a.glow);
    var _b = \"\".concat(b.size,b.glow);
    return _a < _b;
}
将这两个项目组合为字符串，然后将它们按字符串值排序。如果您愿意，可以将_a和_b与parseInt进行包装，以在它们知道是数字的情况下将它们作为数字进行比较。     

PHP按两个字段值对数组进行排序

PHP按两个字段值对数组进行排序

我有这样的数组

数组（ [0] => Array（“ destination” =>“ Sydney”，               “ airlines” =>“ airline_1”，               “ one_way_fare” => 100，               “返回票价=> 300       ）， [2] => Array（“ destination” =>“ Sydney”，               “ airlines” =>“ airline_2”，               “ one_way_fare” => 150，               “返回票价=> 350       ）， [3] => Array（“ destination” =>“ Sydney”，               “ airlines” =>“ airline_3”，               “ one_way_fare” => 180，               “返回票价=> 380       ））

如何按return_fare asc和one_way_fare asc排序值？

我尝试了array_multisort（）但最终却得到了混乱的数据。

Asort仅适用于一维数组，我需要按两个或多个值进行排序，我如何才能像SQL中那样实现此功能，按field1 asc，field2 asc排序？

答案1

小编典典

array_multisort() 是正确的函数，您必须以某种方式搞砸了：

// Obtain a list of columnsforeach ($data as $key => $row) {    $return_fare[$key]  = $row[''return_fare''];    $one_way_fare[$key] = $row[''one_way_fare''];}// Sort the data with volume descending, edition ascendingarray_multisort($return_fare, SORT_ASC, $one_way_fare, SORT_ASC, $data);

如果您在PHP的手册页上查看的注释array_multisort()，您会发现一个非常有用的array_orderby()函数，该函数可以将上述内容简化为：

$sorted = array_orderby($data, ''return_fare'', SORT_ASC, ''one_way_fare'', SORT_ASC);

为了避免循环使用array_column()（从PHP 5.5.0开始）：

array_multisort(array_column($data, ''return_fare''),  SORT_ASC,                array_column($data, ''one_way_fare''), SORT_ASC,                $data);

python - 如何按两列或多列对python pandas中的dataFrame进行排序？

python - 如何按两列或多列对python pandas中的dataFrame进行排序？

假设我有一个带有列的数据框a，b并且c，我想按列b按升序对数据框进行排序，并按列c按降序对数据框进行排序，我该怎么做？

python – 基于两个词典对列表进行排序

python – 基于两个词典对列表进行排序

我已经查看了用于排序字典的不同解决方案并且感到困惑.因此,决定在这里问问我自己.

我正在设计一个排队应用程序,优先考虑之前没有参与的人.之后,优先级将转到请求的时间.

因此,我有两本词典.一个跟踪参与的数量,另一个跟踪参与的时间.

按一下按钮,我在第一本字典中记录时间如下：

dictionary1[name] = time.time()

它将如下：

dictionary1 = {'jessi':time.time(),'jack':time.time(),'bob':time.time()}

time.time()的值是浮点数.
第二本字典记录了以下参与人数：

dictionary2 = {'jack':2,'john':1,'sam': 4}

我希望0参与的人成为排队的首位.在那之后,参与人数较少的人.

通过参与排序后,我想根据提交时间对人进行排序.

我看到许多使用类似的例子：

sorted_dict = sorted(dict['values'],key=lambda k: k['a']['b'])

但是,当字典2中不存在该值时,我收到错误.

在这两个词典中,我希望按照上述标准订购一个列表.该列表应该从dictionary1生成,但是根据dictionary1和dictionary2中的值进行排序.

我怎么处理这个？

编辑：

假如说
dictionary1 = {‘jessi’：10,’jack’：20,’bob’：30}
dictionary2 = {‘jessi’：1,’jack’：2,’john’：1,’sam’：4}
输出应该是：
list = [‘bob’,’jessi’,’jack’]

鲍勃被赋予第一优先权,因为他没有出现在字典2中.

解决方法

您可以使用返回参与计数和时间元组的键函数对其进行排序： 

import time
dictionary1 = {'jessi':time.time()+1,'bob':time.time()-1}
dictionary2 = {'jack':2,'sam': 4}
print(sorted(dictionary1,key=lambda k: (dictionary2.get(k,0),dictionary1[k])))

这输出：

['bob','jessi','jack']

关于按两个字段对Python列表进行排序和按两个字段对python列表进行排序的方法的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于Javascript按两个字段对数组进行排序、PHP按两个字段值对数组进行排序、python - 如何按两列或多列对python pandas中的dataFrame进行排序？、python – 基于两个词典对列表进行排序等相关知识的信息别忘了在本站进行查找喔。

本文标签：

上一篇javascript中是否存在null-coalescing（Elvis）运算符或安全导航运算符？（js 是否存在）

下一篇获取在Python中使用JavaScript生成的页面（python 获取 当前页面 html 内容）

相关文章