Verschillen tussen Python Tuple versus lijst
Python Tuple vs List is de meest gebruikte datastructuur in Python. Ze slaan een verzameling items op, objecten of waarden in een opgegeven volgorde. Ze kunnen items van elk gegevenstype opslaan en dit item is toegankelijk met behulp van de index. Dit zijn de overeenkomsten in lijsten en tupels, maar wat is het verschil?
Het verschil is dat een tuple onveranderlijk is. Dit betekent dat het niet kan worden gewijzigd, gewijzigd of gemanipuleerd. Een tuple wordt meestal precies voor deze eigenschap gebruikt. Een van de vele toepassingen voor Python-tupels is sequentieel uitpakken, waarbij we de geretourneerde gegevens opslaan in een paar opgegeven variabelen. Laten we dit voorbeeld bekijken voor een tuple:
def test ()
retour 1, 2
a, b = test ()
afdrukken (a, b)
Hier hebben we een tuple gebruikt om de waarde van de functie te retourneren en daarom kunnen we deze tijdens het afdrukken van de waarde niet wijzigen.
Een Python Tuple kan er geen haakjes omheen hebben of haakjes als “()” Dit helpt Python een lijst van een tuple te begrijpen. Python-lijst wordt gedefinieerd door vierkante haken. De functionaliteit is vergelijkbaar met hoe een array in andere talen werkt. Voorbeeld:
x = (1, 3, 5, 6, 2, 1, 6) print (x): drukt de volledige lijst af
print (x (0), x (1)): Drukt de lijst af beginnend bij Index 0
Vaak verward vanwege hun gelijkenissen, zijn deze twee structuren aanzienlijk verschillend.
Head to Head-vergelijking tussen Python Tuple vs List (Infographics)
Hieronder vindt u de Top 6-vergelijking Python Tuple vs List 
Belangrijkste verschillen tussen Python Tuple versus lijst
Hieronder staan de lijst met punten, beschrijf de belangrijkste verschillen tussen Python Tuple versus Lijst:
Functionaliteit van operaties
Lijsten hebben een aanvullende ingebouwde functie in vergelijking met tupels. Lijsten en tupels hebben de methoden index () en count () gemeen, maar anders dan deze, hebben lijsten veel functies die alleen specifiek van toepassing zijn op lijsten zoals append (), remove (), clear (), sort (), reverse ( ), enz.
We kunnen de ingebouwde functie dir ((object)) gebruiken om alle functies te vinden die horen bij lijsten en tupels. De output voor een dergelijk commando zou als volgt zijn:
Lijst Object:
('__toevoegen__','__klasse__',
'__Contains__',
'__Delattr__',
'__Delitem__',
'__Dir__',
'__Doc__',
'__Eq__',
'__formaat__',
'__Ge__',
'__Getattribute__',
'__Getitem__',
'__Gt__',
'__Hash__',
'__ik voeg toe__',
'__Imul__',
'__in het__',
'__Init_subclass__',
'__Iter__',
'__Le__',
'__Len__',
'__Lt__',
'__Mul__',
'__Ne__',
'__nieuw__',
'__verminderen__',
'__Reduce_ex__',
'__Repr__',
'__omgekeerd__',
'__Rmul__',
'__Setattr__',
'__Setitem__',
'__De grootte van__',
'__Str__',
'__Subclasshook__',
'Append',
'Doorzichtig',
'kopiëren',
'Tellen',
'uitbreiden',
'inhoudsopgave',
Invoegen,
'knal',
'verwijderen',
'omgekeerde',
'soort')
Tuple-object:
('__toevoegen__','__klasse__',
'__Contains__',
'__Delattr__',
'__Dir__',
'__Doc__',
'__Eq__',
'__formaat__',
'__Ge__',
'__Getattribute__',
'__Getitem__',
'__Getnewargs__',
'__Gt__',
'__Hash__',
'__in het__',
'__Init_subclass__',
'__Iter__',
'__Le__',
'__Len__',
'__Lt__',
'__Mul__',
'__Ne__',
'__nieuw__',
'__verminderen__',
'__Reduce_ex__',
'__Repr__',
'__Rmul__',
'__Setattr__',
'__De grootte van__',
'__Str__',
'__Subclasshook__',
'Tellen',
'inhoudsopgave')
We kunnen zien dat er extra functionaliteiten zijn gekoppeld aan een lijst dan voor een tuple.
Grootte evaluatie
Tuple-bewerkingen zijn kleiner dan die van lijstbewerkingen. Dit maakt de operaties sneller wanneer er een enorm aantal elementen is. Laten we een voorbeeld bekijken om de grootte van de lijst en tuple-elementen te berekenen.
x = (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
y = (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
afdrukken (x = 'x .__ __ sizeof ())
drukken ( 'y =', y .__ __ sizeof ())
Output:
x = 104
y = 120
In dit voorbeeld hebben we een tuple x en een lijst y met hetzelfde aantal items, maar de grootte van de tuple is kleiner dan die van de lijst.
Gevarieerde gebruiksscenario's
Aanvankelijk lijkt het erop dat lijsten altijd in staat zullen zijn om tupels te vervangen, maar dit is niet het geval. We kunnen dit begrijpen om de volgende redenen:
- Wanneer een tuple wordt gebruikt in tegenstelling tot een lijst, geeft dit de kijker een idee dat de aanwezige gegevens wel en niet mogen worden gewijzigd.
- Tuples worden vaak gebruikt om gegevens op te slaan als een woordenboek zonder sleutels.
Voorbeeld:
(('Employee1', 1000), ('Employee2', 1001), ('Employee3', 1002))Tuples kunnen ook worden gebruikt als sleutels in woordenboeken vanwege hun hashtable en onveranderlijke aard. Lijsten zijn hiervoor niet geschikt omdat ze de functie __hash __ () niet aankunnen en van aard zijn.
key_value = (('a', 'b'): 1) #Valid
key_value = (('a', 'b'): 1) #Invalid
- De leesbaarheid is verbeterd, dat wil zeggen dat het lezen van informatie gemakkelijker is wanneer tuples in een lijst worden opgeslagen, in tegenstelling tot wanneer lijsten in een lijst worden opgeslagen. Voorbeeld:
Gebruik van Tuples en Lijsten
We gebruiken een tuple wanneer we weten welke informatie moet worden gegeven en we moeten voorkomen dat de waarden worden gewijzigd, zoals wanneer we inloggegevens voor een website moeten opslaan. Tuples worden ook gebruikt als sleutels voor een woordenboek omdat alleen onveranderlijke waarden kunnen worden gehasht. Daarom kunnen we in dergelijke gevallen geen lijst gebruiken. Als we nog steeds een lijst als sleutel willen gebruiken, moeten we de lijst eerst in een tuple omzetten.
En aan de andere kant kunnen we een lijst gebruiken als we de waarden in de verzameling willen wijzigen, en ook als we niet weten of onze verzameling groot is.
Vergelijkingstabel Python Tuples vs Lists
Hieronder is de bovenste vergelijking tussen Python-tupels versus lijsten
| Kenmerken | lijsten |
tuples |
| Syntaxis | Lijsten worden gedefinieerd door vierkante haken (). | Tuples worden gedefinieerd door haakjes () of helemaal geen haakjes. |
| Veranderlijk versus onveranderlijk | De lijst is van aard veranderlijk, dat wil zeggen dat deze kan worden gewijzigd of gewijzigd nadat deze is gemaakt. | Een tuple is onveranderlijk van aard, dwz het kan niet worden gewijzigd of gewijzigd nadat het is gemaakt. |
| Beschikbare bewerkingen | Ingebouwde functies in lijst zijn meer vergeleken met die in tuple, bijv. Pop (), insert (), etc. | Tuple heeft minder ingebouwde functies. |
| Grootte vergelijking | Lijstbewerkingen zijn groter in vergelijking met tuple-bewerkingen. | Tuple-bewerkingen zijn kleiner van formaat, waardoor het sneller is met veel elementen. |
| Lengte | Lijsten hebben een variabele lengte. | Tupels hebben vaste lengtes. We kunnen de grootte van een bestaande tuple niet wijzigen. |
| Dubbelhartigheid | Lijsten kunnen worden gekopieerd | Tuples kunnen niet worden gekopieerd. |
Conclusie
Dit gaat allemaal over Python Tuples vs Lists. Dus nu we de verschillen tussen python-tupels en lijsten hebben begrepen, zullen we gemakkelijker kunnen beslissen welke van de twee moet worden gebruikt en waar. Daarom kunnen we concluderen dat, hoewel zowel lijsten als tupels belangrijke datastructuren zijn in Python, er opmerkelijke verschillen tussen zijn, met het grote verschil dat lijsten veranderlijk zijn, terwijl tupels dat niet zijn.
Aanbevolen artikel
Dit is een gids geweest voor het verschil tussen Python Tuple vs List. Hier bespreken we ook de belangrijkste verschillen tussen Python Tuple en List met infographics en vergelijkingstabel. U kunt ook de volgende artikelen bekijken voor meer informatie-
- Agile vs Waterfall - Topverschillen
- Digital Ocean vs AWS
- Rook testen versus gezondheidsonderzoek
- Hoe Python te installeren
- Soorten Python-compilers
- Verschillende bewerkingen met betrekking tot Tuples
- Begrip pythonlijst
- Wat is gezondheidstesten en hoe werkt het?