Esempio 1: concatenazione di elenchi con l'operatore '+'.
Possiamo usare l'operatore “+” in Python per concatenare le liste. Utilizzando l'operatore '+', puoi unire due o più elenchi per formare un nuovo elenco. Quando utilizzi l'operatore '+' con gli elenchi, viene creato un nuovo elenco e gli elementi degli elenchi originali vengono copiati nel nuovo elenco nell'ordine in cui appaiono.
Ecco un semplice esempio:
foglio 1 = [ 1 , 2 , 3 ]
elenco2 = [ 4 , 5 , 6 ]
elenco_risultati = lista1 + lista2
stampa ( elenco_risultati )
In questa illustrazione abbiamo due elenchi: “list1” e “list2”. Utilizziamo l'operatore “+” per integrarli in un unico elenco. Se utilizzato con le liste, l'operatore “+” le concatena, cioè unisce gli elementi della seconda lista alla fine della prima. Pertanto, dopo aver eseguito 'result_list = list1 + list2', 'result_list' conterrà gli elementi sia di 'list1' che di 'list2' nell'ordine in cui sono stati concatenati.
Anche se questo metodo è conciso, tieni presente che crea un nuovo elenco che potrebbe non essere efficiente per elenchi di grandi dimensioni a causa del sovraccarico derivante dalla creazione di una copia.
Esempio 2: utilizzo del metodo Extend()
Gli elementi di un iterabile possono essere aggiunti alla fine di un elenco esistente utilizzando il metodo extend(). Modifica l'elenco originale in posizione, a differenza dell'operatore “+” che crea un nuovo elenco.
Supponiamo di avere un elenco di studenti in una classe e di voler estendere questo elenco aggiungendo i nomi dei nuovi studenti che si sono iscritti di recente utilizzando il metodo extend(). Ecco come potresti procedere:
classe_studenti = [ 'Alice' , 'Bella' , 'Charlie' ]
nuovi studenti = [ 'Davide' , 'Eva' , 'Adamo' ]
classe_studenti. estendere ( nuovi studenti )
stampa ( 'Elenco aggiornato degli studenti:' , classe_studenti )
In questo esempio, l'elenco originale “class_students” contiene i nomi degli studenti esistenti. L'elenco 'nuovi_studenti' include i nomi degli studenti che si sono recentemente uniti alla classe. Applicando il metodo extend() aggiungiamo i nomi dei nuovi studenti alla fine della lista originale.
Esempio 3: applicazione dell'operatore “+=' per la concatenazione
L'operatore '+=' è una scorciatoia per il metodo extend(). Modifica l'elenco in atto, combinando gli elementi dell'elenco di destra nell'elenco di sinistra.
Supponiamo di avere un elenco di colori preferiti e di volerlo aggiornare aggiungendo altri colori utilizzando l'operatore “+='.
colori_preferiti = [ 'blu' , 'verde' , 'rosso' ]colori_aggiuntivi = [ 'viola' , 'arancia' , 'giallo' ]
colori_preferiti + = colori_aggiuntivi
stampa ( 'Colori preferiti aggiornati:' , colori_preferiti )
In questo scenario, iniziamo con un elenco dei nostri colori preferiti rappresentato da 'favorite_colors'. Poi, abbiamo alcuni nuovi colori che vorremmo includere nell'elenco 'additional_colors'. Utilizzando l'operatore “+=”, combiniamo i nuovi colori con i nostri preferiti esistenti, modificando l'elenco “favorite_colors”.
Dopo l'operazione, quando stampiamo “I nostri colori preferiti aggiornati”, possiamo vedere il seguente risultato:
Esempio 4: utilizzo dell'operatore “*”.
L'operatore '*' può essere utilizzato per la replica dell'elenco. Ma se applicato agli elenchi, può concatenarli ripetendo gli elementi.
Ecco un esempio:
lista_originale = [ 1 , 2 , 3 ]lista_concatenata = lista_originale * 3
stampa ( lista_concatenata )
In questo caso, iniziamo con una “lista_originale” che contiene gli elementi [1, 2, 3]. Utilizzando l'operatore “*”, creiamo una nuova lista che è la “concatenated_list” composta da tre ripetizioni degli elementi della lista originale.
Sebbene questo approccio sia meno comune per la concatenazione, mostra la flessibilità degli operatori di Python.
Esempio 5: applicazione della funzione Itertools.chain()
La funzione itertools.chain() fa parte del modulo “itertools” e viene utilizzata per concatenare l'iterabile (come liste, tuple o altri oggetti iterabili) in un singolo “iterabile”. A differenza di altri metodi di concatenazione, itertools.chain() non crea un nuovo elenco ma produce un iteratore sugli elementi degli iterabili di input.
da itertools importare catenaL1 = [ 1 , 2 , 3 ]
L2 = [ 'X' , 'E' , 'Con' ]
concatenato_iterabile = catena ( L1 , L2 )
elenco_risultati = elenco ( concatenato_iterabile )
stampa ( elenco_risultati )
Nell'esempio fornito, abbiamo due elenchi: “L1” contiene i valori numerici [1, 2, 3] e “L2” contiene i caratteri alfabetici [“x”, “y”, “z”]. Utilizzando la funzione itertools.chain(), concateniamo questi elenchi in un unico iterabile, rappresentato da “concatenated_iterable”. La funzione list() viene quindi applicata per convertire l'iterabile in una lista che risulta nella lista combinata [1, 2, 3, “x”, “y”, “z”].
Esempio 6: suddivisione dell'elenco
Fornendo una serie di indici, il list slicing è una tecnica che ci consente di recuperare un sottoinsieme di un elenco. Implica l'utilizzo dell'operatore due punti (:) all'interno delle parentesi quadre per indicare i valori di inizio, fine e, facoltativamente, di passo.
Ecco il codice di esempio:
lista_effettiva = [ 1 , 2 , 3 , 4 , 5 ]lista_affettata = lista_effettiva [ 1 : 4 ]
stampa ( lista_affettata )
Iniziamo l'illustrazione con un elenco originale di numeri denominato 'actual_list' che contiene gli elementi [1, 2, 3, 4, 5]. Estraiamo un segmento specifico dell'elenco utilizzando l'affettamento dell'elenco che è una funzionalità potente in Python. In questo caso viene utilizzata la sezione 'actual_list[1:4]' che seleziona gli elementi dall'indice 1 all'indice 3 (ma non dall'indice 4). Il risultato è un nuovo elenco, denominato “sliced_list”, che contiene la porzione affettata [2, 3, 4].
Esempio 7: Concatenazione con la funzione Zip()
La funzione zip() combina gli elementi di più iterabili, creando coppie o tuple di elementi corrispondenti. Gli elementi di ciascuna iterazione sullo stesso indice vengono utilizzati per creare queste coppie.
studenti = [ 'Alice' , 'Bob' , 'Charlie' ]gradi = [ 85 , 92 , 78 ]
student_grade_pairs = cerniera lampo ( studenti , gradi )
risultato_dict = dict ( student_grade_pairs )
stampa ( 'Coppie studente-grado:' , risultato_dict )
In questo esempio, la funzione zip() accoppia i nomi degli studenti dall'elenco 'studenti' con i voti corrispondenti dall'elenco 'voti' che risulta in un dizionario in cui ogni studente è associato al rispettivo voto.
Conclusione
In conclusione, Python offre una moltitudine di modi per concatenare le liste, ognuno con i suoi vantaggi. Mentre esploravamo i vari metodi, dal semplice operatore “+” alla più sfumata funzione zip(), è diventato evidente che Python si adatta a diversi stili e preferenze di programmazione. A seconda del lavoro da svolgere, fattori come la leggibilità, l'efficienza della memoria e il tipo di dati elaborati determineranno quale metodo è migliore.