相关疑难解决方法(0)

几乎我需要编写一个程序来检查列表是否有任何重复项,如果有,它会删除它们并返回一个新列表,其中包含未复制/删除的项目.这就是我所拥有的,但说实话,我不知道该怎么做.

def remove_duplicates():
    t = ['a', 'b', 'c', 'd']
    t2 = ['a', 'c', 'd']
    for t in t2:
        t.append(t.remove())
    return t

是否有内置功能可以从Python中的列表中删除重复项,同时保留顺序？我知道我可以使用一个集来删除重复项,但这会破坏原始顺序.我也知道我可以像这样滚动自己:

def uniq(input):
  output = []
  for x in input:
    if x not in output:
      output.append(x)
  return output

(感谢您放松该代码示例.)

但是如果可能的话,我想利用内置或更多的Pythonic习语.

相关问题:在Python中,从列表中删除重复项的最快算法是什么,以便所有元素在保留顺序的同时是唯一的？

Python中的一个基本数据结构是字典,它允许用户记录"键"以查找任何类型的"值".这在内部实现为哈希表吗？如果没有,那是什么？

假设我有一个词典列表:

[
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 2, 'name': 'hanna', 'age': 30},
]

我需要获取一个唯一的字典列表(删除重复的字典):

[
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 2, 'name': 'hanna', 'age': 30},
]

任何人都可以帮助我在Python中实现这一目标的最有效方法吗？

我有一个Python列表:

k = [[1, 2], [4], [5, 6, 2], [1, 2], [3], [4]]

我想从中删除重复的元素.如果它是一个正常的列表而不是我可以使用的列表set.但不幸的是,该列表不可清除,也无法制作一组列表.只有元组.所以我可以将所有列表转换为元组,然后使用set并返回列表.但这并不快.

如何以最有效的方式完成？

上面列出的结果应该是:

k = [[5, 6, 2], [1, 2], [3], [4]]

我不关心保留秩序.

注意:这个问题很相似,但不是我需要的.搜索了SO但没有找到确切的重复.

标杆:

import itertools, time


class Timer(object):
    def __init__(self, name=None):
        self.name = name

    def __enter__(self):
        self.tstart = time.time()

    def __exit__(self, type, value, traceback):
        if self.name:
            print '[%s]' % self.name,
        print 'Elapsed: %s' % (time.time() - self.tstart)


k = [[1, 2], [4], [5, 6, 2], [1, 2], [3], [5, 2], [6], …

作为一个练习,主要是为了我自己的娱乐,我正在实现一个回溯包装解析器.对此的灵感是我想更好地了解hygenic宏如何在类似algol的语言中工作(与你通常在其中找到的语法免费lisp方言相对应).因此,通过输入的不同传递可能会看到不同的语法,因此缓存的解析结果无效,除非我还存储语法的当前版本以及缓存的解析结果.(编辑:使用键值集合的结果是它们应该是不可变的,但我不打算公开接口以允许它们被更改,因此可变或不可变集合都可以)

问题是python dicts不能作为其他dicts的键.即使使用元组(正如我将要做的那样)也无济于事.

>>> cache = {}
>>> rule = {"foo":"bar"}
>>> cache[(rule, "baz")] = "quux"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'
>>> 

我想它必须一直是元组.现在python标准库提供了我所需要的,collections.namedtuple具有非常不同的语法,但可以用作键.继续上述会议:

>>> from collections import namedtuple
>>> Rule = namedtuple("Rule",rule.keys())
>>> cache[(Rule(**rule), "baz")] = "quux"
>>> cache
{(Rule(foo='bar'), 'baz'): 'quux'}

好.但是我必须为我想要使用的规则中的每个可能的键组合创建一个类,这不是那么糟糕,因为每个解析规则确切地知道它使用了什么参数,因此可以同时定义该类作为解析规则的函数.

编辑:namedtuples 的另一个问题是它们是严格定位的.两个看起来应该不同的元组实际上可以是相同的:

>>> you = namedtuple("foo",["bar","baz"])
>>> me = namedtuple("foo",["bar","quux"])
>>> you(bar=1,baz=2) == me(bar=1,quux=2)
True
>>> bob = namedtuple("foo",["baz","bar"]) …

我在元组/列表中存储了大量复杂数据,但更喜欢使用小包装类来使数据结构更容易理解,例如

class Person:
    def __init__(self, first, last):
        self.first = first
        self.last = last

p = Person('foo', 'bar')
print(p.last)
...

会优先于

p = ['foo', 'bar']
print(p[1])
...

然而,似乎有一个可怕的内存开销:

l = [Person('foo', 'bar') for i in range(10000000)]
# ipython now taks 1.7 GB RAM

和

del l
l = [('foo', 'bar') for i in range(10000000)]
# now just 118 MB RAM

为什么？我有没有想到的任何明显的替代解决方案？

谢谢!

(我知道,在这个例子中,'wrapper'类看起来很傻.但是当数据变得更复杂和嵌套时,它会更有用)