2009-04-16 4 views
11

Qual è il modo più piacevole di splitting questo:Tupla multipla a tupla a due coppie in Python?

tuple = ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h') 

in questo:

tuples = [('a', 'b'), ('c', 'd'), ('e', 'f'), ('g', 'h')] 

Supponendo che l'ingresso ha sempre un numero pari di valori.

+7

Non si può decidere di un nome tupla variabile, in quanto sovrascrive la funzione built-in tuple(). – recursive

risposta

36

zip() è tuo amico:

t = ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h') 
zip(t[::2], t[1::2]) 
+0

Bella alternativa! –

+1

+1 perché è bello e non sapevo della sintassi [::] –

+0

non funziona per tuple = ('a', 'b', 'c', 'd', 'e', ​​'f ',' g ',' h ',' i ') # notano l'ultimo' i ', che rende le tuple di lunghezza dispari – dfa

15
[(tuple[a], tuple[a+1]) for a in range(0,len(tuple),2)] 
+0

+1 uso più esplicito della funzione intervallo –

-1

Ecco una ricetta generale per qualsiasi-dimensione del blocco, se potrebbe non essere sempre 2:

def chunk(seq, n): 
    return [seq[i:i+n] for i in range(0, len(seq), n)] 

chunks= chunk(tuples, 2) 

Oppure, se vi piace iteratori :

def iterchunk(iterable, n): 
    it= iter(iterable) 
    while True: 
     chunk= [] 
     try: 
      for i in range(n): 
       chunk.append(it.next()) 
     except StopIteration: 
      break 
     finally: 
      if len(chunk)!=0: 
       yield tuple(chunk) 
+2

Penso che intendessi range (0, len (seq), n), piuttosto che range (0, len (seq)) – Noah

+0

-1: non funziona. – nosklo

+0

Noah: ta, davvero. – bobince

7

Oppure, noi ing itertools (vedere la recipe per grouper):

from itertools import izip 
def group2(iterable): 
    args = [iter(iterable)] * 2 
    return izip(*args) 

tuples = [ab for ab in group2(tuple)] 
+0

+1: per menzionare la documentazione (sei arrivato prima :) – tzot

0

presento questo codice basato su Peter Hoffmann's answer come risposta alla dfa's comment.

È garantito il funzionamento indipendentemente dal fatto che la tupla abbia o meno un numero pari di elementi.

[(tup[i], tup[i+1]) for i in range(0, (len(tup)/2)*2, 2)] 

Il parametro (len(tup)/2)*2 gamma calcola il maggior numero pari inferiore o uguale alla lunghezza della tupla quindi è garantito il funzionamento se la tupla ha un numero di elementi.

Il risultato del metodo sarà una lista. Questo può essere convertito in tuple usando la funzione tuple().

Esempio:

def inPairs(tup): 
    return [(tup[i], tup[i+1]) for i in range(0, (len(tup)/2)*2, 2)] 

# odd number of elements 
print("Odd Set") 
odd = range(5) 
print(odd) 
po = inPairs(odd) 
print(po) 

# even number of elements 
print("Even Set") 
even = range(4) 
print(even) 
pe = inPairs(even) 
print(pe) 

uscita

 
Odd Set 
[0, 1, 2, 3, 4] 
[(0, 1), (2, 3)] 
Even Set 
[0, 1, 2, 3] 
[(0, 1), (2, 3)]