基于项目的python唯一列表

我有一张单子

old_list = [
        (1, 'AAA', None, 1),
        (2, 'AAA', 'x', 0),
        (5, 'AAB', 'z', 1),
        (6, 'ABB', 'x', 1),
        (9, 'ABB', 'x', 1)]

我希望如何获得一个具有唯一的I[1]和更大的id I[0]的新列表，如下结果

new_list = [
        (2, 'AAA', 'x', 0),
        (5, 'AAB', 'z', 1),
        (9, 'ABB', 'x', 1)]
]

有人能帮我吗？

你可以用

输出

[(2, 'AAA', 'x', 0), (5, 'AAB', 'z', 1), (9, 'ABB', 'x', 1)]

如果

old_list

尚未排序，则可以按如下方式对其排序

old_list = sorted([
        (1, 'AAA', None, 1),
        (2, 'AAA', 'x', 0),
        (5, 'AAB', 'z', 1),
        (6, 'ABB', 'x', 1),
        (9, 'ABB', 'x', 1)], key=itemgetter(1))

你可以用

输出

[(2, 'AAA', 'x', 0), (5, 'AAB', 'z', 1), (9, 'ABB', 'x', 1)]

如果

old_list

尚未排序，则可以按如下方式对其排序

old_list = sorted([
        (1, 'AAA', None, 1),
        (2, 'AAA', 'x', 0),
        (5, 'AAB', 'z', 1),
        (6, 'ABB', 'x', 1),
        (9, 'ABB', 'x', 1)], key=itemgetter(1))

你可以用

输出

[(2, 'AAA', 'x', 0), (5, 'AAB', 'z', 1), (9, 'ABB', 'x', 1)]

如果

old_list

尚未排序，则可以按如下方式对其排序

old_list = sorted([
        (1, 'AAA', None, 1),
        (2, 'AAA', 'x', 0),
        (5, 'AAB', 'z', 1),
        (6, 'ABB', 'x', 1),
        (9, 'ABB', 'x', 1)], key=itemgetter(1))

你可以用

输出

[(2, 'AAA', 'x', 0), (5, 'AAB', 'z', 1), (9, 'ABB', 'x', 1)]

如果

old_list

尚未排序，则可以按如下方式对其排序

old_list = sorted([
        (1, 'AAA', None, 1),
        (2, 'AAA', 'x', 0),
        (5, 'AAB', 'z', 1),
        (6, 'ABB', 'x', 1),
        (9, 'ABB', 'x', 1)], key=itemgetter(1))

您可以这样做：

d={}
for t in old_list:
    d.setdefault(t[1],[]).append(t)
    
new_list=[]    
for k in sorted(d):       # sort by the keys ('AAA', 'AAB', etc)
    new_list.append(max(d[k], key=lambda t: t[0]))    # max index (t[0])
# [(2, 'AAA', 'x', 0), (5, 'AAB', 'z', 1), (9, 'ABB', 'x', 1)]

---

编辑

如果没有重复ID的可能性，您可以执行以下操作：

d={}
for t in old_list:
    d.setdefault(t[1],[]).append(t)
    
new_list=[]    
for k in sorted(d):
    new_list.append(d[k][-1]) 

这与样本数据的答案相同

---

编辑2，计时 印刷品：

3.3.2 (default, Jul  6 2013, 10:40:18) 
[GCC 4.2.1 Compatible Apple LLVM 4.2 (clang-425.0.28)]
defaultdict: 2.384568103996571
setdefault: 1.6183147379779257

2.7.5 (default, Aug 25 2013, 00:04:04) 
[GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)]
drewk: 3.30526208878
Abhijit: 20.5611379147
thefourtheye: 13.2195081711

post的计时显示，这是一种非常快速的方法：

from __future__ import print_function 
from collections import OrderedDict
import itertools
from operator import itemgetter

old_list = [
        (1, 'AAA', None, 1),
        (2, 'AAA', 'x', 0),
        (5, 'AAB', 'z', 1),
        (6, 'ABB', 'x', 1),
        (9, 'ABB', 'x', 1)]
        
def f1():
    d={}
    for t in old_list:
        d.setdefault(t[1],[]).append(t)

    new_list=[]    
    for k in sorted(d):
        new_list.append(d[k][-1]) 
    
    return new_list    
            
def f2():
    nl = sorted(old_list, key=itemgetter(2,1))
    return OrderedDict((elem[1], elem) 
             for elem in nl).values()    
            
def f3():
    nl=sorted(old_list, key=lambda x: x[1])
    return [sorted(list(group), key=lambda x:x[0], reverse=True)[0]
               for key, group in itertools.groupby(nl, key=lambda x:x[1])]                  
  
if __name__ == '__main__':
    import timeit
    import sys
    print(sys.version) 
    print('drewk:',timeit.timeit("f1()", setup="from __main__ import f1, old_list"))
    print('Abhijit:', timeit.timeit("f2()", setup="from __main__ import f2, old_list, OrderedDict, itemgetter"))
    print('thefourtheye:', timeit.timeit("f3()", setup="from __main__ import f3, old_list, itertools"))

印刷品：

3.3.2 (default, Jul  6 2013, 10:40:18) 
[GCC 4.2.1 Compatible Apple LLVM 4.2 (clang-425.0.28)]
defaultdict: 2.384568103996571
setdefault: 1.6183147379779257

2.7.5 (default, Aug 25 2013, 00:04:04) 
[GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)]
drewk: 3.30526208878
Abhijit: 20.5611379147
thefourtheye: 13.2195081711

您可以这样做：

d={}
for t in old_list:
    d.setdefault(t[1],[]).append(t)
    
new_list=[]    
for k in sorted(d):       # sort by the keys ('AAA', 'AAB', etc)
    new_list.append(max(d[k], key=lambda t: t[0]))    # max index (t[0])
# [(2, 'AAA', 'x', 0), (5, 'AAB', 'z', 1), (9, 'ABB', 'x', 1)]

---

编辑

如果没有重复ID的可能性，您可以执行以下操作：

d={}
for t in old_list:
    d.setdefault(t[1],[]).append(t)
    
new_list=[]    
for k in sorted(d):
    new_list.append(d[k][-1]) 

这与样本数据的答案相同

---

编辑2，计时 印刷品：

3.3.2 (default, Jul  6 2013, 10:40:18) 
[GCC 4.2.1 Compatible Apple LLVM 4.2 (clang-425.0.28)]
defaultdict: 2.384568103996571
setdefault: 1.6183147379779257

2.7.5 (default, Aug 25 2013, 00:04:04) 
[GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)]
drewk: 3.30526208878
Abhijit: 20.5611379147
thefourtheye: 13.2195081711

post的计时显示，这是一种非常快速的方法：

from __future__ import print_function 
from collections import OrderedDict
import itertools
from operator import itemgetter

old_list = [
        (1, 'AAA', None, 1),
        (2, 'AAA', 'x', 0),
        (5, 'AAB', 'z', 1),
        (6, 'ABB', 'x', 1),
        (9, 'ABB', 'x', 1)]
        
def f1():
    d={}
    for t in old_list:
        d.setdefault(t[1],[]).append(t)

    new_list=[]    
    for k in sorted(d):
        new_list.append(d[k][-1]) 
    
    return new_list    
            
def f2():
    nl = sorted(old_list, key=itemgetter(2,1))
    return OrderedDict((elem[1], elem) 
             for elem in nl).values()    
            
def f3():
    nl=sorted(old_list, key=lambda x: x[1])
    return [sorted(list(group), key=lambda x:x[0], reverse=True)[0]
               for key, group in itertools.groupby(nl, key=lambda x:x[1])]                  
  
if __name__ == '__main__':
    import timeit
    import sys
    print(sys.version) 
    print('drewk:',timeit.timeit("f1()", setup="from __main__ import f1, old_list"))
    print('Abhijit:', timeit.timeit("f2()", setup="from __main__ import f2, old_list, OrderedDict, itemgetter"))
    print('thefourtheye:', timeit.timeit("f3()", setup="from __main__ import f3, old_list, itertools"))

印刷品：

3.3.2 (default, Jul  6 2013, 10:40:18) 
[GCC 4.2.1 Compatible Apple LLVM 4.2 (clang-425.0.28)]
defaultdict: 2.384568103996571
setdefault: 1.6183147379779257

2.7.5 (default, Aug 25 2013, 00:04:04) 
[GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)]
drewk: 3.30526208878
Abhijit: 20.5611379147
thefourtheye: 13.2195081711

您可以这样做：

d={}
for t in old_list:
    d.setdefault(t[1],[]).append(t)
    
new_list=[]    
for k in sorted(d):       # sort by the keys ('AAA', 'AAB', etc)
    new_list.append(max(d[k], key=lambda t: t[0]))    # max index (t[0])
# [(2, 'AAA', 'x', 0), (5, 'AAB', 'z', 1), (9, 'ABB', 'x', 1)]

---

编辑

如果没有重复ID的可能性，您可以执行以下操作：

d={}
for t in old_list:
    d.setdefault(t[1],[]).append(t)
    
new_list=[]    
for k in sorted(d):
    new_list.append(d[k][-1]) 

这与样本数据的答案相同

---

编辑2，计时 印刷品：

3.3.2 (default, Jul  6 2013, 10:40:18) 
[GCC 4.2.1 Compatible Apple LLVM 4.2 (clang-425.0.28)]
defaultdict: 2.384568103996571
setdefault: 1.6183147379779257

2.7.5 (default, Aug 25 2013, 00:04:04) 
[GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)]
drewk: 3.30526208878
Abhijit: 20.5611379147
thefourtheye: 13.2195081711

post的计时显示，这是一种非常快速的方法：

from __future__ import print_function 
from collections import OrderedDict
import itertools
from operator import itemgetter

old_list = [
        (1, 'AAA', None, 1),
        (2, 'AAA', 'x', 0),
        (5, 'AAB', 'z', 1),
        (6, 'ABB', 'x', 1),
        (9, 'ABB', 'x', 1)]
        
def f1():
    d={}
    for t in old_list:
        d.setdefault(t[1],[]).append(t)

    new_list=[]    
    for k in sorted(d):
        new_list.append(d[k][-1]) 
    
    return new_list    
            
def f2():
    nl = sorted(old_list, key=itemgetter(2,1))
    return OrderedDict((elem[1], elem) 
             for elem in nl).values()    
            
def f3():
    nl=sorted(old_list, key=lambda x: x[1])
    return [sorted(list(group), key=lambda x:x[0], reverse=True)[0]
               for key, group in itertools.groupby(nl, key=lambda x:x[1])]                  
  
if __name__ == '__main__':
    import timeit
    import sys
    print(sys.version) 
    print('drewk:',timeit.timeit("f1()", setup="from __main__ import f1, old_list"))
    print('Abhijit:', timeit.timeit("f2()", setup="from __main__ import f2, old_list, OrderedDict, itemgetter"))
    print('thefourtheye:', timeit.timeit("f3()", setup="from __main__ import f3, old_list, itertools"))

印刷品：

3.3.2 (default, Jul  6 2013, 10:40:18) 
[GCC 4.2.1 Compatible Apple LLVM 4.2 (clang-425.0.28)]
defaultdict: 2.384568103996571
setdefault: 1.6183147379779257

2.7.5 (default, Aug 25 2013, 00:04:04) 
[GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)]
drewk: 3.30526208878
Abhijit: 20.5611379147
thefourtheye: 13.2195081711

您可以这样做：

d={}
for t in old_list:
    d.setdefault(t[1],[]).append(t)
    
new_list=[]    
for k in sorted(d):       # sort by the keys ('AAA', 'AAB', etc)
    new_list.append(max(d[k], key=lambda t: t[0]))    # max index (t[0])
# [(2, 'AAA', 'x', 0), (5, 'AAB', 'z', 1), (9, 'ABB', 'x', 1)]

---

编辑

如果没有重复ID的可能性，您可以执行以下操作：

d={}
for t in old_list:
    d.setdefault(t[1],[]).append(t)
    
new_list=[]    
for k in sorted(d):
    new_list.append(d[k][-1]) 

这与样本数据的答案相同

---

编辑2，计时 印刷品：

3.3.2 (default, Jul  6 2013, 10:40:18) 
[GCC 4.2.1 Compatible Apple LLVM 4.2 (clang-425.0.28)]
defaultdict: 2.384568103996571
setdefault: 1.6183147379779257

2.7.5 (default, Aug 25 2013, 00:04:04) 
[GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)]
drewk: 3.30526208878
Abhijit: 20.5611379147
thefourtheye: 13.2195081711

post的计时显示，这是一种非常快速的方法：

from __future__ import print_function 
from collections import OrderedDict
import itertools
from operator import itemgetter

old_list = [
        (1, 'AAA', None, 1),
        (2, 'AAA', 'x', 0),
        (5, 'AAB', 'z', 1),
        (6, 'ABB', 'x', 1),
        (9, 'ABB', 'x', 1)]
        
def f1():
    d={}
    for t in old_list:
        d.setdefault(t[1],[]).append(t)

    new_list=[]    
    for k in sorted(d):
        new_list.append(d[k][-1]) 
    
    return new_list    
            
def f2():
    nl = sorted(old_list, key=itemgetter(2,1))
    return OrderedDict((elem[1], elem) 
             for elem in nl).values()    
            
def f3():
    nl=sorted(old_list, key=lambda x: x[1])
    return [sorted(list(group), key=lambda x:x[0], reverse=True)[0]
               for key, group in itertools.groupby(nl, key=lambda x:x[1])]                  
  
if __name__ == '__main__':
    import timeit
    import sys
    print(sys.version) 
    print('drewk:',timeit.timeit("f1()", setup="from __main__ import f1, old_list"))
    print('Abhijit:', timeit.timeit("f2()", setup="from __main__ import f2, old_list, OrderedDict, itemgetter"))
    print('thefourtheye:', timeit.timeit("f3()", setup="from __main__ import f3, old_list, itertools"))

印刷品：

3.3.2 (default, Jul  6 2013, 10:40:18) 
[GCC 4.2.1 Compatible Apple LLVM 4.2 (clang-425.0.28)]
defaultdict: 2.384568103996571
setdefault: 1.6183147379779257

2.7.5 (default, Aug 25 2013, 00:04:04) 
[GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)]
drewk: 3.30526208878
Abhijit: 20.5611379147
thefourtheye: 13.2195081711

---

我相信你忽略了一个事实，即字典中插入的最新元素仍然存在。因此，您不需要遍历列表并查找最大值的后处理。此外，

defaultdict

优于

setdefault

。最后，您没有使用

OrderedDict

，而是丢弃了已排序的数据。所以总的来说，这是一个糟糕的方法。@Abhijit:a）哪里说

defaultdict

比

setdefault

更受欢迎；B） OP上写着“我想要。。。较大的id i[0]”他没有声明这是按id排序的，或者没有重复项；C）

orderedict

是用Python编写的。按t[1]键排序可能比保留Python与C dict快得多。当然，C dict比OrderedDict快得多。

其中说明defaultdict比setdefault更“首选”

。读这本书<代码>按t[1]键排序很可能比保留Python vs C dict快对较小的子列表进行多次排序不能比OrderedDict@Abhijit：请看时间安排。使用链接页面上的示例，

defaultdict

并不比

setdefault

快，也不比

setdefault容易，因为您的计时有缺陷；对于这样一个小的数据集，对象的创建时间起着非常大的作用。使用literal
{}
比调用工厂函数（
defaultdict（）
）快得多。我相信您忽略了一个事实，即插入字典中的最新元素仍然存在。因此，您不需要遍历列表并查找最大值的后处理。此外，
defaultdict
优于
setdefault
。最后，您没有使用
OrderedDict
，而是丢弃了已排序的数据。所以总的来说，这是一个糟糕的方法。@Abhijit:a）哪里说
defaultdict
比
setdefault
更受欢迎；B） OP上写着“我想要。。。较大的id i[0]”他没有声明这是按id排序的，或者没有重复项；C） 
orderedict
是用Python编写的。按t[1]键排序可能比保留Python与C dict快得多。当然，C dict比OrderedDict快得多。
其中说明defaultdict比setdefault更“首选”
。读这本书<代码>按t[1]键排序很可能比保留Python vs C dict快

对较小的子列表进行多次排序不能比OrderedDict@Abhijit：请看时间安排。使用链接页面上的示例，

defaultdict

并不比

setdefault

快，也不比

setdefault容易，因为您的计时有缺陷；对于这样一个小的数据集，对象的创建时间起着非常大的作用。使用literal
{}
比调用工厂函数（
defaultdict（）
）快得多。我相信您忽略了一个事实，即插入字典中的最新元素仍然存在。因此，您不需要遍历列表并查找最大值的后处理。此外，
defaultdict
优于
setdefault
。最后，您没有使用
OrderedDict
，而是丢弃了已排序的数据。所以总的来说，这是一个糟糕的方法。@Abhijit:a）哪里说
defaultdict
比
setdefault
更受欢迎；B） OP上写着“我想要。。。较大的id i[0]”他没有声明这是按id排序的，或者没有重复项；C） 
orderedict
是用Python编写的。按t[1]键排序可能比保留Python与C dict快得多。当然，C dict比OrderedDict快得多。
其中说明defaultdict比setdefault更“首选”
。读这本书<代码>按t[1]键排序很可能比保留Python vs C dict快

对较小的子列表进行多次排序不能比OrderedDict@Abhijit：请看时间安排。使用链接页面上的示例，

defaultdict

并不比

setdefault

快，也不比

setdefault容易，因为您的计时有缺陷；拥有如此小的数据集