Python Language
tuple

introduzione

Sintassi

• (1, a, "ciao") # a deve essere una variabile

• () # una tupla vuota

• (1,) # a tupla a 1 elemento. (1) non è una tupla.

• 1, 2, 3 # la tupla a 3 elementi (1, 2, 3)

Osservazioni

Tuple di indicizzazione

x = (1, 2, 3)
x[0]  # 1
x[1]  # 2
x[2]  # 3
x[3]  # IndexError: tuple index out of range

L'indicizzazione con numeri negativi inizierà dall'ultimo elemento come -1:

x[-1] # 3
x[-2] # 2
x[-3] # 1
x[-4] # IndexError: tuple index out of range

Indicizzazione di un intervallo di elementi

print(x[:-1])   # (1, 2)
print(x[-1:])   # (3,)
print(x[1:3])   # (2, 3)

Le tuple sono immutabili

Una delle principali differenze tra le list s e le tuple in Python è che le tuple sono immutabili, cioè non è possibile aggiungere o modificare elementi una volta che la tupla è stata inizializzata. Per esempio:

>>> t = (1, 4, 9)
>>> t[0] = 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Allo stesso modo, le tuple non hanno metodi .append e .extend come fa la list . Usare += è possibile, ma cambia il binding della variabile, e non la tupla stessa:

>>> t = (1, 2)
>>> q = t
>>> t += (3, 4)
>>> t
(1, 2, 3, 4)
>>> q
(1, 2)

Fai attenzione quando posizioni oggetti mutabili, come lists , all'interno di tuple. Questo può portare a risultati molto confusi quando li si cambia. Per esempio:

>>> t = (1, 2, 3, [1, 2, 3])
(1, 2, 3, [1, 2, 3])
>>> t[3] += [4, 5]

Entrambi genereranno un errore e cambieranno il contenuto della lista all'interno della tupla:

TypeError: 'tuple' object does not support item assignment
>>> t
(1, 2, 3, [1, 2, 3, 4, 5])

Puoi usare l'operatore += per "aggiungere" ad una tupla - questo funziona creando una nuova tupla con il nuovo elemento che hai "aggiunto" e assegnandolo alla sua variabile corrente; la vecchia tupla non è cambiata, ma sostituita!

Questo evita la conversione da e verso un elenco, ma questo è lento ed è una cattiva pratica, specialmente se si intende aggiungere più volte.

Tuple Are Element-wise hashable ed Equitable

hash( (1, 2) )  # ok
hash( ([], {"hello"})  # not ok, since lists and sets are not hashabe

Quindi una tupla può essere messa dentro un set o come una chiave in un dict solo se ognuno dei suoi elementi può.

{ (1, 2) } #  ok
{ ([], {"hello"}) ) # not ok

tuple

Sintatticamente, una tupla è un elenco di valori separati da virgole:

t = 'a', 'b', 'c', 'd', 'e'

Sebbene non sia necessario, è comune racchiudere le tuple tra parentesi:

t = ('a', 'b', 'c', 'd', 'e')

Crea una tupla vuota con parentesi:

t0 = ()
type(t0)            # <type 'tuple'>

Per creare una tupla con un singolo elemento, devi includere una virgola finale:

t1 = 'a',
type(t1)              # <type 'tuple'>

Si noti che un singolo valore tra parentesi non è una tupla:

t2 = ('a')
type(t2)              # <type 'str'>

Per creare una tupla singleton è necessario avere una virgola finale.

t2 = ('a',)
type(t2)              # <type 'tuple'>

Si noti che per le tuple singleton è consigliabile (vedere PEP8 sulle virgole finali ) per utilizzare le parentesi. Inoltre, nessuno spazio vuoto dopo la virgola finale (vedi PEP8 sugli spazi bianchi )

t2 = ('a',)           # PEP8-compliant
t2 = 'a',             # this notation is not recommended by PEP8
t2 = ('a', )          # this notation is not recommended by PEP8

Un altro modo per creare una tupla è la funzione tuple integrata.

t = tuple('lupins')
print(t)              # ('l', 'u', 'p', 'i', 'n', 's')
t = tuple(range(3))
print(t)              # (0, 1, 2)

Questi esempi sono basati sul materiale del libro Think Python di Allen B. Downey .

Imballaggio e disimballaggio Tuples

Le tuple in Python sono valori separati da virgole. Includere parentesi per l'immissione di tuple è facoltativo, quindi i due compiti

a = 1, 2, 3   # a is the tuple (1, 2, 3)

e

a = (1, 2, 3) # a is the tuple (1, 2, 3)

sono equivalenti. L'assegnazione a = 1, 2, 3 viene anche chiamata packing perché racchiude i valori insieme in una tupla.

Nota che una tupla a un valore è anche una tupla. Per dire a Python che una variabile è una tupla e non un singolo valore puoi usare una virgola finale

a = 1  # a is the value 1
a = 1, # a is the tuple (1,)

È necessaria una virgola anche se si utilizzano le parentesi

a = (1,) # a is the tuple (1,)
a = (1)  # a is the value 1 and not a tuple

Per decomprimere i valori da una tupla e utilizzare più assegnazioni

# unpacking AKA multiple assignment
x, y, z = (1, 2, 3) 
# x == 1
# y == 2
# z == 3

Il simbolo _ può essere usato come un nome di variabile usa e getta se uno ha bisogno solo di alcuni elementi di una tupla, che agisce come un segnaposto:

a = 1, 2, 3, 4
_, x, y, _ = a
# x == 2
# y == 3

Tuple a singolo elemento:

x, = 1,  # x is the value 1
x  = 1,  # x is the tuple (1,)

In Python 3 una variabile di destinazione con un prefisso * può essere usata come variabile catch-all (vedi Unpacking Iterables ):

first, *more, last = (1, 2, 3, 4, 5)
# first == 1
# more == [2, 3, 4]
# last == 5

Inversione di elementi

Elementi inversi all'interno di una tupla

colors = "red", "green", "blue"
rev = colors[::-1]
# rev: ("blue", "green", "red")
colors = rev
# colors: ("blue", "green", "red")

O usando l'inverso (invertito dà un iterabile che viene convertito in una tupla):

rev = tuple(reversed(colors))
# rev: ("blue", "green", "red")
colors = rev
# colors: ("blue", "green", "red")

Funzioni tuple integrate

Le tuple supportano le seguenti funzioni built-in

Confronto

Se gli elementi sono dello stesso tipo, python esegue il confronto e restituisce il risultato. Se gli elementi sono di tipo diverso, controlla se si tratta di numeri.

• Se i numeri, eseguire il confronto.
• Se uno degli elementi è un numero, viene restituito l'altro elemento.
• Altrimenti, i tipi sono ordinati alfabeticamente.

Se abbiamo raggiunto la fine di uno degli elenchi, la lista più lunga è "più grande". Se entrambe le liste sono uguali, restituisce 0.

tuple1 = ('a', 'b', 'c', 'd', 'e')
tuple2 = ('1','2','3')
tuple3 = ('a', 'b', 'c', 'd', 'e')

cmp(tuple1, tuple2)
Out: 1

cmp(tuple2, tuple1)
Out: -1

cmp(tuple1, tuple3)
Out: 0

Lunghezza della tupla

La funzione len restituisce la lunghezza totale della tupla

len(tuple1)
Out: 5

Max di una tupla

La funzione max restituisce l'elemento dalla tupla con il valore massimo

max(tuple1)
Out: 'e'

max(tuple2)
Out: '3'

Minimo di una tupla

La funzione min restituisce l'elemento dalla tupla con il valore minimo

min(tuple1)
Out: 'a'

min(tuple2)
Out: '1'

Convertire una lista in tupla

La funzione integrata tuple converte una lista in una tupla.

list = [1,2,3,4,5]
tuple(list)
Out: (1, 2, 3, 4, 5)

Concatenazione di tupla

Usa + per concatenare due tuple

tuple1 + tuple2
Out: ('a', 'b', 'c', 'd', 'e', '1', '2', '3')