type(), isinstance() મેળવવા માટે અને Python માં પ્રકાર નક્કી કરો

Python માં, બિલ્ટ-ઇન ફંક્શન્સ type() અને isinstance() નો ઉપયોગ ઑબ્જેક્ટનો પ્રકાર મેળવવા અને તપાસવા માટે થાય છે, જેમ કે વેરીએબલ, અને તે ચોક્કસ પ્રકારનું છે કે કેમ તે નક્કી કરવા માટે.

• class type(object) — Built-in Functions — Python 3.10.4 Documentation
• isinstance(object, classinfo) — Built-in Functions — Python 3.10.4 Documentation

નમૂના કોડ સાથે નીચેની સામગ્રીઓ અહીં સમજાવવામાં આવી છે.

• ઑબ્જેક્ટ પ્રકાર મેળવો અને તપાસો:type()
• ઑબ્જેક્ટ પ્રકારનું નિર્ધારણ:type(),isinstance()
  • પ્રકાર() નો ઉપયોગ કરીને પ્રકાર નિર્ધારણ
  • isinstance() નો ઉપયોગ કરીને પ્રકાર નિર્ધારણ
  • પ્રકાર() અને isinstance() વચ્ચેનો તફાવત

ઑબ્જેક્ટનો પ્રકાર નક્કી કરવાને બદલે, ઑબ્જેક્ટમાં યોગ્ય પદ્ધતિઓ અને વિશેષતાઓ છે કે કેમ તે નિર્ધારિત કરવા માટે તમે અપવાદ હેન્ડલિંગ અથવા બિલ્ટ-ઇન ફંક્શન hasattr() નો ઉપયોગ કરી શકો છો.

ઑબ્જેક્ટ પ્રકાર મેળવો અને તપાસો:પ્રકાર()

type(ઑબ્જેક્ટ) એ એક ફંક્શન છે જે ઑબ્જેક્ટનો પ્રકાર દલીલ તરીકે પસાર કરે છે. આનો ઉપયોગ ઑબ્જેક્ટનો પ્રકાર શોધવા માટે કરી શકાય છે.

print(type('string'))
# <class 'str'>

print(type(100))
# <class 'int'>

print(type([0, 1, 2]))
# <class 'list'>

type() ની રીટર્ન વેલ્યુ એ એક પ્રકાર ઓબ્જેક્ટ છે જેમ કે str અથવા int.

print(type(type('string')))
# <class 'type'>

print(type(str))
# <class 'type'>

ઑબ્જેક્ટ પ્રકારનું નિર્ધારણ:type(),isinstance()

પ્રકાર નક્કી કરવા માટે type() અથવા isinstance() નો ઉપયોગ કરો.

પ્રકાર() નો ઉપયોગ કરીને પ્રકાર નિર્ધારણ

પ્રકાર() ના વળતર મૂલ્યને મનસ્વી પ્રકાર સાથે સરખાવીને, ઑબ્જેક્ટ કોઈપણ પ્રકારનું છે કે કેમ તે નક્કી કરી શકાય છે.

print(type('string') is str)
# True

print(type('string') is int)
# False

def is_str(v):
    return type(v) is str

print(is_str('string'))
# True

print(is_str(100))
# False

print(is_str([0, 1, 2]))
# False

જો તમે તે નક્કી કરવા માંગતા હોવ કે તે ઘણા પ્રકારોમાંથી એક છે, તો in operator અને tuple અથવા ઘણા પ્રકારોની સૂચિનો ઉપયોગ કરો.

def is_str_or_int(v):
    return type(v) in (str, int)

print(is_str_or_int('string'))
# True

print(is_str_or_int(100))
# True

print(is_str_or_int([0, 1, 2]))
# False

દલીલના પ્રકારને આધારે પ્રક્રિયામાં ફેરફાર કરતા કાર્યોને વ્યાખ્યાયિત કરવાનું પણ શક્ય છે.

def type_condition(v):
    if type(v) is str:
        print('type is str')
    elif type(v) is int:
        print('type is int')
    else:
        print('type is not str or int')

type_condition('string')
# type is str

type_condition(100)
# type is int

type_condition([0, 1, 2])
# type is not str or int

isinstance() નો ઉપયોગ કરીને પ્રકાર નિર્ધારણ

isinstance(ઑબ્જેક્ટ, ક્લાસ) એ એક ફંક્શન છે જે સાચું પરત કરે છે જો પ્રથમ દલીલનો ઑબ્જેક્ટ બીજી દલીલના પ્રકાર અથવા સબક્લાસનો દાખલો હોય.

બીજી દલીલ વિવિધ પ્રકારના હોઈ શકે છે. જો તે કોઈપણ પ્રકારનું ઉદાહરણ છે, તો true પરત કરવામાં આવે છે.

print(isinstance('string', str))
# True

print(isinstance(100, str))
# False

print(isinstance(100, (int, str)))
# True

type() નો ઉપયોગ કરીને પ્રકાર નિર્ધારણના ઉદાહરણ જેવું જ કાર્ય નીચે પ્રમાણે લખી શકાય છે

def is_str(v):
    return isinstance(v, str)

print(is_str('string'))
# True

print(is_str(100))
# False

print(is_str([0, 1, 2]))
# False

def is_str_or_int(v):
    return isinstance(v, (int, str))

print(is_str_or_int('string'))
# True

print(is_str_or_int(100))
# True

print(is_str_or_int([0, 1, 2]))
# False

def type_condition(v):
    if isinstance(v, str):
        print('type is str')
    elif isinstance(v, int):
        print('type is int')
    else:
        print('type is not str or int')

type_condition('string')
# type is str

type_condition(100)
# type is int

type_condition([0, 1, 2])
# type is not str or int

પ્રકાર() અને isinstance() વચ્ચેનો તફાવત

type() અને isinstance() વચ્ચેનો તફાવત એ છે કે isinstance() પેટા વર્ગોના દાખલાઓ માટે સાચું પરત કરે છે જે બીજા દલીલ તરીકે ઉલ્લેખિત વર્ગને વારસામાં મેળવે છે.

ઉદાહરણ તરીકે, નીચેના સુપરક્લાસ (બેઝ ક્લાસ) અને સબક્લાસ (ડેરીવ્ડ ક્લાસ) વ્યાખ્યાયિત કરવામાં આવ્યા છે

class Base:
    pass

class Derive(Base):
    pass

base = Base()
print(type(base))
# <class '__main__.Base'>

derive = Derive()
print(type(derive))
# <class '__main__.Derive'>

type() નો ઉપયોગ કરીને પ્રકારનું નિર્ધારણ ત્યારે જ સાચું પરત કરે છે જ્યારે પ્રકારો મેળ ખાય છે, પરંતુ isinstance() સુપરક્લાસ માટે પણ સાચું પરત કરે છે.

print(type(derive) is Derive)
# True

print(type(derive) is Base)
# False

print(isinstance(derive, Derive))
# True

print(isinstance(derive, Base))
# True

પ્રમાણભૂત પ્રકારો માટે પણ, ઉદાહરણ તરીકે, બુલિયન પ્રકાર બૂલ (સાચું, ખોટું), કાળજી લેવી આવશ્યક છે. bool એ પૂર્ણાંક પ્રકારનો પેટા વર્ગ છે, તેથી isinstance() તે પૂર્ણાંક માટે પણ સાચું પરત કરે છે જેમાંથી તે વારસામાં મળે છે.

print(type(True))
# <class 'bool'>

print(type(True) is bool)
# True

print(type(True) is int)
# False

print(isinstance(True, bool))
# True

print(isinstance(True, int))
# True

જો તમે ચોક્કસ પ્રકાર નક્કી કરવા માંગતા હો, તો type(); જો તમે વારસાને ધ્યાનમાં રાખીને પ્રકાર નક્કી કરવા માંગતા હો, તો isinstance() નો ઉપયોગ કરો.

બિલ્ટ-ઇન ફંક્શન issubclass() એ નક્કી કરવા માટે પણ આપવામાં આવે છે કે ક્લાસ એ બીજા ક્લાસનો સબક્લાસ છે કે કેમ.

print(issubclass(bool, int))
# True

print(issubclass(bool, float))
# False