Python 确定n个元素列表的最小值

我在开发一个算法来确定n个元素列表的最小值时遇到了一些困难。这不是寻找长度为n的数组的最小值的情况，这很简单：

min = A[0]
for i in range(1, len(A)):
    if min > A[i]: min = A[i]
print min

但我的列表包含以下对象：

class Object:
    def __init__(self, somelist):
        self.classification = somelist[0] # String
        self.type           = somelist[1] # String
        self.first          = somelist[2] # Integer
        self.last           = somelist[3] # Integer

对于相同的“分类类型”对象，我有m个元素，我想通过比较第一个和最后一个之间的差异来找到相同“分类类型”的最小元素

例如：

obj1 = Object(['A', 'x', 4, 17])
obj2 = Object(['A', 'y', 5, 20])
obj3 = Object(['B', 'z', 10, 27])
obj4 = Object(['B', 'z', 2, 15])
obj5 = Object(['B', 'z', 20, 40])
obj6 = Object(['A', 'x', 6, 10])
obj7 = Object(['A', 'x', 2, 9])
list = [obj1, obj2, obj3, obj4, obj5, obj6, obj7]

所以我需要一个算法来确定列表的最小值：

一个| x-->对象（['A'，x'，6，10]）

B | z-->对象（[B'，z'，2，15]）

A | y-->对象（[A'，y'，5，20]）

谢谢

filtered = [obj for obj in lst if obj.classification == 'A' and obj.type = 'x']
min(filtered, key=lambda x: x.last - x.first)

注意：不要命名变量

列表

：它隐藏了内置变量

import itertools 
group_func = lambda o: (o.classification, o.type)
map(lambda pair: (pair[0], min(pair[1], key=lambda o: o.last - o.first)),
    itertools.groupby(sorted(l, key=group_func), group_func))

group_func

返回包含对象分类的元组键，然后键入（例如

（'a'，'x'）

）。这首先用于对列表进行排序

l

（

sorted

call）。然后，我们调用排序列表上的

groupby

，使用

groupfunc

将其分组到子列表中。每次键更改时，我们都会有一个新的子列表。与SQL不同，groupby要求列表在同一个键上预先排序

map

获取

groupby

函数的输出。对于每个组，

map

返回一个元组。第一个元素是

对[0]

，它是键

（'A'，'x'）

。第二个是组的最小值（

pair[1]

），由

last-first

键确定。

以下是一种简单易懂的动态过程方法：

class Object:
    def __init__(self, somelist):
        self.classification = somelist[0] # String
        self.type           = somelist[1] # String
        self.first          = somelist[2] # Integer
        self.last           = somelist[3] # Integer
    def weight(self):
        return self.last - self.first
    def __str__(self):
        return "Object(%r, %r, %r, %r)" % (self.classification, self.type, self.first, self.last)
    __repr__ = __str__

obj1 = Object(['A', 'x', 4, 17])
obj2 = Object(['A', 'y', 5, 20])
obj3 = Object(['B', 'z', 10, 27])
obj4 = Object(['B', 'z', 2, 15])
obj5 = Object(['B', 'z', 20, 40])
obj6 = Object(['A', 'x', 6, 10])
obj7 = Object(['A', 'x', 2, 9])
olist = [obj1, obj2, obj3, obj4, obj5, obj6, obj7]

mindict = {}
for o in olist:
    key = (o.classification, o.type)
    if key in mindict:
        if o.weight() >= mindict[key].weight():
            continue
    mindict[key] = o
from pprint import pprint
pprint(mindict)

以下是输出：

{('A', 'x'): Object('A', 'x', 6, 10),
 ('A', 'y'): Object('A', 'y', 5, 20),
 ('B', 'z'): Object('B', 'z', 2, 15)}

注意：

\uuuu str\uuuuuu

、

\uuuu repr\uuuu

和

pprint

这些东西只是为了得到精美的打印输出，并不重要。同样，上述代码在Python2.2到2.7上运行不变

---

运行时间：O（N），其中N是列表中对象的数量。对对象进行排序的解决方案平均为O（N*log（N））。另一个解决方案似乎是O（k*n），其中k，如果你必须比较你的对象很多，考虑实现“代码”＞ycMPp< < /代码>已经从Python 3中删除。相反，使用 SytLtxOy（）/<代码>和<>代码> yq-Eqy<。在实践中，我会考虑制作<代码>过滤<代码>生成器。这看起来不错，但我有1000个分类和400种类型。所以我需要一个更“动态”的解决方案。谢谢@ccarpenterg:把它放在一个函数中，然后做

'a'

和

'x'

变量。@ChrisB:他刚刚说他有K=400000个组合键；所以你想让他调用已经是O（N）函数的函数400000次，其中N可能是一百万次？约翰：我认为他不需要一次调用所有函数。如果性能真的是一个问题，你可以将列表重构成一个跟踪最小值的容器，或者对值进行排序，或者其他一些技巧。你能描述一下该算法中出现了什么吗？@ccarcenter，我已经添加了一个解释。如果你有问题，请告诉我。