Parametro funzione Python: tupla/lista

Question

La mia funzione prevede un elenco o una tupla come parametro. Essa in realtà non importa quale è, tutto ciò che fa è passare a un'altra funzione che accetta una lista o tupla:

def func(arg): # arg is tuple or list 
    another_func(x) 
    # do other stuff here 

ora ho bisogno di modificare la funzione un po ', per elaborare un ulteriore elemento:

def func(arg): #arg is tuple or list 
    another_func(x + ['a']) 
    # etc 

Sfortunatamente questo non funzionerà: se arg è tupla, devo dire x + ('a',).

Ovviamente, posso farlo funzionare forzando arg per elencare. Ma non è pulito.

C'è un modo migliore per farlo? Non posso costringere i chiamanti a passare sempre una tupla, naturalmente, dato che si limita a lavorare su di loro.

Answer 1

Se another_func vuole solo un iterabile si può passare itertools.chain(x,'a') ad esso.

Answer 2

come circa:

l = ['a'] 
l.extend(x) 

Edit: Rileggendo domanda, penso che questo sia più ciò che vuoi (l'uso di arg e x era un po 'di confusione):

tuple(arg) + ('a',) 

Come altri hanno già detto, questo probabilmente non è il modo più efficiente, ma è molto chiaro. Se le tue tuple/elenchi sono piccole, potrei usare questa soluzione con soluzioni meno chiare in quanto il risultato della performance sarà trascurabile. Se le tue liste sono grandi, usa le soluzioni più efficienti.

Answer 3

Cosa ne pensi di cambiare l'altra funzione per accettare invece un elenco di parametri?

def func(arg): # arg is tuple or list 
    another_func('a', *x) 

Answer 4

def f(*args): 
    print args 

def a(*args): 
    k = list(args) 
    k.append('a') 
    f(*k) 

a(1, 2, 3) 

uscita:

(1, 2, 3, 'a') 

Answer 5

Il mio suggerimento:

def foo(t): 
    bar(list(t) + [other]) 

Questo non è molto efficiente, però, si sarebbe meglio passare le cose intorno mutabili se si sta andando ad essere , bene, mutandoli.

Answer 6

La funzione accetta qualsiasi iterabile. Quindi utilizzare itertools.chain per aggiungere qualsiasi sequenza si desidera al iterable.

from itertools import chain 

def func(iterable): 
    another_func(chain(iterable, ('a',))) 

Answer 7

È possibile utilizzare il tipo di iterabile passata alla prima funzione di costruire quello che si passa alla seconda:

from itertools import chain 

def func(iterable): 
    it = iter(iterable) 
    another_func(type(iterable)(chain(it, ('a',)))) 

def another_func(arg): 
    print arg 

func((1,2)) 
# (1, 2, 'a') 
func([1,2]) 
# [1, 2, 'a'] 

Answer 8

Se un iterabile è sufficiente è possibile utilizzare itertools.chain, ma essere consapevoli del fatto che se la funzione A (la prima chiamata), itera su iterabile dopo aver chiamato B, è possibile che si verifichino problemi dal momento che i iterabili non possono essere riavvolti.In questo caso si dovrebbe optare per una sequenza o utilizzare iterable.tee per fare una copia del iterabile:

import itertools as it 

def A(iterable): 
    iterable, backup = it.tee(iterable) 
    res = B(it.chain(iterable, 'a')) 
    #do something with res 
    for elem in backup: 
     #do something with elem 

def B(iterable): 
    for elem in iterable: 
     #do something with elem 

Anche se itertools.tee non è poi così efficiente se B consuma tutto o più del iterabile, a quel punto è più semplice convertire lo iterable in uno tuple o uno list.

Answer 9

Direi che la risposta di Santiago Lezica di fare

def foo(t): 
    bar(list(t) + [other]) 

è il migliore perché è il più semplice. (non è necessario importare roba itertools e utilizzare chiamate a catena molto meno leggibili). Ma usalo solo se ti aspetti che sia piccolo. Se t può essere grande, dovresti usare una delle altre soluzioni.