Prawie muszę napisać program, aby sprawdzić, czy lista ma jakieś duplikaty, a jeśli tak, to usuwa je i zwraca nową listę z elementami, które nie zostały zduplikowane / usunięte. To właśnie mam, ale szczerze mówiąc nie wiem, co robić.

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

Powszechnym podejściem do uzyskania unikalnej kolekcji przedmiotów jest użycie set. Zestawy to nieuporządkowane kolekcje różnych obiektów. Aby utworzyć zestaw z dowolnej iteracji, możesz po prostu przekazać go do wbudowanej set()funkcji. Jeśli później będziesz potrzebować prawdziwej listy, możesz podobnie przekazać zestaw do list()funkcji.

Poniższy przykład powinien obejmować wszystko, co próbujesz zrobić:

>>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> t
[1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> list(set(t))
[1, 2, 3, 5, 6, 7, 8]
>>> s = [1, 2, 3]
>>> list(set(t) - set(s))
[8, 5, 6, 7]

Jak widać z przykładowego wyniku, oryginalne zamówienie nie jest utrzymywane . Jak wspomniano powyżej, same zestawy są kolekcjami nieuporządkowanymi, więc zamówienie zostaje utracone. Podczas konwersji zestawu z powrotem na listę tworzona jest dowolna kolejność.

Utrzymanie porządku

Jeśli kolejność jest dla Ciebie ważna, będziesz musiał użyć innego mechanizmu. Bardzo częstym rozwiązaniem jest poleganie na OrderedDictutrzymywaniu kolejności kluczy podczas wstawiania:

>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys(t))
[1, 2, 3, 5, 6, 7, 8]

Począwszy od Python 3.7 , wbudowany słownik gwarantuje również zachowanie kolejności wstawiania, więc możesz również użyć tego bezpośrednio, jeśli korzystasz z Python 3.7 lub nowszej wersji (lub CPython 3.6):

>>> list(dict.fromkeys(t))
[1, 2, 3, 5, 6, 7, 8]

Zauważ, że może to wiązać się z pewnym nakładem na utworzenie słownika, a następnie utworzenie listy z niego. Jeśli tak naprawdę nie musisz zachowywać porządku, często lepiej jest użyć zestawu, zwłaszcza, że ​​daje dużo więcej operacji do pracy. Sprawdź to pytanie, aby uzyskać więcej informacji i alternatywne sposoby zachowania porządku podczas usuwania duplikatów.

Na koniec zauważ, że zarówno rozwiązania, setjak i OrderedDict/ dictwymagają, aby twoje przedmioty mogły być haszowalne . Zazwyczaj oznacza to, że muszą być niezmienne. Jeśli masz do czynienia z elementami, które nie są haszowalne (np. Obiekty z listy), będziesz musiał zastosować powolne podejście, w którym zasadniczo będziesz musiał porównać każdy element z każdym innym elementem w zagnieżdżonej pętli.

W Pythonie 2.7 nowy sposób usuwania duplikatów z iterowalnych przy jednoczesnym zachowaniu ich w oryginalnej kolejności to:

>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']

W Pythonie 3.5 OrDERDict ma implementację C. Moje czasy wskazują, że jest to zarówno najszybsze, jak i najkrótsze z różnych podejść do Pythona 3.5.

W Pythonie 3.6 zwykły słownik stał się uporządkowany i zwarty. (Ta funkcja dotyczy CPython i PyPy, ale może nie występować w innych implementacjach). To daje nam nowy najszybszy sposób deduplikacji przy zachowaniu porządku:

>>> list(dict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']

W Pythonie 3.7 regularny słownik jest gwarantowany zarówno we wszystkich implementacjach. Zatem najkrótszym i najszybszym rozwiązaniem jest:

>>> list(dict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']

Jest to jedna linijka: list(set(source_list))załatwi sprawę.

Jest setto coś, co nie może mieć duplikatów.

Aktualizacja: podejście zachowujące porządek składa się z dwóch linii:

from collections import OrderedDict
OrderedDict((x, True) for x in source_list).keys()

W tym przypadku wykorzystujemy fakt, że OrderedDictzapamiętuje kolejność wstawiania kluczy i nie zmienia go, gdy wartość określonego klucza jest aktualizowana. Wstawiamy Truejako wartości, ale możemy wstawić wszystko, wartości po prostu nie są używane. ( setdziała podobnie jak dictz ignorowanymi wartościami).

>>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> t
[1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> s = []
>>> for i in t:
       if i not in s:
          s.append(i)
>>> s
[1, 2, 3, 5, 6, 7, 8]

Jeśli nie zależy ci na zamówieniu, po prostu zrób to:

def remove_duplicates(l):
    return list(set(l))

setGwarantuje nie ma duplikatów.

Aby utworzyć nową listę zachowującą kolejność pierwszych elementów duplikatów w L

newlist=[ii for n,ii in enumerate(L) if ii not in L[:n]]

na przykład if L=[1, 2, 2, 3, 4, 2, 4, 3, 5]wtedy newlistbędzie[1,2,3,4,5]

To sprawdza, czy każdy nowy element nie pojawiał się wcześniej na liście przed dodaniem go. Nie potrzebuje też importu.

Kolega wysłał mi dzisiaj zaakceptowaną odpowiedź w ramach swojego kodu w celu zapoznania się z kodem. Choć z pewnością podziwiam elegancję odpowiedzi, o której mowa, nie jestem zadowolony z tego przedstawienia. Wypróbowałem to rozwiązanie (używam zestawu, aby skrócić czas wyszukiwania)

def ordered_set(in_list):
    out_list = []
    added = set()
    for val in in_list:
        if not val in added:
            out_list.append(val)
            added.add(val)
    return out_list

Aby porównać wydajność, wykorzystałem losową próbkę 100 liczb całkowitych - 62 były wyjątkowe

from random import randint
x = [randint(0,100) for _ in xrange(100)]

In [131]: len(set(x))
Out[131]: 62

Oto wyniki pomiarów

In [129]: %timeit list(OrderedDict.fromkeys(x))
10000 loops, best of 3: 86.4 us per loop

In [130]: %timeit ordered_set(x)
100000 loops, best of 3: 15.1 us per loop

Co się stanie, jeśli zestaw zostanie usunięty z rozwiązania?

def ordered_set(inlist):
    out_list = []
    for val in inlist:
        if not val in out_list:
            out_list.append(val)
    return out_list

Rezultat nie jest tak zły, jak w przypadku zamówienia OrDERDict , ale wciąż więcej niż 3 razy w porównaniu z oryginalnym rozwiązaniem

In [136]: %timeit ordered_set(x)
10000 loops, best of 3: 52.6 us per loop

Istnieją również rozwiązania wykorzystujące Pandy i Numpy. Oba zwracają tablicę numpy, więc musisz użyć funkcji, .tolist()jeśli chcesz mieć listę.

t=['a','a','b','b','b','c','c','c']
t2= ['c','c','b','b','b','a','a','a']

Rozwiązanie Pandy

Korzystanie z funkcji Pandy unique():

import pandas as pd
pd.unique(t).tolist()
>>>['a','b','c']
pd.unique(t2).tolist()
>>>['c','b','a']

Rozwiązanie Numpy

Korzystanie z funkcji numpy unique().

import numpy as np
np.unique(t).tolist()
>>>['a','b','c']
np.unique(t2).tolist()
>>>['a','b','c']

Zauważ, że numpy.unique () również sortuje wartości . Lista t2jest więc sortowana. Jeśli chcesz zachować porządek, skorzystaj z następującej odpowiedzi :

_, idx = np.unique(t2, return_index=True)
t2[np.sort(idx)].tolist()
>>>['c','b','a']

Rozwiązanie nie jest tak eleganckie w porównaniu z innymi, jednak w porównaniu z pandas.unique (), numpy.unique () pozwala również sprawdzić, czy zagnieżdżone tablice są unikalne wzdłuż jednej wybranej osi.

Kolejny sposób:

>>> seq = [1,2,3,'a', 'a', 1,2]
>> dict.fromkeys(seq).keys()
['a', 1, 2, 3]

Proste i łatwe:

myList = [1, 2, 3, 1, 2, 5, 6, 7, 8]
cleanlist = []
[cleanlist.append(x) for x in myList if x not in cleanlist]

Wynik:

>>> cleanlist 
[1, 2, 3, 5, 6, 7, 8]

W tej odpowiedzi będą dwie sekcje: Dwa unikalne rozwiązania i wykres prędkości dla konkretnych rozwiązań.

Usuwanie zduplikowanych elementów

Większość z tych odpowiedzi usuwa tylko zduplikowane elementy, które można haszować , ale to pytanie nie oznacza, że ​​nie tylko potrzebują haszowanych przedmiotów, co oznacza, że ​​zaoferuję niektóre rozwiązania, które nie wymagają haszowania .

collections.Counter to potężne narzędzie w standardowej bibliotece, które może być do tego idealne. Jest tylko jedno inne rozwiązanie, które zawiera nawet Licznik. Jednak to rozwiązanie ogranicza się również do kluczy mieszalnych .

Aby zezwolić na klucze nieukrywalne w Counter, stworzyłem klasę Container, która spróbuje uzyskać domyślną funkcję skrótu obiektu, ale jeśli zawiedzie, spróbuje użyć funkcji tożsamości. Definiuje także metodę eq i metodę skrótu . To powinno wystarczyć, aby pozwolić naszym produktom na niewymagalne elementy. Obiekty, których nie można skasować, będą traktowane tak, jakby można je było haszować. Jednak ta funkcja skrótu używa tożsamości dla obiektów nieukończonych, co oznacza, że ​​dwa równe obiekty, których oba są nieukończalne, nie będą działać. Sugeruję zastąpienie tego i zmianę go w celu użycia skrótu równoważnego typu zmiennego (np. Użycie hash(tuple(my_list))if my_listjest listą).

Stworzyłem również dwa rozwiązania. Kolejne rozwiązanie, które utrzymuje kolejność elementów, wykorzystując podklasę OrDERDict i Counter o nazwie „OrdersCounter”. Teraz oto funkcje:

from collections import OrderedDict, Counter

class Container:
    def __init__(self, obj):
        self.obj = obj
    def __eq__(self, obj):
        return self.obj == obj
    def __hash__(self):
        try:
            return hash(self.obj)
        except:
            return id(self.obj)

class OrderedCounter(Counter, OrderedDict):
     'Counter that remembers the order elements are first encountered'

     def __repr__(self):
         return '%s(%r)' % (self.__class__.__name__, OrderedDict(self))

     def __reduce__(self):
         return self.__class__, (OrderedDict(self),)

def remd(sequence):
    cnt = Counter()
    for x in sequence:
        cnt[Container(x)] += 1
    return [item.obj for item in cnt]

def oremd(sequence):
    cnt = OrderedCounter()
    for x in sequence:
        cnt[Container(x)] += 1
    return [item.obj for item in cnt]

remd to sortowanie bez uporządkowania, oremd to sortowanie uporządkowane. Możesz wyraźnie powiedzieć, który jest szybszy, ale i tak wyjaśnię. Nieuporządkowane sortowanie jest nieco szybsze. Przechowuje mniej danych, ponieważ nie potrzebuje porządku.

Teraz chciałem też pokazać porównanie prędkości dla każdej odpowiedzi. Zrobię to teraz.

Która funkcja jest najszybsza?

Do usuwania duplikatów zebrałem 10 funkcji z kilku odpowiedzi. Obliczyłem prędkość każdej funkcji i umieściłem ją na wykresie za pomocą matplotlib.pyplot .

Podzieliłem to na trzy rundy wykresów. Hashable to dowolny obiekt, który może być haszowany, hashable to każdy obiekt, który nie może być haszowany. Sekwencja uporządkowana to sekwencja, która zachowuje porządek, sekwencja nieuporządkowana nie zachowuje porządku. Oto kilka innych terminów:

Unordered Hashable był dla każdej metody, która usuwa duplikaty, co niekoniecznie musi zachowywać porządek. Nie musiało to działać na rzeczy nieskrępowane, ale mogło.

Uporządkowany Hashable był dla każdej metody, która zachowywała kolejność pozycji na liście, ale nie musiał działać dla nieusuwalnych, ale mógł.

Order Unhashable to dowolna metoda, która zachowuje porządek pozycji na liście i działa na niehashable.

Na osi y jest czas w sekundach.

Na osi X znajduje się liczba, do której zastosowano funkcję.

Wygenerowaliśmy sekwencje dla nieuporządkowanych skrótów i uporządkowanych skrótów z następującym zrozumieniem: [list(range(x)) + list(range(x)) for x in range(0, 1000, 10)]

W przypadku zamówionych elementów nieukończonych: [[list(range(y)) + list(range(y)) for y in range(x)] for x in range(0, 1000, 10)]

Zauważ, że w zakresie jest „krok”, ponieważ bez niego zajęłoby to 10 razy więcej. Również dlatego, że moim osobistym zdaniem myślałem, że może to wyglądać trochę łatwiej.

Zwróć też uwagę, że klawisze legendy są tym, co starałem się odgadnąć jako najbardziej istotne części funkcji. Co do funkcji, która jest najgorsza lub najlepsza? Wykres mówi sam za siebie.

Po ustaleniu, oto wykresy.

Nieuporządkowane haszysze

(Zbliżony)

Zamówione haszysze

(Zbliżony)

Zamówione Unhashables

(Zbliżony)

Miałem na liście dykt, więc nie mogłem zastosować powyższego podejścia. Dostałem błąd:

TypeError: unhashable type:

Więc jeśli zależy Ci na zamówieniu i / lub niektóre przedmioty są nie do zniesienia . Może się to przydać:

def make_unique(original_list):
    unique_list = []
    [unique_list.append(obj) for obj in original_list if obj not in unique_list]
    return unique_list

Niektórzy mogą uważać, że zrozumienie listy ze skutkiem ubocznym nie jest dobrym rozwiązaniem. Oto alternatywa:

def make_unique(original_list):
    unique_list = []
    map(lambda x: unique_list.append(x) if (x not in unique_list) else False, original_list)
    return unique_list

Wszystkie podejścia do utrzymywania porządku, które do tej pory widziałem, wykorzystują albo naiwne porównanie (w najlepszym razie złożoności czasowej O (n ^ 2)), albo kombinacje ciężkie OrderedDicts/ set+, listktóre są ograniczone do możliwych do wprowadzenia wartości. Oto niezależne od skrótów rozwiązanie O (nlogn):

Aktualizacja dodała keyargument, dokumentację i zgodność z Python 3.

# from functools import reduce <-- add this import on Python 3

def uniq(iterable, key=lambda x: x):
    """
    Remove duplicates from an iterable. Preserves order. 
    :type iterable: Iterable[Ord => A]
    :param iterable: an iterable of objects of any orderable type
    :type key: Callable[A] -> (Ord => B)
    :param key: optional argument; by default an item (A) is discarded 
    if another item (B), such that A == B, has already been encountered and taken. 
    If you provide a key, this condition changes to key(A) == key(B); the callable 
    must return orderable objects.
    """
    # Enumerate the list to restore order lately; reduce the sorted list; restore order
    def append_unique(acc, item):
        return acc if key(acc[-1][1]) == key(item[1]) else acc.append(item) or acc 
    srt_enum = sorted(enumerate(iterable), key=lambda item: key(item[1]))
    return [item[1] for item in sorted(reduce(append_unique, srt_enum, [srt_enum[0]]))] 

Jeśli chcesz zachować porządek i nie używać żadnych modułów zewnętrznych, możesz to zrobić w prosty sposób:

>>> t = [1, 9, 2, 3, 4, 5, 3, 6, 7, 5, 8, 9]
>>> list(dict.fromkeys(t))
[1, 9, 2, 3, 4, 5, 6, 7, 8]

Uwaga: Ta metoda zachowuje kolejność pojawiania się, więc, jak pokazano powyżej, dziewięć pojawi się po jednym, ponieważ był to pierwszy raz, gdy się pojawił. Jest to jednak taki sam wynik, jak w przypadku robienia

from collections import OrderedDict
ulist=list(OrderedDict.fromkeys(l))

ale jest znacznie krótszy i działa szybciej.

Działa to, ponieważ za każdym razem, gdy fromkeysfunkcja próbuje utworzyć nowy klucz, jeśli wartość już istnieje, po prostu ją zastąpi. Nie ma to jednak fromkeysżadnego wpływu na słownik, ponieważ tworzy słownik, w którym wszystkie klucze mają wartość None, więc w ten sposób skutecznie eliminuje wszystkie duplikaty.

Możesz także to zrobić:

>>> t = [1, 2, 3, 3, 2, 4, 5, 6]
>>> s = [x for i, x in enumerate(t) if i == t.index(x)]
>>> s
[1, 2, 3, 4, 5, 6]

Powodem tego jest to, że indexmetoda zwraca tylko pierwszy indeks elementu. Zduplikowane elementy mają wyższe wskaźniki. Zobacz tutaj :

list.index (x [, start [, koniec]])
Zwraca liczony od zera indeks na liście pierwszego elementu, którego wartość wynosi x. Podnosi ValueError, jeśli nie ma takiego elementu.

Spróbuj użyć zestawów:

import sets
t = sets.Set(['a', 'b', 'c', 'd'])
t1 = sets.Set(['a', 'b', 'c'])

print t | t1
print t - t1

Zredukuj wariant z zamówieniem zachowaj:

Załóżmy, że mamy listę:

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

Zredukuj wariant (nieefektywny):

>>> reduce(lambda r, v: v in r and r or r + [v], l, [])
[5, 6, 1, 2, 3, 4]

5 x szybszy, ale bardziej wyrafinowany

>>> reduce(lambda r, v: v in r[1] and r or (r[0].append(v) or r[1].add(v)) or r, l, ([], set()))[0]
[5, 6, 1, 2, 3, 4]

Wyjaśnienie:

default = (list(), set())
# user list to keep order
# use set to make lookup faster

def reducer(result, item):
    if item not in result[1]:
        result[0].append(item)
        result[1].add(item)
    return result

reduce(reducer, l, default)[0]

Najlepszym podejściem do usuwania duplikatów z listy jest użycie funkcji set () dostępnej w Pythonie, ponownie konwertując ten zestaw na listę

In [2]: some_list = ['a','a','v','v','v','c','c','d']
In [3]: list(set(some_list))
Out[3]: ['a', 'c', 'd', 'v']

Możesz użyć następującej funkcji:

def rem_dupes(dup_list): 
    yooneeks = [] 
    for elem in dup_list: 
        if elem not in yooneeks: 
            yooneeks.append(elem) 
    return yooneeks

Przykład :

my_list = ['this','is','a','list','with','dupicates','in', 'the', 'list']

Stosowanie:

rem_dupes(my_list)

[„this”, „is”, „a”, „list”, „with”, „duplicates”, „in”, „the”]

Istnieje wiele innych odpowiedzi sugerujących różne sposoby na zrobienie tego, ale wszystkie są operacjami wsadowymi, a niektóre z nich odrzucają oryginalne zamówienie. Może to być w porządku w zależności od potrzeb, ale jeśli chcesz iterować wartości w kolejności pierwszej instancji każdej wartości i chcesz usunąć duplikaty w locie w porównaniu do wszystkich naraz, możesz użyć ten generator:

def uniqify(iterable):
    seen = set()
    for item in iterable:
        if item not in seen:
            seen.add(item)
            yield item

Zwraca generator / iterator, dzięki czemu można go używać w dowolnym miejscu, w którym można użyć iteratora.

for unique_item in uniqify([1, 2, 3, 4, 3, 2, 4, 5, 6, 7, 6, 8, 8]):
    print(unique_item, end=' ')

print()

Wynik:

1 2 3 4 5 6 7 8

Jeśli chcesz list, możesz to zrobić:

unique_list = list(uniqify([1, 2, 3, 4, 3, 2, 4, 5, 6, 7, 6, 8, 8]))

print(unique_list)

Wynik:

[1, 2, 3, 4, 5, 6, 7, 8]

Bez użycia zestawu

data=[1, 2, 3, 1, 2, 5, 6, 7, 8]
uni_data=[]
for dat in data:
    if dat not in uni_data:
        uni_data.append(dat)

print(uni_data) 

Możesz użyć setdo usunięcia duplikatów:

mylist = list(set(mylist))

Pamiętaj jednak, że wyniki będą nieuporządkowane. Jeśli to jest problem:

mylist.sort()

Jeszcze jednym lepszym podejściem może być

import pandas as pd

myList = [1, 2, 3, 1, 2, 5, 6, 7, 8]
cleanList = pd.Series(myList).drop_duplicates().tolist()
print(cleanList)

#> [1, 2, 3, 5, 6, 7, 8]

i porządek pozostaje zachowany.

Ten dba o zamówienie bez większych problemów (OrderdDict i inni). Prawdopodobnie nie jest to metoda najbardziej Pythońska, ani najkrótsza, ale polega na tym:

def remove_duplicates(list):
    ''' Removes duplicate items from a list '''
    singles_list = []
    for element in list:
        if element not in singles_list:
            singles_list.append(element)
    return singles_list

poniższy kod jest prosty do usunięcia duplikatu z listy

def remove_duplicates(x):
    a = []
    for i in x:
        if i not in a:
            a.append(i)
    return a

print remove_duplicates([1,2,2,3,3,4])

zwraca [1,2,3,4]

Oto najszybsze rozwiązanie python w porównaniu do innych wymienionych w odpowiedziach.

Wykorzystanie szczegółów implementacji oceny zwarć pozwala na użycie listowania, które jest wystarczająco szybkie. visited.add(item)zawsze zwraca Nonewynik, który jest oceniany jako False, więc prawa strona orzawsze będzie wynikiem takiego wyrażenia.

Czas sam

def deduplicate(sequence):
    visited = set()
    adder = visited.add  # get rid of qualification overhead
    out = [adder(item) or item for item in sequence if item not in visited]
    return out

Za pomocą zestawu :

a = [0,1,2,3,4,3,3,4]
a = list(set(a))
print a

Używając unikalnego :

import numpy as np
a = [0,1,2,3,4,3,3,4]
a = np.unique(a).tolist()
print a

Niestety. Większość odpowiedzi tutaj albo nie zachowuje kolejności, albo jest za długa. Oto prosta, zachowująca porządek odpowiedź.

s = [1,2,3,4,5,2,5,6,7,1,3,9,3,5]
x=[]

[x.append(i) for i in s if i not in x]
print(x)

To da ci x z usuniętymi duplikatami, ale zachowując kolejność.

Bardzo prosty sposób w Pythonie 3:

>>> n = [1, 2, 3, 4, 1, 1]
>>> n
[1, 2, 3, 4, 1, 1]
>>> m = sorted(list(set(n)))
>>> m
[1, 2, 3, 4]

Magia wbudowanego typu Python

W Pythonie bardzo łatwo jest przetwarzać tak skomplikowane przypadki, jak i tylko przy użyciu wbudowanego typu python.

Pokażę ci, jak to zrobić!

Metoda 1: Przypadek ogólny

Sposób ( 1 kod wiersza ), aby usunąć zduplikowany element z listy i nadal zachować porządek sortowania

line = [1, 2, 3, 1, 2, 5, 6, 7, 8]
new_line = sorted(set(line), key=line.index) # remove duplicated element
print(new_line)

Otrzymasz wynik

[1, 2, 3, 5, 6, 7, 8]

Metoda 2: Przypadek specjalny

TypeError: unhashable type: 'list'

Specjalny przypadek przetwarzania nieukończonego ( 3 kody linii )

line=[['16.4966155686595', '-27.59776154691', '52.3786295521147']
,['16.4966155686595', '-27.59776154691', '52.3786295521147']
,['17.6508629295574', '-27.143305738671', '47.534955022564']
,['17.6508629295574', '-27.143305738671', '47.534955022564']
,['18.8051102904552', '-26.688849930432', '42.6912804930134']
,['18.8051102904552', '-26.688849930432', '42.6912804930134']
,['19.5504702331098', '-26.205884452727', '37.7709192714727']
,['19.5504702331098', '-26.205884452727', '37.7709192714727']
,['20.2929416861422', '-25.722717575124', '32.8500163147157']
,['20.2929416861422', '-25.722717575124', '32.8500163147157']]

tuple_line = [tuple(pt) for pt in line] # convert list of list into list of tuple
tuple_new_line = sorted(set(tuple_line),key=tuple_line.index) # remove duplicated element
new_line = [list(t) for t in tuple_new_line] # convert list of tuple into list of list

print (new_line)

Otrzymasz wynik:

[
  ['16.4966155686595', '-27.59776154691', '52.3786295521147'], 
  ['17.6508629295574', '-27.143305738671', '47.534955022564'], 
  ['18.8051102904552', '-26.688849930432', '42.6912804930134'], 
  ['19.5504702331098', '-26.205884452727', '37.7709192714727'], 
  ['20.2929416861422', '-25.722717575124', '32.8500163147157']
]

Ponieważ krotka jest haszowalna i możesz łatwo konwertować dane między listą a krotką