Een Set in Python-programmering is een ongeordend verzamelingsgegevenstype dat itereerbaar en veranderlijk is en geen dubbele elementen bevat.
Set wordt weergegeven door { } (waarden tussen accolades)
Het grote voordeel van het gebruik van een set, in tegenstelling tot een lijst , is dat het een sterk geoptimaliseerde methode heeft om te controleren of een specifiek element in de set zit. Dit is gebaseerd op een datastructuur die bekend staat als een hashtabel. Omdat sets ongeordend zijn, kunnen we geen toegang krijgen tot items met behulp van indexen, zoals bij lijsten.
Voorbeeld van Python-sets
Python3
var>=> {>'Geeks'>,>'for'>,>'Geeks'>}> type>(var)> |
>
>
Uitgang:
set>
Tijdcomplexiteit: O(1)
Hulpruimte: O(1)
Type Casting met Python Set-methode
De Python set()-methode wordt gebruikt voor typecasting.
Python3
# typecasting list to set> myset>=> set>([>'a'>,>'b'>,>'c'>])> print>(myset)> # Adding element to the set> myset.add(>'d'>)> print>(myset)> |
>
>
Uitgang:
Python-set is een ongeordend datatype, wat betekent dat we niet kunnen weten in welke volgorde de elementen van de set zijn opgeslagen.
{'c', 'b', 'a'} {'d', 'c', 'b', 'a'}> Tijdcomplexiteit: O(n)
Hulpruimte: O(n)
Controleer uniek en onveranderlijk met Python Set
Python-sets kunnen geen dubbele waarde hebben en als deze eenmaal is gemaakt, kunnen we de waarde ervan niet meer wijzigen.
Python3
# Python program to demonstrate that> # a set cannot have duplicate values> # and we cannot change its items> # a set cannot have duplicate values> myset>=> {>'Geeks'>,>'for'>,>'Geeks'>}> print>(myset)> # values of a set cannot be changed> myset[>1>]>=> 'Hello'> print>(myset)> |
Python-bytes naar string
>
>
Uitgang:
De eerste code legt uit dat de set geen dubbele waarde kan hebben. Elk item daarin heeft een unieke waarde.
De tweede code genereert een fout omdat we geen waarde kunnen toewijzen of wijzigen zodra de set is gemaakt. We kunnen alleen items in de set toevoegen of verwijderen.
{'Geeks', 'for'} TypeError: 'set' object does not support item assignment> Heterogeen element met Python-set
Python-sets kunnen heterogene elementen erin opslaan, dat wil zeggen dat een set een combinatie van string-, integer-, boolean-, enz. datatypes kan opslaan.
Python3
# Python example demonstrate that a set> # can store heterogeneous elements> myset>=> {>'Geeks'>,>'for'>,>10>,>52.7>,>True>}> print>(myset)> |
>
>
Uitgang:
{True, 10, 'Geeks', 52.7, 'for'}> Tijdcomplexiteit: O(n)
Hulpruimte: O(n)
Python Frozen-sets
Bevroren sets in Python zijn onveranderlijke objecten die alleen methoden en operatoren ondersteunen die een resultaat opleveren zonder de bevroren set of sets waarop ze worden toegepast te beïnvloeden. Het kan worden gedaan met de frozenset()-methode in Python.
Hoewel elementen van een set op elk moment kunnen worden gewijzigd, blijven elementen van de bevroren set na het maken hetzelfde.
Als er geen parameters worden doorgegeven, retourneert het een lege frozenset.
Python
# Python program to demonstrate differences> # between normal and frozen set> # Same as {'a', 'b','c'}> normal_set>=> set>([>'a'>,>'b'>,>'c'>])> print>(>'Normal Set'>)> print>(normal_set)> # A frozen set> frozen_set>=> frozenset>([>'e'>,>'f'>,>'g'>])> print>(>'
Frozen Set'>)> print>(frozen_set)> # Uncommenting below line would cause error as> # we are trying to add element to a frozen set> # frozen_set.add('h')> |
>
>
Uitgang:
Normal Set {'a', 'c', 'b'} Frozen Set {'e', 'g', 'f'}> Tijdcomplexiteit: O(n)
Hulpruimte: O(n)
Interne werking van Set
Dit is gebaseerd op een datastructuur die bekend staat als een hashtabel. Als er meerdere waarden aanwezig zijn op dezelfde indexpositie, wordt de waarde aan die indexpositie toegevoegd om een gekoppelde lijst te vormen.
In Python-sets worden geïmplementeerd met behulp van een woordenboek met dummyvariabelen, waarbij sleutelwezens door de leden worden ingesteld met grotere optimalisaties van de tijdscomplexiteit.
Implementatie instellen:
bevat subtekenreeks Java
Sets met talloze bewerkingen op één enkele hashtabel:
Methoden voor sets
Elementen toevoegen aan Python-sets
Het inbrengen in de set gebeurt via de set.add( ) functie, waarbij een geschikte recordwaarde wordt gemaakt om in de hashtabel op te slaan. Hetzelfde als het controleren op een item, d.w.z. gemiddeld O(1). In het ergste geval kan dit echter wel het geval zijn Op) .
Python3
# A Python program to> # demonstrate adding elements> # in a set> # Creating a Set> people>=> {>'Jay'>,>'Idrish'>,>'Archi'>}> print>(>'People:'>, end>=> ' '>)> print>(people)> # This will add Daxit> # in the set> people.add(>'Daxit'>)> # Adding elements to the> # set using iterator> for> i>in> range>(>1>,>6>):> >people.add(i)> print>(>'
Set after adding element:'>, end>=> ' '>)> print>(people)> |
>
>
Uitgang:
People: {'Idrish', 'Archi', 'Jay'} Set after adding element: {1, 2, 3, 4, 5, 'Idrish', 'Archi', 'Jay', 'Daxit'}> Tijdcomplexiteit: O(n)
Hulpruimte: O(n)
Union-bewerking op Python-sets
Twee sets kunnen worden samengevoegd met de functie union() of | exploitant. Beide Hash Table-waarden worden benaderd en doorlopen terwijl er samenvoegbewerkingen op worden uitgevoerd om de elementen te combineren, terwijl duplicaten worden verwijderd. De tijdscomplexiteit hiervan is O(len(s1) + len(s2)) waarbij s1 en s2 twee sets zijn waarvan de vereniging moet worden uitgevoerd.
Python3
# Python Program to> # demonstrate union of> # two sets> people>=> {>'Jay'>,>'Idrish'>,>'Archil'>}> vampires>=> {>'Karan'>,>'Arjun'>}> dracula>=> {>'Deepanshu'>,>'Raju'>}> # Union using union()> # function> population>=> people.union(vampires)> print>(>'Union using union() function'>)> print>(population)> # Union using '|'> # operator> population>=> people|dracula> print>(>'
Union using '|' operator'>)> print>(population)> |
>
>
Uitgang:
Union using union() function {'Karan', 'Idrish', 'Jay', 'Arjun', 'Archil'} Union using '|' operator {'Deepanshu', 'Idrish', 'Jay', 'Raju', 'Archil'}> Tijdcomplexiteit: O(n)
Hulpruimte: O(n)
Snijpuntbewerking op Python Sets
Dit kan gedaan worden via de operator intersection() of &. Gemeenschappelijke elementen zijn geselecteerd. Ze zijn vergelijkbaar met iteratie over de hashlijsten en combineren dezelfde waarden in beide tabellen. De tijdscomplexiteit hiervan is O(min(len(s1), len(s2)) waarbij s1 en s2 twee verzamelingen zijn waarvan de vereniging moet worden uitgevoerd.
Python3
# Python program to> # demonstrate intersection> # of two sets> set1>=> set>()> set2>=> set>()> for> i>in> range>(>5>):> >set1.add(i)> for> i>in> range>(>3>,>9>):> >set2.add(i)> # Intersection using> # intersection() function> set3>=> set1.intersection(set2)> print>(>'Intersection using intersection() function'>)> print>(set3)> # Intersection using> # '&' operator> set3>=> set1 & set2> print>(>'
Intersection using '&' operator'>)> print>(set3)> |
>
>
Uitgang:
Intersection using intersection() function {3, 4} Intersection using '&' operator {3, 4}> Tijdcomplexiteit: O(n)
Hulpruimte: O(n)
Verschillen tussen sets vinden in Python
Om verschillen tussen sets te vinden. Vergelijkbaar met het vinden van verschillen in de gekoppelde lijst. Dit wordt gedaan via de operator Difference() of –. Tijdscomplexiteit van het vinden van verschil s1 – s2 is O(len(s1))
Python3
# Python program to> # demonstrate difference> # of two sets> set1>=> set>()> set2>=> set>()> for> i>in> range>(>5>):> >set1.add(i)> for> i>in> range>(>3>,>9>):> >set2.add(i)> # Difference of two sets> # using difference() function> set3>=> set1.difference(set2)> print>(>' Difference of two sets using difference() function'>)> print>(set3)> # Difference of two sets> # using '-' operator> set3>=> set1>-> set2> print>(>'
Difference of two sets using '-' operator'>)> print>(set3)> |
python chr-functie
>
>
Uitgang:
Difference of two sets using difference() function {0, 1, 2} Difference of two sets using '-' operator {0, 1, 2}> Tijdcomplexiteit: O(n)
Hulpruimte: O(n)
Python-sets wissen
De Set Clear()-methode leegt de hele set.
Python3
# Python program to> # demonstrate clearing> # of set> set1>=> {>1>,>2>,>3>,>4>,>5>,>6>}> print>(>'Initial set'>)> print>(set1)> # This method will remove> # all the elements of the set> set1.clear()> print>(>'
Set after using clear() function'>)> print>(set1)> |
>
>
Uitgang:
Initial set {1, 2, 3, 4, 5, 6} Set after using clear() function set()> Tijdcomplexiteit: O(n)
Hulpruimte: O(n)
Er zijn echter twee grote valkuilen in Python-sets:
- De set bevat geen elementen in een bepaalde volgorde.
- Alleen instanties van onveranderlijke typen kunnen aan een Python-set worden toegevoegd.
Tijdcomplexiteit van sets
| Operatie | Gemiddeld geval | Het slechtste geval | notities |
|---|---|---|---|
| x in s | O(1) | Op) | |
| Unie zit|t | O(len(s)+len(t)) | ||
| Kruispunt s&t | O(min(len(s), len(t)) | O(len(s) * len(t)) | vervang min door max als t geen set is |
| Meerdere kruispunten s1&s2&..&sn | (n-1)*O(l) waarbij l max is(len(s1),..,len(sn)) | ||
| Verschil st | O(slechts(s)) |
Operatoren voor sets
Sets en bevroren sets ondersteunen de volgende operators:
| Exploitanten | Opmerkingen |
|---|---|
| toets s in | controle op insluiting |
| sleutel niet in s | controle op niet-insluiting |
| s1 == s2 | s1 is gelijk aan s2 |
| s1 != s2 | s1 is niet gelijk aan s2 |
| s1 <= s2 | s1 is een deelverzameling van s2 |
| s1 | s1 is de juiste deelverzameling van s2 |
| s1>= s2 | s1 is een superset van s2 |
| s1> s2 | s1 is de juiste superset van s2 |
| s1 | s2 | de vereniging van s1 en s2 |
| s1 & s2 | het snijpunt van s1 en s2 |
| s1 – s2 | de verzameling elementen in s1 maar niet s2 |
| s1ˆs2 | de verzameling elementen in precies één van s1 of s2 |
Recente artikelen over Python Set.