Bepalen of een lijst (array) dubbele elementen heeft in Python

Bedrijf

Hieronder volgt een beschrijving van hoe je in Python kunt bepalen of een lijst (array) dubbele elementen heeft (alle elementen zijn uniek), voor elk van de volgende gevallen.

  • Voor een lijst met geen lijst in het element
  • Voor lijsten met lijsten van elementen (tweedimensionale arrays, lijsten van lijsten, enz.)

Zie het volgende artikel over het verwijderen of extraheren van dubbele elementen uit een lijst.

Merk op dat lijsten verschillende soorten gegevens kunnen opslaan en strikt verschillend zijn van arrays. Als u arrays wilt verwerken in processen die geheugengrootte en geheugenadressen vereisen of numerieke verwerking van grote gegevens, gebruik dan array (standaardbibliotheek) of NumPy.

Bepaal of er dubbele elementen in de lijst zijn (als het element geen lijst heeft)

Indien het element geen actualiseerbaar object heeft, zoals een lijst, gebruik dan de constructor set() van het type set.

Het type set is een gegevenstype dat geen dubbele elementen heeft. Wanneer een lijst wordt doorgegeven aan de constructor set(), worden dubbele waarden genegeerd en wordt een object van het type set teruggegeven met alleen unieke waarden als elementen.

Het aantal elementen in dit set-type object en de oorspronkelijke lijst worden verkregen en vergeleken met behulp van de ingebouwde functie len().

  • Als het aantal elementen gelijk is, zijn er geen dubbele elementen in de oorspronkelijke lijst
  • Dubbele elementen worden opgenomen in de oorspronkelijke lijst als het aantal elementen verschillend is

Functies die fout teruggeven als er geen dubbele elementen zijn en waar als er dubbele elementen zijn, zijn de volgende

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

Het voorbeeld is een lijst, maar dezelfde functie kan gebruikt worden met tupels.

Veranderlijke (bij te werken) objecten zoals lijsten kunnen geen elementen van het type verzameling zijn. Daarom zullen lijsten met lijsten als elementen (tweedimensionale arrays, lijsten van lijsten, enz.) resulteren in een TypeError. De tegenmaatregel wordt hieronder getoond.

l_2d = [[0, 1], [1, 1], [0, 1], [1, 0]]
# print(has_duplicates(l_2d))
# TypeError: unhashable type: 'list'

Bepaal of er dubbele elementen in de lijst zijn (als het element een lijst heeft)

In het geval van een lijst met een lijst van elementen (zoals een lijst van lijsten), kunnen de volgende functies worden gebruikt om te bepalen of er dubbele elementen zijn.

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

In plaats van set(), genereert de list comprehension notatie een lijst waarvan de elementen alleen unieke waarden zijn, en het aantal elementen wordt vergeleken. Zie het volgende artikel voor details.

Deze functie is ook geldig voor lijsten die geen lijst van elementen hebben.

l = [0, 1, 2]
print(has_duplicates2(l))
# False

l = [0, 1, 1, 2]
print(has_duplicates2(l))
# True

Het voorbeeld tot dusver is de bepaling of de lijst van elementen gedupliceerd is (dezelfde lijst bevat).

Of de elementen van elke lijst elkaar overlappen kan worden bepaald na afvlakking van de oorspronkelijke lijst tot één dimensie.

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

Hier wordt sum() gebruikt om de lijst af te vlakken, maar itertools.chain.from_iterable() kan ook worden gebruikt. Bovendien moet voor het afvlakken van een lijst met drie of meer dimensies een nieuwe functie worden gedefinieerd.

Copied title and URL