Il modo migliore per distinguere tra gli argomenti scalari, elenco e dict in Python?

Question

Voglio una funzione che normalmente contiene un argomento di tipo X in cui X è uno scalare, un elenco o un dict e restituisce un elenco di X con gli stessi valori chiave, in base ad altre informazioni.

def foo(info, k): 
    return [bar(item,k) for item in processInfo(info)] 

def bar(item, keydata): 
    # pseudocode follows. 
    # What we want to do is return an output of parallel type to the input key k, 
    # using the key data to lookup information from the input item. 
    if keydata is a scalar: 
     return item[keydata] 
    elif keydata is a list: 
     return [item[k] for k in keydata] 
    elif keydata is a dict: 
     return dict((k,item[v]) for (k,v) in keydata.iteritems()) 
    else: 
     raise ValueError('bar expects a scalar, list, or dict') 

La mia domanda è, come posso effettuare la spedizione tra i tre tipi?

---

modifica: una stringa deve essere interpretata come scalare, non come lista/iterabile. Le tuple devono essere interpretate come iterabili.

modifica 2: Voglio digitazione anatra, non tipizzazione rigorosa.

Answer 1

Dipende da quanto rigorosa vuoi essere con il tuo contributo. L'approccio isinstance ti obbliga a specificare i tipi da accettare (ad es., Senza battitura d'anatra). Funziona fintanto che i tuoi utenti passano solo in quelle classi o sottotipi di quelle classi. Puoi anche provare a distinguere i parametri con i metodi che supportano. Un esempio di questo sarebbe

Edit: aggiunto il caso speciale per le stringhe

if isinstance(keydata, basestring): 
    # special case to avoid considering strings as containers 
    # for python 3.x use str instead of basestring 
    return item[keydata] 
try: 
    return dict((k,item[v]) for (k,v) in keydata.iteritems()) 
except AttributeError: 
    # it's not a dict-like 
    pass 
try: 
    return [item[k] for k in keydata] 
except TypeError: 
    # it's not iterable 
return item[keydata] 

La scelta del flusso di controllo dipende da quanto flessibile si vuole essere, e anche come si desidera yo accordo con ambigui casi. Ad esempio, una stringa è considerata una sequenza di caratteri o uno scalare?

Answer 2

if isinstance(keydata,(int,float,str)): #scalar 

elif isinstance(keydata,(list,tuple)):#iterable 

elif isinstance(keydata,dict):#dictionary 

forse ?? (Im probabilmente manca alcuni tipi) ...

Answer 3

Utilizzare il nuovo roba di fantasia :) da collezioni di importazione

>>> isinstance([], collections.Sequence) 
True 
>>> isinstance({}, collections.Mapping) 
True 

Si dovrebbe anche prendere in considerazione guardando il modulo types

Answer 4

Oppure è possibile utilizzare il tipo, ma isinstance è consigliato in base al http://docs.python.org/2/library/functions.html#type

if type(asd) in (int, str): 
    print 'asd is int or str' 

Answer 5

Hai bisogno di fare le cose nel giusto ordine dal str e dict tipi sono iterabile.

from collections import Iterable, Mapping # in Python 3 use from collections.abc 

def bar(item, keydata): 
    if isinstance(keydata, Mapping): 
     return {k: item[v] for (k,v) in keydata.iteritems()} 
    elif isinstance(keydata, Iterable) and not isinstance(keydata, str): 
     return [item[k] for k in keydata] 
    return item[keydata] 

Answer 6

Grazie per tutte le informazioni!

ho finito per fare questo, dal momento che ho dovuto fare un po 'di pre-elaborazione del keydata prima iterazione sulle informazioni:

def asKVlists(keydata): 
    # return a tuple (keys, values, isScalar) 
    # where keys and values are iterable 
    if not isinstance(keydata, basestring): 
     # check for dict behavior: 
     try: 
      return zip(*keydata.iteritems()) + [False] 
     except AttributeError: 
      pass 

     # otherwise check for list behavior 
     # make sure we can iterate over it 
     try: 
      iter(keydata) 
      return (None, keydata, False) 
     except TypeError: 
      pass 
    return (None, (keydata,), True) 

Answer 7

def is_scalar(x): 
    return hasattr(x, 'lower') or not hasattr(x, '__iter__') 

Allora non dovrai mai preoccuparti di non aver un isinstance a causa di qualcuno implementando una sottoclasse iterabile da qualcosa di inaspettato.