Question

我有一个列表列表，其中每个子列表都是一个对象列表。任务是按照其长度的降序返回前n个子列表的列表。

插图：

[[{},{},{},{}],[{},{},{}],[{},{}],[{}],[]]

对于上面，我想按照长度返回前3个子列表的列表，即

[[{},{},{},{}],[{},{},{}],[{},{}]]

因为子列表中列表的长度最大为3,2,1。

Answer 1

您有两种可能的选择，让我们说：

sorted(l, key=len, reverse=True)[:3]

您可以生成一个全新的列表并获取所需的3个元素：

l.sort(key=len, reverse=True)
l[:3]

或者，您可以对原始列表进行排序，并将它们放在前3个元素中：

In [1]: %timeit sorted(l, key=len, reverse=True)[:3]
1.9 µs ± 28.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [2]: %%timeit
    ...: l.sort(key=len, reverse=True)
    ...: l[:3]
    ...: 
1.22 µs ± 33.8 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

就性能而言，第二种选择似乎更快：

#include <iostream>
#include <vector>
#include <unordered_set>
#include <boost/range/adaptor/transformed.hpp>

struct double_int
{
    typedef int result_type;
    int operator()(int x) const { return x * 2; }
};

int main()
{
  std::unordered_set<int> set;

  for(int i = 0; i < 5; ++i)
    set.insert(i); //adding ints to set

  auto range = set | boost::adaptors::transformed(double_int());

  set.insert(10); //adding some other int

  //this produces: '8 0 2 4 6'
  for(auto i : range)
    std::cout << i << std::endl;

  //this produces: '10 4 0 1 2 3'
  for(auto i : set)
    std::cout << i << std::endl;

  //element 10 is not doubled!

  return 0;
}

Answer 2

>>> a = [[{},{},{},{}],[{},{},{}],[{},{}],[{}],[]]
>>> sorted(a, key=len, reverse=True)
[[{}, {}, {}, {}], [{}, {}, {}], [{}, {}], [{}], []]

在k按sorted(a, key=len, reverse=True)[0:k]拼接sorted的结果后，您始终可以选择顶部key。

要注意的主要观察是参数X，它也可以接受任何疯狂的lambda函数。

Python：返回具有最大长度的子列表中的前n个列表

2 个答案: