精华内容
下载资源
问答
  • 列表去重复

    2018-06-19 13:12:00
    列表去重复有以下几种方法: # *-*coding:utf-8 *-* # Auth: wangxz from functools import reduce import itertools nums = [1,3,4,53,2,21,4,4,3,-1] def first(nums): #原列表中的顺序不会改变 mid...

    列表去重复有以下几种方法:

    # *-*coding:utf-8 *-*
    # Auth: wangxz
    from functools import reduce
    import itertools
    
    nums = [1,3,4,53,2,21,4,4,3,-1]
    
    def first(nums):   #原列表中的顺序不会改变
        mid_list = []
        for i in nums:
            if i not in mid_list:
                mid_list.append(i)
    
        print(mid_list)
    
    
    def secnd(nums):     # 直接使用set处理,不过却不能保证顺序
        print(set(nums))
    
    
    def third(nums):    # 注意python3中reduce函数需要导入from functools import reduce
        func = lambda x, y: x if y in x else x + [y]
        print(reduce(func, [[], ] + nums))
    
    
    def fourth(nums):
        nums.sort()
        it = itertools.groupby(nums)
        for k, g in it:
            print(k)
    
    fourth(nums)


    reducer函数详解

    reduce() 函数会对参数序列中元素进行累积。

    函数将一个数据集合(链表,元组等)中的所有数据进行下列操作:用传给 reduce 中的函数 function(有两个参数)先对集合中的第 1、2 个元素进行操作,得到的结果再与第三个数据用 function 函数运算,最后得到一个结果。

    语法结构如下:

    reduce(function, iterable[, initializer])

    参数说明:
        function: 函数名
        iterable: 可迭代对象,列表,集合等
    实例应用:
        
    计算1~100的加法和:
    func = lambda x, y : x + y
    reduce(func, range(100))

    注意在python3.x中使用reduce函数,需要先导入:from functools import reduce

     

    转载于:https://www.cnblogs.com/wxzhe/p/9198123.html

    展开全文
  • 主要尝试了3种列表去除重复元素 #2.去除列表中的重复元素 #set方法 def removeDuplicates_set(nums): l2 = list(set(l1)) #用l1的顺序排序l2 #l2.sort(key=l1.index) return l2 #重构字典方法 def ...

    主要尝试了3种列表去除重复元素

    #2.去除列表中的重复元素
     #set方法
    def removeDuplicates_set(nums):
        l2 = list(set(l1))
        #用l1的顺序排序l2
        #l2.sort(key=l1.index)
        return l2
     #重构字典方法
    def removeDuplicates_dict_fromkeys(nums):
        l2 = {}.fromkeys(nums).keys()
        return list(l2)
     #列表推到式,普通方法
    def removeDuplicates_normal(nums):
        l2 = []
        [l2.append(i) for i in nums if not i in l2]
        return list(l2)
    
    if __name__=='__main__':
        l1 = ['b','c','d','b','c','a','a']
        print (removeDuplicates_normal(l1))

     

    转载于:https://www.cnblogs.com/yuanzhaoyi/p/6096259.html

    展开全文
  • 主要介绍了Python列表去重复项的N种方法,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • 关于python列表去重复后按照元列表序列输出

    list_t = ['a','b','c','a','d','c','b','e'];

    list_tt = list(set(list_t));

    print list_tt;#无序输出

    list_tt.sort(key=list_t.index)

    print list_tt;#维持和list_t 顺序相同

    展开全文
  • 说明Python语言中列表(List)与其他语言的数组(Array)类似,是一种有序的集合...实现方式有多种,比如新建列表来存储非重复项,或者在原有基础上删除掉重复的项,也可以利用数据结构来达到去重复。具体哪一种方法更好...

    说明

    Python语言中列表(List)与其他语言的数组(Array)类似,是一种有序的集合数据结构,Python List可支持各种数据类型,长度也可动态调整,与JS中的数组或Java ArrayList很接近。在实际编程中,经常会遇到数组或列表去掉重复项,保持成员唯一性。实现方式有多种,比如新建列表来存储非重复项,或者在原有基础上删除掉重复的项,也可以利用数据结构来达到去重复。具体哪一种方法更好呢?以下约20种方式都可以实现,我们可以通过这些来交流和学习。

    a132eb232a145d856aeac2383bec47a5.png

    方式

    ## 1. 新建列表,如果新列表中不存在,则添加到新列表。def unique(data):    new_list = []    for item in data:        if item not in new_list:            new_list.append(item)    return new_list# testdata = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]start_time = time.time()print("new_list + not in data:", unique(data))print("time:" + str((time.time() - start_time) * 1000) + " ms")# result$ python -VPython 2.7.16$ python unique.py ('for list + not in. data:', ['a', 1, 2, 'b'])time:0.0441074371338 ms
    ## 2. 新建列表。根据下标判断是否存在新列表中,如果新列表中不存在则添加到新列表。def unique(data):    new_list = []    for i in range(len(data)):        if data[i] not in new_list:            new_list.append(data[i])    return new_list## 2.1 新建列表,使用列表推导来去重。是前一种的简写。def unique(data):    new_list = []    [new_list.append(i) for i in data if not i in new_list]    return new_list# testdata = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]start_time = time.time()print("for range + not in. data:", unique(data))print("time:" + str((time.time() - start_time) * 1000) + " ms")
    ## 3. 通过index找不到该项,则追加到新列表中。index找不到会报错,因此放在异常处理里。def unique(data):    new_list = []    for i in range(len(data)):        item = data[i]        try:            if (new_list.index(item) < 0):                print('new_list:', new_list)        except ValueError:            new_list.append(item)    return new_list# testdata = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]start_time = time.time()print("list index + except:", unique(data))print("time:" + str((time.time() - start_time) * 1000) + " ms")
    ## 4. 新建列表,两个循环。如果内循环与外循环项相同,且下标相同就添加到新列表,其余忽略def unique(data):    new_list = []    for i in range(len(data)):        j = 0        while j <= i:            if data[i] == data[j]:                if i == j:                    new_list.append(data[i])                break            j += 1    return new_list# testdata = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]start_time = time.time()print("new list + for. new_list:", unique(data))print("time:" + str((time.time() - start_time) * 1000) + " ms")
    ## 5. 在原有列表上移除重复项目。自后往前遍历,逐个与前面项比较,如果值相同且下标相同,则移除当前项。def unique(data):    l = len(data)    while (l > 0):        l -= 1        i = l        while i > 0:            i -= 1            if data[i] == data[l]:                del data[l]                break    return data# testdata = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]start_time = time.time()print("one list while. last -> first result. data:", unique(data))print("time:" + str((time.time() - start_time) * 1000) + " ms")
    ## 6. 在原有列表上移除重复项目。自前往后遍历,逐个与后面项比较,如果值相同且下标相同,则移除当前项。def unique(data):    l = len(data)    i = 0    while i < l:        j = i + 1        while j < l:            if data[i] == data[j]:                del data[j]                l -= 1                i -= 1                break            j += 1        i += 1    return data# testdata = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]start_time = time.time()print("one list while. first -> last result. data:", unique(data))print("time:" + str((time.time() - start_time) * 1000) + " ms")
    ## 7. 新建列表。遍历列表,利用index比较出现的位置,如果出现在第一次的位置则追加到新数组。def unique(data):    new_list = []    for i in range(len(data)):        if i == data.index(data[i]):            new_list.append(data[i])    return new_list# testdata = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]start_time = time.time()print("for range + index. data:", unique(data))print("time:" + str((time.time() - start_time) * 1000) + " ms")
    ## 8. 利用字典属性唯一性来实现去重复。def unique(data):    obj = {}    for item in data:        obj[item] = item    return obj.values()# testdata = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]start_time = time.time()print("list + dict:", unique(data))print("time:" + str((time.time() - start_time) * 1000) + " ms")## 或者直接通过dict.fromkeys来实现print("dict fromkeys:", dict.fromkeys(data).keys())
    ## 9. 利用filter函数,即把不符合条件的过滤掉。这里filter不支持下标,因此需要借助外部列表存储不重复项def uniq(item):    i = data.index(item)    if (item not in new_list):        new_list.append(item)        return True    return Falsedef unique(item):    if obj.get(item) == None:        obj[item] = item        return True    return False# testdata = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]start_time = time.time()new_list = []print('filter + list + not in: ', filter(uniq, data))print("time:" + str((time.time() - start_time) * 1000) + " ms")
    ## 10. 利用字典结合过滤来实现去重复。def unique(item):    if obj.get(item) == None:        obj[item] = item        return True    return False# testdata = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]start_time = time.time()obj = {}print("filter + dict + get:", filter(unique, data))print("time:" + str((time.time() - start_time) * 1000) + " ms")
    ## 11. 利用map来实现去重复。与map与filter类似,是一个高阶函数。可以针对其中项逐个修改操作。## 与filter不同map会保留原有项目,并不会删除,因此值可以改为None,然后再过滤掉。def unique(item):    if item not in new_list:        new_list.append(item)        return item    return None# testdata = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]new_list = []start_time = time.time()print("list from Map:", filter(lambda item: item != None, map(unique, data)))print("time:" + str((time.time() - start_time) * 1000) + " ms")
    ## 12. 利用set数据结构里key的唯一性来去重复data = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]print("from Set:", list(set(data)))print("time:" + str((time.time() - start_time) * 1000) + " ms")
    ## 13. 提前排序,从后向前遍历,将当前项与前一项对比,如果重复则移除当前项def unique(data):    data.sort()    l = len(data)    while (l > 0):        l -= 1        if (data[l] == data[l - 1]):            data.remove(data[l])    return data# testdata = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]start_time = time.time()print("sort + remove:", unique(data))print("time:" + str((time.time() - start_time) * 1000) + " ms")
    ## 14. 提前排序,自前往后遍历,将当前项与后一项对比,如果重复则移除当前项def unique(data):    """     in python 3: TypeError: '
    ## 15. 利用reduce函数来去重复。reduce具有累计的作用,判断如果不在累计结果中出现,则追加到结果中。import functoolsdef unique(data):    new_list = []    def foo(result, item):        if isinstance(result, list) == False:            result = [result]        return result if item in result else result + [item]    return functools.reduce(foo, data)# testdata = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]start_time = time.time()print("functools.reduce:", unique(data))print("time:" + str((time.time() - start_time) * 1000) + " ms")
    ## 16. 利用递归调用来去重复。递归自后往前逐个调用,当长度为1时终止。## 当后一项与前任一项相同说明有重复,则删除当前项。相当于利用自我调用来替换循环def recursion_unique(data, len):    if (len <= 1):        return data    l = len    last = l - 1    is_repeat = False    while (l > 1):        l -= 1        if (data[last] == data[l - 1]):            is_repeat = True            break    if (is_repeat):        del data[last]    return recursion_unique(data, len - 1)# testdata = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]start_time = time.time()print("recursion_unique:", recursion_unique(data, len(data)))print("time:" + str((time.time() - start_time) * 1000) + " ms")
    ## 17. 利用递归调用来去重复的另外一种方式。递归自后往前逐个调用,当长度为1时终止。## 与上一个递归不同,这里将不重复的项目作为结果拼接起来def recursion_unique_new(data, len):    if (len <= 1):        return data    l = len    last = l - 1    is_repeat = False    while (l > 1):        l -= 1        if (data[last] == data[l - 1]):            is_repeat = True            break    if (is_repeat):        del data[last:]        result = []    else:        result = [data[last]]    return recursion_unique_new(data, len - 1) + result# testdata = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]start_time = time.time()print("recursion_unique_new:", recursion_unique_new(data, len(data)))print("time:" + str((time.time() - start_time) * 1000) + " ms")
    ## 18. 利用numpy lib库. 需提前安装 `pip install numpy`import numpy as npdef unique(data):    res = np.array(data)    return list(np.unique(res))# testdata = ['a', 'a', 1, 1, 2, 2, 'b', 'b', 2, 1]start_time = time.time()print("import numpy as np.unique:", unique(data))print("time:" + str((time.time() - start_time) * 1000) + " ms")
    bf8b0cb3a94778b007eb0ccabc21f3d5.png

    讨论

    从以上例子上可以看出,相对来讲,Python比起其它语言要灵活得多,与JS并列最流行的脚本类语言,这也就是为何Python如此流行的原因吧。

    哪一种方式更适合呢?你常用那种方式来实现去重复项?新建数组、非新建、借助Dict或Set等结构,亦或是其它方式?

    b723026cb3627f40dc60872feb297935.png
    展开全文
  • python 中列表去除重复项的方法有很多种,比如 set去重 下面展示 set去重示例。 a = [1,4,4,2,7,3,4,5,6,1] b = list(set(a)) print(b) #输出结果为 [1, 2, 3, 4, 5, 6, 7] 但这种方法缺点也很明显,比如最后结果...
  • Erlang列表去除重复元素

    千次阅读 2018-12-23 15:16:56
    Erlang列表去重的两种方法
  • ls = [2,3,6,5,5,6,6,7] ls = set(ls) ls = list(ls) print(ls) 原理:数组是一个无序的不重复的序列,所以我们可以先把列表转化数组,然后再转化回列表,这样就能实现列表去重的需求。 ...
  • 列表去重复 (1)

    2020-11-12 10:20:43
    先输入一串列表形式的数字 转换为set(集合)格式>>>自动去重 再输出 lst = eval(input('请输入列表lst:')) print(type(lst)) print(list(set(lst))) 请输入列表lst:1,2,3,3,2,1 <class 'tuple'> ...
  • Python列表去重复元素

    2018-12-15 22:49:08
    比较容易记忆的是用内置的set l1 = ['b','c','d','b','c','a','a'] l2 = list(set(l1)) print l2 还有一种据说速度更快的,没测试过两者的速度差别 ...这两种都有个缺点,祛除重复元素后排序变...
  • 列表去除重复的值

    2018-07-10 10:36:00
    1 l = [1,1,2,3,4,5,4] 2 #第一种方法,采用集合 3 print(list(set(l))) 4 5 #第二种方法采用排序 6 d = [] 7 t = sorted(l) 8 i = 0 9 while i < len(t): ...11 d.append(t[i]...
  • Python列表去重复

    2011-12-01 11:57:07
    返回包含原列表中所有元素的新列表,将重复元素去掉,并保持元素原有次序 excludes: 不希望出现在新列表中的元素们 """ seen = set(excludes) # seen是曾经出现的元素集合 return [x for x ...
  • list列表去除重复项(通过HashSet):  HashSet h = new HashSet(list);//去除list中重复项,并保存在集合h中  list.clear();//清空list  list.addAll(h);//将去重结果存在list中 查询某个字符串在list的...
  • I have a list of dictionaries in python. And now i am trying to merge these dictionaries based on a specific key entity in python. Example the list of dictionary is:[[{'max_score': u'110', 'total_mar....
  • 说明Python语言中列表(List)与其他语言的数组(Array)类似,是一种有序的集合...实现方式有多种,比如新建列表来存储非重复项,或者在原有基础上删除掉重复的项,也可以利用数据结构来达到去重复。具体哪一种方法更好...
  • 这两种都有个缺点,祛除重复元素后排序变了: ['a', 'c', 'b', 'd']       如果想要保持他们原来的排序:   用list类的sort方法 l1 = ['b','c','d','b','c','a','a'...
  • 大概的方法参考:... 本人实战总结 @classmethod def list_repeat(cls, original_list): """ 功能:list去重复发万能方法【兼容list内部任何结构--包含可变的lis...
  • 我想删除python列表中的某些重复项。我知道有很多方法可以删除所有重复项,但我只想删除连续的重复项,同时保持列表顺序。在例如,我有如下列表:list1 = [a,a,b,b,c,c,f,f,d,d,e,e,f,f,g,g,c,c]但是,我想删除重复...
  • 用集合set列表list去重。 #!/usr/bin/env python # -*- coding:utf-8 -*- # Author:kahn list1 = [1, 2, 3, 3, 5, 66, 7, 7, 99] # 这个列表中有重复的3和7 set1 = set(list1) # 将列表转成集合,...
  • 集合,去除列表重复项 2、sorted() sorted (iterable, key = None , reverse = False ) iterable : 可迭代对象 key : 指定一个函数,用于 从 iterable 中的每个元素中 提取某个属性来作为用于比较的关键字。...
  •  * set方法去除list中重复的数据 set中插入重复的值只保留一个  */  HashSet h = new HashSet(list);  list.clear();  list.addAll(h);  /* 第一种方法 */    /* 第二种方法 */  /** ...
  • 如果找到新的唯一值,则将其插入到查看列表中,成本为O(r * r)。 from bisect import bisect_left, insort def dedup(seq): 'Remove duplicates. Preserve order first seen. Assume orderable, but not hashable ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,626
精华内容 650
关键字:

列表去重复