筛选Python列表以删除类似值

所以我有一个列表，大约有100个介于0和1之间的浮点值，类似于：

[0.642918256477056,
 0.6429182558639024,
 0.6429182466700671,
 0.6429182068585415,
 0.6429180997884363,
 0.6428178743476422,
 0.6428174651415239,
 0.6428167927406518,
... ]

我需要的是一种创建更简单列表的方法，其中删除4位小数中相同的值，只保留第一位小数。例如：号码06429。。。在这个原始列表中重复了好几次，我只需要一次

在此之后，我仍然需要知道哪些值（索引）被删除了，以便我可以“重新映射”它们。例如：

len(original_list) # Result: 100 | remap 0:1 range (index0 is 0, index 100 is 1)
len(filterted_list) # Result: 10

例如，如果filteres_列表的索引5是原始_列表中的索引80，我需要知道原始的重新映射值是0.8

---

对不起，如果我不能更好地解释这一点，如果你帮助我的第一部分已经是一个很好的帮助。谢谢大家。

集合定义为唯一的元素的无序集合列表

如果顺序不适合您，只需使用一套：

import math
filterted_list = set(round(x, 4) for x in original_list)

您还可以使用此收据实现简单的订购集：

---

它会记住项目的插入顺序。

集合定义为唯一元素的无序集合列表

如果顺序不适合您，只需使用一套：

import math
filterted_list = set(round(x, 4) for x in original_list)

您还可以使用此收据实现简单的订购集：

---

它会记住项目的插入顺序。

集合定义为唯一元素的无序集合列表

如果顺序不适合您，只需使用一套：

import math
filterted_list = set(round(x, 4) for x in original_list)

您还可以使用此收据实现简单的订购集：

---

它会记住项目的插入顺序。

集合定义为唯一元素的无序集合列表

如果顺序不适合您，只需使用一套：

import math
filterted_list = set(round(x, 4) for x in original_list)

您还可以使用此收据实现简单的订购集：

它会记住项目的插入顺序。

使用集合和圆形：

li=[0.642918256477056,
 0.6429182558639024,
 0.6429182466700671,
 0.6429182068585415,
 0.6429180997884363,
 0.6428178743476422,
 0.6428174651415239,
 0.6428167927406518]

seen=set()
data=[]
for n in li:
    nr=round(n,4)
    if nr not in seen:
        seen.add(nr)
        data.append(nr)   # append n if you want the unrounded value

print data 
# [0.6429, 0.6428]

您可以在

数据

中附加

n

（未舍入）或

nr

舍入值。秩序将得到维持

使用集合和圆形：

li=[0.642918256477056,
 0.6429182558639024,
 0.6429182466700671,
 0.6429182068585415,
 0.6429180997884363,
 0.6428178743476422,
 0.6428174651415239,
 0.6428167927406518]

seen=set()
data=[]
for n in li:
    nr=round(n,4)
    if nr not in seen:
        seen.add(nr)
        data.append(nr)   # append n if you want the unrounded value

print data 
# [0.6429, 0.6428]

您可以在

数据

中附加

n

（未舍入）或

nr

舍入值。秩序将得到维持

使用集合和圆形：

li=[0.642918256477056,
 0.6429182558639024,
 0.6429182466700671,
 0.6429182068585415,
 0.6429180997884363,
 0.6428178743476422,
 0.6428174651415239,
 0.6428167927406518]

seen=set()
data=[]
for n in li:
    nr=round(n,4)
    if nr not in seen:
        seen.add(nr)
        data.append(nr)   # append n if you want the unrounded value

print data 
# [0.6429, 0.6428]

您可以在

数据

中附加

n

（未舍入）或

nr

舍入值。秩序将得到维持

使用集合和圆形：

li=[0.642918256477056,
 0.6429182558639024,
 0.6429182466700671,
 0.6429182068585415,
 0.6429180997884363,
 0.6428178743476422,
 0.6428174651415239,
 0.6428167927406518]

seen=set()
data=[]
for n in li:
    nr=round(n,4)
    if nr not in seen:
        seen.add(nr)
        data.append(nr)   # append n if you want the unrounded value

print data 
# [0.6429, 0.6428]

---

您可以在

数据

中附加

n

（未舍入）或

nr

舍入值。秩序将得到维持

除set外，您还可以使用如下列表理解：

d=[0.642918256477056,
 0.6429182558639024,
 0.6429182466700671,
 0.6429182068585415,
 0.6429180997884363,
 0.6428178743476422,
 0.6428174651415239,
 0.6428167927406518]
result=[]
[result.append('%.4f' % round(i, 4)) for i in d if '%.4f' % round(i, 4) not in result]
print result

输出：

['0.6429', '0.6428']

检查各个元素

将元素四舍五入到4位小数

如果在结果列表中找不到该值，则添加到结果

---

除set外，您还可以使用以下列表理解：

d=[0.642918256477056,
 0.6429182558639024,
 0.6429182466700671,
 0.6429182068585415,
 0.6429180997884363,
 0.6428178743476422,
 0.6428174651415239,
 0.6428167927406518]
result=[]
[result.append('%.4f' % round(i, 4)) for i in d if '%.4f' % round(i, 4) not in result]
print result

输出：

['0.6429', '0.6428']

检查各个元素

将元素四舍五入到4位小数

如果在结果列表中找不到该值，则添加到结果

---

除set外，您还可以使用以下列表理解：

d=[0.642918256477056,
 0.6429182558639024,
 0.6429182466700671,
 0.6429182068585415,
 0.6429180997884363,
 0.6428178743476422,
 0.6428174651415239,
 0.6428167927406518]
result=[]
[result.append('%.4f' % round(i, 4)) for i in d if '%.4f' % round(i, 4) not in result]
print result

输出：

['0.6429', '0.6428']

检查各个元素

将元素四舍五入到4位小数

如果在结果列表中找不到该值，则添加到结果

---

除set外，您还可以使用以下列表理解：

d=[0.642918256477056,
 0.6429182558639024,
 0.6429182466700671,
 0.6429182068585415,
 0.6429180997884363,
 0.6428178743476422,
 0.6428174651415239,
 0.6428167927406518]
result=[]
[result.append('%.4f' % round(i, 4)) for i in d if '%.4f' % round(i, 4) not in result]
print result

输出：

['0.6429', '0.6428']

检查各个元素

将元素四舍五入到4位小数

如果在结果列表中找不到该值，则添加到结果

---

用一本简单的字典记录你所看到的。然后使用一个函数进行过滤，该函数在四舍五入到小数点后，检查之前是否看到过某些内容

seen = {}

nums = [0.642918256477056,
 0.6429182558639024,
 0.6429182466700671,
 0.6429182068585415,
 0.6429180997884363,
 0.6428178743476422,
 0.6428174651415239,
 0.6428167927406518]

def filterFN(x):
   x = round(x, 4)
   if seen.get(x) == None:
      seen[x] = 1
      return True
   return False

filter(filterFN, nums)

---

用一本简单的字典记录你所看到的。然后使用一个函数进行过滤，该函数在四舍五入到小数点后，检查之前是否看到过某些内容

seen = {}

nums = [0.642918256477056,
 0.6429182558639024,
 0.6429182466700671,
 0.6429182068585415,
 0.6429180997884363,
 0.6428178743476422,
 0.6428174651415239,
 0.6428167927406518]

def filterFN(x):
   x = round(x, 4)
   if seen.get(x) == None:
      seen[x] = 1
      return True
   return False

filter(filterFN, nums)

---

用一本简单的字典记录你所看到的。然后使用一个函数进行过滤，该函数在四舍五入到小数点后，检查之前是否看到过某些内容

seen = {}

nums = [0.642918256477056,
 0.6429182558639024,
 0.6429182466700671,
 0.6429182068585415,
 0.6429180997884363,
 0.6428178743476422,
 0.6428174651415239,
 0.6428167927406518]

def filterFN(x):
   x = round(x, 4)
   if seen.get(x) == None:
      seen[x] = 1
      return True
   return False

filter(filterFN, nums)

---

用一本简单的字典记录你所看到的。然后使用一个函数进行过滤，该函数在四舍五入到小数点后，检查之前是否看到过某些内容

seen = {}

nums = [0.642918256477056,
 0.6429182558639024,
 0.6429182466700671,
 0.6429182068585415,
 0.6429180997884363,
 0.6428178743476422,
 0.6428174651415239,
 0.6428167927406518]

def filterFN(x):
   x = round(x, 4)
   if seen.get(x) == None:
      seen[x] = 1
      return True
   return False

filter(filterFN, nums)

---

如果订单很重要，请使用

groupby

（）：

---

如果订单很重要，请使用

groupby

（）：

---

如果订单很重要，请使用

groupby

（）：

---

如果订单很重要，请使用

groupby

（）：

---

使用Python2.7和numpyaround函数，结果是一个字典，其中number是键，value是索引

#!/usr/bin/env python

import numpy as np

def getData():
    data=[0.642918256477056,
     0.6429182558639024,
     0.6429182466700671,
     0.6429182068585415,
     0.6429180997884363,
     0.6428178743476422,
     0.6428174651415239,
     0.6428167927406518]
    return data




def main():
    index_data={}
    rounded_data=np.around(getData(),4)
    index=0
    for number in rounded_data:
        if not number in index_data:
            index_data[number]=[index]
        else:
            index_data[number].append(index)

        index+=1
    print index_data
if __name__=="__main__":
    main()

---

使用Python2.7和numpyaround函数，结果是一个字典，其中number是键，value是索引

#!/usr/bin/env python

import numpy as np

def getData():
    data=[0.642918256477056,
     0.6429182558639024,
     0.6429182466700671,
     0.6429182068585415,
     0.6429180997884363,
     0.6428178743476422,
     0.6428174651415239,
     0.6428167927406518]
    return data




def main():
    index_data={}
    rounded_data=np.around(getData(),4)
    index=0
    for number in rounded_data:
        if not number in index_data:
            index_data[number]=[index]
        else:
            index_data[number].append(index)

        index+=1
    print index_data
if __name__=="__main__":
    main()

---

使用Python2.7和numpyaround函数，结果是一个字典，其中number是键，value是索引

#!/usr/bin/env python

import numpy as np

def getData():
    data=[0.642918256477056,
     0.6429182558639024,
     0.6429182466700671,
     0.6429182068585415,
     0.6429180997884363,
     0.6428178743476422,
     0.6428174651415239,
     0.6428167927406518]
    return data




def main():
    index_data={}
    rounded_data=np.around(getData(),4)
    index=0
    for number in rounded_data:
        if not number in index_data:
            index_data[number]=[index]
        else:
            index_data[number].append(index)

        index+=1
    print index_data
if __name__=="__main__":
    main()

---

使用Python2.7和numpyaround函数，结果是一个字典，其中number是键，value是索引

#!/usr/bin/env python

import numpy as np

def getData():
    data=[0.642918256477056,
     0.6429182558639024,
     0.6429182466700671,
     0.6429182068585415,
     0.6429180997884363,
     0.6428178743476422,
     0.6428174651415239,
     0.6428167927406518]
    return data




def main():
    index_data={}
    rounded_data=np.around(getData(),4)
    index=0
    for number in rounded_data:
        if not number in index_data:
            index_data[number]=[index]
        else:
            index_data[number].append(index)

        index+=1
    print index_data
if __name__=="__main__":
    main()

---

我建议

filterted_list=list（set（original_list））

@user1765661，然后使用orderedset。我建议

filterted_list=list（set（original_list））

@user1765661，然后使用orderedset。我建议

filterted_list=list（set（original_list））

@user1765661，然后改用orderedset。我建议

filterted_list=list（set（original_list））

@user1765661，然后改用orderedset。这是一个正确的解决方案，但在最坏的情况下它以O（n²）运行，而使用一个集合以摊销（O（n））运行。这是一个正确的解决方案，但它以O（n²）运行在最坏的情况下，当使用一个集合在摊销（O（n））中运行时，这是一个正确的解决方案，但它在O（n²）中运行。在最坏的情况下，当使用一个集合在摊销（O（n））中运行时，它在O（n²）中运行。我喜欢这个解决方案，尽管我会使用

seen=set（）

和

如果x不在