En Set in Python-programmering är en oordnad insamlingsdatatyp som är itererbar, föränderlig och har inga dubbletter av element.
Uppsättningen representeras av { } (värden omslutna av hängslen)
Den stora fördelen med att använda en uppsättning, i motsats till en lista , är att den har en mycket optimerad metod för att kontrollera om ett specifikt element finns i uppsättningen. Detta är baserat på en datastruktur som kallas en hashtabell. Eftersom uppsättningar är oordnade kan vi inte komma åt objekt med hjälp av index som vi gör i listor.
Exempel på Python-uppsättningar
Python3
var>=> {>'Geeks'>,>'for'>,>'Geeks'>}> type>(var)> |
osi modelllager
>
>
Produktion:
set>
Tidskomplexitet: O(1)
Hjälputrymme: O(1)
Skriv Casting med Python Set-metoden
Metoden Python set() används för typcasting.
Python3
# typecasting list to set> myset>=> set>([>'a'>,>'b'>,>'c'>])> print>(myset)> # Adding element to the set> myset.add(>'d'>)> print>(myset)> |
>
>
Produktion:
Python-uppsättning är en oordnad datatyp, vilket innebär att vi inte kan veta i vilken ordning elementen i uppsättningen är lagrade.
{'c', 'b', 'a'} {'d', 'c', 'b', 'a'}> Tidskomplexitet: O(n)
Hjälputrymme: O(n)
Kontrollera unik och oföränderlig med Python Set
Python-uppsättningar kan inte ha ett duplikatvärde och när det väl har skapats kan vi inte ändra dess värde.
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)> |
>
>
Produktion:
Den första koden förklarar att uppsättningen inte kan ha ett duplikatvärde. Varje föremål i den har ett unikt värde.
Den andra koden genererar ett fel eftersom vi inte kan tilldela eller ändra ett värde när uppsättningen väl har skapats. Vi kan bara lägga till eller ta bort objekt i uppsättningen.
{'Geeks', 'for'} TypeError: 'set' object does not support item assignment> Heterogent element med Python Set
Python-uppsättningar kan lagra heterogena element i den, det vill säga en uppsättning kan lagra en blandning av sträng-, heltals-, booleska, etc datatyper.
Python3
# Python example demonstrate that a set> # can store heterogeneous elements> myset>=> {>'Geeks'>,>'for'>,>10>,>52.7>,>True>}> print>(myset)> |
>
>
Produktion:
{True, 10, 'Geeks', 52.7, 'for'}> Tidskomplexitet: O(n)
Hjälputrymme: O(n)
Python frysta set
Frysta set i Python är oföränderliga objekt som endast stöder metoder och operatorer som producerar ett resultat utan att påverka den frysta uppsättningen eller uppsättningarna som de tillämpas på. Det kan göras med metoden frozenset() i Python.
Även om element i en uppsättning kan ändras när som helst, förblir element i den frysta uppsättningen desamma efter att de skapats.
Om inga parametrar skickas, returnerar den en tom frusen uppsättning.
Pytonorm
# 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')> |
>
>
Produktion:
Normal Set {'a', 'c', 'b'} Frozen Set {'e', 'g', 'f'}> Tidskomplexitet: O(n)
Hjälputrymme: O(n)
Internt arbete av Set
Detta är baserat på en datastruktur som kallas en hashtabell. Om flera värden finns på samma indexposition, läggs värdet till den indexpositionen för att bilda en länkad lista.
I, Python Sets implementeras med hjälp av en ordbok med dummyvariabler, där nyckelväsen medlemmarna ställer in med större optimeringar av tidskomplexiteten.
Set Implementering:
Uppsättningar med många operationer på en enda hashtabell:
Metoder för set
Lägga till element till Python-uppsättningar
Insättning i setet görs genom set.add( ) funktion, där ett lämpligt postvärde skapas för att lagra i hashtabellen. Samma som att kontrollera efter en vara, dvs O(1) i genomsnitt. Men i värsta fall kan det bli På) .
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)> |
>
>
bfs-sökning
Produktion:
People: {'Idrish', 'Archi', 'Jay'} Set after adding element: {1, 2, 3, 4, 5, 'Idrish', 'Archi', 'Jay', 'Daxit'}> Tidskomplexitet: O(n)
Hjälputrymme: O(n)
Unionsdrift på Python-set
Två uppsättningar kan slås samman med funktionen union() eller | operatör. Båda Hash-tabellvärdena nås och korsas med sammanfogningsoperation utför på dem för att kombinera elementen, samtidigt tas dubbletter bort. Tidskomplexiteten i detta är O(len(s1) + len(s2)) där s1 och s2 är två uppsättningar vars förening måste göras.
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)> |
>
>
Produktion:
Union using union() function {'Karan', 'Idrish', 'Jay', 'Arjun', 'Archil'} Union using '|' operator {'Deepanshu', 'Idrish', 'Jay', 'Raju', 'Archil'}> Tidskomplexitet: O(n)
Hjälputrymme: O(n)
Korsningsoperation på Python-uppsättningar
Detta kan göras genom intersection() eller & operator. Gemensamma element väljs. De liknar iteration över Hash-listorna och kombinerar samma värden på båda tabellen. Tidskomplexiteten för detta är O(min(len(s1), len(s2)) där s1 och s2 är två uppsättningar vars förening måste göras.
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)> |
>
>
Produktion:
Intersection using intersection() function {3, 4} Intersection using '&' operator {3, 4}> Tidskomplexitet: O(n)
Hjälputrymme: O(n)
är lika med metod i java
Hitta skillnader mellan uppsättningar i Python
För att hitta skillnader mellan uppsättningar. Liknar att hitta skillnader i den länkade listan. Detta görs genom operatorn different() eller –. Tidskomplexiteten för att hitta skillnaden s1 – s2 är 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)> |
>
>
Produktion:
Difference of two sets using difference() function {0, 1, 2} Difference of two sets using '-' operator {0, 1, 2}> Tidskomplexitet: O(n)
Hjälputrymme: O(n)
Rensa Python-uppsättningar
Set Clear()-metoden tömmer hela uppsättningen på plats.
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)> |
>
>
Produktion:
Initial set {1, 2, 3, 4, 5, 6} Set after using clear() function set()> Tidskomplexitet: O(n)
Hjälputrymme: O(n)
Det finns dock två stora fallgropar i Python-uppsättningar:
- Uppsättningen upprätthåller inte element i någon speciell ordning.
- Endast instanser av oföränderliga typer kan läggas till i en Python-uppsättning.
Tidskomplexitet för uppsättningar
| Drift | Genomsnittligt fall | Värsta fall | anteckningar |
|---|---|---|---|
| x i s | O(1) | På) | |
| Union s|t | O(len(s)+len(t)) | ||
| Korsning s&t | O(min(len(s), len(t)) | O(len(s) * len(t)) | ersätt min med max om t inte är en uppsättning |
| Multipelkorsning s1&s2&..&sn | (n-1)*O(l) där l är max(len(s1),..,len(sn)) | ||
| Skillnad s-t | O(endast(s)) |
Operatörer för set
Set och frysta set stöder följande operatörer:
| Operatörer | Anteckningar |
|---|---|
| knappa in s | kontroll av inneslutning |
| nyckel inte i s | icke-inneslutningskontroll |
| s1 == s2 | s1 är ekvivalent med s2 |
| s1 != s2 | s1 är inte ekvivalent med s2 |
| s1 <= s2 | s1 är en delmängd av s2 |
| s1 | s1 är korrekt delmängd av s2 |
| s1>= s2 | s1 är superset av s2 |
| s1> s2 | s1 är en riktig superset av s2 |
| s1 | s2 | föreningen av s1 och s2 |
| s1 & s2 | skärningspunkten mellan s1 och s2 |
| s1 – s2 | uppsättningen element i s1 men inte s2 |
| s1 ˆ s2 | uppsättningen element i exakt ett av s1 eller s2 |
Nya artiklar om Python Set.