Ky seksion përshkruan se si të gjeneroni një listë të re në Python duke hequr ose nxjerrë elementë dublikatë nga një listë (array).
Detajet e mëposhtme përshkruhen këtu.
- Hiqni elementët e kopjuar dhe krijoni lista të reja
- Mos ruani rendin e listimit origjinal:
set() - Ruan rendin e listimit origjinal:
dict.fromkeys(),sorted() - Vargu dydimensional (lista e listave)
- Mos ruani rendin e listimit origjinal:
- Ekstraktoni elementë dublikatë dhe krijoni një listë të re
- Mos ruani rendin e listimit origjinal
- Ruan rendin e listimit origjinal
- Vargu dydimensional (lista e listave)
I njëjti koncept mund të zbatohet për tuples në vend të listave.
Shihni artikullin e mëposhtëm për
- Nëse dëshironi të përcaktoni nëse një listë ose tuple ka elemente të dyfishta
- Nëse dëshironi të nxirrni elementë që janë të zakonshëm ose jo të zakonshëm midis listimeve të shumta në vend të një listimi të vetëm
Vini re se listat mund të ruajnë lloje të ndryshme të dhënash dhe janë rreptësisht të ndryshme nga grupet. Nëse dëshironi të trajtoni vargje në procese që kërkojnë madhësinë e memories dhe adresat e memories ose përpunimin numerik të të dhënave të mëdha, përdorni grup (bibliotekë standarde) ose NumPy.
Hiqni elementët e kopjuar dhe krijoni lista të reja
Mos ruani rendin e listimit origjinal:set()
Nëse nuk ka nevojë të ruani rendin e listës origjinale, përdorni set(), i cili gjeneron një grup të tipit set.
Lloji i grupit është një lloj i të dhënave që nuk ka elemente të dyfishta. Kur një listë ose një lloj tjetër të dhënash i kalohet set(), vlerat e kopjuara shpërfillen dhe kthehet një objekt i grupit të tipit në të cilin elementë janë vetëm vlerat unike.
Nëse dëshironi ta bëni atë një tuple, përdorni tuple().
l = [3, 3, 2, 1, 5, 1, 4, 2, 3]
print(set(l))
# {1, 2, 3, 4, 5}
print(list(set(l)))
# [1, 2, 3, 4, 5]
Sigurisht, mund të lihet edhe si i vendosur. Shihni artikullin vijues për më shumë informacion mbi grupin e tipit të grupit.
Ruan rendin e listimit origjinal:dict.fromkeys(),sorted()
Nëse dëshironi të ruani rendin e listës origjinale, përdorni metodën e klasës fromkeys() të llojit të fjalorit ose funksionin e integruar sorted().
dict.fromkeys() krijon një objekt të ri fjalori, çelësat e të cilit janë lista, tuple, etj. të specifikuara në argumente. Nëse argumenti i dytë hiqet, vlera është Asnjë.
Meqenëse çelësat e fjalorit nuk kanë elementë dublikatë, vlerat e kopjuara injorohen si në set(). Përveç kësaj, një objekt fjalori mund t’i kalohet si argument list() për të marrë një listë, elementët e së cilës janë çelësat e fjalorit.
print(dict.fromkeys(l))
# {3: None, 2: None, 1: None, 5: None, 4: None}
print(list(dict.fromkeys(l)))
# [3, 2, 1, 5, 4]
Është e garantuar që nga Python 3.7 (CPython është 3.6) që dict.fromkeys() ruan rendin e sekuencës së argumentit. Versionet e mëparshme përdorin funksionin e integruar sorted() si më poshtë.
Specifikoni metodën e listës tuple index() për çelësin e argumentit të renditur, i cili kthen një listë të renditur elementësh.
index() është një metodë që kthen indeksin e vlerës (numrin e elementit në listë), i cili mund të specifikohet si çelësi i sorted() për të renditur listën bazuar në renditjen e listës origjinale. Tasti i argumentit është specifikuar si një objekt i thirrshëm (i thirrshëm), prandaj mos shkruani ().
print(sorted(set(l), key=l.index))
# [3, 2, 1, 5, 4]
Vargu dydimensional (lista e listave)
Për vargjet dy-dimensionale (listat e listave), metoda që përdor set() ose dict.fromkeys() rezulton në një TypeError.
l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]
# l_2d_unique = list(set(l_2d))
# TypeError: unhashable type: 'list'
# l_2d_unique_order = dict.fromkeys(l_2d)
# TypeError: unhashable type: 'list'
Kjo ndodh sepse objektet e pahashueshme si listat nuk mund të jenë elementë të grupit të tipit ose çelësa të tipit dict.
Përcaktoni funksionet e mëposhtme Rendi i listës origjinale ruhet dhe funksionon për listat dhe tuplet njëdimensionale.
def get_unique_list(seq):
seen = []
return [x for x in seq if x not in seen and not seen.append(x)]
print(get_unique_list(l_2d))
# [[1, 1], [0, 1], [0, 0], [1, 0]]
print(get_unique_list(l))
# [3, 2, 1, 5, 4]
Përdoret shënimi i kuptimit të listës.
Këtu, ne përdorim sa vijon
- Nëse X në “X dhe Y” është false në vlerësimin e qarkut të shkurtër të operatorit dhe, atëherë Y nuk vlerësohet (nuk ekzekutohet).
- Metoda append() kthen Asnjë.
Nëse elementet e listës origjinale seq nuk ekzistojnë në të parët, atëherë dhe pas vlerësohen.
shihet.append(x) ekzekutohet dhe elementi shtohet për të parë.
Për shkak se metoda append() kthen None dhe None is False, not seen.append(x) vlerëson në True.
Shprehja e kushtëzuar në shënimin e kuptimit të listës bëhet True dhe shtohet si një element i listës përfundimtare të gjeneruar.
Nëse elementet e listës origjinale seq janë të pranishme në see, atëherë x që nuk shihet është False, dhe shprehja e kushtëzuar për shprehjen e kuptimit të listës është False.
Prandaj, ato nuk shtohen si elemente të listës përfundimtare të gjeneruar.
Një metodë tjetër është vendosja e boshtit të argumentit në funksionin NumPy np.unique(), megjithëse rezultati do të renditet.
Ekstraktoni elementë dublikatë dhe krijoni një listë të re
Mos ruani rendin e listimit origjinal
Për të nxjerrë vetëm elementë dublikatë nga lista origjinale, përdorni collections.Counter().
Kthen një koleksion.Numërues (një nënklasë fjalori) me elementet si çelësa dhe numrin e elementeve si vlera.
import collections
l = [3, 3, 2, 1, 5, 1, 4, 2, 3]
print(collections.Counter(l))
# Counter({3: 3, 2: 2, 1: 2, 5: 1, 4: 1})
Meqenëse është një nënklasë fjalori, artikujt() mund të përdoren për të marrë çelësat dhe vlerat. Mjafton të nxirren çelësa, numri i të cilëve është dy ose më shumë.
print([k for k, v in collections.Counter(l).items() if v > 1])
# [3, 2, 1]
Ruan rendin e listimit origjinal
Siç tregohet në shembullin e mësipërm, që nga Python 3.7, çelësat e koleksioneve. Counter ruajnë rendin e listës origjinale dhe kështu me radhë.
Në versionet e mëparshme, renditja me sorted() është e mjaftueshme, siç është fshirja e elementeve të dublikuara.
print(sorted([k for k, v in collections.Counter(l).items() if v > 1], key=l.index))
# [3, 2, 1]
Nëse dëshironi të nxirrni dublikatë ashtu siç janë, thjesht lini elementë nga lista origjinale me një numër prej dy ose më shumë. Është ruajtur edhe rendi.
cc = collections.Counter(l)
print([x for x in l if cc[x] > 1])
# [3, 3, 2, 1, 1, 2, 3]
Vargu dydimensional (lista e listave)
Për grupet dydimensionale (listat e listave), funksionet e mëposhtme janë të mundshme kur rendi i listës origjinale nuk ruhet dhe kur ruhet, përkatësisht. Ai gjithashtu funksionon për listat njëdimensionale dhe tuples.
l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]
def get_duplicate_list(seq):
seen = []
return [x for x in seq if not seen.append(x) and seen.count(x) == 2]
def get_duplicate_list_order(seq):
seen = []
return [x for x in seq if seq.count(x) > 1 and not seen.append(x) and seen.count(x) == 1]
print(get_duplicate_list(l_2d))
# [[0, 1], [1, 1]]
print(get_duplicate_list_order(l_2d))
# [[1, 1], [0, 1]]
print(get_duplicate_list(l))
# [3, 1, 2]
print(get_duplicate_list_order(l))
# [3, 2, 1]
Nëse dëshironi të nxirrni me dublikatë, lini elementë nga lista origjinale me një numër dy ose më shumë.
print([x for x in l_2d if l_2d.count(x) > 1])
# [[1, 1], [0, 1], [0, 1], [1, 1], [1, 1]]
Vini re se meqenëse kompleksiteti llogaritës i count() është O(n), funksioni i treguar më sipër që ekzekuton në mënyrë të përsëritur count() është shumë joefikas. Mund të ketë një mënyrë më të zgjuar.
Counter është një nënklasë fjalori, kështu që nëse kaloni një listë ose tuple, elementët e së cilës janë lista ose objekte të tjera që nuk mund të hashohen në koleksione. Counter(), do të ndodhë një gabim dhe nuk do të mund ta përdorni.
# print(collections.Counter(l_2d))
# TypeError: unhashable type: 'list'
