Liste 4 - iterazione e funzioni

Scarica zip esercizi

Naviga file online

In questo foglio trovi esercizi su iterazione su liste e come usarle quando sono usate come argomento di funzioni.

ATTENZIONE: Gli esercizi seguenti richiedono di conoscere:

Se sei alle prime armi con la programmazione, ti conviene saltarli e ripassare in seguito

Che fare

  • scompatta lo zip in una cartella, dovresti ottenere qualcosa del genere:

lists
    lists1.ipynb
    lists1-sol.ipynb
    lists2.ipynb
    lists2-sol.ipynb
    lists3.ipynb
    lists3-sol.ipynb
    lists4.ipynb
    lists4-sol.ipynb
    jupman.py

ATTENZIONE: Per essere visualizzato correttamente, il file del notebook DEVE essere nella cartella szippata.

  • apri il Jupyter Notebook da quella cartella. Due cose dovrebbero aprirsi, prima una console e poi un browser. Il browser dovrebbe mostrare una lista di file: naviga la lista e apri il notebook lists4.ipynb

  • Prosegui leggendo il file degli esercizi, ogni tanto al suo interno troverai delle scritte ESERCIZIO, che ti chiederanno di scrivere dei comandi Python nelle celle successive. Gli esercizi sono graduati per difficoltà, da una stellina ✪ a quattro ✪✪✪✪

Scorciatoie da tastiera:

  • Per eseguire il codice Python dentro una cella di Jupyter, premi Control+Invio

  • Per eseguire il codice Python dentro una cella di Jupyter E selezionare la cella seguente, premi Shift+Invio

  • Per eseguire il codice Python dentro una cella di Jupyter E creare una nuova cella subito dopo, premi Alt+Invio

  • Se per caso il Notebook sembra inchiodato, prova a selezionare Kernel -> Restart

Esercizi con le funzioni

stamparole

✪ Scrive una funzione stamparole che STAMPI tutte le parole in una frase

>>> stamparole("ciao come stai?")
ciao
come
stai?
Mostra soluzione
[16]:
# scrivi qui


ciao
come
stai?

stampari

✪ Scrivere una funzione stampari(lista) che STAMPI i numeri pari di una lista di numeri

>>> stampari([1,2,3,4,5,6])

2
4
6
Mostra soluzione
[17]:
# scrivi qui


2
4
6

cerca26

✪ Scrivere una funzione che RITORNA True se il numero 26 è contenuto in una lista di numeri

>>> cerca26( [1,26,143,431,53,6] )
True
Mostra soluzione
[18]:
# scrivi qui


[18]:
True

stamprisec

✪ Scrivere una funzione stamprisec(stringa) che STAMPI la prima e la seconda parola di una frase

  • per ottenere una lista di parole usare il metodo delle stringhe .split()

>>> stamprisec("ciao come stai?")
ciao come
Mostra soluzione
[19]:
# scrivi qui


ciao come

trepari

✪ Scrivi una funzione che STAMPI “si” se i primi tre elementi di una lista sono numeri pari. Altrimenti, la funzione deve STAMPARE “no”. Nel caso in cui la lista contenga meno di tre elementi, STAMPARE “non va bene”

>>> trepari([6,4,8,4,5])
True
>>> trepari([2,5,6,3,4,5])
False
>>> trepari([4])
non va bene
Mostra soluzione
[20]:
# scrivi qui


True
False
non va bene

separa_ip

✪ Un indirizzo IP è una stringa in cui ci sono quattro sequenze di numeri (di lunghezza massima 3) separati “.”. Per esempio, 192.168.19.34 e 255.31.1.0 sono indirizzi IP. Scrivere una funzione che dato un indirizzo IP in input, STAMPI i numeri che compongono l’indirizzo IP (nota: non vale utilizzare il metodo .replace() )

>>> separa_ip("192.168.0.1")

192
168
0
1
Mostra soluzione
[21]:
# scrivi qui


192
168
0
1

media

✪ Data una lista di numeri interi, scrivi una funzione media(lista) che RITORNI la media aritmetica dei numeri che contiene. Se la lista passata alla funzione dovesse essere vuota, RITORNARE 0

>>> x = media([3,4,2,3])  # ( 10/4 => 2.5)
>>> x
2.5
>>> y = media([])
>>> y
0
>>> z = media([ 30, 28 , 20, 29 ])
>>> z
26.75
Mostra soluzione
[22]:
# scrivi qui


0
[22]:
26.75

Verifica comprensione

ATTENZIONE

Gli esercizi che segueno contengono dei test con gli assert. Per capire come svolgerli, leggi prima Gestione errori e testing

contiene

✪ RITORNA True se elem è presente in lista, altrimenti RITORNA False

Mostra soluzione
[23]:
def contiene(lista, elem):
    raise Exception('TODO IMPLEMENT ME !')


# INIZIO TEST - NON TOCCARE !
# se hai scritto tutto il codice giusto, ed esegui la cella, python non dovrebbe lanciare AssertionError

assert contiene([],'a') == False
assert contiene(['a'],'a') == True
assert contiene(['a','b','c'],'b') == True
assert contiene(['a','b','c'],'z') == False
# FINE TEST

primi

✪ RITORNA una lista con i primi numeri da 0 incluso a n escluso.

  • Per esempio, primi(3) deve ritornare [0,1,2]

  • Se n < 0, ritorna la lista vuota

Ingredienti:

  • variabile lista da ritornare

  • variabile contatore

  • ciclo while (volendo ci sono anche altri modi)

  • return

Mostra soluzione
[24]:

def primi(n):
    raise Exception('TODO IMPLEMENT ME !')



# INIZIO TEST - NON TOCCARE !
# se hai scritto tutto il codice giusto, ed esegui la cella, python non dovrebbe lanciare AssertionError

assert primi(-1) == []
assert primi(-2) == []
assert primi(0) == []
assert primi(1) == [0]
assert primi(2) == [0,1]
assert primi(3) == [0,1,2]
# FINE TEST

primul

✪ RITORNA True se il primo elemento di lista è uguale all’ultimo, altrimenti RITORNA False

NOTA: Si può assumere che lista contenga sempre almeno un elemento.

Mostra soluzione
[25]:

def primul(lista):
    raise Exception('TODO IMPLEMENT ME !')



# INIZIO TEST - NON TOCCARE !
# se hai scritto tutto il codice giusto, ed esegui la cella, python non dovrebbe lanciare AssertionError

assert primul(['a']) == True
assert primul(['a','a']) == True
assert primul(['a','b']) == False
assert primul(['a','b','a']) == True
assert primul(['a','b','c','a']) == True
assert primul(['a','b','c','d']) == False
# FINE TEST

duplica

✪ RITORNA una NUOVA lista, in cui ciascun elemento della lista in ingresso è duplicato. Per esempio,

duplica(['ciao','mondo','python'])

deve ritornare

['ciao','ciao','mondo','mondo','python','python']

Ingredienti: - variabile per nuova lista - ciclo for - return

Mostra soluzione
[26]:
def duplica(lista):
    raise Exception('TODO IMPLEMENT ME !')


# INIZIO TEST - NON TOCCARE !
# se hai scritto tutto il codice giusto, ed esegui la cella, python non dovrebbe lanciare AssertionError

assert duplica([]) ==  []
assert duplica(['a']) == ['a','a']
assert duplica(['a','b']) == ['a','a','b','b']
assert duplica(['a','b','c']) == ['a','a','b','b','c','c']
assert duplica(['a','a']) == ['a','a','a','a']
assert duplica(['a','a','b','b']) == ['a','a','a','a','b','b','b','b']
# FINE TEST

hadup

✪✪ RESTITUISCE True se lista contiene l’elemento el più di una volta, altrimenti RESTITUISCE False.

Mostra soluzione
[27]:
def hadup(el, lista):
    raise Exception('TODO IMPLEMENT ME !')

# INIZIO TEST - NON TOCCARE !
# se hai scritto tutto il codice giusto, ed esegui la cella, python non dovrebbe lanciare AssertionError

assert hadup("a", []) == False
assert hadup("a", ["a"]) == False
assert hadup("a", ["a", "a"]) == True
assert hadup("a", ["a", "a", "a"]) == True
assert hadup("a", ["b", "a", "a"]) == True
assert hadup("a", ["b", "a", "a", "a"]) == True
assert hadup("b", ["b", "a", "a", "a"]) == False
assert hadup("b", ["b", "a", "b", "a"]) == True
# FINE TEST

ord3

✪✪ RITORNA True se la lista fornita ha i primi tre elementi ordinati in modo crescente, False altrimenti

  • se lista ha meno di 3 elementi, ritorna False

Mostra soluzione
[28]:
def ord3(lista):
    raise Exception('TODO IMPLEMENT ME !')

# INIZIO TEST - NON TOCCARE !
# se hai scritto tutto il codice giusto, ed esegui la cella, python non dovrebbe lanciare AssertionError

assert ord3([5]) == False
assert ord3([4,7]) == False
assert ord3([4,6,9]) == True
assert ord3([4,9,7]) == False
assert ord3([9,5,7]) == False
assert ord3([4,8,9,1,5]) == True   # primi 3 elementi crescenti
assert ord3([9,4,8,10,13]) == False  # primi 3 elementi NON crescenti

filtrab

✪✪ Prende in input una lista di caratteri, e RITORNA una NUOVA lista contenente solo i caratteri 'a' e 'b' trovati scorrendo la lista originale

Esempio:

filtrab(['c','a','c','d','b','a','c','a','b','e'])

deve ritornare

['a','b','a','a','b']
Mostra soluzione
[29]:
def filtrab(lista):
    raise Exception('TODO IMPLEMENT ME !')


# INIZIO TEST - NON TOCCARE !
# se hai scritto tutto il codice giusto, ed esegui la cella, python non dovrebbe lanciare AssertionError

assert filtrab([]) == []
assert filtrab(['a']) == ['a']
assert filtrab(['b']) == ['b']
assert filtrab(['a','b']) == ['a','b']
assert filtrab(['a','b','c']) == ['a','b']
assert filtrab(['a','c','b']) == ['a','b']
assert filtrab(['c','a','b']) == ['a','b']
assert filtrab(['c','a','c','d','b','a','c','a','b','e']) == ['a','b','a','a','b']

l = ['a','c','b']
assert filtrab(l) == ['a','b'] # verifica che sia ritornata una NUOVA lista
assert l == ['a','c','b']      # verifica che la lista originale non sia stata modificata

# FINE TEST

collina

✪✪ RITORNA una lista in cui all’inizio sono presenti i primi numeri da uno a n in crescendo, e dopo n decrescono fino a 1. NOTA: n è contenuto una sola volta.

Per esempio,

collina(4)

deve ritornare

[1,2,3,4,3,2,1]

Ingredienti: - variabile per la lista da ritornare - due cicli for di seguito e funzioni range oppure due while di seguito

Mostra soluzione
[30]:
def collina(n):

    raise Exception('TODO IMPLEMENT ME !')

# INIZIO TEST - NON TOCCARE !
# se hai scritto tutto il codice giusto, ed esegui la cella, python non dovrebbe lanciare AssertionError

assert collina(0) == []
assert collina(1) == [1]
assert collina(2) == [1,2,1]
assert collina(3) == [1,2,3,2,1]
assert collina(4) == [1,2,3,4,3,2,1]
assert collina(5) == [1,2,3,4,5,4,3,2,1]
# FINE TEST

vetta

✪✪ Supponiamo che in una lista vengano salvate le altitudini di una strada di montagna prendendo una misura ogni 3 km (assumiamo che la strada sia costantemente in salita). Ad un certo punto, si arriverà alla vetta della montagna dove si misurerà l’altezza sul livello del mare. Chiaramente, esiste anche una strada per scendere (costantemente in discesa) e anche qui verrà misurata l’altitudine ogni 3 km.

Un esempio di misurazione è [100, 400, 800, 1220, 1600, 1400, 1000, 300, 40]

  • Scrivere una funzione che RITORNI il valore della lista che corrisponde alla misurazione presa in vetta

  • se la lista contiene meno di tre elementi, lanciare eccezione ValueError

>>> vetta([100,400, 800, 1220, 1600, 1400, 1000, 300, 40])
1600
Mostra soluzione
[31]:

def vetta(lista):
    raise Exception('TODO IMPLEMENT ME !')



# INIZIO TEST - NON TOCCARE !
# se hai scritto tutto il codice giusto, ed esegui la cella, python non dovrebbe lanciare AssertionError

try:
    vetta([])         # con questa lista anomala ci attendiamo che sollevi l'eccezione ValueError
    raise Exception("Non sarei dovuto arrivare fin qua !")
except ValueError:    # se solleva l'eccezione,si sta comportando come previsto e non facciamo niente
    pass
assert vetta([5,40,7]) == 40
assert vetta([5,30,4]) == 30
assert vetta([5,70,70, 4]) == 70
assert vetta([5,10,80,25,2]) == 80
assert vetta([100,400, 800, 1220, 1600, 1400, 1000, 300, 40]) == 1600

pari

✪✪ RITORNA una lista contenente gli elementi dalla lista di input alle posizioni pari, cominciando dalla zero che è considerato pari

  • si può assumere che la lista di input contenga sempre un numero pari di elementi

  • Suggerimento: ricordati che range può prendere tre parametri.

Mostra soluzione
[32]:
def pari(lista):
    raise Exception('TODO IMPLEMENT ME !')



# INIZIO TEST - NON TOCCARE !
# se hai scritto tutto il codice giusto, ed esegui la cella, python non dovrebbe lanciare AssertionError
assert pari([]) == []
assert pari(['a','b']) == ['a']
assert pari(['a','b','c','d']) == ['a', 'c']
assert pari(['a','b','a','c']) == ['a', 'a']
assert pari(['a','b','c','d','e','f']) == ['a', 'c','e']
# FINE TEST

mix

✪✪ RITORNA una nuova lista in cui gli elementi sono presi alternativamente da lista1 e da lista2. - si può assumere che lista1 e lista2 contengano lo stesso numero di elementi

Esempio:

mix(['a', 'b','c'], ['x', 'y','z'])

deve dare

['a', 'x', 'b','y', 'c','z']
Mostra soluzione
[33]:

def mix(lista1, lista2):
    raise Exception('TODO IMPLEMENT ME !')


# INIZIO TEST - NON TOCCARE !
# se hai scritto tutto il codice giusto, ed esegui la cella, python non dovrebbe lanciare AssertionError
assert mix([], []) == []
assert mix(['a'], ['x']) == ['a', 'x']
assert mix(['a'], ['a']) == ['a', 'a']
assert mix(['a', 'b'], ['x', 'y']) == ['a', 'x', 'b','y']
assert mix(['a', 'b','c'], ['x', 'y','z']) == ['a', 'x', 'b','y', 'c','z']
# FINE TEST

nostop

✪✪ Quando si analizza una frase, può essere utile processarla per rimuovere parole molto comuni, come per esempio gli articoli e le preposizioni: "un libro su Python" si può semplificare in "libro Python"

Le parole ‘poco utili’ vengono chiamate stopwords. Questo processo è per esempio eseguito dai motori di ricerca per ridurre la complessità della stringa di input fornita dall’utente.

Implementa una funzione che prende una stringa e RITORNA la stringa di input senza le stopwords

SUGGERIMENTO 1: le stringhe in Python sono immutabili ! Per rimuovere le parole devi creare una nuova stringa a partire dalla stringa di partenza.

SUGGERIMENTO 2: crea una lista di parole così:

lista = stringa.split(" ")

SUGGERIMENTO 3: opera le opportune trasformazioni su lista, e poi costruisci la stringa da restituire con " ".join(lista)

Mostra soluzione
[34]:

def nostop(stringa, stopwords):
    raise Exception('TODO IMPLEMENT ME !')

# INIZIO TEST - NON TOCCARE !
# se hai scritto tutto il codice giusto, ed esegui la cella, python non dovrebbe lanciare AssertionError
assert nostop("un", ["un"]) == ""
assert nostop("un", []) == "un"
assert nostop("", []) == ""
assert nostop("", ["un"]) == ""
assert nostop("un libro", ["un"]) == "libro"
assert nostop("un libro su Python", ["un","su"]) == "libro Python"
assert nostop("un libro su Python per principianti", ["un","uno","il","su","per"]) == "libro Python principianti"