python list create
In questo tutorial su Python List, esploreremo i modi per creare, accedere, sezionare, aggiungere / eliminare elementi a elenchi Python che sono probabilmente uno dei tipi di dati più utili:
Python include 4 tipi di dati di raccolta come indicato di seguito:
- Elenco
- Impostato
- Dizionario
- Tupla
In questo tutorial, discuteremo in dettaglio di List e delle sue varie operazioni. In Python, list è una struttura di dati o è proprio come un array che viene utilizzato per memorizzare più dati contemporaneamente.
=> Esplora la serie di formazione Python qui
Se hai esperienza in altri linguaggi di programmazione come Java, C, C ++ ecc., Allora avrai familiarità con il concetto di array. L'elenco è quasi lo stesso degli array.
Cosa imparerai:
- Cosa sono gli elenchi di Python
- Ulteriori informazioni sugli elenchi in Python
- Conclusione
Cosa sono gli elenchi di Python
In Python, una lista è un file tipo di dati , che memorizza una raccolta di diversi oggetti (elementi) all'interno di una parentesi quadra (()). Ogni elemento in un elenco è separato da una virgola (,) con il primo elemento all'indice 0.
Nota :Andando avanti, tutti gli esempi in questo tutorial verranno eseguiti direttamente da una shell Python, se non diversamente specificato.
Di seguito è riportato un esempio di un elenco con 5 elementi.
>>> l = ('what','who','where','when','how') >>>l ('what','who','where','when','how')
Nell'esempio sopra, possiamo vedere che l'elenco ha Oggetti stringa come elementi e ogni elemento è separato da una virgola.
Caratteristiche dell'elenco di Python
Prima di esaminare come possiamo manipolare gli elementi in un elenco, diamo un'occhiata ad alcune delle caratteristiche che rendono gli elenchi Python preferiti.
Gli elenchi Python sono sequenze di contenitori
A differenza delle sequenze piatte ( corda , array.array , memoryview , ecc.) che può contenere solo elementi di un tipo, un elenco è un file sequenza del contenitore che può contenere elementi di un tipo o di tipi diversi.
Esempio con articoli di un tipo
Apriamo la nostra shell Python e definiamo un elenco di numeri.
>>> numbers = ('one','two','three','four','five') >>> numbers ('one','two','three','four','five')
L'esempio sopra mostra un elenco di elementi dello stesso tipo, in questo caso di tipo stringa (str) .
Esempio con articoli di diverso tipo
Apriamo la nostra shell Python e definiamo un'altra versione di un elenco di numeri.
>>> numbers = ('one',2,3,'four',5.0) >>> numbers ('one',2,3,'four',5.0)
L'esempio sopra mostra un elenco di elementi di diversi tipi. I tipi sono corda , numero intero, e galleggiante .
// a sketch showing the list of items and their types as annotation
L'elenco Python può contenere anche tutti gli oggetti come funzioni , classi , moduli , elenchi , tuple, e altro ancora.
Apri un editor e incolla il codice seguente:
def test(): '''This is a function''' print('This is a test') if __name__ == '__main__': print(test) # return instance object of function 'test' instance = type(test) print(instance) # create a list of colors colors = ('red','blue','green') print(colors) # create a list holding all the various data types defined above, including boolean. my_list = (test, instance, colors, False) print(my_list)
Produzione
Gli elenchi Python sono sequenze ordinate
Un elenco Python è una raccolta ordinata di oggetti. La posizione di ogni elemento in un elenco è molto importante. Infatti, due liste con gli stessi articoli non sono uguali se l'ordine in cui sono posizionati gli articoli non è lo stesso.
>>> ('a','b','c','d') == ('a','c','b','d') False
Questa caratteristica dell'elenco Python rende possibile accedere ai suoi elementi tramite indice e affettatura (ne parleremo più avanti).
Gli elenchi di Python sono sequenze mutevoli
Gli elenchi di Python sono mutevoli. Ma cos'è un oggetto mutevole? È semplicemente un oggetto che può essere modificato dopo essere stato creato. Esempi di altre sequenze mutabili sono dizionario , array.array , collections.deque .
Perché mutevole? Le sequenze come gli elenchi vengono utilizzate per operazioni complesse, quindi ha senso che siano in grado di farlo modificare , crescere , ridursi , aggiornamento, ecc . Questo è possibile solo con la mutabilità. La mutevolezza ci consente anche di modificare gli elenchi in atto (di più su questo).
Verifichiamo la mutabilità di un elenco con l'esempio seguente.
Basta aprire un editor e incollare il codice:
def veryfiy_mutability(): # create a list l = (9,0,4,3,5) print('Display before modifying') print('List: {}
Id: {}'.format(l,id(l))) # modify the list by replacing the item at # index 3 to the item -2. l(3) = -2 print('Display after modifying') print('List: {}
Id: {}'.format(l,id(l))) if __name__ == '__main__': veryfiy_mutability()
Produzione
Dall'output sopra, notiamo che l'elenco prima e dopo la modifica è diverso. comunque, il Id il valore è lo stesso. Il Id il valore qui rappresenta l'indirizzo dell'oggetto in memoria, ottenuto con Python id () .
Questo ci dice che, sebbene il contenuto dell'elenco sia cambiato, è sempre lo stesso oggetto. Quindi, questo soddisfa la nostra definizione: ' È semplicemente un oggetto che può essere modificato dopo essere stato creato '
Nota :Nell'esempio sopra, abbiamo usato l'indicizzazione (più su questo) per modificare l'elenco.
Manipolazione degli elenchi di Python
Con gli elenchi Python, il cielo è il nostro limite. Ci sono innumerevoli cose che possiamo fare con elenchi come aggiungendo , eliminazione , indicizzazione , affettare , verifica dell'adesione , e altro ancora. Inoltre, Python ha funzioni incorporate che aiutano a rendere più eccitante la manipolazione degli elenchi.
In questa sezione, esamineremo alcune operazioni sugli elenchi di uso comune.
Creazione di un elenco
Per creare un elenco, è sufficiente inserire un numero di elementi o espressioni in una parentesi quadra separata da virgole.
(expression1, expression2,...,expresionN)
>>> l = (4,3,5,9+3,False) >>> l (4, 3, 5, 12, False)
Inoltre, Python ha un oggetto incorporato chiamato elenco () che può essere utilizzato per creare elenchi.
list( sequence )
>>> l = list() # create an empty list >>> l ()
Pitone elenco () può accettare tipi di sequenza e convertirli in elenchi. Questo è il modo tipico di convertire una tupla in una lista.
>>> t = (4,3,5) # tuple >>>l = list(t) # convert into list (4,3,5)
Nell'esempio sopra, abbiamo utilizzato il tipo di dati Tupla . È simile a un elenco ma, a differenza degli elenchi, è immutabile e i suoi elementi sono racchiusi tra parentesi.
Un altro mezzo con cui possiamo creare un elenco è usare elenchi di comprensioni che ha la seguente sintassi.
(expression for item in sequence)
>>> (i**2 for i in range(4)) (0, 1, 4, 9)
Vale la pena notare che gli elenchi Python vengono passati per riferimento. Ciò significa che l'assegnazione di un elenco fornirà la sua identità di posizione di memoria. L'errore che fanno molti neofiti è creare elenchi in questo modo.
>>> l1 = l2 = (4,3) # wrong way to create separate list objects >>> l1 (4,3) >>> l2 (4,3)
Qui, potremmo pensare di aver creato due elenchi diversi, ma in realtà ne abbiamo appena creato uno. Dimostriamolo modificando una delle variabili.
>>> l1(0) = 0 >>> l1 (0,3) >>> l2 (0,3)
Notiamo che modificando una variabile cambia l'altra. Questo perché entrambe le variabili l1 e l2 hanno la stessa identità di locazione di memoria, quindi puntano entrambe allo stesso oggetto.
Aggiunta di elementi a un elenco
Python ha molti modi per aggiungere elementi al suo elenco. Il modo più comune è usare il aggiungere() metodo. Gli altri modi sono usando il estendere() metodo. Indicizzazione e affettare (ne parleremo più avanti) sono più probabilmente utilizzati per sostituire gli elementi in un elenco.
# 1) Utilizzo del metodo append ()
Questo metodo accetta un singolo elemento e lo aggiunge alla fine dell'elenco. Non restituisce un nuovo elenco ma modifica semplicemente l'elenco in posizione (grazie alla sua mutabilità).
>>>l = list() # create empty list >>> l () >>> l.append(4) # add an integer >>> l (4) >>> l.append((0,1)) # add a list >>> l (4, (0, 1)) >>> l.append(4 >> l (4, (0, 1), True) >>> l.append(x for x in range(3)) # add result of a tuple comprehension >>> l (4, (0, 1), True, )
Poche cose da notare dall'esempio sopra:
- Gli elementi qui possono essere espressioni, tipi di dati, sequenze e molti altri.
- Il aggiungere() ha una complessità temporale di (0) 1. Significa che è costante.
# 2) Utilizzo del metodo extent ()
Questo metodo accetta un iterabile come argomento e aggiunge tutti gli elementi da esso alla fine dell'elenco. Questo metodo viene utilizzato principalmente quando vogliamo aggiungere singoli elementi di una sequenza in un elenco
Fondamentalmente, il estendere() itera sul proprio argomento e aggiunge ogni elemento all'elenco. Proprio come il metodo append (), non restituisce un nuovo elenco ma modifica l'elenco in posizione.
>>> l1 = (3,2,5) # create a list of items >>> l1 (3, 2, 5) >>> l2 = (0,0,-1) # create a second list of items >>> l2 (0, 0, -1) >>> str = 'hello' # create a string(iterable) >>> str 'hello' >>> l1.extend(l2) # append all items from l2 to l1 >>> l1 (3, 2, 5, 0, 0, -1) >>> l1.extend(str) # append all items from str to l1 >>> l1 (3, 2, 5, 0, 0, -1, 'h', 'e', 'l', 'l', 'o')
Poche cose da notare dall'esempio sopra:
- Una stringa è iterabile, quindi il nostro estendere() il metodo itererà sui suoi caratteri.
- Il estendere() ha una complessità temporale di (0) K dove K è la lunghezza del suo argomento.
Accesso agli elementi da un elenco
Indicizzazione e affettare sono i mezzi più comuni utilizzati per accedere agli elenchi. Possiamo anche accedere agli elementi in un elenco con loop come per loop .
# 1) Indicizzazione
Un elenco Python utilizza l'estensione numerazione in base zero sistema. Significa che tutti i suoi elementi sono identificati in modo univoco da un numero di indice che va da 0 a n-1 dove n è la lunghezza della lista.
Considera l'elenco seguente:
>>> colors = ('red','blue','green','yellow','black') # create list >>> colors ('red','blue','green','yellow','black') >>> len(colors) # get list length 5
La tabella seguente mostra i rispettivi indici nel numerazione in base zero di una lista.
Articolo | netto | blu | verde | giallo | nero |
---|---|---|---|---|---|
pop () | Per eliminare / rimuovere l'elemento dall'ultimo in un elenco. | ||||
Indice | 0 | 1 | Due | 3 | 4 |
Dalla tabella sopra, vediamo che il primo elemento ('rosso') è nella posizione di indice 0 e l'ultimo elemento ('nero') è nella posizione di indice 4 (n-1) dove n = 5 (lunghezza dell'oggetto colori).
Come abbiamo visto nella sezione delle caratteristiche sopra, gli elenchi Python sono sequenze ordinate. Questo ci consente di utilizzare l'indicizzazione per accedere e manipolare facilmente il suo elemento.
Usiamo l'indicizzazione per accedere agli elementi in corrispondenza di indici particolari dell'oggetto colori creato sopra.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0) # access item at index 0 'red' >>> colors(4) # access item at index 4 'black' >>> colors(9) # access item at index 9 Traceback (most recent call last): File '', line 1, in IndexError: list index out of range
Nota :L'ultima affermazione di cui sopra sta tentando di accedere a un elemento nella posizione indice 9 da un oggetto elenco di lunghezza 5. Nella lista Python, l'accesso a un elemento in un indice che non esiste solleverà il IndexError eccezione.
Un concetto importante di indicizzazione è che possiamo utilizzare l'indicizzazione negativa, ovvero possiamo accedere agli elementi di un elenco in modo inverso iniziando da -1 per l'ultimo elemento e terminando con -n per l'ultimo elemento dove n è la lunghezza dell'oggetto elenco.
Nella tabella sopra, se usiamo l'indicizzazione negativa, apparirà come mostrato di seguito:
Articolo | netto | blu | verde | giallo | nero |
---|---|---|---|---|---|
Indice | -5 | -4 | -3 | -Due | -1 |
Usiamo l'indicizzazione negativa per accedere ad alcuni elementi dell'oggetto colore creato sopra.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(-1) # access item and index -1(first item counting backward) 'black' >>> colors(-3) # access item at index -3(third item counting backward) 'green' >>> colors(-5) # access item at index -5 (last item counting backward) 'red'
# 2) Affettare
A differenza dell'indicizzazione che restituisce solo un elemento, affettare d'altra parte può restituire una serie di articoli.
Ha la seguente sintassi:
L(n:m)
Quando n è il numero di indice in cui inizia la sezione (il valore predefinito è 0) e m è il numero di indice esclusivo in cui finisce la sezione (il valore predefinito è length-1). Sono separati da due punti (:)
Considera l'esempio seguente che utilizza la suddivisione in sezioni per accedere agli elementi in corrispondenza di indici particolari dell'oggetto colori creato sopra.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0:2) # get first two items ('red', 'blue') >>> colors(1:4) # get items at index 1,2 and 3 ('blue', 'green', 'yellow') >>> colors(2:len(colors) # get items from index 2 to the last item ('green', 'yellow', 'black') >>> colors(3:4) # get one item at index 3. Same as colors(3) ('yellow') >>>
Nella sintassi L (n: m), n il valore predefinito è 0 e m il valore predefinito è la lunghezza della lista. Quindi, in esempi 1 e 3 sopra, potremmo omettere n e m come colori (: 2) e colori (2:) rispettivamente. Oppure (:) che in questo caso restituisce una copia superficiale dell'intero oggetto elenco.
Possiamo anche usare numeri di indice negativi durante la suddivisione degli elenchi. Questo è in genere utilizzato quando si desidera accedere all'elenco in modo inverso.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(-3:-2) ('green') >>> colors(-2:) ('yellow', 'black')
Inoltre, esiste un terzo parametro che l'affettamento supporta chiamato passo (S). Definisce il numero di elementi da spostare in avanti dopo che il primo elemento è stato recuperato dall'elenco. Il valore predefinito è 1.
L(n:m:s)
Utilizzando il nostro stesso elenco di colori definito sopra, utilizziamo il terzo parametro della sezione per spostare 2 passaggi.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0:3:2) ('red', 'green')
# 3) Utilizzo dei loop
I cicli vengono utilizzati principalmente per accedere agli elementi in un elenco al fine di manipolare gli elementi. Quindi, nel caso in cui vogliamo operare sugli elementi di una lista, possiamo usare il per loop per accedere agli articoli e passarli per essere operati.
Diciamo, vogliamo contare il numero di lettere per ogni elemento. Possiamo usare il file per loop per farlo.
Apri un editor e incolla il codice seguente:
def count_letters(l): count = {} # define a dict to hold our count for i in l: # loop through the list count(i) = len(i) # for each item, compute its length and store it in the dict return count # return the count if __name__ == '__main__': colors = ('red', 'blue', 'green', 'yellow', 'black') print(count_letters(colors))
Produzione
Per concludere questa sezione, diamo un'occhiata a due cose interessanti che possono essere fatte con l'affettatura.
-
Crea una copia superficiale di un elenco
È il modo di base per utilizzare il copia() metodo dell'oggetto elenco o della funzione incorporata copy.copy . Tuttavia, questo può essere ottenuto affettando.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors_copy = colors(:) # make a shallow copy >>> colors_copy ('red', 'blue', 'green', 'yellow', 'black') >>> colors_copy(0) = 0 # modify item at index 0 by changing its value to 0 >>> colors_copy # the copied version now has 0 at index 0 (0, 'blue', 'green', 'yellow', 'black') >>> colors # the original version is unchanged ('red', 'blue', 'green', 'yellow', 'black') >>>
-
Inverti un elenco
Il modo di base è usare il inversione metodo dell'oggetto elenco o della funzione incorporata invertito () . Tuttavia, questo può essere ottenuto affettando.
>>> colors # original list object ('red', 'blue', 'green', 'yellow', 'black') >>> colors(::-1) # returns a reversed shallow copy of the the original list ('black', 'yellow', 'green', 'blue', 'red') >>>
Rimozione di elementi da un elenco
Poiché possiamo aggiungere tanti elementi a un elenco, possono anche essere rimossi da un elenco. I tre modi in cui gli elementi possono essere rimossi sono:
# 1) Utilizzando l'istruzione del
Ha la seguente sintassi:
del target_list
L'elenco di destinazione ( target_list ) può essere l'intero elenco (nel caso in cui si desideri eliminare l'elenco) o un elemento o più elementi in un elenco (in questo caso si utilizza l'indicizzazione o l'affettatura).
Considera l'esempio di seguito .
Diciamo che vogliamo eliminare alcuni elementi dall'elenco dei colori creato sopra.
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> del c_copy(0) # delete item at index 0 >>> c_copy ('blue', 'green', 'yellow', 'black') >>> del c_copy(0:2) # delete items at index 0 and 1(slicing) >>> c_copy ('yellow', 'black') >>> del c_copy(:) # delete all items in a list. Same as ‘c_copy.clear()’ () >>> del c_copy # delete the list object >>> c_copy # access object that doesn't exist Traceback (most recent call last): File '', line 1, in NameError: name 'c_copy' is not defined >>>
Nota :L'istruzione del elimina sul posto, ad es. , modificherà l'oggetto elenco originale anziché restituire un nuovo oggetto elenco.
# 2) Usando list.remove (x)
Rimuove il primo elemento dall'elenco il cui valore è uguale a X . Solleva un'eccezione ValueError se non esiste tale elemento.
Questo metodo viene utilizzato principalmente per rimuovere elementi da un elenco in base al nome, a differenza dell'istruzione del che utilizza l'indicizzazione e l'affettatura.
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # create shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy.remove('blue') # remove first item with name 'blue' >>> c_copy ('red', 'green', 'yellow', 'black') >>> c_copy.remove('blue') # try to remove item that doesn't exist Traceback (most recent call last): File '', line 1, in ValueError: list.remove(x): x not in list >>>
Nota :L'oggetto elenco rimuovere() metodo elimina sul posto, ad es. , modificherà l'oggetto elenco originale anziché restituire un nuovo oggetto elenco.
# 3) Utilizzo di list.pop ((i))
Rimuove e restituisce l'elemento nella posizione data in un oggetto elenco. Se non viene fornito alcun i (indice), rimuove e restituisce l'ultimo elemento nell'elenco.
Nota :La parentesi quadra intorno alla i sopra non significa un elenco di i, piuttosto significa che i è opzionale.
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy.pop(3) # pop out the item at index 3 'yellow' >>> c_copy ('red', 'blue', 'green', 'black') >>> c_copy.pop() # pop out the last item in the list 'black' >>> c_copy ('red', 'blue', 'green') >>>
Nota: La lista. pop ((i)) metodo elimina sul posto, ad es. , modificherà l'oggetto elenco originale anziché restituire un nuovo oggetto elenco. Inoltre, restituisce l'elemento rimosso dall'elenco
Sostituzione di elementi da un elenco
La sostituzione degli elementi è piuttosto semplice. In una delle sezioni precedenti, abbiamo visto indicizzazione e affettatura. Questi possono essere utilizzati per accedere e rimuovere elementi da un elenco.
# 1) Sostituisci usando l'indicizzazione
L(index) = value
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy(0) = 'brown' # replace item at index 0 with 'brown' >>> c_copy ('brown', 'blue', 'green', 'yellow', 'black') >>>
# 2) Sostituzione utilizzando l'affettatura
L(n:m) = value
Nota : Valore dovrebbe essere un file iterabile , oppure il TypeError verrà sollevata un'eccezione.
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy(0:2) = ('brown') # replace items at index 0 and 1 with 'brown' >>> c_copy ('brown', 'green', 'yellow', 'black') >>> c_copy(1:3) = ('white','purple') # replace items at index 1 and 2 with 'white' and 'purple' >>> c_copy ('brown', 'white', 'purple', 'black') >>> c_copy(1:4) = ('white','purple') # replace items at index 1,2 and 3 with 'white' and 'purple'. Here we replace 3 items with 2 items >>> c_copy ('brown', 'white', 'purple') >>>
Domande frequenti
D # 1) Cos'è un elenco di elenchi in Python?
Risposta: Un elenco di elenchi in Python è un elenco che contiene elenchi come elemento.
Per esempio
(('a','b'),('c','d'))
Può anche essere indicato come a elenco nidificato .
D # 2) Come si dichiara una lista in Python?
Risposta: In Python, una lista può essere dichiarata in due modi. O usando la funzione incorporata elenco() o utilizzando la notazione tra parentesi (). elenco() accetta un iterabile e () accetta elementi di qualsiasi tipo separati da una virgola.
(pytyon)>>> list('hello') # a string is iterable ('h', 'e', 'l', 'l', 'o') >>> (3,4,5,23) # numbers are separated by comma (3, 4, 5, 23) >>> (/python)
Q # 3) Puoi mettere una lista in una lista Python?
Risposta: Sì, possiamo mettere un elenco all'interno di un elenco. In effetti, un elenco è una sequenza contenitore che accetta elementi di qualsiasi tipo di dati.
D # 4) Cosa fa list () in Python?
Risposta: list ( ) è una funzione incorporata in Python che crea un oggetto elenco. Accetta un iterabile come argomento.
>>> list((3,2,4)) # The iterable object here is a tuple. (3, 2, 4) >>>
D # 5) Un elenco Python può contenere diversi tipi?
Risposta: Un elenco è una sequenza contenitore che accetta elementi di qualsiasi tipo di dati ( elenco , tupla , numero intero , galleggiante , stringhe , eccetera)
Ulteriori informazioni sugli elenchi in Python
Cos'è la struttura dei dati?
I computer vengono utilizzati per memorizzare un numero enorme di dati o per elaborare un numero enorme di dati con alta velocità e precisione. Quindi, è meglio memorizzare i dati in modo permanente per un accesso rapido.
Sebbene l'elaborazione dei dati avvenga, dovrebbe avvenire nel più breve tempo possibile senza perdere la precisione. Usiamo la struttura dei dati per trattare i dati in modo organizzato e archiviare i dati nella memoria per l'elaborazione.
Poiché Python è un linguaggio di programmazione di alto livello e interpretato, è molto importante utilizzare la struttura dei dati in Python.
Cos'è List?
Un elenco è una struttura di dati utilizzata per memorizzare più dati contemporaneamente.
I dati memorizzati in un elenco sono omogenei e questo, a sua volta, lo rende la funzionalità più potente di elenco in Python. Possiamo memorizzare più dati di diversi tipi di dati come String, Integers e anche oggetti in un unico elenco.
Gli elenchi sono modificabili in Python, quindi i dati possono essere modificati in qualsiasi momento anche dopo la creazione. Gli elenchi sono molto potenti per l'implementazione di stack e code in Python.
Come discusso in precedenza, list archivia i dati in una sequenza ordinata e ai dati archiviati in un elenco si accede utilizzando il loro indice e per l'elenco l'indice partirà sempre da zero. Ogni elemento ha una posizione specifica nell'elenco e tutti questi dati sono accessibili con l'aiuto di un indice.
In elenco, possiamo memorizzare lo stesso valore più volte e ogni dato verrà considerato come un elemento separato e unico. Gli elenchi sono i migliori per archiviare i dati e iterarli in un secondo momento.
Creazione di un elenco
I dati in un elenco vengono memorizzati con valori separati da virgole e racchiusi tra parentesi quadre (()). Gli elementi nell'elenco non devono essere dello stesso tipo.
Syntax: List = (item1, item2, item3)
Esempio 1:
List = ( )
Esempio 2:
List = (2, 5, 6.7)
Esempio 3:
List = (2, 5, 6.7, ‘Hi’)
Esempio 4:
List = (‘Hi’, ‘Python’, ‘Hello’)
Negli esempi precedenti, possiamo osservare che abbiamo memorizzato elementi di diversi tipi di dati separati da virgole, 2 e 5 sono di tipo Integer, 6.7 è di tipo float e 'Hi' è di tipo String, tutti questi elementi sono racchiusi in un list e questo lo rende un elenco.
Possiamo anche dichiarare un elenco vuoto. Possiamo anche dichiarare elenco all'interno di un altro elenco e lo chiamiamo elenco annidato.
Esempio 5:
List = (‘Hi’, (2, 4, 5), (‘Hello’))
Nell'esempio sopra, puoi osservare che una lista è stata dichiarata all'interno di un'altra lista.
Accesso ai valori nell'elenco
Esistono vari modi attraverso i quali possiamo accedere agli elementi presenti all'interno della lista in Python.
Con l'aiuto dell'indice, possiamo accedere agli elementi della lista. L'indice inizia da 0 e l'indice deve essere sempre un numero intero. Se usiamo un indice diverso da un intero come float, il risultato sarà TypeError.
Esempio 1:
List = (2, 5, 6.7, ‘Hi’) print(“List is:”, List)
Produzione:
L'elenco è: (2, 5, 6.7, 'Ciao')
Produzione:
come scrivere il test case nel foglio excel
Nell'esempio sopra, stiamo stampando direttamente l'elenco utilizzando la funzione di stampa, non stiamo accedendo al singolo elemento dall'elenco.
Accediamo al singolo elemento dall'elenco.
Esempio: 2
List = (2, 5, 6.7, ‘Hi’) print(“Second element of the list is:”, List(1))
Produzione:
Il secondo elemento della lista è: 5
Produzione:
Nell'esempio sopra, puoi osservare che stiamo stampando il secondo elemento della lista che è 5, ma potresti ricevere una domanda sul perché nell'istruzione print stiamo stampando List (1)? Questo perché l'indice inizia da Zero, quindi List (1) si riferisce al secondo elemento della lista.
Esempio: 3
List = (2, 5, 6.7, ‘Hi’) print(“First element in the List is: ”, List(0)) print(“Last element in the List is: ”, List(3))
Produzione:
Il primo elemento della lista è: 2
L'ultimo elemento della lista è: Ciao
Produzione:
Esempio: 4
List = (‘Hi’, (2, 4, 5)) print(“First element of the list is: ”, List(0)(1)) print(“Elements present inside another list is: ”, List(1)(2))
Produzione:
Il primo elemento della lista è: i
Gli elementi presenti all'interno di un'altra lista sono: 5
Produzione:
Nel programma sopra, se osservi attentamente, puoi vedere che stiamo accedendo agli elementi dall'elenco annidato.
Internamente i dati verranno archiviati in un formato a matrice come mostrato di seguito:
Ciao
2 4 5
Quindi, quando proviamo ad accedere a List (0) (1), punterà a 1striga e 2ndcolonna, quindi i dati saranno 'i'.
Allo stesso modo, quando proviamo ad accedere a List (1) (2), punterà a 2ndriga e 3rdcolonna, quindi, i dati saranno 5.
Indicizzazione negativa
Possiamo accedere ai dati anche utilizzando un indice negativo. Un indice negativo inizierà sempre da -1 e -1 si riferisce all'ultimo elemento e -2 si riferisce all'ultimo secondo elemento e così via.
Esempio 1
List = (2, 5, 7, 3) print(“Last element in the list is: ”, List(-1))
Produzione:
L'ultimo elemento della lista è: 3
Produzione:
Esempio: 2
List = (2, 5, 7, 3) print(“Second element in the list is: ”, List(-3))
Produzione:
Il secondo elemento della lista è: 5
Produzione:
Affettare l'elenco
Usando l'operatore slice (:) possiamo accedere a una serie di elementi dalla lista
Esempio 1
List = (1, 2, 3, 4, 5, 6, 7) print(“Elements from 2nd to 5th is: ”, List(1:5)) print(“Elements beginning to 2rd is: ”, List(:-3)) print(“Elements 4th to end is: ”, List(3:)) print(“Elements from start to end is: “, List(:))
Produzione:
Gli elementi dal 2 ° al 5 ° sono: (2, 3, 4, 5)
Gli elementi che iniziano al 2 ° sono: (1, 2, 3, 4)
Gli elementi dal quarto alla fine sono: (4, 5, 6, 7)
Gli elementi dall'inizio alla fine sono: (1, 2, 3, 4, 5, 6, 7)
Produzione:
Possiamo anche accedere agli elementi presenti all'interno della lista utilizzando il ciclo for.
Esempio: 2
List = (1, 2, 3, 4, 5, 6, 7) forele in List: print(ele)
Produzione:
1
Due
3
4
5
6
7
Produzione:
Ricorda il formato di indicizzazione di seguito:
H | E | L | L | O | 5 | 7 | 9 | 4 |
0 | 1 | Due | 3 | 4 | 5 | 6 | 7 | 8 |
-9 | -8 | -7 | -6 | -5 | -4 | -3 | -Due | -1 |
Come discusso in precedenza, List in python è mutabile, il che significa che gli elementi possono essere modificati anche se è un numero intero o una stringa o qualsiasi tipo di dati.
Possiamo aggiornare l'elenco utilizzando l'operatore di assegnazione.
Esempio: 3
List = (2, 4, 6, 9) #updating the first element List(0) = 7 print(“Updated list is: ”, List)
Produzione:
L'elenco aggiornato è: (7, 4, 6, 9)
Produzione:
Nell'esempio precedente, stiamo aggiornando il primo elemento dell'elenco '2' con un nuovo elemento '7'.
Esempio: 4
List = (2, 5, 1, 3, 6, 9, 7) #updating one or more elements of the list at once List(2:6) = (2, 4, 9, 0) print(“Updated List is: ”, List)
Produzione:
L'elenco aggiornato è: (2, 5, 2, 4, 9, 0, 7)
Nell'esempio sopra, stiamo aggiornando l'elenco dei dati nell'elenco.
Produzione:
Aggiunta di elementi all'elenco
Ci sono diversi modi in cui possiamo aggiungere elementi alla lista e python ha una funzione incorporata chiamata append ().
Usando append (), possiamo aggiungere un solo elemento alla lista, se vuoi aggiungere più elementi alla lista dobbiamo fare uso di per loop . La funzione append () aggiunge sempre l'elemento alla fine della lista, la funzione append () accetta solo un argomento.
Se vuoi aggiungere elementi in una posizione specifica, devi solo usare il metodo insert (). insert () accetta due argomenti, ovvero posizione e valore, posizione si riferisce all'indice, dove gli elementi devono essere aggiunti e valore si riferisce all'elemento da aggiungere alla lista.
C'è un altro metodo chiamato extent (), utilizzando il quale possiamo aggiungere elementi alla lista. Il metodo extended () viene utilizzato per aggiungere un elenco di elementi all'elenco. Simile al metodo append () e al metodo extent (), aggiungerà anche elementi alla fine dell'elenco.
Esempio 1
List = (“Hello”, “Good Morning”) print(“List before appending values is: “, List) List.append(“Python”) List.append(“Hi”) print(“List after appending values is: ”, List)
Produzione:
L'elenco prima di aggiungere i valori è: ('Hello', 'Good Morning')
L'elenco dopo aver aggiunto i valori è: ('Hello', 'Good Morning', 'Python', 'Hi')
Nell'esempio precedente, stiamo aggiungendo i valori 'Python' e 'Hi' alla fine dell'elenco.
Produzione:
Esempio: 2
List = (“Hello”, “Good Morning”) print(“List before appending values is: “, List) print(“Length of the list before appending is: “, len(List)) List.append(“Python”) List.append(“Hi”) print(“List after appending values is: ”, List) print(“Length of the list after appending is: “, len(List))
Produzione:
L'elenco prima di aggiungere i valori è: ('Hello', 'Good Morning')
La lunghezza della lista prima di aggiungerla è: 2
L'elenco dopo aver aggiunto i valori è: ('Hello', 'Good Morning', 'Python', 'Hi')
La lunghezza dell'elenco dopo l'aggiunta è: 4
Possiamo trovare la lunghezza della lista usando la funzione len (), come mostrato nell'esempio sopra.
Produzione:
Possiamo anche aggiungere più valori all'elenco usando il ciclo for.
Esempio: 3
List = (7, 9, 8) print(“List before adding elements is: “, List) print(“Length of List before adding elements is: “, len(List)) for i in range(2, 6): List.append(i) print(“List after adding elements is: “, List) print(“Length of List after adding elements is: “, len(List))
Produzione:
L'elenco prima di aggiungere elementi è: (7, 9, 8)
La lunghezza dell'elenco prima di aggiungere elementi è: 3
L'elenco dopo l'aggiunta di elementi è: (7, 9, 8, 2, 3, 4, 5)
La lunghezza dell'elenco dopo l'aggiunta di elementi è: 7
Produzione:
Cosa succede se aggiungiamo un elenco di elenchi a un elenco? Vediamolo nell'esempio seguente.
Esempio: 4
List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.append(List2) print(“List1 after appending List2 is: “, List1)
Produzione:
List1 dopo aver aggiunto List2 è: ('Hi', 'Python', (1, 5, 7, 2))
Se noti nell'esempio precedente, quando aggiungiamo List2 a List1, List1 diventerà un elenco nidificato.
Produzione:
Se non vuoi rendere l'elenco come un elenco nidificato dopo aver aggiunto l'elenco, è meglio utilizzare il metodo extent ().
Esempio: 5
List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.extend(List2) print(“List1 after appending List2 is: “, List1)
Produzione:
List1 dopo aver aggiunto List2 è: ('Hi', 'Python', 1, 5, 7, 2)
Quando usiamo il metodo extent (), gli elementi di List1 verranno estesi con gli elementi di List2. Ricorda che non aggiungerà l'elenco quando usiamo il metodo extent ().
Produzione:
Quando estendi un elenco con una stringa, aggiungerà ogni carattere della stringa all'elenco, poiché una stringa è iterabile.
Esempio: 6
List = (1, 5, 7, 2) List.extend(“Python”) print(“List after extending the String is: “, List)
Produzione:
L'elenco dopo aver esteso la stringa è: (1, 5, 7, 2, 'P', 'y', 't', 'h', 'o', 'n')
Produzione:
Elenco append () vs extent ()
Diamo un'occhiata ad alcuni esempi per extent () e append ().
Esempio 1
def my_fun(): List1 = (“Hi”, 1, “Hello”, 2, 5) print(“The elements of List is: “, List) List.append(“Python”) print(“List after appending the String is: “, List) List.append((“one”, “two”, 3)) print(“List after appending the list is: “, List) List2 = (“Apple”, “Orange”, 2, 8) List1.extend(List2) print(“List1 after extending the List2 is: “, List1) if __name__ == “__main__”: my_fun()
Produzione:
Gli elementi di List sono: ('Hi', 1, 'Hello', 2, 5)
L'elenco dopo aver aggiunto la stringa è: ('Hi', 1, 'Hello', 2, 5, 'Python')
L'elenco dopo aver aggiunto l'elenco è: ('Ciao', 1, 'Ciao', 2, 5, 'Python', ('uno', 'due', 3))
List1 dopo aver esteso List2 è: ('Hi', 1, 'Hello', 2, 5, 'Python', ('one', 'two', 3), 'Apple', 'Orange', 2, 8)
Produzione:
Esempio: 2
List = (“Apple”, “Orange”, “Mango”, “Strawberry”) print(“List before inserting is: “, List) List.insert(2, “Watermelon”) print(“List after inserting is: “, List)
Produzione:
L'elenco prima dell'inserimento è: ('Mela', 'Arancia', 'Mango', 'Fragola')
L'elenco dopo l'inserimento è: ('Apple', 'Orange', 'Watermelon', 'Mango', 'Strawberry')
Produzione
Come abbiamo discusso in precedenza, il metodo insert () viene utilizzato per inserire valori in un indice specifico della lista.
Esempio: 3
List1 = (2, 4, 6, 8) print(“List after adding the elements is: “, List1 + (1, 3, 5, 7)) print(“After adding same elements repeatedly is: “, (“Hi”) *5)
Produzione:
L'elenco dopo l'aggiunta degli elementi è: (2, 4, 6, 8, 1, 3, 5, 7)
Dopo aver aggiunto ripetutamente gli stessi elementi è: ('Ciao', 'Ciao', 'Ciao', 'Ciao', 'Ciao')
Produzione:
Eliminazione o rimozione di elementi da un elenco
Possiamo anche eliminare o rimuovere elementi dall'elenco utilizzando le istruzioni del e remove ().
che cos'è un tipo di file swf
Vediamo nell'esempio seguente.
Esempio 1
List = (1, 2, 3, 4, 5, 6, 7, 8, 9) print(“List before deleting 3rd element is: ”, List) del List(3) print(“List after deleting 3rd element is: ”, List) del List(1:3) print(“List after deleting multiple elements is: “, List)
Produzione:
L'elenco prima di eliminare il terzo elemento è: (1, 2, 3, 4, 5, 6, 7, 8, 9)
L'elenco dopo l'eliminazione del terzo elemento è: (1, 2, 3, 5, 6, 7, 8, 9)
L'elenco dopo l'eliminazione di più elementi è: (1, 5, 6, 7, 8, 9)
Nell'esempio sopra, puoi osservare che abbiamo usato l'istruzione del per eliminare un elemento o più istruzioni dall'elenco.
Produzione:
Ora vedremo il metodo remove ().
Esempio: 2
List = (1, 2, 3, 4, 5, 6, 7) print(“List before removing a element is: “, List) List.remove(3) print(“List after removing a element is: “, List) List.pop() print(“List after poping the element is: “, List)
Produzione:
L'elenco prima di rimuovere un elemento è: (1, 2, 3, 4, 5, 6, 7)
L'elenco dopo la rimozione di un elemento è: (1, 2, 4, 5, 6, 7)
L'elenco dopo aver visualizzato l'elemento è: (1, 2, 4, 5, 6)
Nell'esempio sopra, puoi osservare che stiamo rimuovendo un elemento dall'elenco utilizzando il metodo remove (). Il metodo pop () viene utilizzato per rimuovere / eliminare l'ultimo elemento dall'elenco.
Produzione:
Metodi di elenco
Metodi | Descrizione |
---|---|
chiaro() | Per rimuovere tutti gli elementi dall'elenco. |
aggiungere() | Per aggiungere un elemento alla fine della lista. |
inserire() | Per inserire un elemento in un indice specifico della lista. |
estendere() | Per aggiungere un elenco di elementi alla fine dell'elenco. |
contare() | Per restituire un numero di elementi con un valore specifico. |
indice() | Per restituire l'indice del primo elemento. |
inversione() | Per invertire un elenco esistente. |
rimuovere() | Per rimuovere gli elementi dall'elenco. |
Conclusione
In questo tutorial, abbiamo esaminato alcuni caratteristiche delle liste Python insieme ai vari modi di manipolare un elenco come creare un elenco , accedere agli elementi da un elenco , e sostituzione di elementi da un elenco.
Questo tutorial sulla lista Python può essere concluso con i seguenti puntatori:
- List è uno dei tipi di dati in Python, che viene anche definito struttura dei dati.
- List viene utilizzato per memorizzare un gran numero di valori di qualsiasi tipo di dati in una singola variabile, che a sua volta aiuta ad accedervi facilmente.
- L'indice della lista parte sempre da zero come gli altri linguaggi di programmazione.
- Se stai lavorando sulla lista, devi ricordare tutte le sue funzioni integrate comuni.
=> Visita qui per imparare Python da zero
Lettura consigliata
- Tutorial Python per principianti (formazione pratica GRATUITA su Python)
- Variabili Python
- Python Advanced List Tutorial (List Sort, Reverse, Index, Copy, Join, Sum)
- Python Tuple Tutorial con esempi pratici
- Funzioni stringa Python
- Elenchi in STL
- Struttura Dati Elenco Collegato In C ++ Con Illustrazione
- Struttura Dati Elenco Collegato Circolare In C ++ Con Illustrazione