पाइथन में स्केलर, सूची और निर्देश तर्कों के बीच अंतर करने का सबसे अच्छा तरीका?

Question

मुझे एक ऐसा फ़ंक्शन चाहिए जो आम तौर पर टाइप एक्स के तर्क में होता है जहां एक्स या तो स्केलर, एक सूची या एक टोक होता है, और अन्य जानकारी के आधार पर एक्स की एक ही कुंजी मानों की एक सूची देता है।

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

मेरा सवाल है, मैं तीन प्रकार के बीच कैसे प्रेषित कर सकता हूं?

---

संपादित करें: एक स्ट्रिंग को स्केलर के रूप में व्याख्या किया जाना चाहिए, सूची/पुनरावर्तनीय नहीं। ट्यूपल्स को पुनरावृत्त के रूप में व्याख्या किया जाना है।

संपादित 2: मुझे बतख टाइपिंग चाहिए, सख्त टाइपिंग नहीं।

Answer 1

यह कैसे सख्त निर्भर करता है आप अपने इनपुट के साथ रहना चाहते हैं। isinstance दृष्टिकोण आपको स्वीकार करने के प्रकारों को निर्दिष्ट करने के लिए मजबूर करता है (यानी, कोई बतख-टाइपिंग नहीं)। यह तब तक काम करता है जब तक कि आपके उपयोगकर्ता केवल उन वर्गों या उन वर्गों के उपप्रकारों में गुजर रहे हों। आप पैरामीटर को उन तरीकों से अलग करने की कोशिश भी कर सकते हैं जो वे समर्थन करते हैं। इस का एक उदाहरण होगा

संपादित: स्ट्रिंग्स के लिए विशेष मामला जोड़ा

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] 

नियंत्रण प्रवाह की पसंद कैसे लचीला आप होना चाहते हैं पर निर्भर करता है, और यह भी कि कैसे आप अस्पष्ट साथ यो सौदा चाहते हैं मामलों। उदाहरण के लिए, एक स्ट्रिंग वर्णों या एक स्केलर का अनुक्रम माना जाता है?

Answer 2

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

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

elif isinstance(keydata,dict):#dictionary 

शायद ??

Answer 3

(आईएम शायद कुछ प्रकार के लापता) ... आयात संग्रह से नई फैंसी सामान :) का उपयोग करें

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

तुम भी types मॉड्यूल को देख पर विचार करना चाहिए

Answer 4

या आप प्रकार का उपयोग कर सकते हैं, लेकिन isinstance http://docs.python.org/2/library/functions.html#type

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

Answer 5

आप के बाद से str और dict प्रकार 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

सभी जानकारी के लिए धन्यवाद!

मैं यह कर समाप्त हो गया, के बाद से मैं के कुछ पूर्व प्रसंस्करण करना था keydata जानकारी पर पुनरावृत्ति करने से पहले:

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

तो फिर तुम किसी की वजह से एक isinstance में नाकाम रहने के बारे में चिंता करने की आवश्यकता नहीं है अप्रत्याशित कुछ से उपनिवेशित एक पुनरावर्तनीय कार्यान्वयन।