Gestisce in modo elegante diversi tipi di parametri

Question

Ho una funzione che, nel più semplice dei casi, opera su un iterabile di elementi.

def foo(items): 
    for item in items: 
     # do stuff 

A volte, io non voglio passare un iterabile di voci direttamente, ma piuttosto un oggetto che fornisce un metodo per ottenere il iterabili:

def foo(obj): 
    for item in obj.iteritems(): 
     # do same stuff as above 

posso unire questi due casi come questo :

Questo funziona bene. Ora ho una terza caso d'uso che assomiglia a questo:

def foo(objs): 
    for item in itertools.chain.from_iterable(obj.iteritems() for obj in objs): 
     # do same stuff again 

posso ancora usare l'approccio try-except, dal momento che le interfacce sono incompatibili. Tuttavia, il tentativo di cattura annidato inizierà a diventare molto brutto. Ancora di più quando voglio aggiungere un quarto caso d'uso. C'è un modo per risolvere questo problema senza annidare i blocchi try?

Answer 1

Così com'è, probabilmente si dovrebbe utilizzare almeno due metodi qui, il terzo basta chiamare il primo con il risultato itertools.chain.from_iterable. Potresti anche potenzialmente avere un uso per * args; dipende dal tuo caso preciso (fornire un esempio reale è utile). È inoltre possibile utilizzare una semplice funzione di supporto per restituire il giusto tipo di iteratore.

Forse questo potrebbe funzionare:

def _foo_iter(obj): 
    try: 
     return obj.iteritems() 
    except AttributeError: 
     return obj 

def foo(*objs): 
    for obj in objs: 
     for item in _foo_iter(obj): 

Answer 2

Per verificare se un oggetto è iterabile:

import collections 
isinstance(obj, collections.Iterable) 

Questo dovrebbe farti liberarsi di alcuni problemi.

Inoltre, un modo per gestire questi problemi è quello di utilizzare ricorsività (non so se è applicabile però):

def foo(obj): 
    if isinstance(obj, collections.Iterable): 
     for el in obj: 
      foo(el) 
    # now do stuff 

Answer 3

hasattr(object, name)

if hasattr(obj, '__iter__'): 
     return [o for o in obj] 
    elif hasattr(obj, 'iteritems'): 
     return [o for o in obj.iteritems()] 
    elif isinstance(obj, list) or isinstance(obj, tuple): 
     return [o.iteritems() for o in [o for o in obj]] 
    else: 
     raise TypeError 

class Bar(list): 
    def iteritems(self): 
     return self.__iter__() 

print foo([1,2,3]) 
print foo(Bar([1,2,3])) 
print foo([[1,2,3], [1,2,3]]) 
print foo(1) 

[1, 2, 3] 
[1, 2, 3] 
[[1, 2, 3], [1, 2, 3]] 
Traceback (most recent call last): 
    File "test.py", line 20, in <module> 
    print foo(1) 
    File "test.py", line 11, in foo 
    raise TypeError 
TypeError 

Answer 4

deve essere d'accordo con Chris: la magia capire-tutto ingresso sta per girarsi e mordere. Se si passa a un iterable di oggetti-con-iterables di iterable, come si specifica a quale livello avviare effettivamente l'elaborazione dei dati?

Molto meglio attenersi a "un elenco o un generatore" come input, quindi pre-elaborare le chiamate alla funzione.