Mindere, ik moet een programma schrijven om te controleren of een lijst een duplicaten heeft en als het het doet, verwijdert het en retourneert een nieuwe lijst met de items die niet worden gedupliceerd / verwijderd. Dit is wat ik heb, maar om eerlijk te zijn, ik weet niet wat ik moet doen.
def remove_duplicates():
t = ['a', 'b', 'c', 'd']
t2 = ['a', 'c', 'd']
for t in t2:
t.append(t.remove())
return t
Antwoord 1, Autoriteit 100%
De gemeenschappelijke aanpak om een unieke verzameling items te krijgen is om een set. Sets zijn ongeordende -collecties van DICTECT Objecten. Om een set van aacable te maken, kunt u het eenvoudig doorgeven aan de ingebouwde set()functie. Als u later opnieuw een echte lijst nodig heeft, kunt u op dezelfde manier de ingesteld doorgeven aan de list()FUNCTION.
Het volgende voorbeeld moet dekken wat u probeert te doen:
>>> 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]
Zoals u kunt zien uit het voorbeeldresultaat, is de oorspronkelijke bestelling niet onderhouden . Zoals hierboven vermeld, zijn sets zelf ongeordende collecties, dus de bestelling is verloren. Bij het converteren van een set terug naar een lijst, wordt een willekeurige bestelling gemaakt.
Order handhaven
Als de bestelling belangrijk voor u is, dan moet u een ander mechanisme gebruiken. Een zeer gebruikelijke oplossing hiervoor is om te vertrouwen op OrderedDictom de volgorde van de toetsen tijdens het inbrengen te behouden:
>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys(t))
[1, 2, 3, 5, 6, 7, 8]
beginnend met python 3.7 , de ingebouwde In Woordenboek is gegarandeerd om ook de insertionorder te handhaven, zodat u dat ook rechtstreeks kunt gebruiken als u op Python 3.7 of later (of CPYTHON 3.6) bent:
>>> list(dict.fromkeys(t))
[1, 2, 3, 5, 6, 7, 8]
Merk op dat dit een overhead kan hebben om eerst een woordenboek te maken en vervolgens een lijst van het te maken. Als u de bestelling niet echt hoeft te bewaren, bent u vaak beter af met een set, vooral omdat het u veel meer operaties geeft om mee te werken. Uitchecken Deze vraag voor meer details en alternatieve manieren om de bestelling te behouden bij het verwijderen van duplicaten.
Noteer Eindelijk op dat zowel de seten de OrderedDict/ dictSolutions vereisen dat uw artikelen Hashable . Dit betekent meestal dat ze onveranderlijk moeten zijn. Als u te maken hebt met items die niet hashable zijn (b.v. lijstobjecten), dan moet u een langzame aanpak gebruiken waarin u in principe elk item met elk ander item in een geneste lus moet vergelijken.
Antwoord 2, Autoriteit 23%
In Python 2.7is de nieuwe manier om duplicaten uit een iterable te verwijderen terwijl het in de oorspronkelijke volgorde blijft:
>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']
In Python 3.5heeft de OrderedDict een C-implementatie. Uit mijn timing blijkt dat dit nu zowel de snelste als de kortste is van de verschillende benaderingen voor Python 3.5.
In Python 3.6werd het reguliere dictaat zowel geordend als compact. (Deze functie is geldig voor CPython en PyPy, maar is mogelijk niet aanwezig in andere implementaties). Dat geeft ons een nieuwe snelste manier om te ontdubbelen met behoud van orde:
>>> list(dict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']
In Python 3.7is het reguliere dict gegarandeerd voor beide geordend voor alle implementaties. Dus de kortste en snelste oplossing is:
>>> list(dict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']
Antwoord 3, autoriteit 11%
Het is een one-liner: list(set(source_list))zal het lukken.
Een setis iets dat onmogelijk duplicaten kan hebben.
Update: een aanpak om de bestelling te bewaren bestaat uit twee regels:
from collections import OrderedDict
OrderedDict((x, True) for x in source_list).keys()
Hier gebruiken we het feit dat OrderedDictde invoegvolgorde van sleutels onthoudt en deze niet verandert wanneer een waarde bij een bepaalde sleutel wordt bijgewerkt. We voegen Truein als waarden, maar we kunnen alles invoegen, waarden worden alleen niet gebruikt. (setwerkt ook veel als een dictmet genegeerde waarden.)
Antwoord 4, autoriteit 6%
>>> 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]
Antwoord 5, autoriteit 5%
Als de bestelling je niet interesseert, doe dan dit:
def remove_duplicates(l):
return list(set(l))
Een setbevat gegarandeerd geen duplicaten.
Antwoord 6, autoriteit 2%
Een nieuwe lijst maken met behoud van de volgorde van de eerste elementen van duplicaten in L
newlist=[ii for n,ii in enumerate(L) if ii not in L[:n]]
bijvoorbeeld if L=[1, 2, 2, 3, 4, 2, 4, 3, 5]dan is newlist[1,2,3,4,5]
Hiermee wordt gecontroleerd of elk nieuw element niet eerder in de lijst is verschenen voordat het wordt toegevoegd.
Ook hoeft het niet geïmporteerd te worden.
Antwoord 7, autoriteit 2%
Een collega heeft mij vandaag het geaccepteerde antwoord als onderdeel van zijn code gestuurd voor een codereview.
Hoewel ik de elegantie van het antwoord in kwestie zeker bewonder, ben ik niet blij met de uitvoering.
Ik heb deze oplossing geprobeerd (ik gebruik setom de zoektijd te verkorten)
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
Om de efficiëntie te vergelijken, heb ik een willekeurige steekproef van 100 gehele getallen gebruikt – 62 waren uniek
from random import randint
x = [randint(0,100) for _ in xrange(100)]
In [131]: len(set(x))
Out[131]: 62
Hier zijn de resultaten van de metingen
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
Nou, wat gebeurt er als set uit de oplossing wordt verwijderd?
def ordered_set(inlist):
out_list = []
for val in inlist:
if not val in out_list:
out_list.append(val)
return out_list
Het resultaat is niet zo slecht als met de OrderedDict, maar toch meer dan 3 keer van de oorspronkelijke oplossing
In [136]: %timeit ordered_set(x)
10000 loops, best of 3: 52.6 us per loop
Antwoord 8, autoriteit 2%
Er zijn ook oplossingen met Panda’s en Numpy. Ze retourneren allebei een numpy-array, dus je moet de functie .tolist()als je een lijst wilt.
t=['a','a','b','b','b','c','c','c']
t2= ['c','c','b','b','b','a','a','a']
Panda’s-oplossing
Panda’s-functie gebruiken unique():
import pandas as pd
pd.unique(t).tolist()
>>>['a','b','c']
pd.unique(t2).tolist()
>>>['c','b','a']
Numpy-oplossing
Numpy-functie gebruiken unique().
import numpy as np
np.unique(t).tolist()
>>>['a','b','c']
np.unique(t2).tolist()
>>>['a','b','c']
Merk op dat numpy.unique() ook de waarden sorteert. Dus de lijst t2wordt gesorteerd geretourneerd. Als je de bestelling wilt behouden, gebruik dan zoals in dit antwoord:
_, idx = np.unique(t2, return_index=True)
t2[np.sort(idx)].tolist()
>>>['c','b','a']
De oplossing is niet zo elegant in vergelijking met de andere, maar vergeleken met pandas.unique(), kunt u met numpy.unique() ook controleren of geneste arrays uniek zijn langs één geselecteerde as.
Antwoord 9
In dit antwoord zijn er twee secties: twee unieke oplossingen en een snelheidsgrafiek voor specifieke oplossingen.
Dubbele items verwijderen
De meeste van deze antwoorden verwijderen alleen dubbele items die hashablezijn, maar deze vraag betekent niet dat er niet alleen hashableitems nodig zijn, wat betekent dat ik sommige oplossingen die geen hashbareitems vereisen.
collections.Counteris een krachtige tool in de standaardbibliotheek die hier perfect voor zou kunnen zijn. Er is maar één andere oplossing die zelfs Counter bevat. Die oplossing is echter ook beperkt tot hashbaresleutels.
Om niet-hashbare sleutels in Counter toe te staan, heb ik een Container-klasse gemaakt, die zal proberen de standaard hash-functie van het object te krijgen, maar als het niet lukt, zal het zijn identiteitsfunctie proberen. Het definieert ook een eqen een hashmethode. Dit zou voldoende moeten zijn om niet-hashbareitems in onze oplossing toe te staan. Unhashable objecten worden behandeld alsof ze hashable zijn. Deze hashfunctie gebruikt echter identiteit voor niet-hashbare objecten, wat betekent dat twee gelijke objecten die beide niet-hashbaar zijn, niet werken. Ik raad je aan dit te negeren en het te wijzigen om de hash van een equivalent veranderlijk type te gebruiken (zoals het gebruik van hash(tuple(my_list))als my_listeen lijst is).
Ik heb ook twee oplossingen gemaakt. Een andere oplossing die de volgorde van de items behoudt, met behulp van een subklasse van zowel OrderedDict als Counter die ‘OrderedCounter’ wordt genoemd. Dit zijn de functies:
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]
remdis niet-geordende sortering, terwijl oremdgeordende sortering is. Je kunt duidelijk zien welke sneller is, maar ik zal het toch uitleggen. De niet-geordende sortering is iets sneller, omdat de volgorde van de items niet wordt opgeslagen.
Nu wilde ik ook de snelheidsvergelijkingen van elk antwoord laten zien. Dus dat doe ik nu.
Welke functie is de snelste?
Voor het verwijderen van duplicaten heb ik 10 functies verzameld uit een paar antwoorden. Ik heb de snelheid van elke functie berekend en in een grafiek gezet met behulp van matplotlib.pyplot.
Ik heb dit verdeeld in drie rondes van grafieken. Een hashable is elk object dat kan worden gehasht, een unhashable is elk object dat niet kan worden gehasht. Een geordende reeks is een reeks die de orde handhaaft, een ongeordende reeks bewaart de orde niet. Hier zijn nog een paar termen:
Ongeordende hashablewas voor elke methode die duplicaten verwijderde, die niet noodzakelijk de volgorde hoefden te behouden. Het hoefde niet te werken voor unhashables, maar het zou kunnen.
Geordende hashablewas voor elke methode die de volgorde van de items in de lijst aanhield, maar het hoefde niet te werken voor unhashables, maar het kon.
Ordered Unhashablewas een methode die de volgorde van de items in de lijst aanhield en werkte voor unhashables.
Op de y-as staat het aantal seconden dat nodig was.
Op de x-as staat het nummer waarop de functie is toegepast.
Ik heb sequenties gegenereerd voor ongeordende hashables en heb hashables besteld met het volgende begrip: [list(range(x)) + list(range(x)) for x in range(0, 1000, 10)]
Voor bestelde unhashables: [[list(range(y)) + list(range(y)) for y in range(x)] for x in range(0, 1000, 10)]
Let op: er zit een stepin het bereik, want zonder deze stap zou dit 10x zo lang hebben geduurd. Ook omdat ik, naar mijn persoonlijke mening, dacht dat het er misschien wat makkelijker uitzag om te lezen.
Merk ook op dat de toetsen in de legenda zijn wat ik probeerde te raden als de meest vitale onderdelen van de implementatie van de functie. Wat betreft welke functie het slechtst of het beste is? De grafiek spreekt voor zich.
Nu dat geregeld is, zijn hier de grafieken.
Ongeordende hashables
(Ingezoomd)
Hashables besteld
(Ingezoomd)
Unhashables besteld
(Ingezoomd)
Antwoord 10
Een andere manier van doen:
>>> seq = [1,2,3,'a', 'a', 1,2]
>> dict.fromkeys(seq).keys()
['a', 1, 2, 3]
Antwoord 11
Eenvoudig en eenvoudig:
myList = [1, 2, 3, 1, 2, 5, 6, 7, 8]
cleanlist = []
[cleanlist.append(x) for x in myList if x not in cleanlist]
Uitgang:
>>> cleanlist
[1, 2, 3, 5, 6, 7, 8]
Antwoord 12
Ik had een dict in mijn lijst, dus ik kon de bovenstaande aanpak niet gebruiken. Ik heb de foutmelding:
TypeError: unhashable type:
Dus als u geeft om Order en / of sommige items zijn ongedwongen . Dan kunt u dit nuttig vinden:
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
Sommigen kunnen beschavingsgegevens overwegen met een bijwerking om niet een goede oplossing te zijn. Hier is een alternatief:
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
Antwoord 13
Zeer late antwoord. Als u niet om de lijstorder geeft, kunt u *arguitbreiding gebruiken met setUniekheid om DUPES, I.E te verwijderen.:
l = [*{*l}]
Antwoord 14
Als u de bestelling wilt behouden en geen externe modules gebruikt, is hier een eenvoudige manier om dit te doen:
>>> 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]
Opmerking: deze methode behoudt de volgorde van verschijnen, dus, zoals hierboven te zien, negen komen na één omdat het de eerste keer was dat het verscheen. Dit is echter hetzelfde resultaat als bij het doen van
from collections import OrderedDict
ulist=list(OrderedDict.fromkeys(l))
maar het is veel korter en werkt sneller.
Dit werkt omdat elke keer dat de functie fromkeyseen nieuwe sleutel probeert te maken, deze, als de waarde al bestaat, deze gewoon zal overschrijven. Dit heeft echter helemaal geen invloed op het woordenboek, omdat fromkeyseen woordenboek maakt waarin alle sleutels de waarde Nonehebben, dus het elimineert op deze manier effectief alle duplicaten.
Antwoord 15
Alle orde-behoudende benaderingen die ik hier tot nu toe heb gezien, gebruiken ofwel naïeve vergelijking (met O(n^2) tijd-complexiteit op zijn best) of zwaargewicht OrderedDicts/set+listcombinaties in die beperkt zijn tot hashbare invoer. Hier is een hash-onafhankelijke O(nlogn)-oplossing:
Updateheeft het argument key, documentatie en Python 3-compatibiliteit toegevoegd.
# 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]]))]
Antwoord 16
U kunt dit ook doen:
>>> 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]
De reden waarom boven de werken is dat indexmethode alleen de eerste index van een element retourneert. Dubbele elementen hebben hogere indices. Raadpleeg hier :
lijst.index (x [, start [, einde]])
Retourneer op nul gebaseerde index in de lijst van
het eerste item waarvan de waarde X is. Verhoogt een waardeerror als er geen is
een dergelijk item.
Antwoord 17
De beste aanpak van het verwijderen van duplicaten uit een lijst is het gebruik van Set () -functie, beschikbaar in Python, opnieuw omzetten dat in lijst
In [2]: some_list = ['a','a','v','v','v','c','c','d']
In [3]: list(set(some_list))
Out[3]: ['a', 'c', 'd', 'v']
Antwoord 18
U kunt setgebruiken om duplicaten te verwijderen:
mylist = list(set(mylist))
Maar let op de resultaten zullen ongeordend zijn. Als dat is een probleem:
mylist.sort()
Antwoord 19
Probeer het gebruik van sets:
import sets
t = sets.Set(['a', 'b', 'c', 'd'])
t1 = sets.Set(['a', 'b', 'c'])
print t | t1
print t - t1
Antwoord 20
Verminder variant met bestellen bewaren:
Stel dat we hebben de lijst:
l = [5, 6, 6, 1, 1, 2, 2, 3, 4]
verkleinen variant (unefficient):
>>> reduce(lambda r, v: v in r and r or r + [v], l, [])
[5, 6, 1, 2, 3, 4]
5 x sneller, maar meer verfijnde
>>> 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]
Uitleg:
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]
Antwoord 21
Nog een betere aanpak zou kunnen zijn,
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]
en de bestelling blijft behouden.
Antwoord 22
U kunt de volgende functie gebruiken:
def rem_dupes(dup_list):
yooneeks = []
for elem in dup_list:
if elem not in yooneeks:
yooneeks.append(elem)
return yooneeks
Voorbeeld:
my_list = ['this','is','a','list','with','dupicates','in', 'the', 'list']
Gebruik:
rem_dupes(my_list)
[‘this’, ‘is’, ‘a’, ‘list’, ‘with’, ‘dupicates’, ‘in’, ‘the’]
Antwoord 23
Er zijn veel andere antwoorden die verschillende manieren suggereren om dit te doen, maar het zijn allemaal batchbewerkingen en sommige verwerpen de oorspronkelijke volgorde. Dat is misschien goed, afhankelijk van wat je nodig hebt, maar als je de waarden wilt herhalen in de volgorde van het eerste exemplaar van elke waarde, en je wilt de duplicaten on-the-fly versus allemaal tegelijk verwijderen, je zou kunnen gebruiken deze generator:
def uniqify(iterable):
seen = set()
for item in iterable:
if item not in seen:
seen.add(item)
yield item
Dit retourneert een generator/iterator, zodat u deze overal kunt gebruiken waar u een iterator kunt gebruiken.
for unique_item in uniqify([1, 2, 3, 4, 3, 2, 4, 5, 6, 7, 6, 8, 8]):
print(unique_item, end=' ')
print()
Uitvoer:
1 2 3 4 5 6 7 8
Als je een listwilt, kun je dit doen:
unique_list = list(uniqify([1, 2, 3, 4, 3, 2, 4, 5, 6, 7, 6, 8, 8]))
print(unique_list)
Uitvoer:
[1, 2, 3, 4, 5, 6, 7, 8]
Antwoord 24
Zonder set
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)
Antwoord 25
de onderstaande code is eenvoudig voor het verwijderen van duplicaat in de lijst
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])
het geeft [1,2,3,4] terug
Antwoord 26
Dit is de snelste pythonische oplossing in vergelijking met andere die in de antwoorden worden vermeld.
Het gebruik van implementatiedetails van kortsluitingsevaluatie maakt het mogelijk om lijstbegrip te gebruiken, wat snel genoeg is. visited.add(item)retourneert altijd Noneals resultaat, wat wordt geëvalueerd als False, dus de rechterkant van orzou altijd het resultaat zijn van zo’n uitdrukking.
Tijd het zelf
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
Antwoord 27
setgebruiken:
a = [0,1,2,3,4,3,3,4]
a = list(set(a))
print a
Gebruik uniek:
import numpy as np
a = [0,1,2,3,4,3,3,4]
a = np.unique(a).tolist()
print a
Antwoord 28
Zeer eenvoudige manier in Python 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]
Antwoord 29
Helaas. De meeste antwoorden hier behouden de volgorde niet of zijn te lang. Hier is een eenvoudig antwoord dat de volgorde behoudt.
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)
Hiermee krijgt u x met verwijderde duplicaten maar met behoud van de bestelling.
Antwoord 30
De magie van Python ingebouwd type
In python is het heel gemakkelijk om de gecompliceerde gevallen op deze manier te verwerken en alleen door het ingebouwde type van python.
Laat me je laten zien hoe het moet!
Methode 1: Algemeen geval
De manier (1 regelcode) om gedupliceerd element in de lijst te verwijderen en toch de sorteervolgorde te behouden
line = [1, 2, 3, 1, 2, 5, 6, 7, 8]
new_line = sorted(set(line), key=line.index) # remove duplicated element
print(new_line)
Je krijgt het resultaat
[1, 2, 3, 5, 6, 7, 8]
Methode 2: Speciaal geval
TypeError: unhashable type: 'list'
Het speciale geval om unhashable (3-regelcodes) te verwerken
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)
Je krijgt het resultaat:
[
['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']
]
Omdat tuple hashable is en u gemakkelijk gegevens tussen lijst en tuple kunt converteren