Ricerca nel sito web

Impara la struttura dei dati dell'elenco Python - Parte 1


La struttura dei dati è una raccolta di tipi di dati, la relazione tra loro e le funzioni o operazioni che possono essere applicate ai dati. Il tipo di dati può essere stringa, intero, valore mobile e così via.

Qual è la differenza tra oggetto mutabile/immutabile?
Oggetti mutevoli
  1. Oggetti il cui stato può essere modificato una volta creato, ad esempio aggiungendo, aggiornando o eliminando elementi.
  2. Elenchi, dizionario, set e bytearray sono tipi di oggetti mutabili in Python.
Oggetti immutabili
  1. Lo stato dell'oggetto non può essere modificato. Una volta creato l'oggetto, non possiamo aggiungere, rimuovere o aggiornare elementi.
  2. String, Integer, Tuples, Frozenset sono alcuni dei tipi di oggetti immutabili in Python.
Qual è la differenza tra struttura dati omogenea/eterogenea?
  1. Struttura dati omogenea: gli elementi dati saranno dello stesso tipo di dati (es: Array).
  2. Struttura dati eterogenea – Gli elementi dati potrebbero non essere dello stesso tipo di dati (es: elenco, tuple, insiemi ecc…).
Cosa sono i tipi di dati primitivi e non primitivi?

Prima di comprendere la funzionalità della struttura dati integrata, vediamo alcune funzioni integrate che verranno utilizzate con gli oggetti della struttura dati.

  • dir(obj) – una funzione integrata che restituirà l'attributo e i metodi.
  • len(obj) – Restituisce la lunghezza (il numero di elementi) di un oggetto. L'argomento può essere una sequenza (come una stringa, byte, una tupla, una lista o un intervallo) o una raccolta (come un dizionario, un insieme o un insieme congelato).
  • del – Questa parola chiave incorporata viene utilizzata per eliminare un oggetto da uno spazio dei nomi o rimuovere elementi da un oggetto come un elenco, un dizionario, ecc.
  • type(obj) – La funzione type() restituisce il tipo dell'oggetto o restituisce un nuovo oggetto di tipo in base agli argomenti passati.
  • id() – Questa funzione restituisce l'“identità” di un oggetto. Si tratta di un numero intero che è garantito come univoco e costante per questo oggetto durante la sua vita.

Ora che hai visto alcuni dettagli importanti, procediamo con le strutture dati Python.

Python viene fornito con strutture dati integrate e gli utenti possono definire le proprie strutture dati. La struttura dei dati incorporata include LIST, DICTIONARY, TUPLE e SET. Alcuni esempi di strutture dati definite dall'utente sono STACK, QUEUES, TREE, HASHMAP, ecc...

Le persone che provengono da altri linguaggi di programmazione avranno molta familiarità con il tipo di array. Ma in Python non sono così comuni.

Qui l'elenco è simile a un array ma l'elenco ci consente di memorizzare valori di qualsiasi tipo di dati (eterogeneo) mentre l'array conterrà solo dati di tipo particolare (int, float ecc…). Per utilizzare l'array è necessario importare esplicitamente l'array dal modulo “array”.

In questa serie di articoli su Python, esamineremo cos'è una struttura dati e la struttura dati incorporata in Python.

ELENCO

Elenco è una struttura dati che è una raccolta di diversi tipi di dati. Cosa significa "raccolta di diversi tipi di dati"? L'elenco può memorizzare stringhe, numeri interi, valori in virgola mobile, elenchi nidificati e così via.

Gli oggetti Elenco sono "Mutabili", il che significa che è possibile accedere, modificare o eliminare gli elementi creati all'interno dell'elenco. L'elenco supporta l'indicizzazione. A ogni elemento negli elenchi viene assegnato un indirizzo e tale indirizzo può essere utilizzato per accedere o modificare il valore dell'elemento specifico.

  • Crea un elenco
  • Inserisci/Accedi/Modifica elenco
  • Elimina elenco

CREA LISTA

L'elenco può essere creato utilizzando parentesi quadre.

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

Possiamo usare la funzione incorporata type() per verificare il tipo di oggetto.

>>> type(name)

Possiamo accedere ai metodi e agli attributi dell'istanza list utilizzando la funzione 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']

Possiamo scoprire il numero totale di elementi nell'elenco utilizzando il metodo len().

>>> len(name)

Possiamo creare un nuovo elenco da un elenco esistente utilizzando il metodo list.copy().

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

INSERIMENTO/ACCESSO/MODIFICA LISTA

Possiamo inserire un elemento in un elenco in qualsiasi posizione utilizzando il metodo list.insert(i, x).

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

Possiamo usare il metodo list.append(x) per aggiungere un singolo elemento all'elenco. Questo inserirà l'elemento alla fine dell'elenco.

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

Possiamo usare il metodo list.extend() per aggiungere più elementi all'elenco.

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

Possiamo anche usare l'operatore '+' per combinare due elenchi. Entrambi gli elenchi possono contenere tipi di dati diversi.

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

Come già affermato, gli oggetti delle liste sono mutabili. Un elemento dell'elenco può essere modificato facendo riferimento alla posizione dell'indice e assegnandogli un valore.

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

L'elenco supporta sia l'indicizzazione positiva che quella negativa.

L'indicizzazione inizia da 0 e l'indicizzazione negativa inizia da -1.

Possiamo accedere all'elemento dell'elenco utilizzando la loro posizione nell'indice.

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

Possiamo anche utilizzare lo slicing per accedere agli elementi nell'elenco. L'affettamento ci consente di accedere a una serie di elementi definendo i parametri di inizio, fine e passaggio.

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

Possiamo trovare il numero di occorrenze per un dato valore utilizzando il metodo list.count(x).

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

Possiamo trovare la posizione dell'indice di un determinato elemento utilizzando il metodo list.index(x[, start[, end]]).

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

Possiamo usare il metodo list.reverse() per invertire gli elementi nell'elenco.

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

ELIMINA LISTA

Possiamo usare il metodo list.pop(x) per rimuovere un elemento da un elenco nella posizione x. Questa funzione rimuoverà l'elemento dall'elenco e visualizzerà l'elemento rimosso. Se x non è specificato, il metodo pop() restituirà l'ultimo elemento dall'elenco.

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

Possiamo anche usare il metodo list.remove (x) per rimuovere l'elemento dall'elenco. Qui x prende il valore dell'elemento e genera un ValueError se x non è nell'elenco.

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

Possiamo rendere vuota una lista assegnando il nome della lista tra parentesi quadre o utilizzando il metodo list.clear().

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

Invece di utilizzare metodi di elenco per rendere l'elenco vuoto o rimuovere un elemento dall'elenco, possiamo utilizzare la parola chiave incorporata del per eseguire queste azioni. La parola chiave “del” può eliminare un oggetto dell'elenco dalla memoria o eliminare un elemento da un elenco o eliminare un elemento da una sezione.

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

La funzione id() incorporata restituisce l'“identità” di un oggetto. Si tratta di un numero intero che è garantito come unico e costante per questo oggetto durante la sua vita.

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

Nota: abbiamo rimosso la variabile di lista dalla memoria usando del(), quindi genera un errore di nome.

help() funtion:

L'aiuto integrato function() è molto utile per ottenere dettagli su un particolare oggetto o metodi di quell'oggetto.

help(object)
help(object.method)
Riepilogo

Finora in questo articolo, abbiamo visto come possiamo utilizzare una struttura dati elenco per archiviare, accedere, modificare ed eliminare oggetti elenco utilizzando i metodi elenco. Abbiamo anche visto alcune funzioni integrate come id(), dir(), type(), help()< che sono funzioni molto efficaci. Abbiamo anche la comprensione delle liste in Python che fornisce un modo più conciso e leggibile per creare una lista.