Keywords: easytut-it

Next: Cicli For Up: Tutorial per principianti in Previous: Definire le Funzioni Indice
Subsections

- Variabili con più di un valore
- Altre funzioni delle liste
- Esempi
- Esercizi

# Liste

# Variabili con più di un valore

Avete già visto le variabili ordinarie che immagazzinano un singolo valore. Tuttavia esistono altri tipi di variabili che possono contenere più di un valore. Queste variabili vengono chiamate liste. Ecco un esempio del'utilizzo delle liste:

    which_one = input("What month (1-12)? ")
    months = ['January', 'February', 'March', 'April', 'May', 'June', 'July',\
            'August', 'September', 'October', 'November', 'December']
    if 1 <= which_one <= 12:
            print "The month is",months[which_one - 1]

E questo l'output dell'esempio:

    What month (1-12)? 3
    The month is March

In questo esempio la variabile `months` è una lista. `months` è definita dalla linea `months = ['January', 'February', 'March', 'April', 'May', 'June', 'July',`\` 'August', 'September', 'October', 'November', 'December']` (osserva nel codice che `\` permette di andare a capo quando la linea di codice è troppo lunga). Le parentesi quadrate `[` e `]` iniziano e finiscono la lista e la virgola (```,`'') separa un elemento della lista dall'altro. La lista qui descritta viene usata nell'istruzione `months[which_one - 1]` e consiste in un insieme di elementi numerati partendo da 0. In altre parole, se cercate l'elemento January dovrete utilizzare `months[0]`. Ovvero, quando assegnate ad una lista un numero, utilizzando la sintassi appena descritta, essa ritornerà l'elemento immagazzinato nella locazione corrispondente.

L'istruzione `if 1 <= which_one <= 12:` sarà vera solo nel caso in cui `which_one` sia un numero tra 1 e 12 inclusi. In altre parole, segue le regole dell'algebra.

Le liste possono essere pensate come una serie di scatole. Ad esempio le scatole create da `demolist = ['life',42, 'the universe', 6,'and',7]` sarebbero all'incirca così:

box number | 0 | 1 | 2 | 3 | 4 | 5
demolist | `life' | 42 | `the universe' | 6 | `and' | 7

Ogni scatola ha un numero di riferimento, cosicché l'istruzione `demolist[0]` seleziona l'elemento `'life'` dalla lista, `demolist[1]` l'elemento `42`, `demolist[5]` l'elemento `7`.

# Altre funzioni delle liste

Il prossimo esempio vi mostrerà moltissimi altri utilizzi per le liste (non mi aspetto che proviate ogni esempio, ma dovreste provarli finché non vi sentite a vostro agio nell'utilizzo delle liste). Iniziamo:

    demolist = ['life',42, 'the universe', 6,'and',7]
    print 'demolist = ',demolist
    demolist.append('everything')
    print "after 'everything' was appended demolist is now:"
    print demolist
    print 'len(demolist) =', len(demolist)
    print 'demolist.index(42) =',demolist.index(42)
    print 'demolist[1] =', demolist[1]
    # Il prossimo ciclo analizza la lista.
    c = 0
    while c < len(demolist):
        print 'demolist[',c,']=',demolist[c]
        c = c + 1
    del demolist[2]
    print "After 'the universe' was removed demolist is now:"
    print demolist
    if 'life' in demolist:
        print "'life' was found in demolist"
    else:
        print "'life' was not found in demolist"
    if 'amoeba' in demolist:
        print "'amoeba' was found in demolist"
    if 'amoeba' not in demolist:
        print "'amoeba' was not found in demolist"
    demolist.sort()
    print 'The sorted demolist is ',demolist

E questo è l'output:

    demolist =  ['life', 42, 'the universe', 6, 'and', 7]
    after 'everything' was appended demolist is now:
    ['life', 42, 'the universe', 6, 'and', 7, 'everything']
    len(demolist) = 7
    demolist.index(42) = 1
    demolist[1] = 42
    demolist[ 0 ]= life
    demolist[ 1 ]= 42
    demolist[ 2 ]= the universe
    demolist[ 3 ]= 6
    demolist[ 4 ]= and
    demolist[ 5 ]= 7
    demolist[ 6 ]= everything
    After 'the universe' was removed demolist is now:
    ['life', 42, 6, 'and', 7, 'everything']
    'life' was found in demolist
    'amoeba' was not found in demolist
    The sorted demolist is  [6, 7, 42, 'and', 'everything', 'life']

Questo esempio utilizza moltissime nuove funzioni. Ad esempio guardate come potete stampare (`print`) un'intera lista per poi aggiungere nuovi elementi con la funzione `append`. `len` serve a contare quanti elementi sono presenti nella lista. Le entrate (`index`) valide di una lista (cioè quelle richiamabili grazie a nome_lista [numero dell'elemento]) vanno da 0 a `len - 1`. La funzione `index` serve a sapere la posizione di un elemento in una lista. Nel caso esistano elementi con lo stesso nome ritornerà la prima posizione dell'elemento. Osservate come l'istruzione `demolist.index(42)` ritorni il valore 1 e l'istruzione `demolist[1]` ritorni il valore 42. La linea `# Il prossimo ciclo analizza la lista` è un semplice commento usato per introdurre le prossime righe di codice:

    c = 0
    while c < len(demolist):
        print 'demolist[',c,']=',demolist[c]
        c = c + 1

Crea una variabile `c` inizialmente di valore 0 che viene incrementata finché non raggiunge l'ultimo elemento della lista. Nel frattempo l'istruzione `print` stampa ogni elemento della lista.

L'istruzione `del` può essere usata per rimuovere un elemento dalla lista. Le linee successive utilizzano l'operatore `in` per sapere se un elemento è presente o meno nella lista.

La funzione `sort` ordina la lista ed è utile se avete bisogno di una lista ordinata dall'elemento più piccolo a quello più grande, oppure in ordine alfabetico. Notate che questo comporta elaborare nuovamente la lista.

Riassumendo possiamo compiere le seguenti operazioni:

esempio | spiegazione
`list[2]` | accesso all'elemento 2 dell'indice
`list[2] = 3` | imposta a 3 l'elemento 2 dell'indice
`del list[2]` | cancella l'elemento 2 dall'indice
`len(list)` | restituisci la lunghezza della lista
`"value" in list` | è vero se `"value"` è un elemento della lista
`"value" not in list` | è vero se `"value"` non è un elemento della lista
`list.sort()` | ordina la lista
`list.index("value")` | restituisce l'indice dove viene trovata la prima occorrenza di `"value"`
`list.append("value")` | aggiunge l'elemento `"value"` alla fine della lista

Il prossimo esempio applica queste funzioni per qualcosa di più utile:

    menu_item = 0
    list = []
    while menu_item != 9:
            print "--------------------"
            print "1. Print the list"
            print "2. Add a name to the list"
            print "3. Remove a name from the list"
            print "4. Change an item in the list"
            print "9. Quit"
            menu_item = input("Pick an item from the menu: ")
            if menu_item == 1:
                    current = 0
                    if len(list) > 0:
                            while current < len(list):
                                    print current,". ",list[current]
                                    current = current + 1
                    else:
                            print "List is empty"
            elif menu_item == 2:
                    name = raw_input("Type in a name to add: ")
                    list.append(name)
            elif menu_item == 3:
                    del_name = raw_input("What name would you like to remove: ")
                    if del_name in list:
                            item_number = list.index(del_name)
                            del list[item_number]
                            # Il codice precedente rimuove solamente le
                            # prime occorrenze di name. Quello successivo,
                            # da Gerald, rimuove tutto.
                            # while del_name in list:
                            #        item_number = list.index(del_name)
                            #        del list[item_number]
                    else:
                            print del_name," was not found"
            elif menu_item == 4:
                    old_name = raw_input("What name would you like to change: ")
                    if old_name in list:
                            item_number = list.index(old_name)
                            new_name = raw_input("What is the new name: ")
                            list[item_number] = new_name
                    else:
                            print old_name," was not found"
    print "Goodbye"

Ecco una parte dell'output:

    --------------------
    1. Print the list
    2. Add a name to the list
    3. Remove a name from the list
    4. Change an item in the list
    9. Quit

    Pick an item from the menu: 2
    Type in a name to add: Jack

    Pick an item from the menu: 2
    Type in a name to add: Jill

    Pick an item from the menu: 1
    0 .  Jack
    1 .  Jill

    Pick an item from the menu: 3
    What name would you like to remove: Jack

    Pick an item from the menu: 4
    What name would you like to change: Jill
    What is the new name: Jill Peters

    Pick an item from the menu: 1
    0 .  Jill Peters

    Pick an item from the menu: 9
    Goodbye

È un programma abbastanza lungo, diamo un'occhiata al codice sorgente per capirlo meglio. La linea `list = []` crea una variabile `list` senza elementi al suo interno. La prossima linea importante è `while menu_item != 9:`. Questa linea inizia un ciclo che permette di ottenere il menu di questo programma. Le linee seguenti del programma visualizzano un menu per permettere di decidere quale parte del programma eseguire.

La sezione:

    current = 0
    if len(list) > 0:
            while current < len(list):
                    print current,". ",list[current]
                    current = current + 1
    else:
            print "List is empty"

Scorre tutta la lista e visualizza ogni suo elemento. `len(list_name)` conta quanti elementi sono presenti nella lista, se `len` ritorna `0` significa che la lista è vuota.

Poche linee più sotto appare l'istruzione `list.append(name)` che aggiunge un elemento alla fine della lista. Saltate giù di un'altro paio di linee e osservate questa sezione di codice:

    item_number = list.index(del_name)
    del list[item_number]

Qui la funzione `index` viene utilizzata per trovare l'indice dell'elemento richiesto, per poi utilizzarlo nella sua cancellazione. `del list[item_number]` viene utilizzato appunto per rimuovere l'elemento dalla lista.

La prossima sezione:

    old_name = raw_input("What name would you like to change: ")
    if old_name in list:
            item_number = list.index(old_name)
            new_name = raw_input("What is the new name: ")
            list[item_number] = new_name
    else:
            print old_name," was not found"

Usa `index` per cercare l'elemento `item_number` ed assegnare il nuovo valore desiderato, `new_name`, alla variabile `old_name`.

Congratulazioni, con le liste sotto il vostro controllo, conoscete abbastanza il linguaggio da poter compiere ogni genere di calcolo che il computer può svolgere (questo tecnicamente sottintende la conoscenza della macchina di Turing). Naturalmente ci sono ancora molte altre funzionalità che vi possono rendere la vita più semplice.

# Esempi

test.py

    ## Questo programma verifica la vostra conoscenza.

    true = 1
    false = 0

    # Prima ottieni il questionario, successivamente sarà modificato
    # per l'uso del file IO.
    def get_questions():
        # Nota come il dato viene magazzinato in una lista di liste.
        return [["What color is the daytime sky on a clear day?","blue"],\
                ["What is the answer to life, the universe and everything?","42"],\
                ["What is a three letter word for mouse trap?","cat"]]

    # Questo verificherà una singola domanda, restituirà vero, se l'utente
    # ha scritto la risposta corretta, altrimenti restituirà falso.
    def check_question(question_and_answer):
        # Estrai la domanda e la risposta dalla lista.
        question = question_and_answer[0]
        answer = question_and_answer[1]
        # Poni la domanda all'utente.
        given_answer = raw_input(question)
        # Confronta le risposte dell'utente con quelle del test.
        if answer == given_answer:
            print "Correct"
            return true
        else:
            print "Incorrect, correct was:",answer
            return false

    # Questa funzione effettuerà tutte le domande.
    def run_test(questions):
        if len(questions) == 0:
            print "No questions were given."
            # Esce dalla funzione.
            return
        index = 0
        right = 0
        while index < len(questions):
            # Controlla la domanda.
            if check_question(questions[index]):
                right = right + 1
            # Vai alla prossima domanda.
            index = index + 1
        # Attenzione all'ordine dei conteggi, prima moltiplica, poi dividi.
        print "You got ",right*100/len(questions),"% right out of",len(questions)

    # Adesso esegui la funzione sulle domande.
    run_test(get_questions())

Semplice output:

    What color is the daytime sky on a clear day?green
    Incorrect, correct was: blue
    What is the answer to life, the universe and everything?42
    Correct
    What is a three letter word for mouse trap?cat
    Correct
    You got  66 % right out of 3

# Esercizi

Espandete il programma test.py in modo che abbia un menu per selezionare le opzioni del test, visualizzi la lista delle domande ed un'opzione per terminare l'esecuzione. Aggiungete inoltre un'altra domanda: "What noise does a truly advanced machine make ?" la risposta sarà "Ping".

Next: Cicli For Up: Tutorial per principianti in Previous: Definire le Funzioni Indice