Zoeken op website

Leer Python-lijstgegevensstructuur - deel 1

Gegevensstructuur is een verzameling gegevenstypen, de relatie daartussen en de functies of bewerkingen die op de gegevens kunnen worden toegepast. Het gegevenstype kan tekenreeks, Geheel getal, Zwevende waarde enzovoort zijn.

Wat is het verschil tussen veranderlijk/onveranderlijk object?
Veranderlijke objecten
  1. Objecten waarvan de status kan worden gewijzigd zodra deze is gemaakt, zoals het toevoegen, bijwerken of verwijderen van elementen.
  2. Lijsten, Woordenboek, Set, bytearray zijn veranderlijke objecttypen in Python.
Onveranderlijke objecten
  1. De objectstatus kan niet worden gewijzigd. Zodra het object is gemaakt, kunnen we geen elementen meer toevoegen, verwijderen of bijwerken.
  2. String, Integer, Tuples en Frozenset zijn enkele van de onveranderlijke objecttypen in Python.
Wat is het verschil tussen homogene/heterogene datastructuur?
  1. Homogene gegevensstructuur – Gegevenselementen zullen van hetzelfde gegevenstype zijn (bijvoorbeeld: Array).
  2. Heterogene gegevensstructuur – Gegevenselementen hoeven niet van hetzelfde gegevenstype te zijn (bijvoorbeeld: lijst, tupels, sets enz...).
Wat zijn primitieve en niet-primitieve gegevenstypen?

Voordat we de functionaliteit van de ingebouwde datastructuur begrijpen, moeten we een paar ingebouwde functies bekijken die zullen worden gebruikt met datastructuurobjecten.

  • dir(obj) – een ingebouwde functie die het attribuut en de methoden retourneert.
  • len(obj) – Geeft de lengte (het aantal items) van een object terug. Het argument kan een reeks zijn (zoals een tekenreeks, bytes, tupel, lijst of bereik) of een verzameling (zoals een woordenboek, set of bevroren set).
  • del – Dit ingebouwde trefwoord wordt gebruikt om een object uit een naamruimte te verwijderen of items uit een object te verwijderen, zoals een lijst, woordenboek, enz.
  • type(obj) – De functie type() retourneert het type van het object of retourneert een nieuw type object op basis van de doorgegeven argumenten.
  • id() – Deze functie retourneert de “identiteit” van een object. Dit is een geheel getal dat gegarandeerd uniek en constant is voor dit object gedurende zijn levensduur.

Nu je enkele belangrijke details hebt gezien, gaan we verder met Python-datastructuren.

Python wordt geleverd met ingebouwde datastructuren en gebruikers kunnen hun eigen datastructuren definiëren. De ingebouwde gegevensstructuur omvat LIST, DICTIONARY, TUPLE en SET. Enkele voorbeelden van door de gebruiker gedefinieerde datastructuren zijn STACK, QUEUES, TREE, HASHMAP, enz...

Mensen die uit andere programmeertalen komen, zullen zeer bekend zijn met een arraytype. Maar in Python komen ze niet zo vaak voor.

Hier lijkt de lijst een beetje op een array, maar met de lijst kunnen we waarden van elk gegevenstype opslaan (heterogeen), terwijl de array alleen gegevens van een bepaald type bevat (int, float enz...). Om array te gebruiken, moet u de array expliciet uit de “array” -module importeren.

In deze serie artikelen over Python gaan we kijken naar wat een datastructuur en de ingebouwde datastructuur van Python is.

LIJST

Lijst is een gegevensstructuur die een verzameling verschillende gegevenstypen is. Wat betekent “verzameling van verschillende gegevenstypen ”? Lijst kan tekenreeksen, gehele getallen, waarden met drijvende komma, geneste lijst enzovoort opslaan.

Lijst objecten zijn “Veranderlijk”, wat betekent dat items die in de lijst zijn gemaakt, kunnen worden geopend, gewijzigd of verwijderd. Lijst ondersteunt indexering. Elk item in de lijsten is toegewezen aan een adres en dat adres kan worden gebruikt om toegang te krijgen tot de specifieke itemwaarde of deze te wijzigen.

  • Maak een lijst
  • Lijst invoegen/toegang verkrijgen/wijzigen
  • Lijst verwijderen

MAAK LIJST

Lijst kan worden gemaakt met vierkante haakjes.

>>> name_empty = []			# Empty list
>>> name = ['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']	# list with string data type
>>> name_int = [1,2,3]			# list with Integer data type
>>> name_mixed = [name_int,name,1,2,3.14]	# list with nested list items.
>>> name_mixed
[[1, 2, 3], ['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will'], 1, 2, 3.14]
>>> name_int
[1, 2, 3]

We kunnen de ingebouwde functie type() gebruiken om het objecttype te controleren.

>>> type(name)

We hebben toegang tot de methoden en attributen van de list instantie met behulp van de functie dir().

>>> dir(name)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

We kunnen het totale aantal items in de lijst achterhalen met behulp van de len() methode.

>>> len(name)

We kunnen een nieuwe lijst maken van een bestaande lijst met behulp van de list.copy() methode.

>>> name_new = name.copy()
>>> name_new
['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']

LIJST INVOEGEN/OPENEN/WIJZIGEN

We kunnen een item op elke positie in een lijst invoegen met behulp van de list.insert(i, x) methode.

>>> name = ['Leo','Matt','Kane','Scott','Petter','Will']
>>> name
['Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name.insert(0,'Tom')	# Insert method takes 2 arguments (Index position, Item)
>>> name
['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']	# Tom is inserted at the 0th position.

We kunnen de list.append(x) methode gebruiken om een enkel item aan de lijst toe te voegen. Hierdoor wordt het item aan het einde van de lijst ingevoegd.

>>> name = []
>>> len(name)
0
>>> name.append('Leo')
>>> name.append('Matt')
>>> name.append('Kane')
>>> print(name)
['Leo', 'Matt', 'Kane']

We kunnen de list.extend() methode gebruiken om meerdere items aan de lijst toe te voegen.

>>> new_name = ['Gowtham','Martin','Luis']
>>> name.extend(new_name)
>>> name
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin', 'Luis']

We kunnen ook de operator '+' gebruiken om twee lijsten te combineren. Beide lijsten kunnen uit verschillende gegevenstypen bestaan.

>>> a = [1,2,3]
>>> b = [2,3,3]
>>> c = a + b
>>> c
[1, 2, 3, 2, 3, 3]
>>> d = ['karthi','kenny']
>>> e = a + d
>>> e
[1, 2, 3, 'karthi', 'kenny']

Zoals reeds vermeld zijn lijstenobjecten veranderlijk. Een lijstitem kan worden gewijzigd door naar de indexpositie te verwijzen en er waarde aan toe te kennen.

>>> name									# Before modified
['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name[0] = 'Karthi'
>>> name									# After Modified
['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']

De lijst ondersteunt zowel positieve als negatieve indexering.

Indexering begint vanaf 0 en negatieve indexering begint vanaf -1.

We hebben toegang tot het lijstitem met behulp van hun indexpositie.

>>> name[0]			# Accessing the List item at index 0
'Leo'
>>> name[1]
'Matt'
>>> name[4]
'Petter'
>>> name[5]
'Will'
>>> name[-1]			# Accessing the list item with negative indexing
'Will'
>>> name[-6]
'Leo'

We kunnen ook slicen gebruiken om toegang te krijgen tot de items in de lijst. Met slicen hebben we toegang tot een reeks items door de start-, eind- en stapparameters te definiëren.

SYNTAX: list[starting position, ending position, Step]

>>> name[0:3]
['Tom', 'Leo', 'Matt']
>>> name[:]
['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name[:4]
['Tom', 'Leo', 'Matt', 'Kane']
>>> name[:-2]
['Tom', 'Leo', 'Matt', 'Kane', 'Scott']
>>> name[:-1]
['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter']
>>> name[:-1:2]
['Tom', 'Matt', 'Scott']

We kunnen het aantal keren dat een gegeven waarde voorkomt vinden met behulp van de list.count(x) methode.

>>> name_int = [1,1,2,3,1]
>>> name_int.count(1)
3

We kunnen de indexpositie van een bepaald item vinden met behulp van de list.index(x[, start[, end]]) methode.

>>> name			# Inserted ‘Will’ at the end of the list. Now we have 2 name ‘Will’.
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will']
>>> name.index('Will)	# Returns the index position of first occurence of x.
0
>>> name.index('Will',2)	# Starting index positon’2’ is given.
7
>>> name.index('Will',2,4)	# Starting and Ending Index position is given. Since there is no 					occurence of ‘Will’ within the given search position it will throw 					Value Error.
Traceback (most recent call last):
File "<stdin>", line 1, in 
ValueError: 'Will' is not in list

We kunnen de list.reverse() methode gebruiken om de items in de lijst om te keren.

>>> name
['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name.reverse()
>>> name
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi']

VERWIJDER LIJST

We kunnen de list.pop(x) methode gebruiken om een item uit een lijst op x positie te verwijderen. Deze functie verwijdert het item uit de lijst en geeft het verwijderde item weer. Als x niet is opgegeven, retourneert de methode pop() het laatste item uit de lijst.

>>> name
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin', 'Luis']
>>> name.pop(0)
'Will'
>>> name
['Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin', 'Luis']
>>> name.pop()
'Luis'

We kunnen ook de list.remove (x) methode gebruiken om het item uit de lijst te verwijderen. Hier neemt x de waarde van het item en genereert een ValueError als x niet in de lijst staat.

>>> name = ['Leo','Matt','Kane','Scott','Petter','Will']
>>> name.remove('Leo')
>>> name
['Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name.remove('Leo')
Traceback (most recent call last):
  File "", line 1, in 
ValueError: list.remove(x): x not in list

We kunnen een lijst leeg maken door de lijstnaam aan vierkante haakjes toe te wijzen of door de list.clear() methode te gebruiken.

>>> name1 = name.copy()
>>> name1
['Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin']
>>> name
['Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin']
>>> name = []			
>>> name
[]
>>> name1.clear()		
>>> name1
[]

In plaats van lijstmethoden te gebruiken om de lijst leeg te maken of een item uit de lijst te verwijderen, kunnen we het ingebouwde trefwoord del gebruiken om deze acties uit te voeren. Met het trefwoord “del” kunt u een lijstobject uit het geheugen verwijderen, een item uit een lijst verwijderen of een item uit een segment verwijderen.

>>> name = ['Leo','Matt','Kane','Scott','Petter','Will']
>>> del name[0]
>>> name
['Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> del name[-3:]
>>> name
['Matt', 'Kane']
>>> del name[:]
>>> name
[]

Ingebouwde id() functie retourneert de “identiteit ” van een object. Dit is een geheel getal dat gegarandeerd uniek en constant is voor dit object gedurende zijn levensduur.

>>> id(name)
139979929658824
>>> del name
>>> id(name)
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'name' is not defined

Opmerking: we hebben de lijstvariabele uit het geheugen verwijderd met behulp van del(), waardoor er een naamfout ontstaat.

help() funtion:

Ingebouwde help function() is erg handig om details te krijgen over een bepaald object of de methoden van dat object.

help(object)
help(object.method)
Samenvatting

Tot nu toe hebben we in dit artikel gezien hoe we een lijstgegevensstructuur kunnen gebruiken om lijstobjecten op te slaan, te openen, te wijzigen en te verwijderen met behulp van de lijstmethoden. We hebben ook enkele ingebouwde functies gezien, zoals id(), dir(), type(), help()< wat zeer effectieve functies zijn. We hebben ook lijstbegrip in Python, wat een beknoptere en leesbare manier biedt om een lijst te maken.