ਟਾਈਪ(), isinstance() ਪਾਈਥਨ ਵਿੱਚ ਟਾਈਪ ਪ੍ਰਾਪਤ ਕਰਨ ਅਤੇ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ

ਪਾਈਥਨ ਵਿੱਚ, ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨਾਂ ਦੀ ਕਿਸਮ() ਅਤੇ 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(object) ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਆਰਗੂਮੈਂਟ ਦੇ ਰੂਪ ਵਿੱਚ ਪਾਸ ਕੀਤੀ ਗਈ ਵਸਤੂ ਦੀ ਕਿਸਮ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਸਦੀ ਵਰਤੋਂ ਕਿਸੇ ਵਸਤੂ ਦੀ ਕਿਸਮ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

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

ਜੇਕਰ ਤੁਸੀਂ ਇਹ ਨਿਰਧਾਰਿਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਕੀ ਇਹ ਕਈ ਕਿਸਮਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ, ਤਾਂ ਇਨ ਆਪਰੇਟਰ ਅਤੇ ਟੂਪਲ ਜਾਂ ਕਈ ਕਿਸਮਾਂ ਦੀ ਸੂਚੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।

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(object, class) ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਸਹੀ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਪਹਿਲੀ ਆਰਗੂਮੈਂਟ ਦਾ ਆਬਜੈਕਟ ਦੂਜੀ ਆਰਗੂਮੈਂਟ ਦੀ ਕਿਸਮ ਜਾਂ ਸਬਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ।

ਦੂਜੀ ਦਲੀਲ ਕਿਸਮਾਂ ਦਾ ਇੱਕ ਟੁਪਲ ਹੋ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਇਹ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ, ਤਾਂ ਸਹੀ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

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

print(isinstance(100, str))
# False

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

ਟਾਈਪ() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਸਮ ਨਿਰਧਾਰਨ ਦੀ ਉਦਾਹਰਨ ਦੇ ਸਮਾਨ ਫੰਕਸ਼ਨ ਨੂੰ ਹੇਠਾਂ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ

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

ਟਾਈਪ () ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਟਾਈਪ ਨਿਰਧਾਰਨ ਉਦੋਂ ਹੀ ਸਹੀ ਰਿਟਰਨ ਕਰਦਾ ਹੈ ਜਦੋਂ ਕਿਸਮਾਂ ਮੇਲ ਖਾਂਦੀਆਂ ਹਨ, ਪਰ 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() ਉਸ int ਲਈ ਵੀ ਸਹੀ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਿਸ ਤੋਂ ਇਹ ਵਿਰਾਸਤ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ ਹੈ।

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

ਜੇਕਰ ਤੁਸੀਂ ਸਹੀ ਕਿਸਮ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਕਿਸਮ(); ਜੇਕਰ ਤੁਸੀਂ ਵਿਰਾਸਤ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ ਕਿਸਮ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ isinstance() ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ issubclass() ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਵੀ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਕਿ ਕੀ ਕੋਈ ਕਲਾਸ ਕਿਸੇ ਹੋਰ ਕਲਾਸ ਦਾ ਉਪ-ਕਲਾਸ ਹੈ।

print(issubclass(bool, int))
# True

print(issubclass(bool, float))
# False