Spliting un largo tupla en tuplas más pequeños

Question

Tengo una larga tupla como

(2, 2, 10, 10, 344, 344, 45, 43, 2, 2, 10, 10, 12, 8, 2, 10) 

y yo estoy tratando de dividirlo en una tupla de tuplas como

((2, 2, 10, 10), (344, 344, 45, 43), (2, 2, 10, 10), (12, 8, 2, 10)) 

Soy nuevo en Python y estoy no muy bueno con las tuplas o (2, 2, 10, 10, 344, 344, 45, 43, 2, 2, 10, 10, 12, 8, 2, 10) r listas. Mi amigo dijo que debería dividirlo, pero simplemente no puedo obtenerlo -_-

Necesito dividir la tupla en tuplas con 4 elementos que luego usaré un rectángulo para dibujar en una imagen con PIL.

Answer 1

bien hay una cierta expresión idiomática para ello:

def grouper(n, iterable): 
    args = [iter(iterable)] * n 
    return zip(*args) 

t = (2, 2, 10, 10, 344, 344, 45, 43, 2, 2, 10, 10, 12, 8, 2, 10) 
print grouper(4, t) 

Pero este tipo de complicado de explicar. Una versión un poco más general de esto se enumera en the itertools receipes.

También puede cortar la tupla ti mismo

parts = (t[0:4], t[4:8], t[8:12], t[12:16]) 

# or as a function 
def grouper2(n, lst): 
    return [t[i:i+n] for i in range(0, len(t), n)] 

que es probablemente lo que significaba su amigo.

Answer 2

Otra respuesta posible (utilizando un generador):

oldTuple = (2, 2, 10, 10, 344, 344, 45, 43, 2, 2, 10, 10, 12, 8, 2, 10) 
newTuple = tuple(oldTuple[x:x+4] for x in range(0, len(oldTuple), 4)) 

Answer 3

>>> atup 
(2, 2, 10, 10, 344, 344, 45, 43, 2, 2, 10, 10, 12, 8, 2, 10) 
>>> [ atup[n:n+4] for n,i in enumerate(atup) if n%4==0 ] 
[(2, 2, 10, 10), (344, 344, 45, 43), (2, 2, 10, 10), (12, 8, 2, 10)] 

Answer 4

que había escrito una función tal como GIST algún tiempo atrás, disponible en http://gist.github.com/616853

def split(input_list,num_fractions=None,subset_length=None): 
    '''                                 
    Given a list/tuple split original list based on either one of two parameters given but NOT both,         
    Returns generator                             
    num_fractions : Number of subsets original list has to be divided into, of same size to the extent possible.      
        In case equilength subsets can't be generated, all but the last subset            
        will have the same number of elements.                    
    subset_length : Split on every subset_length elements till the list is exhausted.             

    ''' 
    if not input_list: 
     yield input_list #For some reason I can't just return from here : return not allowed in generator expression     
    elif not bool(num_fractions)^bool(subset_length): #Will check for both the invalid cases, '0' and 'None'.. Oh Python :)   
     raise Exception("Only one of the params : num_fractions,subset_length to be provided") 
    else: 
     if num_fractions: #calcluate subset_length in this case                   
      subset_length = max(len(input_list)/num_fractions,1) 

     for start in xrange(0,len(input_list),subset_length): 
      yield input_list[start:start+subset_length] 



>> list(list_split.split((2, 2, 10, 10, 344, 344, 45, 43, 2, 2, 10, 10, 12, 8, 2, 10),subset_length=4)) 
[(2, 2, 10, 10), (344, 344, 45, 43), (2, 2, 10, 10), (12, 8, 2, 10)] 

El código es más largo que las soluciones dadas anteriormente, pero cubren todas las condiciones de división de secuencia posibles.