5. Strutture Dati
*****************

Questo capitolo descrive alcune cose che hai già imparato in maggiore
dettaglio, e aggiunge anche alcune nuove cose.


5.1. Più sulle Liste
====================

Il tipo di dato lista ha alcuni metodi aggiuntivi. Ecco tutti i metodi
degli oggetti lista:

list.append(x)

   Aggiunge un elemento alla fine della lista. Equivalente a
   "a[len(a):] = [x]".

list.extend(iterable)

   Estende la lista aggiungendo tutti gli elementi dall'iterabile.
   Equivalente a "a[len(a):] = iterable".

list.insert(i, x)

   Inserisce un elemento in una posizione specificata. Il primo
   argomento è l'indice dell'elemento prima del quale inserire, quindi
   "a.insert(0, x)" inserisce all'inizio della lista, e
   "a.insert(len(a), x)" è equivalente a "a.append(x)".

list.remove(x)

   Rimuove il primo elemento dalla lista il cui valore è uguale a *x*.
   Solleva una "ValueError" se non c'è un tale elemento.

list.pop([i])

   Rimuove l'elemento nella posizione specificata nella lista e lo
   restituisce. Se non viene specificato un indice, "a.pop()" rimuove
   e restituisce l'ultimo elemento della lista. Solleva un
   "IndexError" se la lista è vuota o l'indice è fuori dal range della
   lista.

list.clear()

   Rimuove tutti gli elementi dalla lista. Equivalente a "del a[:]".

list.index(x[, start[, end]])

   Restituisce l'indice zero-based del primo elemento nella lista il
   cui valore è uguale a *x*. Solleva una "ValueError" se non c'è un
   tale elemento.

   Gli argomenti opzionali *start* e *end* sono interpretati come
   nella notazione delle slice e sono usati per limitare la ricerca a
   una particolare sottosequenza della lista. L'indice restituito è
   calcolato rispetto all'inizio della sequenza completa piuttosto che
   all'argomento *start*.

list.count(x)

   Restituisce il numero di volte che *x* appare nella lista.

list.sort(*, key=None, reverse=False)

   Ordina gli elementi della lista in loco (gli argomenti possono
   essere usati per la personalizzazione dell'ordinamento, vedere
   "sorted()" per la loro spiegazione).

list.reverse()

   Inverte gli elementi della lista in loco.

list.copy()

   Restituisce una copia superficiale della lista. Equivalente a
   "a[:]".

Un esempio che utilizza la maggior parte dei metodi della lista:

   >>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
   >>> fruits.count('apple')
   2
   >>> fruits.count('tangerine')
   0
   >>> fruits.index('banana')
   3
   >>> fruits.index('banana', 4)  # Find next banana starting at position 4
   6
   >>> fruits.reverse()
   >>> fruits
   ['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
   >>> fruits.append('grape')
   >>> fruits
   ['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
   >>> fruits.sort()
   >>> fruits
   ['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
   >>> fruits.pop()
   'pear'

Avrai notato che metodi come "insert", "remove" o "sort" che
modificano solo la lista non stampano alcun valore di ritorno --
ritornano il default "None". [1] Questo è un principio di design per
tutte le strutture dati mutabili in Python.

Un'altra cosa che potresti notare è che non tutti i dati possono
essere ordinati o confrontati. Per esempio, "[None, 'hello', 10]" non
può essere ordinata perché gli interi non possono essere confrontati
con le stringhe e "None" non può essere confrontato con altri tipi.
Inoltre, ci sono alcuni tipi che non hanno una relazione di
ordinamento definita. Ad esempio, "3+4j < 5+7j" non è un confronto
valido.


5.1.1. Usare le Liste come Pile
-------------------------------

I metodi delle liste rendono molto facile usare una lista come una
pila, dove l'ultimo elemento aggiunto è il primo elemento recuperato
("last-in, first-out"). Per aggiungere un elemento alla cima della
pila, usa "append()". Per recuperare un elemento dalla cima della
pila, usa "pop()" senza un indice esplicito. Per esempio:

   >>> stack = [3, 4, 5]
   >>> stack.append(6)
   >>> stack.append(7)
   >>> stack
   [3, 4, 5, 6, 7]
   >>> stack.pop()
   7
   >>> stack
   [3, 4, 5, 6]
   >>> stack.pop()
   6
   >>> stack.pop()
   5
   >>> stack
   [3, 4]


5.1.2. Usare le Liste come Code
-------------------------------

È anche possibile usare una lista come una coda, dove il primo
elemento aggiunto è il primo elemento recuperato ("first-in, first-
out"); tuttavia, le liste non sono efficienti per questo scopo. Mentre
gli append e i pop dalla fine della lista sono veloci, fare inserzioni
o pop dall'inizio di una lista è lento (perché tutti gli altri
elementi devono essere spostati di uno).

Per implementare una coda, usa "collections.deque" che è stata
progettata per avere append e pop veloci da entrambi i lati. Per
esempio:

   >>> from collections import deque
   >>> queue = deque(["Eric", "John", "Michael"])
   >>> queue.append("Terry")           # Terry arrives
   >>> queue.append("Graham")          # Graham arrives
   >>> queue.popleft()                 # The first to arrive now leaves
   'Eric'
   >>> queue.popleft()                 # The second to arrive now leaves
   'John'
   >>> queue                           # Remaining queue in order of arrival
   deque(['Michael', 'Terry', 'Graham'])


5.1.3. Comprensioni di Lista
----------------------------

Le comprensioni di lista forniscono un modo conciso per creare liste.
Le applicazioni comuni sono creare nuove liste dove ogni elemento è il
risultato di alcune operazioni applicate a ciascun membro di un'altra
sequenza o iterabile, o creare una sottosequenza di quegli elementi
che soddisfano una certa condizione.

Per esempio, supponiamo di voler creare una lista di quadrati, come:

   >>> squares = []
   >>> for x in range(10):
   ...     squares.append(x**2)
   ...
   >>> squares
   [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Nota che questo crea (o sovrascrive) una variabile chiamata "x" che
esiste ancora dopo che il ciclo è completo. Possiamo calcolare la
lista dei quadrati senza effetti collaterali usando:

   squares = list(map(lambda x: x**2, range(10)))

oppure, equivalentemente:

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

il che è più conciso e leggibile.

Una comprensione di lista consiste di parentesi contenenti
un'espressione seguita da una clausola "for", quindi zero o più
clausole "for" o "if". Il risultato sarà una nuova lista risultante
dalla valutazione dell'espressione nel contesto delle clausole "for" e
"if" che la seguono. Per esempio, questa listcomp combina gli elementi
di due liste se non sono uguali:

   >>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
   [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

e equivale a:

   >>> combs = []
   >>> for x in [1,2,3]:
   ...     for y in [3,1,4]:
   ...         if x != y:
   ...             combs.append((x, y))
   ...
   >>> combs
   [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

Nota come l'ordine delle istruzioni "for" e "if" sia lo stesso in
entrambi questi snippet.

Se l'espressione è una tupla (per es. il "(x, y)" nell'esempio
precedente), deve essere racchiusa tra parentesi.

   >>> vec = [-4, -2, 0, 2, 4]
   >>> # create a new list with the values doubled
   >>> [x*2 for x in vec]
   [-8, -4, 0, 4, 8]
   >>> # filter the list to exclude negative numbers
   >>> [x for x in vec if x >= 0]
   [0, 2, 4]
   >>> # apply a function to all the elements
   >>> [abs(x) for x in vec]
   [4, 2, 0, 2, 4]
   >>> # call a method on each element
   >>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
   >>> [weapon.strip() for weapon in freshfruit]
   ['banana', 'loganberry', 'passion fruit']
   >>> # create a list of 2-tuples like (number, square)
   >>> [(x, x**2) for x in range(6)]
   [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
   >>> # the tuple must be parenthesized, otherwise an error is raised
   >>> [x, x**2 for x in range(6)]
     File "<stdin>", line 1
       [x, x**2 for x in range(6)]
        ^^^^^^^
   SyntaxError: did you forget parentheses around the comprehension target?
   >>> # flatten a list using a listcomp with two 'for'
   >>> vec = [[1,2,3], [4,5,6], [7,8,9]]
   >>> [num for elem in vec for num in elem]
   [1, 2, 3, 4, 5, 6, 7, 8, 9]

Le comprensioni di lista possono contenere espressioni complesse e
funzioni nidificate:

   >>> from math import pi
   >>> [str(round(pi, i)) for i in range(1, 6)]
   ['3.1', '3.14', '3.142', '3.1416', '3.14159']


5.1.4. Comprensioni di Lista Nidificate
---------------------------------------

L'espressione iniziale in una comprensione di lista può essere
qualsiasi espressione arbitraria, inclusa un'altra comprensione di
lista.

Considera il seguente esempio di una matrice 3x4 implementata come una
lista di 3 liste di lunghezza 4:

   >>> matrix = [
   ...     [1, 2, 3, 4],
   ...     [5, 6, 7, 8],
   ...     [9, 10, 11, 12],
   ... ]

La seguente comprensione di lista trasporrà righe e colonne:

   >>> [[row[i] for row in matrix] for i in range(4)]
   [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

Come abbiamo visto nella sezione precedente, la comprensione di lista
interna è valutata nel contesto del "for" che la segue, quindi questo
esempio è equivalente a:

   >>> transposed = []
   >>> for i in range(4):
   ...     transposed.append([row[i] for row in matrix])
   ...
   >>> transposed
   [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

che, a sua volta, è lo stesso di:

   >>> transposed = []
   >>> for i in range(4):
   ...     # the following 3 lines implement the nested listcomp
   ...     transposed_row = []
   ...     for row in matrix:
   ...         transposed_row.append(row[i])
   ...     transposed.append(transposed_row)
   ...
   >>> transposed
   [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

Nel mondo reale, dovresti preferire le funzioni built-in a strutture
di controllo complesse. La funzione "zip()" farebbe un ottimo lavoro
per questo caso d'uso:

   >>> list(zip(*matrix))
   [(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

Vedi Spacchettamento delle Liste di Argomenti per dettagli
sull'asterisco in questa riga.


5.2. L'istruzione "del"
=======================

Esiste un modo per rimuovere un elemento da una lista dato il suo
indice invece del suo valore: l'istruzione "del". Questo differisce
dal metodo "pop()" che restituisce un valore. L'istruzione "del" può
essere usata anche per rimuovere slice da una lista o per cancellare
l'intera lista (cosa che abbiamo fatto prima assegnando una lista
vuota alla slice). Per esempio:

   >>> a = [-1, 1, 66.25, 333, 333, 1234.5]
   >>> del a[0]
   >>> a
   [1, 66.25, 333, 333, 1234.5]
   >>> del a[2:4]
   >>> a
   [1, 66.25, 1234.5]
   >>> del a[:]
   >>> a
   []

"del" può anche essere usato per cancellare variabili intere:

   >>> del a

Fare riferimento al nome "a" d'ora in poi è un errore (almeno finché
un altro valore non viene assegnato ad esso). Troveremo altri usi per
"del" più avanti.


5.3. Tuple e Sequenze
=====================

Abbiamo visto che liste e stringhe hanno molte proprietà comuni, come
le operazioni di indicizzazione e slicing. Sono due esempi di tipi di
dati *sequenza* (vedi Tipi di Sequenza --- list, tuple, range). Poiché
Python è un linguaggio in evoluzione, possono essere aggiunti altri
tipi di dati sequenza. Esiste anche un altro tipo di dati sequenza
standard: la *tupla*.

Una tupla consiste in un numero di valori separati da virgole, ad
esempio:

   >>> t = 12345, 54321, 'hello!'
   >>> t[0]
   12345
   >>> t
   (12345, 54321, 'hello!')
   >>> # Tuples may be nested:
   >>> u = t, (1, 2, 3, 4, 5)
   >>> u
   ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
   >>> # Tuples are immutable:
   >>> t[0] = 88888
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: 'tuple' object does not support item assignment
   >>> # but they can contain mutable objects:
   >>> v = ([1, 2, 3], [3, 2, 1])
   >>> v
   ([1, 2, 3], [3, 2, 1])

Come vedi, in uscita le tuple sono sempre racchiuse tra parentesi, in
modo che le tuple annidate siano interpretate correttamente; possono
essere inserite con o senza parentesi, anche se spesso le parentesi
sono comunque necessarie (se la tupla fa parte di un'espressione più
grande). Tuttavia, non è possibile assegnare ai singoli elementi di
una tupla, mentre è possibile creare tuple che contengono oggetti
mutabili, come le liste.

Sebbene le tuple possano sembrare simili alle liste, vengono spesso
utilizzate in situazioni diverse e per scopi diversi. Le tuple sono
*immutable*, e di solito contengono una sequenza eterogenea di
elementi che sono accessibili tramite unpacking (vedi più avanti in
questa sezione) o indicizzazione (o anche per attributo nel caso di
"namedtuples"). Le liste sono *mutable*, e i loro elementi sono di
solito omogenei e sono accessibili iterando sulla lista.

Un problema speciale è la costruzione di tuple contenenti 0 o 1
elemento: la sintassi presenta alcune peculiarità per accogliere
questi casi. Le tuple vuote sono costruite da una coppia di parentesi
vuota; una tupla con un solo elemento è costruita seguendo un valore
con una virgola (non è sufficiente racchiudere un singolo valore tra
parentesi). Brutto, ma efficace. Ad esempio:

   >>> empty = ()
   >>> singleton = 'hello',    # <-- note trailing comma
   >>> len(empty)
   0
   >>> len(singleton)
   1
   >>> singleton
   ('hello',)

L'istruzione "t = 12345, 54321, 'hello!'" è un esempio di *tuple
packing*: i valori "12345", "54321" e "'hello!'" sono racchiusi
insieme in una tupla. L'operazione inversa è anche possibile:

   >>> x, y, z = t

Questo è chiamato, appropriatamente, *sequence unpacking* e funziona
per qualsiasi sequenza sul lato destro. Lo sequence unpacking richiede
che ci siano tante variabili sul lato sinistro del segno di uguale
quante sono gli elementi nella sequenza. Nota che l'assegnazione
multipla è davvero solo una combinazione di tuple packing e sequence
unpacking.


5.4. Insiemi
============

Python include anche un tipo di dato per gli *insiemi*. Un insieme è
una collezione non ordinata senza elementi duplicati. Gli usi
principali includono il controllo dell'appartenenza e l'eliminazione
degli elementi duplicati. Gli oggetti set supportano anche operazioni
matematiche come unione, intersezione, differenza e differenza
simmetrica.

Le parentesi graffe o la funzione "set()" possono essere utilizzate
per creare insiemi. Nota: per creare un insieme vuoto devi utilizzare
"set()", non "{}"; quest'ultimo crea un dizionario vuoto, una
struttura dati che discuteremo nella sezione successiva.

Ecco una breve dimostrazione:

   >>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
   >>> print(basket)                      # show that duplicates have been removed
   {'orange', 'banana', 'pear', 'apple'}
   >>> 'orange' in basket                 # fast membership testing
   True
   >>> 'crabgrass' in basket
   False

   >>> # Demonstrate set operations on unique letters from two words
   >>>
   >>> a = set('abracadabra')
   >>> b = set('alacazam')
   >>> a                                  # unique letters in a
   {'a', 'r', 'b', 'c', 'd'}
   >>> a - b                              # letters in a but not in b
   {'r', 'd', 'b'}
   >>> a | b                              # letters in a or b or both
   {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
   >>> a & b                              # letters in both a and b
   {'a', 'c'}
   >>> a ^ b                              # letters in a or b but not both
   {'r', 'd', 'b', 'm', 'z', 'l'}

Analogamente alle list comprehensions, sono supportate anche le set
comprehensions:

   >>> a = {x for x in 'abracadabra' if x not in 'abc'}
   >>> a
   {'r', 'd'}


5.5. Dizionari
==============

Un altro tipo di dato utile incorporato in Python è il *dizionario*
(vedi Tipi di Mapping --- dict). I dizionari sono a volte conosciuti
in altre lingue come "memorie associative" o "array associativi". A
differenza delle sequenze, che sono indicizzate da un intervallo di
numeri, i dizionari sono indicizzati da *chiavi*, che possono essere
di qualsiasi tipo immutabile; stringhe e numeri possono sempre essere
chiavi. Le tuple possono essere usate come chiavi se contengono solo
stringhe, numeri o tuple; se una tupla contiene un qualsiasi oggetto
mutabile direttamente o indirettamente, non può essere utilizzata come
chiave. Non puoi usare le liste come chiavi, poiché le liste possono
essere modificate in loco usando assegnazioni di indice, assegnazioni
di slice o metodi come "append()" e "extend()".

È meglio pensare a un dizionario come a un insieme di coppie *chiave:
valore*, con il requisito che le chiavi siano uniche (all'interno di
un dizionario). Una coppia di parentesi crea un dizionario vuoto:
"{}". Inserendo una lista di coppie chiave:valore separate da virgole
dentro le parentesi si aggiungono le coppie iniziali al dizionario;
questo è anche il modo in cui i dizionari vengono scritti in uscita.

Le principali operazioni su un dizionario sono memorizzare un valore
con una chiave e estrarre il valore data la chiave. È anche possibile
eliminare una coppia chiave:valore con "del". Se memorizzi usando una
chiave già in uso, il vecchio valore associato a quella chiave viene
dimenticato. È un errore estrarre un valore usando una chiave
inesistente.

Eseguendo "list(d)" su un dizionario si ottiene una lista di tutte le
chiavi utilizzate nel dizionario, in ordine di inserimento (se la vuoi
ordinata, basta usare "sorted(d)"). Per controllare se una singola
chiave è nel dizionario, usa la parola chiave "in".

Ecco un piccolo esempio usando un dizionario:

   >>> tel = {'jack': 4098, 'sape': 4139}
   >>> tel['guido'] = 4127
   >>> tel
   {'jack': 4098, 'sape': 4139, 'guido': 4127}
   >>> tel['jack']
   4098
   >>> del tel['sape']
   >>> tel['irv'] = 4127
   >>> tel
   {'jack': 4098, 'guido': 4127, 'irv': 4127}
   >>> list(tel)
   ['jack', 'guido', 'irv']
   >>> sorted(tel)
   ['guido', 'irv', 'jack']
   >>> 'guido' in tel
   True
   >>> 'jack' not in tel
   False

Il costruttore "dict()" costruisce dizionari direttamente da sequenze
di coppie chiave-valore:

   >>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
   {'sape': 4139, 'guido': 4127, 'jack': 4098}

Inoltre, le dict comprehensions possono essere utilizzate per creare
dizionari da espressioni di chiave e valore arbitrarie:

   >>> {x: x**2 for x in (2, 4, 6)}
   {2: 4, 4: 16, 6: 36}

Quando le chiavi sono semplici stringhe, a volte è più facile
specificare le coppie utilizzando gli argomenti per parola chiave:

   >>> dict(sape=4139, guido=4127, jack=4098)
   {'sape': 4139, 'guido': 4127, 'jack': 4098}


5.6. Tecniche di Looping
========================

Quando si scorre un dizionario, è possibile recuperare
contemporaneamente la chiave e il valore corrispondente usando il
metodo "items()".

   >>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
   >>> for k, v in knights.items():
   ...     print(k, v)
   ...
   gallahad the pure
   robin the brave

Quando si scorre una sequenza, è possibile recuperare
contemporaneamente l'indice di posizione e il valore corrispondente
usando la funzione "enumerate()".

   >>> for i, v in enumerate(['tic', 'tac', 'toe']):
   ...     print(i, v)
   ...
   0 tic
   1 tac
   2 toe

Per scorrere due o più sequenze contemporaneamente, le voci possono
essere abbinate con la funzione "zip()".

   >>> questions = ['name', 'quest', 'favorite color']
   >>> answers = ['lancelot', 'the holy grail', 'blue']
   >>> for q, a in zip(questions, answers):
   ...     print('What is your {0}?  It is {1}.'.format(q, a))
   ...
   What is your name?  It is lancelot.
   What is your quest?  It is the holy grail.
   What is your favorite color?  It is blue.

Per scorrere una sequenza al contrario, specifica prima la sequenza in
direzione avanti e poi chiama la funzione "reversed()".

   >>> for i in reversed(range(1, 10, 2)):
   ...     print(i)
   ...
   9
   7
   5
   3
   1

Per scorrere una sequenza in ordine ordinato, usa la funzione
"sorted()" che restituisce una nuova lista ordinata lasciando
invariata la sorgente.

   >>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
   >>> for i in sorted(basket):
   ...     print(i)
   ...
   apple
   apple
   banana
   orange
   orange
   pear

Usare "set()" su una sequenza elimina gli elementi duplicati. L'uso di
"sorted()" in combinazione con "set()" su una sequenza è un modo
idiomatico di scorrere gli elementi unici della sequenza in ordine
ordinato.

   >>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
   >>> for f in sorted(set(basket)):
   ...     print(f)
   ...
   apple
   banana
   orange
   pear

A volte è allettante modificare una lista mentre la stai scorrendo;
tuttavia, è spesso più semplice e sicuro creare una nuova lista
invece.

   >>> import math
   >>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
   >>> filtered_data = []
   >>> for value in raw_data:
   ...     if not math.isnan(value):
   ...         filtered_data.append(value)
   ...
   >>> filtered_data
   [56.2, 51.7, 55.3, 52.5, 47.8]


5.7. Maggiori informazioni sulle Condizioni
===========================================

Le condizioni utilizzate nelle istruzioni "while" e "if" possono
contenere qualsiasi operatore, non solo confronti.

Gli operatori di confronto "in" e "not in" sono test di appartenenza
che determinano se un valore è (o non è) in un contenitore.  Gli
operatori "is" e "is not" confrontano se due oggetti sono davvero lo
stesso oggetto.  Tutti gli operatori di confronto hanno la stessa
priorità, che è inferiore a quella di tutti gli operatori numerici.

I confronti possono essere concatenati.  Ad esempio, "a < b == c"
verifica se "a" è minore di "b" e inoltre se "b" è uguale a "c".

I confronti possono essere combinati usando gli operatori booleani
"and" e "or", e il risultato di un confronto (o di qualsiasi altra
espressione booleana) può essere negato con "not".  Questi hanno una
priorità inferiore rispetto agli operatori di confronto; tra di loro,
"not" ha la priorità più alta e "or" la più bassa, in modo che "A and
not B or C" sia equivalente a "(A and (not B)) or C". Come sempre, le
parentesi possono essere utilizzate per esprimere la composizione
desiderata.

Gli operatori booleani "and" e "or" sono i cosiddetti operatori
*short-circuit*: i loro argomenti vengono valutati da sinistra a
destra, e la valutazione si arresta non appena l'esito è determinato.
Ad esempio, se "A" e "C" sono veri ma "B" è falso, "A and B and C" non
valuta l'espressione "C".  Quando vengono utilizzati come un valore
generale e non come booleani, il valore restituito di un operatore
short-circuit è l'ultimo argomento valutato.

È possibile assegnare il risultato di un confronto o di un'altra
espressione booleana a una variabile.  Ad esempio,

   >>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
   >>> non_null = string1 or string2 or string3
   >>> non_null
   'Trondheim'

Nota che in Python, a differenza del C, l'assegnazione dentro
espressioni deve essere fatta esplicitamente con l'operatore detto
walrus operator ":=". Questo evita una comune classe di problemi
incontrati nei programmi C: digitare "=" in un'espressione quando si
intendeva "==".


5.8. Confronto tra Sequenze e Altri Tipi
========================================

Gli oggetti sequenza possono essere tipicamente confrontati con altri
oggetti dello stesso tipo di sequenza. Il confronto usa l'ordinamento
*lessicografico*: prima vengono confrontati i primi due elementi, e se
differiscono questo determina il risultato del confronto; se sono
uguali, vengono confrontati i due successivi, e così via, fino a
quando una delle due sequenze è esaurita. Se gli elementi da
confrontare sono essi stessi sequenze dello stesso tipo, il confronto
lessicografico viene effettuato ricorsivamente.  Se tutti gli elementi
di due sequenze sono uguali tra di loro, le sequenze sono considerate
uguali. Se una sequenza è una sottosequenza iniziale dell'altra, la
sequenza più corta è considerata la minore.  L'ordinamento
lessicografico per le stringhe utilizza il numero del punto di codice
Unicode per ordinare i singoli caratteri. Alcuni esempi di confronti
tra sequenze dello stesso tipo:

   (1, 2, 3)              < (1, 2, 4)
   [1, 2, 3]              < [1, 2, 4]
   'ABC' < 'C' < 'Pascal' < 'Python'
   (1, 2, 3, 4)           < (1, 2, 4)
   (1, 2)                 < (1, 2, -1)
   (1, 2, 3)             == (1.0, 2.0, 3.0)
   (1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)

Nota che confrontare oggetti di tipi diversi con "<" o ">" è legale a
condizione che gli oggetti abbiano metodi di confronto appropriati.
Ad esempio, i tipi numerici misti sono confrontati in base al loro
valore numerico, quindi 0 è uguale a 0.0, ecc.  Altrimenti, invece di
fornire un ordinamento arbitrario, l'interprete alzerà un'eccezione
"TypeError".

-[ Note a piè di pagina ]-

[1] Altri linguaggi possono restituire l'oggetto mutato, il che
    consente di concatenare i metodi, come
    "d->insert("a")->remove("b")->sort();".
