Le 18 domande più comuni sulle liste in Python

Che cos'è esattamente una lista in Python?

Le liste sono una delle quattro strutture dati integrate in Python, insieme a tuple, dizionari e set. Servono per memorizzare una raccolta ordinata di elementi, che possono anche essere di tipi diversi, ma di solito non lo sono. Le virgole separano gli elementi contenuti in una lista, racchiusa tra parentesi quadre. Proprio come in questo esempio:

# These list elements are all of the same type
zoo = ['bear', 'lion', 'panda', 'zebra']
print(zoo)

# But these list elements are not
biggerZoo = ['bear', 'lion', 'panda', 'zebra', ['chimpanzees', 'gorillas', 'orangutans', 'gibbons']]
print(biggerZoo)

Vedi che la seconda variabile biggerZoo è una lista simile alla variabile zoo. Tuttavia, noti anche che biggerZoo contiene un'altra lista con diversi tipi di scimmie all'interno.

Poiché le liste in Python memorizzano raccolte ordinate di elementi o oggetti, possiamo dire che sono tipi sequenza, proprio perché si comportano come una sequenza. Altri tipi considerati sequenze sono le stringhe e le tuple.

Potresti chiederti cosa ci sia di speciale nei tipi sequenza. In parole semplici, significa che il programma può iterarci sopra! Ecco perché liste, stringhe, tuple e set sono chiamati "iterabili".

Ricorda che questo concetto è particolarmente importante e potresti ritrovarlo in altri linguaggi di programmazione usati nella data science, come Scala!

Ora passiamo al lavoro vero e proprio! Approfondiamo le domande sulle liste che potrebbero averti assillato come programmatore Python. Ecco l'elenco di tutte le domande a cui risponderemo in questo tutorial:

1. Quando usare le liste in Python e quando usare tuple, dizionari o set

L'introduzione sembra piuttosto semplice quando la leggi, ma quando lavori davvero su un piccolo script Python o su un intero progetto, la scelta tra una lista o un altro tipo sequenza potrebbe non essere così chiara.

Tuttavia, scegliere la struttura dati giusta per i tuoi dati è essenziale!

Continua a leggere per saperne di più.

# Import the `collections` library
____ ____

# Check if a dictionary is hashable
print(isinstance({}, collections.Hashable))

# Check if a float is hashable
print(isinstance(0.125, collections.Hashable))

2. Come selezionare un elemento da una lista

Se vuoi lavorare correttamente con queste liste, devi sapere come accedervi.

Tipicamente accedi alle liste per cambiare alcuni valori, aggiornarli o eliminarli, o per eseguire qualche altra operazione su di essi. Il modo in cui accedi alle liste, e per estensione a tutti gli altri tipi sequenza, è usando l'operatore di indice [ ]. All'interno, metti un valore intero.

Ti mostro un esempio:

# Select the first list element
oneZooAnimal = biggerZoo[0]

# Print `oneZooAnimal`
print(____)

Esegui il codice e guarda cosa ottieni. Noterai che viene restituito il primo elemento della variabile biggerZoo. Può essere un po' confuso o sorprendente all'inizio, ma gli indici partono da 0 e non da 1.

# Run this code to trigger an "Index Out Of Range" Error
biggerZoo[6]

# Use the slice notation like this
someZooAnimals = biggerZoo[2: ]

# Print to see what you exactly select from `biggerZoo`
print(someZooAnimals)

# Try putting 2 on the other side of the colon
otherZooAnimals = biggerZoo[____]

# Print to see what you're getting back
print(otherZooAnimals)

# items start through the end (but the end is not included!)
a[start:end]

# items start through the rest of the array
a[start:]    

# items from the beginning through the end (but the end is not included!)
a[:end]Offerto da

# start through not past end, by step
a[start:end:step]Offerto da

# Print to see how the step value influences your result
print(biggerZoo[2::2])
print(biggerZoo[1::3])

# Import `choice` from the `random` library
from ____ import ____

# Construct your `list` variable with a list of the first 4 letters of the alphabet
list = ['_','_','_','_']

# Print your random 'list' element
print(choice(list))

# Import `randrange` from the `random` library
from ____ import ____

# Construct your `randomLetters` variable with a list of the first 4 letters of the alphabet
randomLetters = ['_','_', '_', '_']

# Select a random index from 'randomLetters`
randomIndex = randrange(0,len(randomLetters))

# Print your random element from `random`
print(randomLetters[randomIndex])

3. Come trasformare le liste di Python in altre strutture dati

A volte, una lista non è esattamente ciò di cui hai bisogno. In questi casi, potresti voler sapere come trasformare la tua lista in una struttura dati più adatta. Qui sotto elenchiamo alcune delle domande di trasformazione più comuni e le loro risposte.

# List of Strings to a String
listOfStrings = ['One', 'Two', 'Three']
strOfStrings = ''.join(listOfStrings)
print(strOfStrings)

# List Of Integers to a String
listOfNumbers = [1, 2, 3]
strOfNumbers = ''.join(str(n) for n in listOfNumbers)
print(strOfNumbers)

# Pass your list to `tuple()`
tuple(___)

# Transform your list into a set
set(___)

helloWorld = ['hello','world','1','2']Offerto da

list(zip(helloWorld))

# Convert to a dictionary
helloWorldDictionary = dict(zip(helloWorld[0::2], helloWorld[1::2]))

# Print out the result
print(helloWorldDictionary)

a = [1, 2, 3, 4, 5]

# Create a list iterator object
i = iter(a)

# Zip and create a dictionary
print(dict(zip(i, i)))

4. Come determinare la dimensione della tua lista in Python

Puoi passare la tua lista alla funzione len() per ottenere la lunghezza della lista.

Provalo qui sotto! Abbiamo già creato una lista justAList che puoi usare.

# Pass `justAList` to `len()`
len(____)

Nota che la funzione len() non serve specificamente a recuperare la lunghezza delle liste, ma può essere usata anche con altre sequenze o collezioni, come dizionari, set, stringhe, ecc. Puoi trovare altre funzioni integrate generali qui.

5. Qual è la differenza tra i metodi Python append() ed extend()?

Per cominciare a rispondere a questa domanda, riprendiamo il concetto di iterabile spiegato nella prima sezione di questo post:

Ricorda che diciamo che un certo valore è iterabile quando il tuo programma può iterarci sopra. In altre parole, un iterabile è un valore che rappresenta una sequenza di uno o più valori. Come probabilmente hai letto nella prima sezione, le liste sono sequenze e tutte le istanze dei tipi sequenza di Python sono iterabili.

Consiglio: verifichi se una variabile è iterabile quando ha il metodo .__iter__, come in questo frammento di codice:

# This is your list
list = [5, 6, 7, 8, 9]

# Check whether it's iterable
list.__iter__

Esegui il codice qui sopra e prova altri semplici esempi nella shell IPython!

Ora che il concetto di iterabile è chiaro, possiamo capire la differenza tra i due metodi. extend(), da una parte, prende un iterabile (già, prende una lista, un set, una tupla o una stringa!) e aggiunge ciascun elemento dell'iterabile alla lista uno alla volta.

append(), dall'altra, aggiunge il suo argomento alla fine della lista come elemento singolo, il che significa che quando la funzione append() riceve un iterabile come argomento, lo tratterà come un singolo oggetto.

Studia i blocchi di codice qui sotto e gioca con il codice per capire le differenze tra questi due metodi:

# Append [4,5] to `shortList`
shortList.append([4, 5])

# Use the print() method to show shortList
print(____)

# Extend `longerList` with [4,5]
longerList.extend([4, 5])

# Use the print() method to see longerList
print(____)

Puoi vedere che extend() è una versione più efficiente del chiamare append() più volte.

6. Come concatenare liste in Python

Per concatenare liste, usa l'operatore +. Ti restituirà una nuova lista che è la concatenazione delle due senza modificare quelle originali.

Nota che concatenare e fare append può creare confusione. append() è diverso dall'operatore +, che a sua volta è molto simile al metodo extend(), ma non esattamente uguale... Vedi che con append() ed extend() modifichi la lista originale, mentre con l'operatore + puoi creare un'altra variabile lista.

Provalo tu stesso e confronta con gli esempi del blocco di codice precedente:

# Concatenate `shortList` with `[4,5]`
plusList = shortList + [4,5]

#Use the `print()` method to see `plusList`
print(____)

7. Come ordinare una lista in Python

Ci sono due modi molto semplici per ottenere i valori delle liste in ordine crescente o decrescente:

• Usi il metodo sort()
• Oppure usi la funzione sorted() passandole una lista

La funzione sorted() può essere applicata a qualsiasi oggetto iterabile, il che significa che accetta anche stringhe, set, dizionari quando le vengono passati!

Consiglio: prova tu stesso! Abbiamo già creato due liste, rooms e orders, che puoi ordinare con le due tecniche descritte sopra :)

# Use sort() on the rooms list
____.sort()

# Print out rooms to see the result
print(____)

# Now use the sorted() function on orders
sorted(____)

# Print out orders
print(____)

Nota come la lista originale cambia dopo averla ordinata. È consigliabile usare questo metodo quando non ti serve più la lista originale.

8. Come clonare o copiare una lista in Python

Ci sono molti modi per clonare o copiare una lista:

• Puoi fare lo slice della lista originale e memorizzarla in una nuova variabile: newList = oldList[:]
• Puoi usare la funzione integrata list(): newList = list(oldList)
• Puoi usare la libreria copy:
  • Con il metodo copy(): newList = copy.copy(oldList)
  • Se la tua lista contiene oggetti e vuoi copiare anche quelli, puoi usare copy.deepcopy(): copy.deepcopy(oldList)

Provalo qui sotto! Abbiamo già creato una lista groceries da copiare e condividere con i tuoi amici.

# Copy the grocery list by slicing and store it in the `newGroceries` variable
newGroceries = groceries[__]

# Copy the grocery list with the `list()` function and store it in a `groceriesForFriends` variable
groceriesForFriends = list(____)

# Import the copy library as c
import ____ as __

# Create a `groceriesForFamily` variable and assign the copied grocery list to it
groceriesForFamily =  c.copy(____)

# Use `deepcopy()` and assign the copied list to a `groceriesForKids` variable
groceriesForKids= c.deepcopy(____)

Nota che quando usi i metodi di copia "semplici", le tue liste originali verranno modificate. Tuttavia, se usi il metodo deepcopy(), questo verrà evitato. Esegui il codice qui sotto per vedere cosa succede:

# This is your list
objectList = ['a','b',['ab','ba']]

# Copy the `objectList`
copiedList = objectList[:]

# Change the first list element of `copiedList`
copiedList[0] = 'c'

# Go to the third element (the nested list) and change the second element
copiedList[2][1] = 'd'

# Print out the original list to see what happened to it
print(objectList)

Per chi ha già portato le liste in Python a un livello successivo, la sezione seguente offre risposte semplici a domande complesse.

Per chi invece si chiede cosa ci sia oltre le liste, e quali vantaggi possano offrire le librerie rispetto alla struttura lista integrata, la prossima sezione potrebbe essere molto utile.

Continua a leggere per saperne di più!

9. Come funziona la list comprehension in Python?

La list comprehension è, in sostanza, un modo elegante di costruire le tue liste. La cosa migliore, per chi ama la matematica, è che assomigliano molto alle liste matematiche. Giudica tu stesso:

[x**2 for x in range(10)]

Ora, cosa significa? Prendi tutti i numeri da 0 a 10, dove 10 non è incluso, e moltiplichi ciascuno di quei numeri per 2. Esegui il frammento di codice sopra per vedere se il risultato corrisponde alle tue aspettative.

Niente di troppo difficile, vero? Alziamo un po' l'asticella!

Supponiamo che tu voglia creare la stessa lista di prima, ma vuoi moltiplicare solo i numeri divisibili per 2. Anche questo è facile con l'aiuto della list comprehension:

[x**2 for x in range(10) if x%2==0]

Aggiungi semplicemente una condizione, indicata da if, alla tua istruzione originale. Se quella condizione risulta VERA, il numero verrà considerato per la moltiplicazione per 2. In questo caso, la nostra condizione è che il numero sia divisibile per 2 (senza resto dall'operazione di divisione).

In senso più generale, puoi anche usare la list comprehension per trasformare le tue liste in altre liste, il che suona un po' più difficile, vero?

Considera il prossimo esempio:

myList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[(lambda x: x*x)(x) for x in myList]

In questo esempio, hai già una lista myList che stai trasformando tramite list comprehension: vedi di nuovo for x in myList, per ogni elemento in myList verrà eseguita un'operazione.

Poi vedi che è inclusa (lambda x: x*x). Per semplificare, ti basta sapere che le funzioni lambda sono funzioni anonime costruite a runtime. Considerando che quel frammento può servirti solo da indicazione, puoi ignorarlo e concentrarti su x*x.

Vedi che questa funzione prende un elemento e lo moltiplica per se stesso. È una funzione anonima, quindi devi passarle l'elemento della lista per assicurarti che la funzione lambda lo prenda come input. Ecco perché vedi (lambda x: x*x)(x).

In altre parole, potresti riscrivere l'intera seconda riga del blocco di codice qui sopra così:

f = lambda x: x*x
[f(x) for x in range(10)]Offerto da

In cui prima definisci la funzione lambda che dice che vuoi moltiplicare un elemento per se stesso, e poi nella seconda riga la applichi all'elemento della lista, così che ogni elemento venga moltiplicato per se stesso.

Nota che oltre alle list comprehension, esistono anche le set e le dictionary comprehension.

È già tanta roba, ma c'è molto altro da scoprire sulla list comprehension.

Continua a leggere le prossime domande frequenti per imparare di più sulle list comprehension annidate e per vedere esempi pratici di cosa possono significare per la tua programmazione in Python!

10. Come contare le occorrenze di un elemento in una lista in Python

Poiché le liste non hanno il criterio di unicità degli elementi, come i set, potresti voler sapere non solo quante volte un particolare elemento compare nella lista, ma anche quante volte compare ciascun elemento.

Qui sotto trovi le risposte a entrambe le domande!

# Count the occurrences of the number 4
print([1, 2, 9, 4, 5, 4, 1].count(4))

# Count the occurrences of the letter "a"
list = ["d", "a", "t", "a", "c", "a", "m", "p"]
list.count("a")

list= ["a","b","b"]
[[x,list.count(x)] for x in set(list)]

# Import `Counter` from the `collections` library
from collections import Counter

# This is your list
list = ["a","b","b"]

# Pass `list` to `Counter()`
Counter(list)

11. Come suddividere una lista Python in blocchi di dimensioni uguali

Per suddividere la tua lista in parti della stessa dimensione, puoi ricorrere alla funzione zip() in combinazione con iter():

# Your list `x`
x = [1,2,3,4,5,6,7,8,9]

# Split `x` up in chunks of 3
y = zip(*[iter(x)]*3)

# Use `list()` to print the result of `zip()`
list(y)

Il codice sopra funziona così:

• iter() è un iteratore su una sequenza.
• [iter(x)] * 3 produce una lista con tre oggetti listiterator: ogni list iterator è un iteratore di x.
• l'* passato alla funzione zip() prima di tutto il resto spacchetta la sequenza in argomenti in modo da passare lo stesso iteratore tre volte a zip(), e ogni volta estrae un elemento dall'iteratore.

Aspetta. Quest'ultimo passaggio non è per niente chiaro.

Ti guido passo passo:

1. Avrai tre oggetti list iterator, che puoi immaginare così:

[1,2,3,4,5,6,7,8,9], [1,2,3,4,5,6,7,8,9], [1,2,3,4,5,6,7,8,9]

2. La prima volta, zip() prenderà un elemento dalla lista in sequenza, il che ti lascia con:

[1][2][3]

Nota che gli oggetti iteratore terranno traccia per te di quale elemento è il prossimo nell'iterazione!

3. La seconda volta, gli elementi verranno aggiunti alle tre liste appena create e ti ritroverai con:

[1, 4], [2, 5], [3, 6]

4. L'ultima volta, segui la stessa procedura e ottieni:

[1, 4, 7], [2, 5, 8], [3, 6, 9]

5. Unendo queste tre liste insieme con zip, rimarrai con:

[1, 2, 3], [4, 5, 6], [7, 8, 9]

Se però decidi di inserire questa logica in una funzione, puoi seguire questo approccio:

# Method to split up your lists into chunks
def chunks(list, chunkSize):
    """Yield successive chunkSize-sized chunks from list."""
    for i n range(0, len(list), chunkSize):
        yield list[i:i + chunkSize]

# Use your `chunks` function to print out chunks of the same size
import pprint
pprint.print(list(chunks(range(10, 75), 10)))

La tua funzione chunks() riceve una lista e una dimensione del blocco come input. Poi stamperà: "Yield successive (la tua dimensione) porzioni dalla lista" (cioè la lista che dai al metodo chunks()).

Poi vedi range(0, len(list), chunkSize): questa lista parte da 0 e termina all'intero che indica la lunghezza della tua lista. Il valore di step è uguale al valore chunkSize che passi a chunks().

Per ogni elemento in questa lista costruita da range(), produci una porzione della lista originale, a partire dall'indice dell'elemento che viene dato e terminando all'indice + la dimensione del blocco fornita.

Per esempio, se l'indice 0 passa attraverso il ciclo for, verrà restituita una lista [0:2]. Nell'iterazione successiva, l'indice 2 passa attraverso il ciclo for (ricorda il valore di step!), e verrà restituita una porzione [2:4] della lista originale.

Nota che usi pprint(), o pretty print, per stampare il risultato.

Puoi anche semplicemente usare la list comprehension invece di scrivere una funzione:

# Set up your list and chunk size
list = range(0, 50)
chunk = 5

# Split up your list into chunks
[list[i:i + chunk] for i in range(0, len(list), chunk)]

12. Come iterare su una lista in Python

Puoi facilmente scorrere qualsiasi lista con un for loop. Per chi non ha lavorato molto con i for loop, funziona così: il for loop consente di eseguire un'azione per ogni elemento della lista.

In Python, un for loop è così:

# This is your list
mylist = [[1,2,3],[4,5,6,7],[8,9,10]]

# Loop over your list and print all elements that are of size 3
for x in mylist:
      if len(x)==3:
        print(x)

Hai una lista mylist e dici a Python di verificare se la lunghezza di ogni elemento è uguale a 3. Poiché le nostre liste contengono due liste che hanno tre elementi ciascuna, cioè [1,2,3] e [8, 9,10], verranno stampate solo queste.

Nota come x nel blocco di codice sopra possa essere cambiato in element, listElement o qualsiasi altro nome tu voglia. Provalo in console!

Vedi che il risultato non mostra gli indici degli elementi. Se vuoi iterare su una lista usando l'indice, puoi fare così:

# This is your list
myList = [3,4,5,6]

# Loop over `myList` and print tuples of all indices and values 
for i, val in enumerate(myList):
     print(i, val)

Dal momento che vuoi stampare non solo gli elementi ma anche il loro indice, ovviamente devi mostrarlo nel for loop. Ecco perché usiamo enumerate(myList), che restituirà un indice e un valore. Naturalmente, dobbiamo mostrarlo anche all'inizio della for statement: vedi i, val per chiarire che ci aspettiamo indice e valore come risultato.

Nota che puoi anche usare la list comprehension per iterare su una lista. Qui, i risultati vengono già stampati senza dover passare print():

[x for x in myList if len(x)==3]

13. Come creare liste piatte a partire da liste di liste

Per creare una semplice lista da una lista di liste, puoi usare la funzione sum(). Non dimenticare di passarle la tua lista e una lista vuota:

# Your initial list of lists
list = [[1,2],[3,4],[5,6]]

# Flatten out your original list of lists with `sum()`
sum(list, [])

Puoi anche usare due diversi approcci per appiattire le tue liste:

# You can reduce the lists of lists of lists like this
from functools import reduce
print(reduce(lambda x,y: x+y,listOfLists))

# Or you can use list comprehension
print([item for sublist in listOfLists for item in sublist])

• Usi il metodo reduce(), a cui passi una funzione lambda. Il metodo reduce() serve a ridurre il tuo iterabile a un singolo valore. Come viene ridotto lo stabilisci con la funzione che gli passi. In questo caso, dici che vuoi sommare gli elementi in modo cumulativo: quello che succede è che [1,2] viene aggiunto a [3,4] e questo risultato viene aggiunto a [5,6]. Rappresentato visivamente, ottieni:

([1,2]+[3,4])+[5,6]Offerto da

Ricorda che l'operatore + concatena le liste.

• La seconda opzione per creare liste piatte da liste di liste è usare la list comprehension. Questa istruzione con for annidati non è delle più semplici. In sostanza, prima prendi sublist in list cioè [1, 2], [3, 4], [5, 6] e poi consideri item for item in sublist, stampando ogni elemento della sottolista.

Un altro modo di vedere questa list comprehension annidata è riscriverla come un normale for loop:

list1 = []

for sublist in list:
  for item in sublist:
    list1.append(item)Offerto da

14. Come ottenere l'intersezione di due liste Python

# Intersect both lists with list comprehension
intersection = [list(filter(lambda x: x in list1, sublist)) for sublist in list2]

# Print the result of the intersection
print(____)

# An intersection of both lists, stored in `intersection`
intersection = [[x for x in sublist if x in list1] for sublist in list2]

# Print the result of the intersection
print(intersection)

# Make use of the list and set data structures
print(list(set(list1) & set(list2)))

# Use `intersection()`
print(list(set(list1).intersection(list2)))

15. Come rimuovere i duplicati da una lista in Python

Come descritto nella prima sezione di questo post, è meglio scegliere un set se vuoi memorizzare una raccolta unica di elementi non ordinati.

Per creare un set da un qualsiasi iterabile, puoi semplicemente passarlo alla funzione integrata set(). Se in seguito ti serve di nuovo una vera lista, puoi analogamente passare il set alla funzione list().

Ricorda che un iterabile può essere una lista, un dizionario, ... Verifica se una variabile è un iterabile applicandole il metodo .__iter__.

Il seguente esempio dimostra chiaramente l'uso di set() per eliminare tutti i duplicati dalla tua lista:

# Your list with duplicate values
duplicates = [1, 2, 3, 1, 2, 5, 6, 7, 8]

# Print the unique `duplicates` list
print(list(set(duplicates)))

# A list with small numbers 
smallNumbers = [1, 2, 3]

# Print the unique `duplicates` list without the small numbers
list(set(duplicates) - set(smallNumbers))

Come vedi dall'ultimo risultato, l'ordine originale della lista non viene mantenuto dopo che sottrai gli elementi del set smallNumbers. Come ormai sai, i set sono collezioni non ordinate, quindi qualsiasi ordine avessi nella lista va perso. Quando converti di nuovo il set in lista, viene creato un ordine arbitrario.

Se l'ordine dei tuoi elementi è importante, allora dovrai usare un meccanismo diverso. Questa pagina tratta l'argomento più nel dettaglio.

16. Perché NumPy invece delle liste Python?

In generale, ci sono quattro motivi per cui i programmatori Python preferiscono gli array NumPy alle liste:

• perché gli array NumPy sono più compatti delle liste.
• perché leggere e scrivere elementi è più veloce con NumPy.
• perché NumPy può essere più comodo da usare, grazie al fatto che ottieni molte operazioni su vettori e matrici gratuitamente
• perché NumPy può essere più efficiente da usare, in quanto implementato in modo più efficiente.

17. Come creare array NumPy vuoti

Se vuoi semplicemente creare un array NumPy vuoto, puoi eseguire quanto segue:

import numpy
numpy.array([])

Tuttavia, se il tuo obiettivo è inizializzare un array NumPy, puoi anche seguire uno dei seguenti approcci:

# Make a NumPy array of four rows and two columns and filled with 0
numpy.zeros(shape=(4,2))

# Make a NumPy array of 1 values of three columns
numpy.ones(3)

# Make an empty NumPy array
numpy.empty(shape=(0,0))

Assicurati di consultare questa documentazione se cerchi altri modi per inizializzare un array NumPy.

18. Come fare matematica con le liste in Python

Spesso non usiamo le liste solo per memorizzare una raccolta di valori, ma anche per eseguire su di esse alcune operazioni matematiche. Questa sezione copre alcune delle domande più frequenti sul fare matematica con le liste.

cost = [0.424, 0.4221, 0.4185, 0.4132, 0.413]
cases = [10, 20, 30, 40, 50]Offerto da

for c in range(len(cost)):
   cost[c] = (cost[c] * cases[c] / sum(cases))
cost = sum(cost)
print(cost)

sum(cost[c] * cases[c] / sum(cases) for c in range(len(cost)))

sum(cost[c] * cases[c] for c in range(len(cost))) / sum(cases)

# See what `zip()` does to your `cost` and `cases`
print(list(zip(____, ____)))

# Calculate the weighted average
print(sum([x * y for x, y in zip(cost, cases)]) / sum(cases))

# Import numpy as np
import ____ as __

# Make a NumPy array
a = np.array([1,2,3,4,5])

# Return the 50th percentile of our NumPy array
p = np.percentile(a, 50)

#Print the result
print(____)

list1=[1, 2, 3]
list2=[4, 5, 6]Offerto da

from operator import add
list(map(add, list1, list2))

[sum(x) for x in zip(list1, list2)]

Cosa ti aspetta dopo nel tuo percorso di Data Science con Python?

Sei arrivato alla fine del nostro tutorial interattivo sulle liste in Python. È stato parecchio da assimilare e un bel po' di lavoro, ma ce l'hai fatta!

Le liste sono solo un piccolo ma essenziale elemento nel tuo percorso di data science con Python. C'è molto di più da esplorare! Il nostro corso interattivo Introduzione a Python per la Data Science è perfetto per chi vuole imparare di più su Python e su come viene usato nella data science: partirà dalle basi di Python per portarti gradualmente e con delicatezza a un livello intermedio introducendoti a NumPy. Perfetto per chi ha poca esperienza nella programmazione (in Python)!

Se invece sei già un utente Python più avanzato, potresti valutare il nostro corso Python intermedio per la Data Science, pensato per chi è pronto a portare al livello successivo le proprie competenze in data science e Python. Questo corso ti porterà sicuramente ancora più avanti nel tuo apprendimento: ti introduce a più librerie, come matplotlib e pandas, a concetti come logica, flusso di controllo e filtraggio, e include uno studio di caso di data science per consolidare le tue abilità.

Stai già usando Python per la data science ma vuoi spingerti ancora oltre? Potresti essere interessato al nostro corso Importare dati in Python o leggere la nostra serie di tutorial L'importanza del preprocessing nella data science e nella pipeline di machine learning!