python列表如何去重复_Python列表去重复项的N种方法

## 1. 新建列表，如果新列表中不存在，则添加到新列表。

def unique(data):

new_list = []

foritemindata:

if item notinnew_list:

new_list.append(item)

returnnew_list

# test

data = ['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 -V

Python 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 = []

foriinrange(len(data)):

if data[i] notinnew_list:

new_list.append(data[i])

returnnew_list

## 2.1 新建列表，使用列表推导来去重。是前一种的简写。

def unique(data):

new_list = []

[new_list.append(i) foriindata ifnotiinnew_list]

returnnew_list

# test

data = ['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 = []

foriinrange(len(data)):

item = data[i]

try:

if (new_list.index(item) 

print('new_list:', new_list)

exceptValueError:

new_list.append(item)

returnnew_list

# test

data = ['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 = []

foriinrange(len(data)):

j = 0

while j <= i:

if data[i] == data[j]:

if i == j:

new_list.append(data[i])

break

j += 1

returnnew_list

# test

data = ['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

returndata

# test

data = ['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 

j = i + 1

while j 

if data[i] == data[j]:

del data[j]

l -= 1

i -= 1

break

j += 1

i += 1

returndata

# test

data = ['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 = []

foriinrange(len(data)):

if i == data.index(data[i]):

new_list.append(data[i])

returnnew_list

# test

data = ['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 = {}

foritemindata:

obj[item] = item

returnobj.values()

# test

data = ['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 notinnew_list):

new_list.append(item)

returnTrue

returnFalse

def unique(item):

if obj.get(item) == None:

obj[item] = item

returnTrue

returnFalse

# test

data = ['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

returnTrue

returnFalse

# test

data = ['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 notinnew_list:

new_list.append(item)

returnitem

returnNone

# test

data = ['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])

returndata

# test

data = ['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):

"""

inpython 3: TypeError:'

need tokeep the same TypeofmemberinList

"""

data.sort()

l = len(data) - 1

i = 0

while i 

if (data[i] == data[i + 1]):

del data[i]

i -= 1

l -= 1

i += 1

returndata

# test

data = ['a','a', 1, 1, 2, 2,'b','b', 2, 1]

start_time = time.time()

print("sort+del ASE:",unique(data))

print("time:"+ str((time.time() - start_time) * 1000) +" ms")

## 15. 利用reduce函数来去重复。reduce具有累计的作用，判断如果不在累计结果中出现，则追加到结果中。

import functools

def unique(data):

new_list = []

def foo(result, item):

if isinstance(result, list) == False:

result = [result]

returnresult if iteminresultelseresult + [item]

returnfunctools.reduce(foo, data)

# test

data = ['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):

returndata

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]

returnrecursion_unique(data, len - 1)

# test

data = ['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):

returndata

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]]

returnrecursion_unique_new(data, len - 1) + result

# test

data = ['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 asnp

def unique(data):

res = np.array(data)

returnlist(np.unique(res))

# test

data = ['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")