tuplas - obtener valores de una tupla python

Cómo desempaquetar una tupla de longitud n a m<n variables

Question

Esta pregunta ya tiene una respuesta aquí:

• Desempaquetado de tuplas extendido en Python 2 3 respuestas

En Python 3 puedo hacer lo siguiente (ver también PEP3132 en Desempaquetado Iterable Extendido):

a, *b = (1, 2, 3)
# a = 1; b = (2, 3)

¿Qué puedo hacer para lograr el mismo estilo similar en Python 2.x?

Sé que podría usar el acceso a elementos únicos y las operaciones de corte, pero me pregunto si hay una forma más pitonica . Mi código hasta ahora:

a, b = (1, 2, 3)[0], (1, 2, 3)[1:]
# a = 1; b = (2, 3)

Answer 1

Descubrí que el PEP3132 relacionado da algunos ejemplos para Python 2.x también:

Muchos algoritmos requieren dividir una secuencia en un par "primero, descansar":

first, rest = seq[0], seq[1:]

[...]

Además, si el valor de la derecha no es una lista, sino un iterable, debe convertirse a una lista antes de poder hacer slicing; para evitar crear esta lista temporal, uno tiene que recurrir a

it = iter(seq)
first = it.next()
rest = list(it)

Otros enfoques dados en las respuestas a esta pregunta:

Lista de argumentos de función Desempaquetado

requiere una definición / llamada de función adicional:

def unpack(first, *rest): 
  return first, rest
first, rest = unpack( *seq )

Me pregunto por qué se implementa en las listas de argumentos de la función de desembalaje, pero no para el desempaquetado normal de tuplas.

Enfoque del generador

Credits También requiere una implementación de función personalizada. Es un poco más flexible con respecto al número de primeras variables.

def unpack_nfirst(seq, nfirst):
  it = iter(seq)
  for x in xrange(nfirst):
    yield next(it, None)
  yield tuple(it)
first, rest = unpack_nfirst(seq, 1)

Los más pitonicos probablemente serían los mencionados en el PEP de arriba, ¿no?

Answer 2

No creo que haya una manera mejor que la que publicaste, pero aquí hay una alternativa que usa iter

>>> x = (1,2,3)
>>> i = iter(x)
>>> a,b = next(i), tuple(i)
>>> a
1
>>> b
(2, 3)

Answer 3

No estoy seguro sobre el contexto, pero ¿qué pasa con .pop (0)?

Veo que hay tuplas en tu ejemplo, pero si quieres hacer el tipo de cosas que haces, las listas serían más adecuadas, ¿no? (A menos que haya alguna buena razón para que sean inmutables, no se da en la pregunta).

b = [1,2,3]
a = b.pop(0)

Answer 4

Puedo estar equivocado, pero por lo que sé

a, *b = (1, 2, 3)

es solo azúcar sintáctico para cortar e indexar tuplas. Lo encuentro útil pero no muy explícito.

Answer 5

Tengo esta pequeña y práctica función:

def just(n, seq):
    it = iter(seq)
    for _ in range(n - 1):
        yield next(it, None)
    yield tuple(it)

Por ejemplo:

a, b, c = just(3, range(5))
print a, b, c
## 0 1 (2, 3, 4)

también funciona con menos argumentos:

a, b, c = just(3, [''X'', ''Y''])
print a, b, c
## X Y ()

En respuesta al comentario, también puede definir:

def take2(a, *rest): return a, rest
def take3(a, b, *rest): return a, b, rest
def take4(a, b, c, *rest): return a, b, rest
... etc

y úsalo así:

p = (1,2,3)
a, b = take2(*p)
print a, b
## 1 (2, 3)