Python Language
Tupla

Introducción

Sintaxis

• (1, a, "hola") # a debe ser una variable

• () # una tupla vacía

• (1,) # una tupla de 1 elemento. (1) no es una tupla.

• 1, 2, 3 # la tupla de 3 elementos (1, 2, 3)

Observaciones

Tuplas de indexación

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

La indexación con números negativos comenzará desde el último elemento como -1:

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

Indexando una gama de elementos

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

Las tuplas son inmutables

Una de las principales diferencias entre las list y las tuple en Python es que las tuplas son inmutables, es decir, no se pueden agregar o modificar elementos una vez que se inicializa la tupla. Por ejemplo:

>>> 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

De manera similar, las tuplas no tienen los métodos .append y .extend como la list . Usar += es posible, pero cambia el enlace de la variable, y no la tupla en sí:

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

Tenga cuidado al colocar objetos mutables, como lists , dentro de tuplas. Esto puede llevar a resultados muy confusos al cambiarlos. Por ejemplo:

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

Ayude a poner de un error y cambiar el contenido de la lista dentro de la tupla:

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

Puede usar el operador += para "agregar" a una tupla; esto funciona creando una nueva tupla con el nuevo elemento que "agregó" y asignándola a su variable actual; La tupla antigua no se cambia, pero se reemplaza!

Esto evita la conversión hacia y desde una lista, pero esto es lento y es una mala práctica, especialmente si se va a agregar varias veces.

Tuple son elementos sabios hashable y equiparables

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

Por lo tanto, una tupla se puede poner dentro de un set o como una clave en un dict solo si cada uno de sus elementos puede.

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

Tupla

Sintácticamente, una tupla es una lista de valores separados por comas:

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

Aunque no es necesario, es común encerrar las tuplas entre paréntesis:

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

Crea una tupla vacía con paréntesis:

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

Para crear una tupla con un solo elemento, debe incluir una coma final:

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

Tenga en cuenta que un solo valor entre paréntesis no es una tupla:

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

Para crear una tupla de singleton es necesario tener una coma al final.

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

Tenga en cuenta que para las tuplas singleton se recomienda (vea PEP8 en comas al final ) usar paréntesis. Además, no hay espacios en blanco después de la coma final (ver PEP8 en espacios en blanco )

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

Otra forma de crear una tupla es la función integrada tuple .

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

Estos ejemplos se basan en material del libro Think Python de Allen B. Downey .

Embalaje y desembalaje de tuplas

Las tuplas en Python son valores separados por comas. Los paréntesis que se incluyen para ingresar las tuplas son opcionales, por lo que las dos asignaciones

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

y

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

son equivalentes La asignación a = 1, 2, 3 también se denomina empaquetamiento porque reúne valores en una tupla.

Tenga en cuenta que una tupla de un solo valor también es una tupla. Para decirle a Python que una variable es una tupla y no un solo valor, puedes usar una coma al final

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

También se necesita una coma si usa paréntesis

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

Para desempaquetar valores de una tupla y hacer múltiples asignaciones use

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

El símbolo _ se puede usar como un nombre de variable desechable si solo se necesitan algunos elementos de una tupla, actuando como un marcador de posición:

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

Tuplas de un solo elemento:

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

En Python 3, una variable de destino con un prefijo * se puede usar como una variable de captura (ver Desempaquetando los iterables ):

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

Elementos de inversión

Invertir elementos dentro de una tupla

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

O usando reversa (invertida da un iterable que se convierte en una tupla):

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

Funciones de tupla incorporadas

Las tuplas soportan las siguientes funciones integradas

Comparación

Si los elementos son del mismo tipo, python realiza la comparación y devuelve el resultado. Si los elementos son de diferentes tipos, verifica si son números.

• Si son números, realice la comparación.
• Si cualquiera de los elementos es un número, se devuelve el otro elemento.
• De lo contrario, los tipos se ordenan alfabéticamente.

Si llegamos al final de una de las listas, la lista más larga es "más grande". Si ambas listas son iguales devuelve 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

Longitud de la tupla

La función len devuelve la longitud total de la tupla.

len(tuple1)
Out: 5

Max de una tupla

La función max devuelve el elemento de la tupla con el valor máximo

max(tuple1)
Out: 'e'

max(tuple2)
Out: '3'

Min de una tupla

La función min devuelve el elemento de la tupla con el valor mínimo

min(tuple1)
Out: 'a'

min(tuple2)
Out: '1'

Convertir una lista en tupla

La función integrada tuple convierte una lista en una tupla.

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

Concatenación de tuplas

Usa + para concatenar dos tuplas

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