A Pythonban a type() és az isinstance() beépített függvények egy objektum, például egy változó típusának lekérdezésére és ellenőrzésére szolgálnak, valamint annak megállapítására, hogy az objektum egy adott típushoz tartozik-e.
- class type(object) — Built-in Functions — Python 3.10.4 Documentation
- isinstance(object, classinfo) — Built-in Functions — Python 3.10.4 Documentation
A következő tartalmakat ismertetjük itt, mintakóddal együtt.
- Objektumtípus beszerzése és ellenőrzése:
type() - Az objektum típusának meghatározása:
type(),isinstance()- Típusmeghatározás a type() segítségével
- Típusmeghatározás az isinstance() használatával
- A type() és az isinstance() közötti különbség
Az objektum típusának meghatározása helyett használhatjuk a kivételkezelést vagy a beépített hasattr() függvényt annak megállapítására, hogy egy objektum rendelkezik-e a megfelelő metódusokkal és attribútumokkal.
Objektumtípus beszerzése és ellenőrzése: type()
type(object) egy olyan függvény, amely visszaadja az argumentumként átadott objektum típusát. Ez egy objektum típusának megállapítására használható.
print(type('string'))
# <class 'str'>
print(type(100))
# <class 'int'>
print(type([0, 1, 2]))
# <class 'list'>
A type() visszatérési értéke egy típusú objektum, például str vagy int.
print(type(type('string')))
# <class 'type'>
print(type(str))
# <class 'type'>
Az objektum típusának meghatározása: type(), isinstance()
Használja a type() vagy az isinstance() funkciót a típus meghatározásához.
Típusmeghatározás a type() segítségével
A type() visszatérési értékének egy tetszőleges típussal való összehasonlításával megállapítható, hogy az objektum bármilyen típusú.
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
Ha azt szeretné meghatározni, hogy több típus közül az egyikről van-e szó, használja az in operátort és egy több típusból álló tuple-t vagy listát.
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
Lehetőség van olyan függvények definiálására is, amelyek az argumentum típusától függően változtatják a feldolgozást.
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
Típusmeghatározás az isinstance() használatával
Az isinstance(object, class) egy olyan függvény, amely igazat ad vissza, ha az első argumentum objektuma a második argumentum típusának vagy alosztályának példánya.
A második argumentum lehet egy típusok sokasága. Ha ez valamelyik típus példánya, akkor true-t kapunk vissza.
print(isinstance('string', str))
# True
print(isinstance(100, str))
# False
print(isinstance(100, (int, str)))
# True
A type() használatával történő típusmeghatározás példájához hasonló függvényt a következőképpen írhatjuk le
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
A type() és az isinstance() közötti különbség
A type() és az isinstance() közötti különbség az, hogy az isinstance() igazat ad vissza azon alosztályok példányaira, amelyek a második argumentumként megadott osztályt öröklik.
Például a következő szuperosztály (alaposztály) és alosztály (származtatott osztály) van definiálva
class Base:
pass
class Derive(Base):
pass
base = Base()
print(type(base))
# <class '__main__.Base'>
derive = Derive()
print(type(derive))
# <class '__main__.Derive'>
A type() segítségével történő típusmeghatározás csak akkor ad vissza igazat, ha a típusok megegyeznek, de az isinstance() még a szuperosztályok esetében is igazat ad vissza.
print(type(derive) is Derive)
# True
print(type(derive) is Base)
# False
print(isinstance(derive, Derive))
# True
print(isinstance(derive, Base))
# True
Még a szabványos típusok, például a bool (true,false) boolean típus esetében is óvatosnak kell lennünk.A bool az integer típus alosztálya, így az isinstance() igazat ad vissza még az int típusra is, amelytől örökölte.
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
Ha a pontos típust szeretné meghatározni, használja a type() parancsot; ha a típust az öröklődés figyelembevételével szeretné meghatározni, használja az isinstance() parancsot.
A beépített issubclass() függvény is rendelkezésre áll annak megállapítására, hogy egy osztály egy másik osztály alosztálya-e.
print(issubclass(bool, int))
# True
print(issubclass(bool, float))
# False
