Ang sumusunod ay isang paglalarawan kung paano matukoy kung ang isang listahan (array) ay may mga dobleng elemento (lahat ng mga elemento ay natatangi/natatangi) sa Python, para sa bawat isa sa mga sumusunod na kaso.
- Para sa isang listahan na walang listahan sa elemento
- Para sa mga listahan na may mga listahan ng mga elemento (two-dimensional arrays, listahan ng mga listahan, atbp.)
Tingnan ang sumusunod na artikulo kung paano mag-alis o mag-extract ng mga duplicate na elemento mula sa isang listahan.
Tandaan na ang mga listahan ay maaaring mag-imbak ng iba’t ibang uri ng data at mahigpit na naiiba sa mga array. Kung gusto mong pangasiwaan ang mga array sa mga prosesong nangangailangan ng laki ng memory at mga address ng memory o numerical processing ng malaking data, gumamit ng array (standard library) o NumPy.
Tukuyin kung may mga dobleng elemento sa listahan (kung ang elemento ay walang listahan)
Kung ang elemento ay walang naa-update na bagay tulad ng isang listahan, gamitin ang constructor set() ng set set type.
Ang uri ng hanay ay isang uri ng data na walang mga duplicate na elemento. Kapag ang isang listahan ay ipinasa sa constructor set(), ang mga duplicate na value ay hindi papansinin at isang object ng uri na set na may mga natatanging value lamang habang ibinabalik ang mga elemento.
Ang bilang ng mga elemento sa set na uri ng bagay na ito at ang orihinal na listahan ay nakuha at inihambing gamit ang built-in na function na len().
- Kung pantay ang bilang ng mga elemento, walang mga duplicate na elemento sa orihinal na listahan
- Ang mga duplicate na elemento ay kasama sa orihinal na listahan kung ang bilang ng mga elemento ay iba
Ang mga function na nagbabalik ng false kung walang mga duplicate na elemento at true kung may mga duplicate na elemento ay ang mga sumusunod
def has_duplicates(seq):
return len(seq) != len(set(seq))
l = [0, 1, 2]
print(has_duplicates(l))
# False
l = [0, 1, 1, 2]
print(has_duplicates(l))
# True
Ang halimbawa ay isang listahan, ngunit ang parehong function ay maaaring gamitin sa mga tuple.
Ang mga bagay na nababago (naa-update) gaya ng mga listahan ay hindi maaaring mga elemento ng set ng uri. Samakatuwid, ang mga listahan na may mga listahan bilang mga elemento (two-dimensional arrays, listahan ng mga listahan, atbp.) ay magreresulta sa isang TypeError. Ang countermeasure ay ipinapakita sa ibaba.
l_2d = [[0, 1], [1, 1], [0, 1], [1, 0]]
# print(has_duplicates(l_2d))
# TypeError: unhashable type: 'list'
Tukuyin kung may mga dobleng elemento sa listahan (kung ang elemento ay may listahan)
Sa kaso ng isang listahan na may listahan ng mga elemento (tulad ng isang listahan ng mga listahan), ang mga sumusunod na function ay maaaring gamitin upang matukoy kung mayroong mga dobleng elemento.
def has_duplicates2(seq):
seen = []
unique_list = [x for x in seq if x not in seen and not seen.append(x)]
return len(seq) != len(unique_list)
l_2d = [[0, 0], [0, 1], [1, 1], [1, 0]]
print(has_duplicates2(l_2d))
# False
l_2d = [[0, 0], [0, 1], [1, 1], [1, 1]]
print(has_duplicates2(l_2d))
# True
Sa halip na set(), ang notasyon ng pag-unawa sa listahan ay bumubuo ng isang listahan na ang mga elemento ay mga natatanging halaga lamang, at ang bilang ng mga elemento ay inihambing. Tingnan ang sumusunod na artikulo para sa mga detalye.
Ang function na ito ay may bisa din para sa mga listahan na walang listahan ng mga elemento.
l = [0, 1, 2]
print(has_duplicates2(l))
# False
l = [0, 1, 1, 2]
print(has_duplicates2(l))
# True
Ang halimbawa sa ngayon ay ang pagpapasiya kung ang listahan ng mga elemento ay nadoble (naglalaman ng parehong listahan).
Kung ang mga elemento ng bawat listahan ay magkakapatong ay matutukoy pagkatapos na i-flatte ang orihinal na listahan sa isang dimensyon.
l_2d = [[0, 1], [2, 3]]
print(sum(l_2d, []))
# [0, 1, 2, 3]
print(has_duplicates(sum(l_2d, [])))
# False
l_2d = [[0, 1], [2, 0]]
print(has_duplicates(sum(l_2d, [])))
# True
Dito, ang sum() ay ginagamit upang patagin ang listahan, ngunit ang itertools.chain.from_iterable() ay maaari ding gamitin. Bilang karagdagan, kapag nag-flatte ng isang listahan ng tatlo o higit pang mga dimensyon, kinakailangan upang tukuyin ang isang bagong function.
