මෙම කේත කොටස් දෙක අතර ඇති වෙනස්කම් මොනවාද?

භාවිතා කිරීම type():

import types

if type(a) is types.DictType:
    do_something()
if type(b) in types.StringTypes:
    do_something_else()

භාවිතා කිරීම isinstance():

if isinstance(a, dict):
    do_something()
if isinstance(b, str) or isinstance(b, unicode):
    do_something_else()

වෙනත් (දැනටමත් හොඳ!) පිළිතුරු, අන්තර්ගතය සාරාංශ ගත කිරීමට isinstanceඋරුම ඕනම මට්ටමක (අ ව්යුත්පන්න පන්තියේ උදාහරණයක් යනු සමානතාව සඳහා පරීක්ෂා අතර, ද, පදනම පන්තියේ උදාහරණයක්) type(එය වර්ග හා ප්රතික්ෂේප කරයි අවස්ථා අනන්යතාව ඉල්ලා නැත උප වර්ගවල, AKA උප පංති).

සාමාන්‍යයෙන්, පයිතන්හිදී, ඔබේ කේතය උරුමයට සහය දැක්වීමට ඔබට අවශ්‍යය, ඇත්ත වශයෙන්ම (උරුමය ඉතා පහසු බැවින්, එය භාවිතා කිරීම ඔබේ කේතය භාවිතා කිරීම නැවැත්වීම නරක ය!), එබැවින් isinstanceඅනන්‍යතාවය පරීක්ෂා කිරීමට වඩා නරක typeවන්නේ එය බාධාවකින් තොරව සහාය දක්වන බැවිනි. උරුමය.

ඒක ගැන නෙවෙයි isinstanceවේ හොඳ , ඔබ-එය ඒ ආකාරයෙන්ම හුදෙක් තියෙන්නේ අඩු නරක වර්ග සමානාත්මතාවය පරීක්ෂා වඩා. සාමාන්‍ය, පයිතොනික්, කැමති විසඳුම බොහෝ විට පාහේ “තාරා ටයිප් කිරීම” වේ: තර්කය එය යම් අපේක්ෂිත වර්ගයකට සමාන ලෙස භාවිතා කිරීමට උත්සාහ කරන්න, තර්කය ඇත්ත වශයෙන්ම නොවේ නම් ඇතිවිය හැකි සියලු ව්‍යතිරේකයන් හසුකර ගනිමින් try/ exceptප්‍රකාශයකින් එය කරන්න . ටයිප් කරන්න (හෝ වෙනත් ඕනෑම වර්ගයක් එය හොඳින් තාරාවා අනුකරණය කරයි ;-), සහ exceptවගන්තියේ වෙනත් දෙයක් උත්සාහ කරන්න ("එය වෙනත් වර්ගයක මෙන්" යන තර්කය භාවිතා කරමින්).

basestring ය ඉතා විශේෂ අවස්ථාවක් එනම් builtin පවතින වර්ගය, කෙසේ වෙතත්, එකම ඔබ භාවිතා ඉඩ isinstance(දෙකම strහා unicodeඋප පංති basestring). නූල් යනු අනුක්‍රමයන්ය (ඔබට ඒවා ලිහිල් කළ හැකිය, ඒවා සුචිගත කළ හැකිය, ඒවා පෙති කපන්න ...), නමුත් ඔබට සාමාන්‍යයෙන් අවශ්‍ය වන්නේ ඒවා “පරිමාණ” වර්ග ලෙස සැලකීමටයි - එය සියලු වර්ගවල ප්‍රතිකාර කිරීමට තරමක් අපහසු (නමුත් සාධාරණ ලෙස නිතර භාවිතා වන අවස්ථාවකි) නූල් (හා සමහරවිට අනෙකුත් අදිශ රාශියක් වර්ග, එනම්, අය ඔබ පුඩුවක් නොහැකි) එක් ක්රමයක්, සියලු කන්ටේනර් තවත් ආකාරයකින් (ලැයිස්තු, කට්ටල, dicts, ...), සහ basestringප්ලස් isinstanceඔබ මේ පිලිබඳ සමස්ත ව්යුහය කරන්න උදව් idiom යනු එවැනි දෙයක්:

if isinstance(x, basestring)
  return treatasscalar(x)
try:
  return treatasiter(iter(x))
except TypeError:
  return treatasscalar(x)

basestringඑය වියුක්ත පාදක පන්තියක් ("ඒබීසී") යැයි ඔබට පැවසිය හැකිය - එය උප පංති සඳහා නිශ්චිත ක්‍රියාකාරීත්වයක් සපයන්නේ නැත, නමුත් එය ප්‍රධාන වශයෙන් භාවිතා කිරීම සඳහා "සලකුණු" ලෙස පවතී isinstance. මෙම සංකල්පය පැහැදිලිවම පයිතන්හි වර්ධනය වන එකක් වන අතර , එය සාමාන්‍යකරණය කිරීමක් හඳුන්වා දෙන PEP 3119 පිළිගෙන ඇති අතර එය ක්‍රියාත්මක කර ඇත්තේ Python 2.6 සහ 3.0 වලින් ය.

පීඊපී පැහැදිලි කරන්නේ, ඒබීසී වලට බොහෝ විට තාරාවන් ටයිප් කිරීම වෙනුවට ආදේශ කළ හැකි වුවද, සාමාන්‍යයෙන් ඒ සඳහා විශාල පීඩනයක් නොමැති බවයි ( මෙහි බලන්න ). මෑත කාලීන පයිතන් අනුවාද වල ක්‍රියාත්මක කර ඇති ඒබීසී අමතර වාසි ලබා දෙයි: isinstance(සහ issubclass) දැන් "[ව්‍යුත්පන්න පංතියක උදාහරණයක්" "ට වඩා වැඩි යමක් අදහස් කළ හැකිය (විශේෂයෙන්, ඕනෑම පන්තියක් ඒබීසී සමඟ" ලියාපදිංචි "කළ හැකි වන පරිදි උප පංතියක් ලෙස පෙන්වන්න, සහ එහි අවස්ථා ABC හි අවස්ථා ලෙස); සහ ආකෘති ක්‍රම සැලසුම් රටා යෙදුම් හරහා ස්වාභාවික උප පංති සඳහා අමතර පහසුවක් ABC වලට ලබා දිය හැකිය ( ටීඑම් ඩීපී පිළිබඳ වැඩි විස්තර සඳහා මෙහි සහ මෙහි [[II කොටස] බලන්න], පොදුවේ සහ විශේෂයෙන් පයිතන්හි, ඒබීසී වලින් ස්වාධීනව) .

පයිතන් 2.6 හි දක්වා ඇති පරිදි ABC ආධාරකයේ යටින් පවතින යාන්ත්‍ර විද්‍යාව සඳහා, මෙහි බලන්න ; ඔවුන්ගේ 3.1 අනුවාදය සඳහා, ඉතා සමාන, මෙහි බලන්න . අනුවාද දෙකෙහිම, සම්මත පුස්තකාල මොඩියුල එකතුව (එය 3.1 අනුවාදය - ඉතා සමාන 2.6 අනුවාදය සඳහා, මෙහි බලන්න ) ප්‍රයෝජනවත් ABC කිහිපයක් ඉදිරිපත් කරයි.

මෙම පිළිතුරේ අරමුණ සඳහා, ඒබීසී ගැන රඳවා තබා ගත යුතු ප්‍රධාන දෙය (ටීඑම් ඩීපී ක්‍රියාකාරිත්වය සඳහා තර්ක කළ හැකි තරම් ස්වාභාවික ස්ථානගත කිරීමකට වඩා, පරිශීලක ඩික්ට් ඩික්ට්මික්සින් වැනි මික්සින් පංතිවල සම්භාව්‍ය පයිතන් විකල්පයට සාපේක්ෂව ) ඒවා සෑදීම isinstance(සහ issubclass) (2.5 සහ ඊට පෙර) පෙරට වඩා ආකර්ශනීය හා ව්‍යාප්ත (පයිතන් 2.6 සහ ඉදිරියට යාම), එම නිසා ඊට වෙනස්ව, වර්ගය සමානාත්මතාවය පරීක්ෂා කිරීම මෑත කාලීන පයිතන් අනුවාදවල පෙර පැවති තත්වයට වඩා නරක පුරුද්දක් බවට පත් කරන්න.

කළ නොහැකි isinstanceදෙයක් සාක්ෂාත් typeකරගත හැකි උදාහරණයක් මෙන්න :

class Vehicle:
    pass

class Truck(Vehicle):
    pass

මෙම අවස්ථාවේදී, ට්‍රක් වස්තුවක් යනු වාහනයකි, නමුත් ඔබට මෙය ලැබෙනු ඇත:

isinstance(Vehicle(), Vehicle)  # returns True
type(Vehicle()) == Vehicle      # returns True
isinstance(Truck(), Vehicle)    # returns True
type(Truck()) == Vehicle        # returns False, and this probably won't be what you want.

වෙනත් වචන වලින් කිවහොත්, isinstanceඋප පංති සඳහා ද සත්‍ය වේ.

මෙයද බලන්න: පයිතන්හි ඇති වස්තුවක වර්ගය සංසන්දනය කරන්නේ කෙසේද?

පයිතන් අතර isinstance()සහ අතර වෙනස්කම් type()?

සමඟ ටයිප් කිරීම

isinstance(obj, Base)

උප පංති සහ බහු විභව පදනම් සඳහා අවස්ථා ලබා දේ:

isinstance(obj, (Base1, Base2))

සමග ටයිප් පරික්ෂා කිරීම

type(obj) is Base

යොමු කරන ලද වර්ගයට පමණක් සහය දක්වයි.

පැත්තක සටහනක් ලෙස, isවඩා සුදුසු ය

type(obj) == Base

පංති තනි බොත්තම් නිසා.

ටයිප් පරික්ෂා කිරීමෙන් වළකින්න - බහුමාපකය (තාරා-ටයිප් කිරීම) භාවිතා කරන්න

පයිතන්හිදී, සාමාන්‍යයෙන් ඔබට අවශ්‍ය වන්නේ ඔබේ තර්ක සඳහා ඕනෑම වර්ගයකට ඉඩ දීමට, එය අපේක්ෂා කළ ආකාරයට සලකන්න, සහ වස්තුව අපේක්ෂිත පරිදි හැසිරෙන්නේ නැත්නම්, එය සුදුසු දෝෂයක් මතු කරයි. මෙය බහුමාපකය ලෙස හැඳින්වෙන අතර එය තාරා-ටයිප් කිරීම ලෙසද හැඳින්වේ.

def function_of_duck(duck):
    duck.quack()
    duck.swim()

ඉහත කේතය ක්‍රියාත්මක වන්නේ නම්, අපගේ තර්කය තාරාවෙකු යැයි උපකල්පනය කළ හැකිය. මේ අනුව අපට වෙනත් දේ පසුකර යා හැකිය තථ්‍ය උප වර්ග තාරාවන්:

function_of_duck(mallard)

හෝ එය තාරාවෙකු මෙන් වැඩ කරයි:

function_of_duck(object_that_quacks_and_swims_like_a_duck)

අපේ කේතය තවමත් ක්‍රියාත්මකයි.

කෙසේ වෙතත්, පැහැදිලිව ටයිප් කිරීම සුදුසු සමහර අවස්ථා තිබේ. සමහර විට ඔබට විවිධ වස්තු වර්ග සමඟ කළ හැකි බුද්ධිමත් දේවල් තිබේ. උදාහරණයක් ලෙස, පණ්ඩස් ඩේටාෆ්‍රේම් වස්තුව ඩික්ස් හෝ වාර්තා වලින් සෑදිය හැකිය . එවැනි අවස්ථාවකදී, ඔබේ කේතය එය ලබා ගන්නේ කුමන ආකාරයේ තර්කයක් දැයි දැන ගැනීමට අවශ්‍ය වන අතර එමඟින් එය නිසි ලෙස හැසිරවිය හැකිය.

එබැවින්, ප්රශ්නයට පිළිතුරු දීමට:

පයිතන් අතර isinstance()සහ අතර වෙනස්කම් type()?

වෙනස නිරූපණය කිරීමට මට ඉඩ දෙන්න:

type

ඔබේ ශ්‍රිතයට යම් ආකාරයක තර්කයක් ලැබෙන්නේ නම් යම් නිශ්චිත හැසිරීමක් සහතික කළ යුතු යැයි පවසන්න (ඉදිකිරීම්කරුවන් සඳහා පොදු භාවිත අවස්ථාවක්). ඔබ මෙවැනි වර්ගයක් සඳහා පරීක්ෂා කරන්නේ නම්:

def foo(data):
    '''accepts a dict to construct something, string support in future'''
    if type(data) is not dict:
        # we're only going to test for dicts for now
        raise ValueError('only dicts are supported for now')

අපි උප පංතියක් වන ආ ict ාවකින් සම්මත වීමට උත්සාහ කළහොත් dict(අපට හැකි පරිදි, අපගේ කේතය ලිස්කොව් ආදේශනයේ මූලධර්මය අනුගමනය කරනු ඇතැයි අපි අපේක්ෂා කරන්නේ නම් , එම උප වර්ග වර්ග සඳහා ආදේශ කළ හැකිය) අපගේ කේතය කැඩී යයි!

from collections import OrderedDict

foo(OrderedDict([('foo', 'bar'), ('fizz', 'buzz')]))

දෝෂයක් මතු කරයි!

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in foo
ValueError: argument must be a dict

isinstance

නමුත් අපි භාවිතා කරන්නේ නම් isinstance, අපට ලිස්කොව් ආදේශනයට සහාය විය හැකිය!

def foo(a_dict):
    if not isinstance(a_dict, dict):
        raise ValueError('argument must be a dict')
    return a_dict

foo(OrderedDict([('foo', 'bar'), ('fizz', 'buzz')]))

ප්‍රතිලාභ OrderedDict([('foo', 'bar'), ('fizz', 'buzz')])

වියුක්ත මූලික පන්ති

ඇත්ත වශයෙන්ම, අපට ඊටත් වඩා හොඳින් කළ හැකිය. collectionsවිවිධ වර්ග සඳහා අවම ප්‍රොටෝකෝල ක්‍රියාත්මක කරන වියුක්ත මූලික පන්ති සපයයි. අපගේ නඩුවේදී, අපි Mappingප්‍රොටෝකෝලය පමණක් අපේක්ෂා කරන්නේ නම් , අපට පහත සඳහන් දෑ කළ හැකි අතර අපගේ කේතය වඩාත් නම්‍යශීලී වේ:

from collections import Mapping

def foo(a_dict):
    if not isinstance(a_dict, Mapping):
        raise ValueError('argument must be a dict')
    return a_dict

අදහස් දැක්වීමට ප්‍රතිචාරය:

බහු පංති භාවිතයෙන් පරීක්ෂා කිරීම සඳහා වර්ගය භාවිතා කළ හැකි බව සැලකිල්ලට ගත යුතුය type(obj) in (A, B, C)

ඔව්, ඔබට වර්ගවල සමානාත්මතාවය සඳහා පරීක්ෂා කළ හැකිය, නමුත් ඉහත සඳහන් දෑ වෙනුවට, පාලක ප්‍රවාහය සඳහා බහු භෂ්ම භාවිතා කරන්න, ඔබ විශේෂයෙන් එම වර්ග වලට පමණක් ඉඩ නොදෙන්නේ නම්:

isinstance(obj, (A, B, C))

වෙනස, නැවතත්, isinstanceලිස්කොව් ආදේශනය ලෙස හැඳින්වෙන දේපළක් වන වැඩසටහන බිඳ දැමීමකින් තොරව දෙමව්පියන්ට ආදේශ කළ හැකි උප පංති සඳහා සහාය වීමයි.

ඊටත් වඩා හොඳයි, ඔබේ පරායත්තතාවයන් හරවා නිශ්චිත වර්ග සඳහා කිසිසේත් පරීක්ෂා නොකරන්න.

නිගමනය

එබැවින් අපට උප පංති ආදේශ කිරීම සඳහා සහය දැක්වීමට අවශ්‍ය බැවින්, බොහෝ අවස්ථාවන්හිදී, අපට අවශ්‍ය වන්නේ ටයිප් පරීක්‍ෂා කිරීමෙන් වැළකී ටයිප් පරීක්‍ෂා කිරීමට typeකැමැත්තක් isinstanceදක්වන්න.

දෙවැන්න වඩාත් සුදුසු වන්නේ එය උප පංති නිසි ලෙස හැසිරවිය හැකි බැවිනි. ඇත්ත වශයෙන්ම, ඔබේ උදාහරණය ඊටත් වඩා පහසුවෙන් ලිවිය හැකිය, මන්ද isinstance()දෙවන පරාමිතිය ටුපල් එකක් විය හැකිය:

if isinstance(b, (str, unicode)):
    do_something_else()

හෝ, basestringවියුක්ත පන්තිය භාවිතා කිරීම :

if isinstance(b, basestring):
    do_something_else()

පයිතන් ලියකියවිලි වලට අනුව මෙහි ප්‍රකාශයක්:

8.15. වර්ග - සාදන ලද වර්ග සඳහා නම්

Python 2.2 දී ආරම්භ වන අතර, බිල්ට් වැනි කර්මාන්ත ශාලා කටයුතු int()හා str()ද අනුරූප වර්ග සඳහා නම් වේ.

එබැවින් isinstance()වඩා කැමති විය යුතුය type().

ප්‍රායෝගික භාවිත වෙනස වන්නේ ඔවුන් හැසිරෙන ආකාරයයි booleans:

Trueහා Falseපමණක් බව මධ්යන්ය මූල පද ඇත 1හා 0උත්කර්ෂවත් අන්දමින් දී. මේ අනුව,

isinstance(True, int)

සහ

isinstance(False, int)

දෙදෙනාම ආපසු පැමිණේ True. බූලියන් දෙකම පූර්ණ සංඛ්‍යාවක් සඳහා උදාහරණයකි. type()කෙසේ වෙතත්, වඩාත් දක්ෂ ය:

type(True) == int

ප්‍රතිලාභ False.

සැබෑ වෙනස්කම් සඳහා, අපට එය සොයාගත හැකිය code, නමුත් පෙරනිමි හැසිරීම ක්‍රියාත්මක කිරීම මට සොයාගත නොහැක isinstance().

කෙසේ වෙතත් අපට __instancecheck__ ට අනුව ඒ හා සමාන abc .__ instancecheck__ ලබා ගත හැකිය .

ඉහළ සිට abc.__instancecheck__, පහත පරීක්ෂණය භාවිතා කිරීමෙන් පසු:

# file tree
# /test/__init__.py
# /test/aaa/__init__.py
# /test/aaa/aa.py
class b():
pass

# /test/aaa/a.py
import sys
sys.path.append('/test')

from aaa.aa import b
from aa import b as c

d = b()

print(b, c, d.__class__)
for i in [b, c, object]:
    print(i, '__subclasses__',  i.__subclasses__())
    print(i, '__mro__', i.__mro__)
    print(i, '__subclasshook__', i.__subclasshook__(d.__class__))
    print(i, '__subclasshook__', i.__subclasshook__(type(d)))
print(isinstance(d, b))
print(isinstance(d, c))

<class 'aaa.aa.b'> <class 'aa.b'> <class 'aaa.aa.b'>
<class 'aaa.aa.b'> __subclasses__ []
<class 'aaa.aa.b'> __mro__ (<class 'aaa.aa.b'>, <class 'object'>)
<class 'aaa.aa.b'> __subclasshook__ NotImplemented
<class 'aaa.aa.b'> __subclasshook__ NotImplemented
<class 'aa.b'> __subclasses__ []
<class 'aa.b'> __mro__ (<class 'aa.b'>, <class 'object'>)
<class 'aa.b'> __subclasshook__ NotImplemented
<class 'aa.b'> __subclasshook__ NotImplemented
<class 'object'> __subclasses__ [..., <class 'aaa.aa.b'>, <class 'aa.b'>]
<class 'object'> __mro__ (<class 'object'>,)
<class 'object'> __subclasshook__ NotImplemented
<class 'object'> __subclasshook__ NotImplemented
True
False

මට මෙම නිගමනය ලැබෙන්නේ, සඳහා type:

# according to `abc.__instancecheck__`, they are maybe different! I have not found negative one 
type(INSTANCE) ~= INSTANCE.__class__
type(CLASS) ~= CLASS.__class__

සඳහා isinstance:

# guess from `abc.__instancecheck__`
return any(c in cls.__mro__ or c in cls.__subclasses__ or cls.__subclasshook__(c) for c in {INSTANCE.__class__, type(INSTANCE)})

BTW: භාවිතය මිශ්‍ර නොකිරීමට වඩා හොඳයි relative and absolutely import, absolutely importproject_dir වෙතින් භාවිතා කරන්න (එකතු කරන ලද්දේ sys.path)