Najlepszy sposób na rozróżnienie między argumentami skalarnymi, listowymi i dict w Pythonie?

Question

Chcę funkcji, która zwykle przyjmuje argument typu X, gdzie X jest skalarem, listą lub dyktatem, i zwraca listę X z tymi samymi kluczami wartości, na podstawie innych informacji.

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') 

Moje pytanie brzmi: jak mogę wysłać między tymi trzema typami?

---

edytuj: Ciąg znaków należy interpretować jako skalar, a nie jako listę/iterowalną. Krotki należy interpretować jako iterowalne.

edit 2: Chcę pisać na maszynie, a nie ściśle pisać.

Answer 1

To zależy od tego, jak ścisłe chcesz być przy swoim wkładzie. Podejście isinstance wymusza określenie typów do zaakceptowania (tj. Bez pisania kaczkami). Działa tak długo, jak użytkownicy przechodzą tylko w tych klasach lub podtypach tych klas. Możesz również spróbować rozróżnić parametry za pomocą obsługiwanych metod. Przykładem tego byłoby

Edit: dodano specjalny przypadek ciągów

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] 

Wybór kontroli przepływu zależy od tego jak elastyczna chcesz być, a także w jaki sposób chcesz yo kontrakt z dwuznaczny przypadki. Np. Czy ciąg jest uważany za sekwencję znaków lub skalar?

Answer 2

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

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

elif isinstance(keydata,dict):#dictionary 

może? (Im prawdopodobnie brakuje kilka rodzajów) ...

Answer 3

Użyj nowego wymyślnych rzeczy :) od zbiorów przywozowych

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

Należy również rozważyć patrząc na module types

Answer 4

Albo można użyć typu, ale isinstance zaleca według http://docs.python.org/2/library/functions.html#type

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

Answer 5

musisz robić rzeczy we właściwej kolejności od str i dict typy są iterable.

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

Dzięki za wszystkie informacje!

skończyło się to zrobić, ponieważ miałem zrobić jakieś wstępne przetwarzanie z następujących keydata przed iteracji nad informacjami:

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__') 

Wtedy nie trzeba się martwić o braku osiągnięcia jednego isinstance bo kogoś implementacja iterowalnej subklassed z czegoś nieoczekiwanego.