python 高效的list 去重方式

list(set(seq))
# or
{}.fromkeys(seq).keys()

from random import shuffle, randint
import re
from sets import Set

def f1(seq): # Raymond Hettinger
    # not order preserving
    set = {}
    map(set.__setitem__, seq, [])
    return set.keys()

    
def f2(seq):   # *********
    # order preserving
    checked = []
    for e in seq:
        if e not in checked:
            checked.append(e)
    return checked

def f3(seq):
    # Not order preserving
    keys = {}
    for e in seq:
        keys[e] = 1
    return keys.keys()

def f4(seq): # ********** order preserving
    noDupes = []
    [noDupes.append(i) for i in seq if not noDupes.count(i)]
    return noDupes

def f5(seq, idfun=None): # Alex Martelli ******* order preserving
    if idfun is None:
        def idfun(x): return x
    seen = {}
    result = []
    for item in seq:
        marker = idfun(item)
        # in old Python versions:
        # if seen.has_key(marker)
        # but in new ones:
        if marker in seen: continue
        seen[marker] = 1
        result.append(item)
    return result

def f5b(seq, idfun=None): # Alex Martelli ******* order preserving
    if idfun is None:
        def idfun(x): return x
    seen = {}
    result = []
    for item in seq:
        marker = idfun(item)
        # in old Python versions:
        # if seen.has_key(marker)
        # but in new ones:
        if marker not in seen:
            seen[marker] = 1
            result.append(item)
            
    return result

def f6(seq):
    # Not order preserving
    return list(Set(seq))

def f7(seq):
    # Not order preserving
    return list(set(seq))

def f8(seq): # Dave Kirby
    # Order preserving
    seen = set()
    return [x for x in seq if x not in seen and not seen.add(x)]

def f9(seq):
    # Not order preserving
    return {}.fromkeys(seq).keys()

def f10(seq, idfun=None): # Andrew Dalke
    # Order preserving
    return list(_f10(seq, idfun))

def _f10(seq, idfun=None):
    seen = set()
    if idfun is None:
        for x in seq:
            if x in seen:
                continue
            seen.add(x)
            yield x
    else:
        for x in seq:
            x = idfun(x)
            if x in seen:
                continue
            seen.add(x)
            yield x
            
            
def f11(seq): # f10 but simpler
    # Order preserving
    return list(_f10(seq))

def _f11(seq):
    seen = set()
    for x in seq:
        if x in seen:
            continue
        seen.add(x)
        yield x
            
import time

def timing(f, n, a):
    print f.__name__,
    r = range(n)
    t1 = time.clock()
    for i in r:
        f(a); f(a); f(a); f(a); f(a); f(a); f(a); f(a); f(a); f(a)
    t2 = time.clock()
    print round(t2-t1, 3)
    

def getRandomString(length=10, loweronly=1, numbersonly=0,
                    lettersonly=0):
    """ return a very random string """
    _letters = 'abcdefghijklmnopqrstuvwxyz'
    if numbersonly:
        l = list('0123456789')
    elif lettersonly:
        l = list(_letters + _letters.upper())
    else:
        lowercase = _letters+'0123456789'*2
        l = list(lowercase + lowercase.upper())
    shuffle(l)
    s = ''.join(l)
    if len(s) < length:
        s = s + getRandomString(loweronly=1)
    s = s[:length]
    if loweronly:
        return s.lower()
    else:
        return s

testdata = {}
for i in range(35):
    k = getRandomString(5, lettersonly=1)
    v = getRandomString(100 )
    testdata[k] = v
    
testdata = [int(x) for x in list('21354612')]
testdata += list('abcceeaa5efm')
class X:
    def __init__(self, n):
        self.foo = n
    def __repr__(self):
        return "<foo %r>"%self.foo
    def __cmp__(self, e):
        return cmp(self.foo, e.foo)
        
testdata = []
for i in range(10000):
    testdata.append(getRandomString(3, loweronly=True))
#testdata = ['f','g','c','d','b','a','a']

order_preserving = f2, f4, f5, f5b, f8, f10, f11
order_preserving = f5, f5b, f8, f10, f11

not_order_preserving = f1, f3, f6, f7, f9
testfuncs = order_preserving + not_order_preserving

for f in testfuncs:
    if f in order_preserving:
        print "*",
    timing(f, 100, testdata)

* f5 3.51
* f5b 3.49
* f8 2.02
* f10 2.57
* f11 2.54
f1 1.54
f3 1.25
f6 1.36
f7 0.89
f9 0.89

def f7(seq):
    # Not order preserving
    return list(set(seq))

def f9(seq):
    # Not order preserving
    return {}.fromkeys(seq).keys()

with open("file.txt") as rf, open("out.txt", "w") as wf:
    for line in rf:
        wf.write("%s\r\n" % line.strip())

发表第一条评论！

提交

相关推荐

• Python List 按键高效排序方法

  Python含有许多古老的排序规则，这些规则在你创建定制的排序方法时会占用很多时间，而这些排序方法运行时也会拖延程序实际的运行速度。

  Python List 按键 排序 高效
• go 和 python 解析 markdown 速度比较

  最近想把markdown 格式引入项目，首先来了解一下golang 的解析速度，以及与python 解析的对比。

  markdown python 解析 速度 比较
• Go 和 Python 在简单的 web 服务器方面的性能比较

  在选择一种新的语言或框架之前种喜欢作性能的比较，下面是Go 和 Python 在简单的 web 服务器方面的性能比较。

  Python Go web 服务器 性能
• python JSON 中文 unicode 的性能问题

  python2.x 版的字符编码一直是大家的诟病，字典转换成json时中文字符串变成 unicode。

  python JSON unicode 中文 性能
• python 标准库读写CSV 文件

  CSV 是（Comma Separated Values 逗号分隔值）的英文缩写，通常都是纯文本文件。这里介绍使用python 标准库读写csv 文件的方法。

  CSV python 读写 文件 标准
• python 获取某一年的天干地支的方法

  这是基于 60花甲子 计算法，用python 获取某一年的天干地支。

  天干地支 python 获取 一年 方法
• python 解析电子书的信息

  epub 书是可供人们下载的开放性资源格式的电子图书。epub 文件通常与类似亚马逊Kindle 这样的电子阅读器不兼容。

  python 解析 电子书 信息
• 这款基于SAE Python tornado 的blog 告一段落

  因为 SAE 的 Python 平台刚刚内测，平台功能还没定型，好多服务在紧张开发中，这款blog 程序也使用了前期可用的一些服务。

  tornado SAE Python blog 告一段落
• python 半角全角的相互转换

  全角与半角在中文输入法里经常要接触到，后台在处理用户输入数据时需要对半角全角的相互转换。下面是python 实现的半角全角的相互转换功能。

  全角 python 半角 转换 相互
• 一个简单高效的LRU 缓存，golang 实现

  LRU（Least recently used，最近最少使用）是根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。

  LRU golang 缓存 高效 简单