Ontvang unieke waarden uit een lijst in python

Ik wil de unieke waarden uit de volgende lijst halen:

['nowplaying', 'PBS', 'PBS', 'nowplaying', 'job', 'debate', 'thenandnow']

De uitvoer die ik nodig heb is:

['nowplaying', 'PBS', 'job', 'debate', 'thenandnow']

Deze code werkt:

output = []
for x in trends:
    if x not in output:
        output.append(x)
print(output)

is er een betere oplossing die ik zou moeten gebruiken?

---

Antwoord 1, autoriteit 100%

Declareer eerst je lijst correct, gescheiden door komma’s. U kunt de unieke waarden verkrijgen door de lijst naar een set te converteren.

mylist = ['nowplaying', 'PBS', 'PBS', 'nowplaying', 'job', 'debate', 'thenandnow']
myset = set(mylist)
print(myset)

Als je het verder als een lijst gebruikt, moet je het terug naar een lijst converteren door het volgende te doen:

mynewlist = list(myset)

Een andere mogelijkheid, waarschijnlijk sneller, is om vanaf het begin een set te gebruiken in plaats van een lijst. Dan zou je code moeten zijn:

output = set()
for x in trends:
    output.add(x)
print(output)

Zoals is opgemerkt, behouden sets de oorspronkelijke volgorde niet. Als je dat nodig hebt, zoek dan naar een bestelde set implementatie (zie deze vraag voor meer).

---

Antwoord 2, autoriteit 31%

Om consistent te zijn met het type dat ik zou gebruiken:

mylist = list(set(mylist))

---

Antwoord 3, autoriteit 13%

Als we de elementen op volgorde moeten houden, wat dacht je van dit:

used = set()
mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = [x for x in mylist if x not in used and (used.add(x) or True)]

En nog een oplossing met reduce en zonder de tijdelijke used var.

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = reduce(lambda l, x: l.append(x) or l if x not in l else l, mylist, [])

UPDATE – Dec, 2020 – Misschien wel de beste aanpak!

Vanaf python 3.7, het standaard dict behoudt de invoegvolgorde.

Gewijzigd in versie 3.7: Woordenboekvolgorde is gegarandeerd invoegvolgorde. Dit gedrag was een implementatiedetail van CPython uit 3.6.

Dit geeft ons dus de mogelijkheid om dict.from_keys te gebruiken voor de-duplicatie!

OPMERKING: Credits gaan naar @rlat voor het geven van deze aanpak in de opmerkingen!

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = list(dict.fromkeys(mylist))

In termen van snelheid – voor mij is het snel genoeg en leesbaar genoeg om mijn nieuwe favoriete aanpak te worden!

UPDATE – maart 2019

En een derde oplossing, wat een nette oplossing is, maar een beetje traag omdat .index O(n) is.

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = [x for i, x in enumerate(mylist) if i == mylist.index(x)]

UPDATE – okt 2016

Een andere oplossing met reduce, maar deze keer zonder .append waardoor het voor mensen leesbaarder en gemakkelijker te begrijpen is.

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = reduce(lambda l, x: l+[x] if x not in l else l, mylist, [])
#which can also be writed as:
unique = reduce(lambda l, x: l if x in l else l+[x], mylist, [])

OPMERKING: Houd er rekening mee dat het script beter leesbaar voor mensen wordt, en slechter presteert. Behalve alleen voor de dict.from_keys-aanpak die specifiek is voor Python 3.7+.

import timeit
setup = "mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']"
#10x to Michael for pointing out that we can get faster with set()
timeit.timeit('[x for x in mylist if x not in used and (used.add(x) or True)]', setup='used = set();'+setup)
0.2029558869980974
timeit.timeit('[x for x in mylist if x not in used and (used.append(x) or True)]', setup='used = [];'+setup)
0.28999493700030143
# 10x to rlat for suggesting this approach!   
timeit.timeit('list(dict.fromkeys(mylist))', setup=setup)
0.31227896199925453
timeit.timeit('reduce(lambda l, x: l.append(x) or l if x not in l else l, mylist, [])', setup='from functools import reduce;'+setup)
0.7149233570016804
timeit.timeit('reduce(lambda l, x: l+[x] if x not in l else l, mylist, [])', setup='from functools import reduce;'+setup)
0.7379565160008497
timeit.timeit('reduce(lambda l, x: l if x in l else l+[x], mylist, [])', setup='from functools import reduce;'+setup)
0.7400134069976048
timeit.timeit('[x for i, x in enumerate(mylist) if i == mylist.index(x)]', setup=setup)
0.9154880290006986

OPMERKINGEN BEANTWOORDEN

Omdat @monica een goede vraag stelde over “hoe werkt dit?”. Voor iedereen die er moeite mee heeft om het uit te zoeken. Ik zal proberen een meer diepgaande uitleg te geven over hoe dit werkt en welke tovenarij hier gebeurt 😉

Dus vroeg ze eerst:

Ik probeer te begrijpen waarom unique = [used.append(x) for x in mylist if x not in used] niet werkt.

Nou, het werkt echt

>>> used = []
>>> mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
>>> unique = [used.append(x) for x in mylist if x not in used]
>>> print used
[u'nowplaying', u'PBS', u'job', u'debate', u'thenandnow']
>>> print unique
[None, None, None, None, None]

Het probleem is dat we gewoon niet de gewenste resultaten krijgen binnen de unique variabele, maar alleen binnen de used variabele. Dit komt omdat tijdens het lijstbegrip .append de used-variabele wijzigt en None retourneert.

Dus om de resultaten in de unique variabele te krijgen en nog steeds dezelfde logica te gebruiken met .append(x) if x not in used, moeten we verplaats deze .append-aanroep naar de rechterkant van het lijstbegrip en retourneer gewoon x aan de linkerkant.

Maar als we te naïef zijn en gewoon gaan met:

>>> unique = [x for x in mylist if x not in used and used.append(x)]
>>> print unique
[]

We krijgen er niets voor terug.

Nogmaals, dit komt omdat de methode .append None retourneert, en dit geeft op onze logische uitdrukking het volgende uiterlijk:

x not in used and None

Dit zal in principe altijd:

1. evalueert tot False wanneer x in used staat,
2. evalueert tot None wanneer x niet in used is.

En in beide gevallen (False/None), wordt dit behandeld als falsy waarde en krijgen we een lege lijst als een resultaat.

Maar waarom evalueert dit tot None wanneer x niet in used is? Iemand kan het vragen.

Nou, het is omdat dit is hoe Python’s kort -circuit operators werken.

De uitdrukking x and y evalueert eerst x; als x onwaar is, is de waarde ervan
geretourneerd; anders wordt y geëvalueerd en is de resulterende waarde
teruggestuurd.

Dus wanneer x niet in gebruik is (dwz wanneer het True) is, wordt het volgende deel of de uitdrukking geëvalueerd ( used.append(x)) en de waarde (None) worden geretourneerd.

Maar dat is wat we willen om de unieke elementen uit een lijst met duplicaten te halen, we willen ze alleen .append in een nieuwe lijst als we ze voor de eerste keer tegenkomen.

Dus we willen used.append(x) alleen evalueren als x niet in used staat, misschien als er een manier is om deze None waarde om te zetten in een truthy waarde, komt het wel goed, toch?

Nou ja, en hier komt het tweede type short-circuit operators om de hoek kijken.

De uitdrukking x or y evalueert eerst x; als x waar is, is de waarde ervan
geretourneerd; anders wordt y geëvalueerd en is de resulterende waarde
teruggestuurd.

We weten dat .append(x) altijd falsy zal zijn, dus als we er één or naast hem toevoegen, zullen we krijg altijd het volgende deel. Daarom schrijven we:

x not in used and (used.append(x) or True)

zodat we evalueren used.append(x) en als resultaat True krijgen, alleen wanneer het eerste deel van de uitdrukking (x not in used) is True.

Vergelijkbare mode is te zien in de 2e benadering met de reduce-methode.

(l.append(x) or l) if x not in l else l
#similar as the above, but maybe more readable
#we return l unchanged when x is in l
#we append x to l and return l when x is not in l
l if x in l else (l.append(x) or l)

waar we:

1. Voeg x toe aan l en retourneer die l wanneer x niet in l. Dankzij de or-instructie wordt .append geëvalueerd en wordt l daarna geretourneerd.
2. Retourneer l onaangeroerd wanneer x zich in l

bevindt

---

Antwoord 4, autoriteit 8%

Een Python-lijst:

>>> a = ['a', 'b', 'c', 'd', 'b']

Om unieke items te krijgen, verandert u deze in een set (die u indien nodig weer in een lijst kunt omzetten):

>>> b = set(a)
>>> print(b)
{'b', 'c', 'd', 'a'}

---

Antwoord 5, autoriteit 8%

Wat voor type is uw uitvoervariabele?

Python sets zijn wat je nodig hebt. Declareer uitvoer als volgt:

output = set()  # initialize an empty set

en je bent klaar om elementen toe te voegen met output.add(elem) en er zeker van te zijn dat ze uniek zijn.

Waarschuwing: sets behouden NIET de oorspronkelijke volgorde van de lijst.

---

Antwoord 6, autoriteit 5%

Opties om duplicaten te verwijderen kunnen de volgende generieke gegevensstructuren omvatten:

• set: ongeordende, unieke elementen
• bestelde set: bestelde, unieke elementen

Hier is een samenvatting om snel een van beide in Python te krijgen.

Gegeven

from collections import OrderedDict
seq = [u"nowplaying", u"PBS", u"PBS", u"nowplaying", u"job", u"debate", u"thenandnow"]

Code

Optie 1 – Een set (ongeordend):

list(set(seq))
# ['thenandnow', 'PBS', 'debate', 'job', 'nowplaying']

Optie 2 – Python heeft geen bestelde sets, maar hier zijn enkele manieren om er een na te bootsen (invoeging besteld):

list(OrderedDict.fromkeys(seq))
# ['nowplaying', 'PBS', 'job', 'debate', 'thenandnow']

list(dict.fromkeys(seq))                               # py36
# ['nowplaying', 'PBS', 'job', 'debate', 'thenandnow']

De laatste optie wordt aanbevolen bij gebruik van Python 3.6+. Bekijk meer details in deze post.

Opmerking: vermelde elementen moeten hashable zijn. Zie details over het laatste voorbeeld in deze blog plaatsen. Zie verder de post van R. Hettinger over dezelfde techniek; het ordebehoud is een uitbreiding van een van zijn vroege implementaties. Zie ook meer over totale bestelling.

---

Antwoord 7, autoriteit 4%

Orde handhaven:

# oneliners
# slow -> . --- 14.417 seconds ---
[x for i, x in enumerate(array) if x not in array[0:i]]
# fast -> . --- 0.0378 seconds ---
[x for i, x in enumerate(array) if array.index(x) == i]
# multiple lines
# fastest -> --- 0.012 seconds ---
uniq = []
[uniq.append(x) for x in array if x not in uniq]
uniq

Bestelling maakt niet uit:

# fastest-est -> --- 0.0035 seconds ---
list(set(array))

---

Antwoord 8, autoriteit 2%

Unieke elementen uit de lijst halen

mylist = [1,2,3,4,5,6,6,7,7,8,8,9,9,10]

Eenvoudige logica gebruiken uit sets – sets zijn een unieke lijst met items

mylist=list(set(mylist))
In [0]: mylist
Out[0]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Eenvoudige logica gebruiken

newList=[]
for i in mylist:
    if i not in newList:
        newList.append(i)
In [0]: mylist
Out[0]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Pop-methode gebruiken
->pop verwijdert het laatste of geïndexeerde item en toont dat aan de gebruiker. video

k=0
while k < len(mylist):
    if mylist[k] in mylist[k+1:]:
        mylist.pop(mylist[k])
    else:
        k=k+1
In [0]: mylist
Out[0]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Numpy gebruiken

import numpy as np
np.unique(mylist)
In [0]: mylist
Out[0]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Referentie

---

Antwoord 9

Als je numpy gebruikt in je code (wat een goede keuze kan zijn voor grotere hoeveelheden gegevens), bekijk dan numpy.unique:

>>> import numpy as np
>>> wordsList = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
>>> np.unique(wordsList)
array([u'PBS', u'debate', u'job', u'nowplaying', u'thenandnow'], 
      dtype='<U10')

(http://docs.scipy.org/doc /numpy/reference/generated/numpy.unique.html)

Zoals je kunt zien, ondersteunt numpy niet alleen numerieke gegevens, maar zijn ook stringarrays mogelijk. Het resultaat is natuurlijk een numpy-array, maar dat maakt niet veel uit, omdat het zich nog steeds als een reeks gedraagt:

>>> for word in np.unique(wordsList):
...     print word
... 
PBS
debate
job
nowplaying
thenandnow

Als je echt een vanillepythonlijst terug wilt hebben, kun je list() altijd aanroepen.

Het resultaat wordt echter automatisch gesorteerd, zoals u kunt zien aan de hand van de bovenstaande codefragmenten. Bekijk numpy unique zonder sort als het behouden van de lijstvolgorde vereist is.

---

Antwoord 10

set – ongeordende verzameling unieke elementen. Lijst met elementen kan worden doorgegeven aan de constructor van de set. Dus geef een lijst door met dubbele elementen, we worden ingesteld met unieke elementen en transformeren deze terug naar een lijst en krijgen vervolgens een lijst met unieke elementen. Ik kan niets zeggen over prestaties en geheugenoverhead, maar ik hoop dat het niet zo belangrijk is met kleine lijsten.

list(set(my_not_unique_list))

Eenvoudig en kort.

---

Antwoord 11

Dezelfde volgorde unieke lijst met alleen een lijstcompressie.

> my_list = [1, 2, 1, 3, 2, 4, 3, 5, 4, 3, 2, 3, 1]
> unique_list = [
>    e
>    for i, e in enumerate(my_list)
>    if my_list.index(e) == i
> ]
> unique_list
[1, 2, 3, 4, 5]

enumerates geeft de index i en element e als een tuple.

my_list.index retourneert de eerste index van e. Als de eerste index niet i is, dan is de e van de huidige iteratie niet de eerste e in de lijst.

Bewerken

Ik moet er rekening mee houden dat dit qua prestaties geen goede manier is om het te doen. Dit is slechts een manier om dit te bereiken met alleen een lijstcompressie.

---

Antwoord 12

Als een bonus, Counter is een eenvoudige manier om zowel de unieke waarden als het aantal voor elke waarde te krijgen:

from collections import Counter
l = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
c = Counter(l)

---

Antwoord 13

Door de basiseigenschap van Python Dictionary te gebruiken:

inp=[u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
d={i for i in inp}
print d

Uitvoer zal zijn:

set([u'nowplaying', u'job', u'debate', u'PBS', u'thenandnow'])

---

Antwoord 14

Ten eerste, het voorbeeld dat je gaf is geen geldige lijst.

example_list = [u'nowplaying',u'PBS', u'PBS', u'nowplaying', u'job', u'debate',u'thenandnow']

Stel dat bovenstaande de voorbeeldlijst is. Vervolgens kunt u het volgende recept gebruiken om het itertools-voorbeelddocument te geven dat de unieke waarden kan retourneren en de volgorde kan behouden zoals u lijkt te vereisen. De iterabele hier is de example_list

from itertools import ifilterfalse
def unique_everseen(iterable, key=None):
    "List unique elements, preserving order. Remember all elements ever seen."
    # unique_everseen('AAAABBBCCDAABBB') --> A B C D
    # unique_everseen('ABBCcAD', str.lower) --> A B C D
    seen = set()
    seen_add = seen.add
    if key is None:
        for element in ifilterfalse(seen.__contains__, iterable):
            seen_add(element)
            yield element
    else:
        for element in iterable:
            k = key(element)
            if k not in seen:
                seen_add(k)
                yield element

---

Antwoord 15

def get_distinct(original_list):
    distinct_list = []
    for each in original_list:
        if each not in distinct_list:
            distinct_list.append(each)
    return distinct_list

---

Antwoord 16

set kan u helpen de elementen uit de lijst te filteren die duplicaten zijn. Het werkt goed voor str, int of tuple elementen, maar als uw lijst dict of andere list elementen, dan krijg je TypeError uitzonderingen.

Hier is een algemene oplossing voor het bewaren van bestellingen voor sommige (niet alle) niet-hashbare typen:

def unique_elements(iterable):
    seen = set()
    result = []
    for element in iterable:
        hashed = element
        if isinstance(element, dict):
            hashed = tuple(sorted(element.iteritems()))
        elif isinstance(element, list):
            hashed = tuple(element)
        if hashed not in seen:
            result.append(element)
            seen.add(hashed)
    return result

---

Antwoord 17

Gebruik onderstaande code om unieke waarden uit uw lijst te krijgen:

trends = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
output = set(trends)
output = list(output)

BELANGRIJK:
Bovenstaande aanpak werkt niet als een van de items in een lijst niet hashable wat het geval is voor veranderlijke typen, bijvoorbeeld list of dict.

trends = [{'super':u'nowplaying'}, u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
output = set(trends)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  TypeError: unhashable type: 'dict'

Dat betekent dat je er zeker van moet zijn dat de trends-lijst altijd alleen hashbare items bevat, anders moet je meer geavanceerde code gebruiken:

from copy import deepcopy
try:
    trends = [{'super':u'nowplaying'}, [u'PBS',], [u'PBS',], u'nowplaying', u'job', u'debate', u'thenandnow', {'super':u'nowplaying'}]
    output = set(trends)
    output = list(output)
except TypeError:
    trends_copy = deepcopy(trends)
    while trends_copy:
        trend = trends_copy.pop()
        if trends_copy.count(trend) == 0:
            output.append(trend)
print output

---

Antwoord 18

Als u unieke elementen uit een lijst wilt halen en hun oorspronkelijke volgorde wilt behouden, kunt u OrderedDict gegevensstructuur uit de standaardbibliotheek van Python:

from collections import OrderedDict
def keep_unique(elements):
    return list(OrderedDict.fromkeys(elements).keys())
elements = [2, 1, 4, 2, 1, 1, 5, 3, 1, 1]
required_output = [2, 1, 4, 5, 3]
assert keep_unique(elements) == required_output

Als je Python gebruikt? 3.6, daar kun je gewoon dict voor gebruiken:

def keep_unique(elements):
    return list(dict.fromkeys(elements).keys())

Het is mogelijk geworden na de introductie van “compacte” weergave van dictaten. Bekijk het hier. Hoewel dit “een implementatiedetail werd beschouwd en er niet op mag worden vertrouwd”.

---

Antwoord 19

Het verbaast me dat niemand tot nu toe een direct orderbehoudend antwoord heeft gegeven:

def unique(sequence):
    """Generate unique items from sequence in the order of first occurrence."""
    seen = set()
    for value in sequence:
        if value in seen:
            continue
        seen.add(value)
        yield value

Het genereert de waarden zodat het werkt met meer dan alleen lijsten, b.v. unique(range(10)). Om een ​​lijst te krijgen, roept u gewoon list(unique(sequence)) aan, zoals dit:

>>> list(unique([u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']))
[u'nowplaying', u'PBS', u'job', u'debate', u'thenandnow']

Het heeft de vereiste dat elk item hashable is en niet alleen vergelijkbaar, maar de meeste dingen in Python zijn en het is O(n) en niet O(n^2), dus werkt prima met een lange lijst.

---

Antwoord 20

Naast de vorige antwoorden, waarin staat dat je je lijst kunt converteren naar een set, kun je dat ook op deze manier doen

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenadnow']
mylist = [i for i in set(mylist)]

uitvoer zal zijn

[u'nowplaying', u'job', u'debate', u'PBS', u'thenadnow']

hoewel de volgorde niet behouden blijft.

Een ander eenvoudiger antwoord zou kunnen zijn (zonder sets te gebruiken)

>>> t = [v for i,v in enumerate(mylist) if mylist.index(v) == i]
[u'nowplaying', u'PBS', u'job', u'debate', u'thenadnow']

---

Antwoord 21

def setlist(lst=[]):
   return list(set(lst))

---

Antwoord 22

Je kunt sets gebruiken. Voor de duidelijkheid, ik leg uit wat het verschil is tussen een lijst en een set.
sets zijn een ongeordende verzameling van unieke elementen. Lijsten zijn een geordende verzameling van elementen.
Dus,

    unicode_list=[u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job',u'debate', u'thenandnow']
    list_unique=list(set(unicode_list))
    print list_unique
[u'nowplaying', u'job', u'debate', u'PBS', u'thenandnow']

Maar: gebruik list/set niet bij het benoemen van de variabelen. Het zal een fout veroorzaken:
EX: in plaats van lijst te gebruiken in plaats van unicode_list in de bovenstaande.

list=[u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job',u'debate', u'thenandnow']
        list_unique=list(set(list))
        print list_unique
    list_unique=list(set(list))
TypeError: 'list' object is not callable

---

Antwoord 23

Set is een verzameling van ongeordende en unieke elementen. U kunt dus de onderstaande set gebruiken om een ​​unieke lijst te krijgen:

unique_list = list(set([u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']))

---

Antwoord 24

1. Verklaar aan het begin van uw code uw uitvoerlijst als leeg: output=[]
2. In plaats van uw code kunt u deze code gebruiken trends=list(set(trends))

---

Antwoord 25

Mijn oplossing om de inhoud te controleren op uniciteit, maar de oorspronkelijke volgorde te behouden:

def getUnique(self):
    notunique = self.readLines()
    unique = []
    for line in notunique: # Loop over content
        append = True # Will be set to false if line matches existing line
        for existing in unique:
            if line == existing: # Line exists ? do not append and go to the next line
                append = False
                break # Already know file is unique, break loop
        if append: unique.append(line) # Line not found? add to list
    return unique

Bewerken:
Waarschijnlijk kan het efficiënter zijn door woordenboeksleutels te gebruiken om te controleren op het bestaan ​​in plaats van een hele bestandslus voor elke regel te maken, ik zou mijn oplossing niet gebruiken voor grote sets.

---

Antwoord 26

gebruik set om een ​​lijst te dedupliceren, terug te keren als lijst

def get_unique_list(lst):
        if isinstance(lst,list):
            return list(set(lst))

---

Antwoord 27

Ik weet dat dit een oude vraag is, maar hier is mijn unieke oplossing: klasse-overerving!:

class UniqueList(list):
    def appendunique(self,item):
        if item not in self:
            self.append(item)
            return True
        return False

Als u items op een unieke manier aan een lijst wilt toevoegen, roept u appendunique op een UniqueList aan. Omdat het van een lijst erft, werkt het in feite als een lijst, dus je kunt functies gebruiken zoals index() enz. En omdat het waar of onwaar retourneert, kun je erachter komen of het toevoegen is geslaagd (uniek item) of mislukt (reeds in de lijst).

Om een ​​unieke lijst met items uit een lijst te krijgen, gebruikt u een for-lus om items toe te voegen aan een UniqueList (kopieer vervolgens naar de lijst).

Voorbeeld gebruikscode:

unique = UniqueList()
for each in [1,2,2,3,3,4]:
    if unique.appendunique(each):
        print 'Uniquely appended ' + str(each)
    else:
        print 'Already contains ' + str(each)

Afdrukken:

Uniquely appended 1
Uniquely appended 2
Already contains 2
Uniquely appended 3
Already contains 3
Uniquely appended 4

Kopiëren naar lijst:

unique = UniqueList()
for each in [1,2,2,3,3,4]:
    unique.appendunique(each)
newlist = unique[:]
print newlist

Afdrukken:

[1, 2, 3, 4]

---

Antwoord 28

Voor lange arrays

s = np.empty(len(var))
s[:] = np.nan
for  x in  set(var):
    x_positions = np.where(var==x)
    s[x_positions[0][0]]=x
sorted_var=s[~np.isnan(s)]

---

Antwoord 29

Probeer deze functie, het is vergelijkbaar met uw code, maar het is een dynamisch bereik.

def unique(a):
    k=0
    while k < len(a):
        if a[k] in a[k+1:]:
            a.pop(k)
        else:
            k=k+1
    return a

---

Antwoord 30

Gebruik de volgende functie:

def uniquefy_list(input_list):
"""
This function  takes a list as input and return a list containing only unique elements from the input list
"""
output_list=[]
for elm123 in input_list:
    in_both_lists=0
    for elm234 in output_list:
        if elm123 == elm234:
            in_both_lists=1
            break
    if in_both_lists == 0:
        output_list.append(elm123)
return output_list