Léiert Python Lëscht Datestruktur - Deel 1


Datestruktur ass eng Sammlung vun Datentypen, d'Relatioun tëscht hinnen an d'Funktiounen oder Operatiounen déi op d'Daten applizéiert kënne ginn. Datetyp kann String, Integer, Floating Wäert a sou weider sinn.

  1. Objeten deenen hiren Zoustand geännert ka ginn wann en erstallt ass wéi Elementer derbäisetzen, aktualiséieren oder läschen.
  2. Lëschten, Wierderbuch, Set, Bytearray si mutéierbar Objekttypen am Python.

  1. Objetzoustand kann net geännert ginn. Wann den Objet erstallt ass, kënne mir Elementer net derbäisetzen, ewechhuelen oder aktualiséieren.
  2. String, Integer, Tuples, Frozenset sinn e puer vun den onverännerbaren Objekttypen am Python.

  1. Homogen Datestruktur - Dateelementer wäerte vum selwechten Datetyp sinn (zB: Array).
  2. Heterogen Datenstruktur - Dateelementer kënnen net vum selwechten Datetyp sinn (zB: Lëscht, Tuples, Sets etc ...).

Ier Dir d'Funktionalitéit vun der agebauter Datestruktur versteet, loosst eis e puer agebaute Funktiounen gesinn, déi mat Datenstrukturobjekter benotzt ginn.

  • dir(obj) - eng agebaute Funktioun déi d'Attributer a Methoden zréckginn.
  • len(obj) - Gitt d'Längt (d'Zuel vun den Artikelen) vun engem Objet zréck. D'Argument kann eng Sequenz sinn (wéi e String, Bytes, Tupel, Lëscht oder Range) oder eng Sammlung (wéi e Wierderbuch, Set oder gefruerene Set).
  • del - Dëst agebaute Schlësselwuert gëtt benotzt fir en Objet aus engem Nummraum ze läschen oder Elementer aus engem Objet ze läschen wéi eng Lëscht, Wierderbuch, asw.
  • type(obj) - D'Typ() Funktioun gëtt entweder d'Zort vum Objet zréck oder en neien Typ Objet zréck op Basis vun den Argumenter déi passéiert sinn.
  • id() - Dës Funktioun gëtt d'Identitéit vun engem Objet zréck. Dëst ass eng ganz Zuel déi garantéiert ass eenzegaarteg a konstant fir dësen Objet während senger Liewensdauer.

Elo wéi Dir e puer wichteg Detailer gesinn hutt, loosst eis weidergoen mat Python Datestrukturen.

Python kënnt mat agebauten Datestrukturen souwéi Benotzer kënnen hir eege Datestrukturen definéieren. Déi agebauter Datestruktur enthält LIST, DICTIONARY, TUPLE, a SET. E puer vun de Beispiller fir Benotzerdefinéiert Datestrukturen sinn STACK, QUEUES, TREE, HASHMAP, etc ...

Leit, déi aus anere Programméierungssprooche kommen, si ganz vertraut mat engem Array-Typ. Awer am Python si se net sou heefeg.

Hei ass d'Lëscht ähnlech wéi eng Array awer d'Lëscht erlaabt eis Wäerter vun all Datentyp (Heterogen) ze späicheren, während d'Array nëmmen Daten vu bestëmmten Typ hält (int, float etc ...). Fir Array ze benotzen musst Dir d'Array aus dem Array Modul explizit importéieren.

An dëser Python Serie vun Artikelen wäerte mir kucken wat eng Datestruktur ass a Python agebauter Datestruktur.

Lëscht ass eng Datestruktur déi eng Sammlung vu verschiddenen Datentypen ass. Wat heescht Sammlung vu verschiddenen Datentypen? Lëscht kann Strings, Integers, Floating Point Wäerter, Nested Lëscht a sou weider späicheren.

Lëscht Objete sinn mutable dat heescht Elementer déi an der Lëscht erstallt kënne ginn zougänglech, geännert oder geläscht. Lëscht Ënnerstëtzung Indexéierung. All Element an de Lëschte gëtt un eng Adress zougewisen an déi Adress ka benotzt ginn fir de bestëmmten Elementwäert z'änneren oder z'änneren .

  • Erstellt eng Lëscht
  • Lëscht setzen/Zougäng/änneren
  • Lëscht läschen

Lëscht kann mat véiereckege Klammeren erstallt ginn.

>>> 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]

Mir kënnen inbuilt Typ() Funktioun benotzen fir den Objekttyp ze kontrolléieren.

>>> type(name)

Mir kënnen Zougang zu de Methoden an Attributer vun der Lëscht Instanz benotzt dir() Funktioun.

>>> 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']

Mir kënnen d'Gesamtzuel vun Elementer an der Lëscht erausfannen mat der len() Method.

>>> len(name)

Mir kënnen eng nei Lëscht vun enger existéierender Lëscht erstellen mat der list.copy() Method.

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

Mir kënnen en Element an eng Lëscht op all Positioun aginn mat der list.insert(i, x) Method.

>>> 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.

Mir kënnen d'Method list.append(x) benotzen fir en eenzegen Element an d'Lëscht ze addéieren. Dëst wäert den Artikel um Enn vun der Lëscht setzen.

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

Mir kënnen d'Method list.extend() benotzen fir e puer Elementer op d'Lëscht ze addéieren.

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

Mir kënnen och den + Bedreiwer benotzen fir zwou Lëschten ze kombinéieren. Souwuel d'Lëscht ka vu verschiddenen Datentypen sinn.

>>> 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']

Wéi schonn uginn Lëschten Objete sinn mutable. E Lëschtepunkt kann geännert ginn andeems Dir d'Indexpositioun referéiert an e Wäert dozou zouginn.

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

D'Lëscht ënnerstëtzt souwuel positiv wéi negativ Indexéierung.

Indexéierung fänkt vun 0 un an Negativ Indexéierung fänkt vun -1 un.

Mir kënnen op d'Lëschtartikel zougräifen mat hirer Indexpositioun.

>>> 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'

Mir kënnen och Schnëtt benotze fir Zougang zu den Artikelen an der Lëscht ze kréien. Slicing erlaabt eis Zougang zu enger Rei vun Elementer ze kréien andeems Dir d'Start-, Enn-, Step-Parameteren definéiert.

# 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']

Mir kënnen d'Zuel vun Optriede fir e bestëmmte Wäert mat der list.count(x) Method fannen.

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

Mir kënnen d'Indexpositioun vun engem bestëmmten Element mat der list.index(x[, Start[, Enn]]) Method fannen.

>>> 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

Mir kënnen d'Method list.reverse() benotzen fir d'Elementer an der Lëscht ëmzedréien.

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

Mir kënnen d'Method list.pop(x) benotze fir en Element vun enger Lëscht op der x Positioun ze läschen. Dës Funktioun wäert den Element vun der Lëscht ewechhuelen an de geläscht Element weisen. Wann x net spezifizéiert ass, da gëtt pop() Method de leschten Element vun der Lëscht zréck.

>>> 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'

Mir kënnen och d'Method list.remove (x) benotzen fir den Artikel aus der Lëscht ze läschen. Hei hëlt x de Wäert vum Element a werft en ValueError wann x net an der Lëscht ass.

>>> 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

Mir kënnen eng Lëscht eidel maachen andeems Dir entweder den Numm vun der Lëscht op de Klammern zouginn oder d'Method list.clear() benotzt.

>>> 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
[]

Amplaz Lëschtemethoden ze benotzen fir d'Lëscht eidel ze maachen oder en Element aus der Lëscht ze läschen, kënne mir agebaute Schlësselwuert del benotzen fir dës Aktiounen auszeféieren. De Schlësselwuert del kann e Lëschtobjekt aus der Erënnerung läschen oder en Element aus enger Lëscht läschen oder en Element aus enger Slice läschen.

>>> 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
[]

Gebaut an id() Funktioun gëtt d'Identitéit vun engem Objet zréck. Dëst ass eng ganz Zuel déi garantéiert ass eenzegaarteg a konstant fir dësen Objet während senger Liewensdauer.

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

Bemierkung: Mir hunn d'Lëschtvariabel aus der Erënnerung geläscht mat del(), dofir werft et Nummfehler.

help() funtion:

Gebaut an Hëllef Funktioun() ass ganz nëtzlech fir Detailer iwwer e bestëmmten Objet oder Methode vun deem Objet ze kréien.

help(object)
help(object.method)

Bis elo an dësem Artikel hu mir gesinn wéi mir eng Lëschtdatenstruktur benotze kënnen fir d'Lëscht vun Objeten ze späicheren, z'erreechen, z'änneren, ze läschen andeems Dir d'Lëschtmethoden benotzt. Mir hunn och e puer agebaute Funktiounen gesinn wéi id(), dir(), Typ(), Hëllef() déi ganz effektiv Funktiounen sinn. Mir hunn och Lëschteverständnis am Python deen eng méi präzis a liesbar Manéier bitt fir eng Lëscht ze kreéieren.