Website-Suche

Lernen Sie die Datenstruktur der Python-Liste kennen – Teil 1

Datenstruktur ist eine Sammlung von Datentypen, der Beziehung zwischen ihnen und den Funktionen oder Operationen, die auf die Daten angewendet werden können. Der Datentyp kann String, Integer, Floating Value usw. sein.

Was ist der Unterschied zwischen veränderlichem und unveränderlichem Objekt?
Veränderliche Objekte
  1. Objekte, deren Status nach der Erstellung geändert werden kann, z. B. durch Hinzufügen, Aktualisieren oder Löschen von Elementen.
  2. Listen, Wörterbuch, Set und Bytearray sind veränderbare Objekttypen in Python.
Unveränderliche Objekte
  1. Der Objektstatus kann nicht geändert werden. Sobald das Objekt erstellt wurde, können wir keine Elemente mehr hinzufügen, entfernen oder aktualisieren.
  2. String, Integer, Tuples und Frozenset sind einige der unveränderlichen Objekttypen in Python.
Was ist der Unterschied zwischen homogener/heterogener Datenstruktur?
  1. Homogene Datenstruktur – Datenelemente haben denselben Datentyp (z. B. Array).
  2. Heterogene Datenstruktur – Datenelemente dürfen nicht vom gleichen Datentyp sein (z. B. Liste, Tupel, Mengen usw.).
Was sind primitive und nicht-primitive Datentypen?

Bevor wir die Funktionalität der integrierten Datenstruktur verstehen, sehen wir uns einige integrierte Funktionen an, die mit Datenstrukturobjekten verwendet werden.

  • dir(obj) – eine integrierte Funktion, die das Attribut und die Methoden zurückgibt.
  • len(obj) – Gibt die Länge (die Anzahl der Elemente) eines Objekts zurück. Das Argument kann eine Sequenz (z. B. eine Zeichenfolge, Bytes, ein Tupel, eine Liste oder ein Bereich) oder eine Sammlung (z. B. ein Wörterbuch, eine Menge oder eine eingefrorene Menge) sein.
  • del – Dieses integrierte Schlüsselwort wird verwendet, um ein Objekt aus einem Namespace zu löschen oder Elemente aus einem Objekt wie einer Liste, einem Wörterbuch usw. zu entfernen.
  • type(obj) – Die Funktion type() gibt entweder den Typ des Objekts oder ein neues Typobjekt basierend auf den übergebenen Argumenten zurück.
  • id() – Diese Funktion gibt die „Identität“ eines Objekts zurück. Dies ist eine Ganzzahl, die für dieses Objekt während seiner Lebensdauer garantiert eindeutig und konstant ist.

Nachdem Sie nun einige wichtige Details gesehen haben, fahren wir mit den Python-Datenstrukturen fort.

Python verfügt über integrierte Datenstrukturen und Benutzer können ihre eigenen Datenstrukturen definieren. Die integrierte Datenstruktur umfasst LIST, DICTIONARY, TUPLE und SET. Einige Beispiele für benutzerdefinierte Datenstrukturen sind STACK, QUEUES, TREE, HASHMAP usw.

Leute, die aus anderen Programmiersprachen kommen, werden mit einem Array-Typ sehr vertraut sein. Aber in Python sind sie nicht so häufig.

Hier ähnelt die Liste einem Array, aber die Liste ermöglicht es uns, Werte jedes Datentyps (heterogen) zu speichern, während das Array nur Daten eines bestimmten Typs (int, float usw.) enthält. Um ein Array zu verwenden, müssen Sie das Array explizit aus dem Modul „array“ importieren.

In dieser Python-Artikelserie werden wir uns mit einer Datenstruktur und einer in Python integrierten Datenstruktur befassen.

AUFFÜHREN

Liste ist eine Datenstruktur, die eine Sammlung verschiedener Datentypen darstellt. Was bedeutet „Erhebung verschiedener Datentypen? Liste kann Zeichenfolgen, Ganzzahlen, Gleitkommawerte, verschachtelte Listen usw. speichern.

Listenobjekte sind „veränderlich“, was bedeutet, dass auf in der Liste erstellte Elemente zugegriffen, diese geändert oder gelöscht werden können. Listenunterstützungsindizierung. Jedem Element in den Listen ist eine Adresse zugewiesen, und diese Adresse kann verwendet werden, um auf den jeweiligen Elementwert zuzugreifen oder ihn zu ändern.

  • Erstelle eine Liste
  • Liste einfügen/zugreifen/ändern
  • Liste löschen

ERSTELLE LISTE

Eine Liste kann mit eckigen Klammern erstellt werden.

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

Wir können die integrierte Funktion type() verwenden, um den Objekttyp zu überprüfen.

>>> type(name)

Mit der Funktion dir() können wir auf die Methoden und Attribute der list-Instanz zugreifen.

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

Mit der Methode len() können wir die Gesamtzahl der Elemente in der Liste ermitteln.

>>> len(name)

Mit der Methode list.copy() können wir eine neue Liste aus einer vorhandenen Liste erstellen.

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

LISTE EINFÜGEN/ZUGRIFFEN/ÄNDERN

Mit der Methode list.insert(i, x) können wir ein Element an jeder Position in eine Liste einfügen.

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

Wir können die Methode list.append(x) verwenden, um ein einzelnes Element an die Liste anzuhängen. Dadurch wird das Element am Ende der Liste eingefügt.

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

Wir können die Methode list.extend() verwenden, um mehrere Elemente zur Liste hinzuzufügen.

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

Wir können auch den Operator '+' verwenden, um zwei Listen zu kombinieren. Beide Listen können unterschiedliche Datentypen haben.

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

Wie bereits erwähnt, sind Objekte veränderbar. Ein Listenelement kann geändert werden, indem die Indexposition referenziert und ihr ein Wert zugewiesen wird.

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

Die Liste unterstützt sowohl positive als auch negative Indizierung.

Die Indizierung beginnt bei 0 und die negative Indizierung beginnt bei -1.

Wir können über ihre Indexposition auf das Listenelement zugreifen.

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

Wir können auch Slicing verwenden, um auf die Elemente in der Liste zuzugreifen. Durch das Slicing können wir auf eine Reihe von Elementen zugreifen, indem wir die Start-, End- und Schrittparameter definieren.

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

Mit der Methode list.count(x) können wir die Häufigkeit des Vorkommens eines bestimmten Werts ermitteln.

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

Mit der Methode list.index(x[, start[, end]]) können wir die Indexposition eines bestimmten Elements ermitteln.

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

Wir können die Methode list.reverse() verwenden, um die Elemente in der Liste umzukehren.

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

LISTE LÖSCHEN

Wir können die Methode list.pop(x) verwenden, um ein Element an der Position x aus einer Liste zu entfernen. Diese Funktion entfernt das Element aus der Liste und zeigt das entfernte Element an. Wenn x nicht angegeben ist, gibt die Methode pop() das letzte Element aus der Liste zurü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'

Wir können auch die Methode list.remove (x) verwenden, um das Element aus der Liste zu entfernen. Hier nimmt x den Wert des Elements und löst einen ValueError aus, wenn x nicht in der Liste enthalten ist.

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

Wir können eine Liste leer machen, indem wir entweder den Listennamen in eckige Klammern setzen oder die Methode list.clear() verwenden.

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

Anstatt Listenmethoden zu verwenden, um die Liste zu leeren oder ein Element aus der Liste zu entfernen, können wir das integrierte Schlüsselwort del verwenden, um diese Aktionen auszuführen. Das Schlüsselwort „del“ kann ein Listenobjekt aus dem Speicher oder ein Element aus einer Liste oder ein Element aus einem 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
[]

Die integrierte Funktion id() gibt die „Identität“ eines Objekts zurück. Dies ist eine Ganzzahl, die für dieses Objekt während seiner Lebensdauer garantiert eindeutig und konstant ist.

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

Hinweis: Wir haben die Listenvariable mit del() aus dem Speicher entfernt, daher wird ein Namensfehler ausgegeben.

help() funtion:

Die integrierte Hilfe function() ist sehr nützlich, um Details zu einem bestimmten Objekt oder Methoden dieses Objekts abzurufen.

help(object)
help(object.method)
Zusammenfassung

Bisher haben wir in diesem Artikel gesehen, wie wir eine Listendatenstruktur verwenden können, um Listenobjekte mithilfe der Listenmethoden zu speichern, darauf zuzugreifen, sie zu ändern und zu löschen. Wir haben auch einige integrierte Funktionen wie id(), dir(), type(), help()< gesehen Das sind sehr effektive Funktionen. Wir haben auch Listenverständnis in Python, das eine prägnantere und lesbarere Möglichkeit zum Erstellen einer Liste bietet.