 |
 |
 |
La libreria di riferimento di Python |  |
 |
 |
|
|
|
La libreria di riferimento di Python | |
|
|
Esistono sei tipi sequenza: stringhe, stringhe Unicode, liste, tuple, buffer e oggetti xrange.
Le stringhe costanti vengono scritte tra apici singoli o doppi:
'xyzzy', "frobozz". Vedete il capitolo 2 del
Manuale di riferimento Python per
maggiori informazioni sulle stringhe costanti. Le stringhe Unicode
sono molto simili alle stringhe, ma vengono specificate nella sintassi
usando un carattere "u" che le precede: u'abc',
u"def". Le liste si costruiscono con parentesi quadre, gli
elementi vengono separati da virgole: [a, b, c]. Le tuple
vengono costruite dall'operatore virgola (non all'interno di parentesi
quadre) con o senza le parentesi tonde, ma una tupla vuota deve avere le
parentesi tonde, come a, b, c o (). Una tupla costituita
da un singolo elemento deve evere virgola in coda, come (d,).
Gli oggetti buffer non vengono direttamente supportati dalla sintassi di Python, ma possono essere creati chiamando la funzione built-in buffer(). Non supportano la concatenazione o la ripetizione.
Gli oggetti Xrange sono simili ai buffer in quanto non esiste una
specifica sintassi per crearli, ma vengono creati usando la funzione
xrange(). Non supportano l'affettamento, la concatenazione
o la ripetizione, e l'uso di in, not in,
min() o max() su di essi non ha effetto.
La maggior parte dei tipi sequenza supporta le seguenti operazioni. Le operazioni "in" e "not in" hanno la stessa priorità delle operazioni di confronto. Le operazioni "+" e "*" hanno la stessa priorità delle corrispondenti operazioni numeriche.2.7
Questa tabella mostra la sequenza delle operazioni ordinate per priorità ascendente (operazioni nello stesso gruppo hanno la stessa priorità). Nella tabella, s e t sono sequenze dello stesso tipo; n, i e j sono interi:
| Operazione | Risultato | Note |
|---|---|---|
x in s |
1 se un elemento di s è uguale a x, altrimenti 0 |
(1) |
x not in s |
0 se un elemento di s è uguale a x, altrimenti 1 |
(1) |
s + t |
la concatenazione di s e t | |
s * n , n * s |
n copie superficiali di s concatenate | (2) |
s[i] |
lo i-esimo elemento i di s, origine 0 | (3) |
s[i:j] |
fetta di s da i a j | (3), (4) |
s[i:j:k] |
fetta di s da i a j con passo k | (3), (5) |
len(s) |
lunghezza di s | |
min(s) |
il più piccolo elemento di s | |
max(s) |
il più grande elemento di s |
Note:
in e not in agiscono come una
sotto stringa di prova. In versioni di Python precedenti la 2.3,
x doveva essere una stringa di lunghezza 1. In Python 2.3 e
successive, x può essere una stringa di qualsiasi lunghezza.
0 viene trattato
come 0 (che restituisce una sequenza vuota dello stesso tipo
di s). Notate anche che le copie sono superficiali; le
strutture annidate non vengono copiate. Questo spesso confonde i
nuovi programmatori Python; considerate:
>>> lists = [[]] * 3 >>> lists [[], [], []] >>> lists[0].append(3) >>> lists [[3], [3], [3]]
È accaduto che lists è una lista contenente tre copie
della lista [[]] (una lista di un elemento che contiene una
lista vuota), ma la lista contenuta viene condivisa da ogni copia.
Potete generare una lista di differenti liste in questo modo:
>>> lists = [[] for i in range(3)] >>> lists[0].append(3) >>> lists[1].append(5) >>> lists[2].append(7) >>> lists [[3], [5], [7]]
len(s) + i o
len(s) + j vengono sostituiti. Ma notate che -0
è sempre 0.
i <= k < j. Se i o j è più
grande di len(s), usate len(s). Se i
viene omesso, usate 0. Se j viene omesso, usate
len(s). Se i è più grande o uguale a j, la
fetta è vuota.
x = i + n*k tali che
0 <= n < abs(i-j). Se i o
j è più grande di len(s), usate
len(s). Se i o j vengono omessi diventano
allora valori ``end'' (dipendenti dal segno di k).
Notate, k non può essere zero.
|
|
|
La libreria di riferimento di Python | |
|
|