1790

क्या यह निर्धारित करने का एक सरल तरीका है कि एक चर एक सूची, शब्दकोश, या कुछ और है? मुझे एक वस्तु वापस मिल रही है जो या तो टाइप हो सकती है और मुझे अंतर बताने में सक्षम होने की आवश्यकता है।

— जस्टिन एथियर
स्रोत

44

जबकि सामान्य तौर पर मैं आपसे सहमत हूं, ऐसी परिस्थितियां हैं जहां यह जानना उपयोगी है। इस विशेष मामले में मैं कुछ त्वरित हैकिंग कर रहा था जिसे मैंने अंततः वापस ले लिया, इसलिए आप इस समय सही हैं। लेकिन कुछ मामलों में - जब प्रतिबिंब का उपयोग करते हैं, उदाहरण के लिए - यह जानना महत्वपूर्ण है कि आप किस प्रकार की वस्तु के साथ काम कर रहे हैं।

— जस्टिन एथियर

67

@ S.Lott मैं इससे असहमत था; प्रकार जानने में सक्षम होने से, आप कुछ सुंदर प्रकार के इनपुट से निपट सकते हैं और फिर भी सही काम कर सकते हैं। यह आपको शुद्ध बतख-टाइपिंग (जैसे, .bark) पर एक पेड़ पर पूरी तरह से अलग मतलब है।) उदाहरण के लिए, इंटरफ़ेस पर काम करने देता है। उदाहरण के लिए, आप एक फ़ंक्शन बना सकते हैं जो कुछ काम करता है। एक फ़ाइल जो एक स्ट्रिंग (जैसे, एक पथ), एक पथ वस्तु या एक सूची को स्वीकार करती है। सभी में अलग-अलग इंटरफेस हैं, लेकिन अंतिम परिणाम समान है: उस फ़ाइल पर कुछ ऑपरेशन करें।

— रॉबर्ट पी।

22

@ एस। मुझे उम्मीद है कि यह स्पष्ट होगा कि यह एक वंचित उदाहरण है; फिर भी यह डक टाइपिंग का एक प्रमुख विफल बिंदु है, और वह जो tryइसके साथ मदद नहीं करता है। उदाहरण के लिए, यदि आप जानते हैं कि एक उपयोगकर्ता एक स्ट्रिंग या एक सरणी में पारित कर सकता है, तो दोनों सूचकांक-सक्षम हैं, लेकिन उस सूचकांक का मतलब पूरी तरह से अलग है। बस उन मामलों में एक कोशिश पकड़ पर भरोसा अप्रत्याशित और अजीब तरीके से विफल हो जाएगा। एक समाधान एक अलग विधि बनाना है, दूसरा एक छोटे प्रकार की जाँच को जोड़ना है। मैं व्यक्तिगत रूप से कई तरीकों पर बहुआयामी व्यवहार पसंद करता हूं जो लगभग एक ही काम करते हैं ... लेकिन यह सिर्फ मेरे लिए है :)

— रॉबर्ट पी।

22

@ S.Lott, यूनिट परीक्षण के बारे में क्या? कभी-कभी आप चाहते हैं कि आपके परीक्षण यह सत्यापित करें कि कोई फ़ंक्शन सही प्रकार का कुछ लौटा रहा है। एक बहुत ही वास्तविक उदाहरण तब है जब आपके पास वर्ग का कारखाना हो।

— इलियट कैमरन

17

कम वंचित उदाहरण के लिए, एक धारावाहिक / डिसेरिएलाइज़र पर विचार करें। परिभाषा के अनुसार आप उपयोगकर्ता द्वारा प्रदत्त वस्तुओं और क्रमबद्ध प्रतिनिधित्व के बीच रूपांतरण कर रहे हैं। धारावाहिक को आपके द्वारा पारित किए गए ऑब्जेक्ट के प्रकार को निर्धारित करने की आवश्यकता है, और आपके पास रनटाइम पूछे बिना (या बहुत कम से कम, deserialized प्रकार का निर्धारण करने के लिए पर्याप्त जानकारी नहीं हो सकती है, आपको प्रवेश करने से पहले खराब डेटा को पकड़ने के लिए इसे जाँचने की आवश्यकता हो सकती है। आपका सिस्टम!)

— कार्ल

1975

दो अंतर्निहित कार्य हैं जो किसी ऑब्जेक्ट के प्रकार को पहचानने में आपकी सहायता करते हैं। type() यदि आपको किसी वस्तु के सटीक प्रकार की आवश्यकता है, और किसी चीज़ के विरुद्ध किसी वस्तु के प्रकार की जांचisinstance() करने के लिए आप इसका उपयोग कर सकते हैं । आमतौर पर, आप ज्यादातर समय का उपयोग करना चाहते हैं क्योंकि यह बहुत मजबूत है और प्रकार की विरासत का भी समर्थन करता है।isistance()

किसी ऑब्जेक्ट का वास्तविक प्रकार प्राप्त करने के लिए, आप अंतर्निहित type()फ़ंक्शन का उपयोग करते हैं । किसी ऑब्जेक्ट को एकमात्र पैरामीटर के रूप में पास करने से उस ऑब्जेक्ट का प्रकार वापस आ जाएगा:

>>> type([]) is list
True
>>> type({}) is dict
True
>>> type('') is str
True
>>> type(0) is int
True

यह कोर्स कस्टम प्रकारों के लिए भी काम करता है:

>>> class Test1 (object):
        pass
>>> class Test2 (Test1):
        pass
>>> a = Test1()
>>> b = Test2()
>>> type(a) is Test1
True
>>> type(b) is Test2
True

ध्यान दें कि type()केवल तात्कालिक प्रकार की वस्तु वापस आएगी, लेकिन आपको प्रकार विरासत के बारे में नहीं बता पाएंगे।

>>> type(b) is Test1
False

इसे कवर करने के लिए, आपको isinstanceफ़ंक्शन का उपयोग करना चाहिए । यह कोर्स बिल्ट-इन प्रकारों के लिए भी काम करता है:

>>> isinstance(b, Test1)
True
>>> isinstance(b, Test2)
True
>>> isinstance(a, Test1)
True
>>> isinstance(a, Test2)
False
>>> isinstance([], list)
True
>>> isinstance({}, dict)
True

isinstance()आमतौर पर किसी वस्तु के प्रकार को सुनिश्चित करने का पसंदीदा तरीका है क्योंकि यह व्युत्पन्न प्रकारों को भी स्वीकार करेगा। इसलिए जब तक आपको वास्तव में ऑब्जेक्ट (जो भी कारण से) की आवश्यकता है, का उपयोग isinstance()करना पसंद किया जाता है type()।

दूसरा पैरामीटर isinstance()भी एक प्रकार का टुल्ल स्वीकार करता है, इसलिए एक ही बार में कई प्रकार की जांच करना संभव है। isinstanceयदि वस्तु उन प्रकारों में से किसी भी प्रकार की है, तो फिर वापस आ जाएगी:

>>> isinstance([], (tuple, list, set))
True

— प्रहार
स्रोत

68

मुझे लगता है कि यह स्पष्ट करने के isबजाय उपयोग करने के लिए स्पष्ट है ==कि प्रकार एकल हैं

— जॉन ला रोय

18

@gnibbler, मामलों में आप, typechecking जाएगा (जो आप के साथ शुरू करने जा नहीं होना चाहिए) isinstanceकिसी भी तरह है वरीयता स्वरूप, इसलिए कोई भी ==या isइस्तेमाल किया जा है।

— माइक ग्राहम

23

@ माइक ग्राहम, ऐसे समय होते हैं जब typeसबसे अच्छा जवाब होता है। ऐसे समय होते हैं जब isinstanceसबसे अच्छा उत्तर होता है और ऐसे समय होते हैं जब बतख टाइपिंग सबसे अच्छा उत्तर होता है। सभी विकल्पों को जानना महत्वपूर्ण है ताकि आप चुन सकें कि स्थिति के लिए कौन अधिक उपयुक्त है।

— जॉन ला रोय

6

@gnibbler, यह हो सकता है, हालांकि मैं अभी तक उस स्थिति में नहीं भागा हूं जहां type(foo) is SomeTypeसे बेहतर होगा isinstance(foo, SomeType)।

— माइक ग्राहम

5

@poke: मैं पूरी तरह PEP8 के बारे में सहमत हैं, लेकिन आप एक strawman यहाँ पर हमला कर रहे हैं: स्वेन के कुछ तर्कों महत्वपूर्ण हिस्सा PEP8 नहीं था, लेकिन यह है कि आप उपयोग कर सकते हैं isinstanceअपने USECASE के लिए (प्रकार की एक सीमा के लिए जाँच) साथ ही, और साथ साथ ही एक सिंटैक्स को साफ करें, जिसका बहुत बड़ा फायदा है कि आप उपवर्गों पर कब्जा कर सकते हैं। उपयोग करने वाला कोई व्यक्ति OrderedDictआपके कोड को विफल करने के लिए घृणा करेगा क्योंकि यह सिर्फ शुद्ध dicts को स्वीकार करता है।

— फ्लाइंग भेड़

165

आप इसका उपयोग कर सकते हैं type():

>>> a = []
>>> type(a)
<type 'list'>
>>> f = ()
>>> type(f)
<type 'tuple'>

— inkedmn
स्रोत

40

यह एक try... exceptब्लॉक का उपयोग करने के लिए अधिक पायथोनिक हो सकता है । इस तरह, यदि आपके पास एक वर्ग है जो एक सूची की तरह ढेर करता है, या एक तानाशाह की तरह चुटकी लेता है, तो यह ठीक से व्यवहार करेगा कि इसका प्रकार वास्तव में क्या है।

स्पष्ट करने के लिए, चर प्रकारों के बीच "अंतर बताने" का पसंदीदा तरीका कुछ है, जिसे बतख टाइपिंग कहा जाता है : जब तक कि विधियाँ (और वापसी प्रकार) जो एक चर का जवाब देती हैं कि आपकी सबरूटीन अपेक्षाएं हैं, तो उससे वैसा ही व्यवहार करें जैसा आप उससे अपेक्षा करते हैं। होने के लिए। उदाहरण के लिए, यदि आपके पास एक वर्ग है जो ब्रैकेट संचालकों के साथ ओवरलोड करता है getattrऔर setattr, लेकिन कुछ मज़ेदार आंतरिक योजना का उपयोग करता है, तो इसके लिए एक शब्दकोश के रूप में व्यवहार करना उचित होगा यदि यह अनुकरण करने की कोशिश कर रहा है।

type(A) is type(B)चेकिंग के साथ दूसरी समस्या यह है कि अगर Aयह उप-वर्ग है B, तो यह मूल्यांकन करता है कि falseकब, प्रोग्रामिक रूप से, आपको उम्मीद है कि यह होगा true। यदि कोई ऑब्जेक्ट किसी सूची का उपवर्ग है, तो उसे एक सूची की तरह काम करना चाहिए: अन्य उत्तर में प्रस्तुत किए गए प्रकार की जाँच करने से यह रोका जा सकेगा। ( isinstanceहालांकि, काम करेगा)।

— सेठ जॉनसन
स्रोत

16

बतख टाइपिंग वास्तव में अंतर बताने के बारे में नहीं है, हालांकि। यह एक सामान्य इंटरफ़ेस का उपयोग करने के बारे में है।

— जस्टिन एथियर

5

सावधान रहें - अधिकांश कोडिंग स्टाइल गाइड, कोड के सामान्य नियंत्रण प्रवाह के हिस्से के रूप में अपवाद हैंडलिंग का उपयोग नहीं करने की सलाह देते हैं, आमतौर पर क्योंकि यह कोड को पढ़ना मुश्किल बनाता है। try... exceptएक अच्छा समाधान है जब आप त्रुटियों से निपटना चाहते हैं, लेकिन प्रकार के आधार पर व्यवहार का निर्णय लेते समय नहीं।

— रेंस वैन डेर हाइजेन

34

वस्तु के उदाहरणों पर भी आपके पास:

__class__

विशेषता। यहाँ पायथन 3.3 कंसोल से लिया गया एक नमूना है

>>> str = "str"
>>> str.__class__
<class 'str'>
>>> i = 2
>>> i.__class__
<class 'int'>
>>> class Test():
...     pass
...
>>> a = Test()
>>> a.__class__
<class '__main__.Test'>

खबरदार है कि अजगर 3.x और न्यू-स्टाइल कक्षाओं में (वैकल्पिक रूप से पायथन 2.6 से) वर्ग और प्रकार को विलय कर दिया गया है और यह कुछ समय के लिए अप्रत्याशित परिणाम दे सकता है। मुख्य रूप से इस कारण से परीक्षण प्रकार / कक्षाओं के लिए मेरा पसंदीदा तरीका फ़ंक्शन में निर्मित आइंस्टीन है ।

— लोरेंजो पर्सिचेती
स्रोत

2

अंत में आपकी बात बहुत महत्वपूर्ण है। प्रकार (obj) वर्ग सही ढंग से काम नहीं कर रहा था, लेकिन आइंस्टीन ने चाल चली। मैं समझता हूं कि पुनर्स्थापना को वैसे भी पसंद किया जाता है, लेकिन यह केवल व्युत्पन्न प्रकारों की जाँच करने से अधिक लाभदायक है, जैसा कि स्वीकृत उत्तर में सुझाया गया है।

— 22

__class__पाइथन 2.x पर ज्यादातर ठीक है, पाइथन में केवल वही ऑब्जेक्ट्स हैं जिनके पास __class__विशेषता नहीं है वे पुराने-शैली की कक्षाएं AFAIK हैं। मैं आपके पायथन 3 की चिंता को नहीं समझता, वैसे - ऐसे संस्करण पर, बस हर वस्तु में एक __class__विशेषता होती है जो उचित वर्ग की ओर इशारा करती है।

— एलन फ्रांजोनी

21

पायथन ऑब्जेक्ट के प्रकार का निर्धारण करें

किसी वस्तु के प्रकार का निर्धारण type

>>> obj = object()
>>> type(obj)
<class 'object'>

हालांकि यह काम करता है, डबल अंडरस्कोर विशेषताओं से बचें, जैसे __class__- वे शब्दार्थ रूप से सार्वजनिक नहीं हैं, और, जबकि शायद इस मामले में, अंतर्निहित कार्यों में आमतौर पर बेहतर व्यवहार नहीं होता है।

>>> obj.__class__ # avoid this!
<class 'object'>

प्रकार की जाँच

क्या यह निर्धारित करने का एक सरल तरीका है कि एक चर एक सूची, शब्दकोश, या कुछ और है? मुझे एक वस्तु वापस मिल रही है जो या तो टाइप हो सकती है और मुझे अंतर बताने में सक्षम होने की आवश्यकता है।

खैर यह एक अलग सवाल है, प्रकार का उपयोग न करें - उपयोग करें isinstance:

def foo(obj):
    """given a string with items separated by spaces, 
    or a list or tuple, 
    do something sensible
    """
    if isinstance(obj, str):
        obj = str.split()
    return _foo_handles_only_lists_or_tuples(obj)

यह उस मामले को कवर करता है जहां आपका उपयोगकर्ता सबक्लासिंग द्वारा कुछ चतुर या समझदार हो सकता है str- लिस्कोव प्रतिस्थापन के सिद्धांत के अनुसार, आप अपने कोड को तोड़ने के बिना उपवर्ग उदाहरणों का उपयोग करने में सक्षम होना चाहते हैं - और इसका isinstanceसमर्थन करता है।

सार का उपयोग करें

इससे भी बेहतर, आप एक विशिष्ट एब्सट्रैक्ट बेस क्लास की तलाश collectionsकर सकते हैं numbers:

from collections import Iterable
from numbers import Number

def bar(obj):
    """does something sensible with an iterable of numbers, 
    or just one number
    """
    if isinstance(obj, Number): # make it a 1-tuple
        obj = (obj,)
    if not isinstance(obj, Iterable):
        raise TypeError('obj must be either a number or iterable of numbers')
    return _bar_sensible_with_iterable(obj)

या बस स्पष्ट रूप से टाइप-चेक न करें

या, शायद सबसे अच्छा, बतख-टाइपिंग का उपयोग करें, और अपने कोड को स्पष्ट रूप से टाइप-चेक न करें। बत्तख-टाइपिंग अधिक लालित्य और कम वाचालता के साथ लिस्कोव प्रतिस्थापन का समर्थन करता है।

def baz(obj):
    """given an obj, a dict (or anything with an .items method) 
    do something sensible with each key-value pair
    """
    for key, value in obj.items():
        _baz_something_sensible(key, value)

निष्कर्ष

उपयोग typeकरने के लिए वास्तव में एक उदाहरण वर्ग मिलता है।
isinstanceवास्तविक उपवर्गों या पंजीकृत सार के लिए स्पष्ट रूप से जांच करने के लिए उपयोग करें ।
और सिर्फ टाइप-चेकिंग से बचें जहां यह समझ में आता है।

— हारून हॉल
स्रोत

हमेशा try/ exceptस्पष्ट रूप से जाँच करने के बजाय है।

— toonarmycaptain

संभवतः यह है कि उपयोगकर्ता क्या करेंगे यदि वे उन प्रकारों के बारे में सुनिश्चित नहीं हैं, जिनमें वे गुजर रहे हैं। मैं अपवाद को संभालने के साथ एक सही कार्यान्वयन को अव्यवस्थित करना पसंद नहीं करता हूं जब तक कि मुझे अपवाद के साथ कुछ बहुत अच्छा न हो। उठाए गए अपवाद को उपयोगकर्ता को सूचित करने के लिए पर्याप्त होना चाहिए कि उन्हें अपने उपयोग को सही करने की आवश्यकता है।

— हारून हॉल

13

आप उपयोग कर सकते हैं type()या isinstance()।

>>> type([]) is list
True

चेतावनी दी जाती है कि आप listएक ही नाम के वर्तमान दायरे में एक चर असाइन करके क्लोबर या किसी अन्य प्रकार का उपयोग कर सकते हैं ।

>>> the_d = {}
>>> t = lambda x: "aight" if type(x) is dict else "NOPE"
>>> t(the_d) 'aight'
>>> dict = "dude."
>>> t(the_d) 'NOPE'

ऊपर हम देखते हैं कि dictएक स्ट्रिंग को पुन: सौंप दिया जाता है, इसलिए परीक्षण:

type({}) is dict

... विफल रहता है।

इसके आसपास जाने के लिए और type()अधिक सावधानी से उपयोग करने के लिए :

>>> import __builtin__
>>> the_d = {}
>>> type({}) is dict
True
>>> dict =""
>>> type({}) is dict
False
>>> type({}) is __builtin__.dict
True

— deed02392
स्रोत

2

मुझे यकीन नहीं है कि यह बताना जरूरी है कि इस मामले के लिए एक बिल्टइन डेटा टाइप का नाम खराब है। आपका dictस्ट्रिंग बहुत सारे अन्य कोड के लिए भी विफल हो जाएगा, जैसे dict([("key1", "value1"), ("key2", "value2")])। उन प्रकार के मुद्दों का उत्तर "फिर ऐसा न करें" है । बिल्ट टाइप नामों को छायांकित न करें और चीजों को ठीक से काम करने की उम्मीद करें।

— ब्लेकन्थ

3

मैं आपके साथ "ऐसा नहीं करता" भाग पर सहमत हूं। लेकिन वास्तव में किसी को कुछ न करने के लिए कहने के लिए आपको कम से कम यह बताना चाहिए कि क्यों नहीं और मुझे लगा कि यह सिर्फ करने के लिए एक प्रासंगिक अवसर था। मेरा मतलब था कि सतर्क पद्धति बदसूरत दिखती है और यह स्पष्ट करने के लिए कि वे ऐसा क्यों नहीं करना चाहते हैं, यह तय करने के लिए उन्हें छोड़ देना चाहिए।

— .02392

प्रकार () क्लासिक उदाहरणों के लिए पायथन 2.x पर अपेक्षित रूप से काम नहीं करता है।

— एलन फ्रांजोनी

5

हालांकि प्रश्न बहुत पुराने हैं, मैंने खुद को एक उचित तरीका बताते हुए इस पर ठोकर खाई, और मुझे लगता है कि इसे अभी भी स्पष्ट करने की आवश्यकता है, कम से कम पाइथन 2.x के लिए (पायथन 3 पर जांच नहीं की, लेकिन जब से यह मुद्दा क्लासिक कक्षाओं के साथ उठता है जो इस तरह के संस्करण पर चले गए हैं, यह शायद कोई फर्क नहीं पड़ता)।

यहां मैं शीर्षक के प्रश्न का उत्तर देने की कोशिश कर रहा हूं: मैं एक मनमानी वस्तु का प्रकार कैसे निर्धारित कर सकता हूं ? आइंस्टीन का उपयोग करने या न करने के बारे में अन्य सुझाव कई टिप्पणियों और उत्तरों में ठीक हैं, लेकिन मैं उन चिंताओं को संबोधित नहीं कर रहा हूं।

type()दृष्टिकोण के साथ मुख्य मुद्दा यह है कि यह पुरानी शैली के उदाहरणों के साथ ठीक से काम नहीं करता है :

class One:
    pass

class Two:
    pass


o = One()
t = Two()

o_type = type(o)
t_type = type(t)

print "Are o and t instances of the same class?", o_type is t_type

इस स्निपेट को निष्पादित करने से उपज होगी:

Are o and t instances of the same class? True

जो, मैं तर्क देता हूं, वह नहीं है जो ज्यादातर लोग उम्मीद करते हैं।

__class__दृष्टिकोण शुद्धता के लिए सबसे करीब है, लेकिन यह होगा एक महत्वपूर्ण मामले में काम नहीं: जब से पारित कर दिया-वस्तु एक पुरानी शैली है वर्ग (! नहीं एक उदाहरण), के बाद से उन वस्तुओं में इस तरह के गुण की कमी है।

यह कोड का सबसे छोटा स्निपेट है जिसके बारे में मैं सोच सकता था कि इस तरह के वैध प्रश्न को सुसंगत तरीके से संतुष्ट करता है:

#!/usr/bin/env python
from types import ClassType
#we adopt the null object pattern in the (unlikely) case
#that __class__ is None for some strange reason
_NO_CLASS=object()
def get_object_type(obj):
    obj_type = getattr(obj, "__class__", _NO_CLASS)
    if obj_type is not _NO_CLASS:
        return obj_type
    # AFAIK the only situation where this happens is an old-style class
    obj_type = type(obj)
    if obj_type is not ClassType:
        raise ValueError("Could not determine object '{}' type.".format(obj_type))
    return obj_type

— एलन फ्रांजोनी
स्रोत

5

का उपयोग कर सावधान रहना होगा

isinstance(True, bool)
True
>>> isinstance(True, int)
True

लेकिन टाइप करें

type(True) == bool
True
>>> type(True) == int
False

— tnusraddinov
स्रोत

3

पिछले उत्तरों के एक तरफ के रूप में, यह अस्तित्व के उल्लेख के लायक है collections.abcजिसमें कई सार आधार वर्ग (एबीसी) शामिल हैं जो बतख-टाइपिंग के पूरक हैं।

उदाहरण के लिए, स्पष्ट रूप से जाँचने के बजाय कि कोई चीज़ किसके साथ है:

isinstance(my_obj, list)

आप देख सकते हैं, यदि आप केवल यह देखने में रुचि रखते हैं कि आपके पास जो वस्तु है, वह आइटम प्राप्त करने की अनुमति देता है, उपयोग करें collections.abc.Sequence:

from collections.abc import Sequence
isinstance(my_obj, Sequence)

यदि आप उन वस्तुओं में सख्ती से रुचि रखते हैं, जो आइटमों को प्राप्त करने, स्थापित करने और हटाने ( अनुमति देने योग्य अनुक्रम) की अनुमति देती हैं, तो आप इसका विकल्प चुनेंगेcollections.abc.MutableSequence ।

कई अन्य एबीसी वहाँ परिभाषित कर रहे हैं, Mappingवस्तुओं है कि के रूप में नक्शे, इस्तेमाल किया जा सकता के लिए Iterable, Callable, वगैरह। इन सभी की एक पूरी सूची प्रलेखन के लिए देखी जा सकती है ।collections.abc

— दिमित्रिस फासरकिस हिलियार्ड
स्रोत

1

सामान्य तौर पर आप कक्षा के नाम के साथ ऑब्जेक्ट से एक स्ट्रिंग निकाल सकते हैं,

str_class = object.__class__.__name__

और तुलना के लिए इसका उपयोग करते हुए,

if str_class == 'dict':
    # blablabla..
elif str_class == 'customclass':
    # blebleble..

— जोस क्रेस्पो बैरियोस
स्रोत

1

उपयोग करने के बजाय कई व्यावहारिक मामलों में typeया isinstanceआप भी उपयोग कर सकते हैं @functools.singledispatch, जिसका उपयोग जेनेरिक कार्यों ( विभिन्न प्रकारों के लिए एक ही ऑपरेशन को लागू करने वाले कई कार्यों से बना कार्य ) को परिभाषित करने के लिए किया जाता है ।

दूसरे शब्दों में, आप इसका उपयोग तब करना चाहेंगे जब आपके पास निम्नलिखित जैसा कोई कोड हो:

def do_something(arg):
    if isinstance(arg, int):
        ... # some code specific to processing integers
    if isinstance(arg, str):
        ... # some code specific to processing strings
    if isinstance(arg, list):
        ... # some code specific to processing lists
    ...  # etc

यहाँ एक छोटा सा उदाहरण दिया गया है कि यह कैसे काम करता है:

from functools import singledispatch


@singledispatch
def say_type(arg):
    raise NotImplementedError(f"I don't work with {type(arg)}")


@say_type.register
def _(arg: int):
    print(f"{arg} is an integer")


@say_type.register
def _(arg: bool):
    print(f"{arg} is a boolean")

>>> say_type(0)
0 is an integer
>>> say_type(False)
False is a boolean
>>> say_type(dict())
# long error traceback ending with:
NotImplementedError: I don't work with <class 'dict'>

अतिरिक्त हम एक ही बार में कई प्रकारों को कवर करने के लिए अमूर्त कक्षाओं का उपयोग कर सकते हैं :

from collections.abc import Sequence


@say_type.register
def _(arg: Sequence):
    print(f"{arg} is a sequence!")

>>> say_type([0, 1, 2])
[0, 1, 2] is a sequence!
>>> say_type((1, 2, 3))
(1, 2, 3) is a sequence!

— जॉर्जी
स्रोत

0

type()से बेहतर समाधान है isinstance(), खासकर के लिए booleans:

Trueऔर Falseकेवल कीवर्ड हैं जो अर्थ 1और 0अजगर में हैं। इस प्रकार,

isinstance(True, int)

तथा

isinstance(False, int)

दोनों लौट आए True। दोनों बूलियन पूर्णांक का एक उदाहरण हैं। type()हालाँकि, अधिक चतुर है:

type(True) == int

लौटता है False।

— एलेक अल्मेडीन
स्रोत

किसी वस्तु का प्रकार निर्धारित करें?

पायथन ऑब्जेक्ट के प्रकार का निर्धारण करें

प्रकार की जाँच

सार का उपयोग करें

या बस स्पष्ट रूप से टाइप-चेक न करें

निष्कर्ष