Тип объекта в Python: способы определения и сравнения

Расширенные примеры определения типов в Python

В этом разделе представлены менее очевидные, но полезные сценарии работы с типами объектов. Каждый пример сопровождается пояснением и выводом.

Пример 1: Проверка на None и NoneType

None - единственный экземпляр класса NoneType. Частая ошибка - использовать type(x) is None (это всегда False, так как None - объект, а не класс).

x = None
print(type(x))                   # <class 'NoneType'>
print(type(x) is type(None))     # True
print(isinstance(x, type(None))) # True
print(x is None)                 # True (рекомендуемый способ)

True
True
True

Вывод: для проверки на None используйте оператор is, а не type.

Пример 2: Использование typing.Union для проверки нескольких типов

Модуль typing позволяет объединять типы с помощью Union, что удобно в аннотациях и при проверках isinstance.

from typing import Union

def accept_int_or_float(value: Union[int, float]):
    if isinstance(value, (int, float)):
        print(f"Получено число: {value}")
    else:
        print("Неверный тип")

accept_int_or_float(10)       # Получено число: 10
accept_int_or_float(3.14)     # Получено число: 3.14

Получено число: 10
Получено число: 3.14

Пример 3: Получение всех родителей класса с помощью __mro__

Атрибут __mro__ (Method Resolution Order) показывает цепочку наследования класса.

class A: pass
class B(A): pass
class C(B): pass

print(C.__mro__)
# (<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

(<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

Пример 4: Динамическое создание типа с помощью type()

Функция type() может не только определять тип, но и создавать новые классы (это основа метаклассов).

MyClass = type('MyClass', (object,), {'x': 10, 'method': lambda self: self.x})
obj = MyClass()
print(type(obj))        # <class '__main__.MyClass'>
print(obj.method())     # 10

<class '__main__.MyClass'>
10

Пример 5: Проверка итерируемости с помощью collections.abc

Абстрактные базовые классы позволяют определить, поддерживает ли объект протокол итерации, не привязываясь к конкретному типу.

from collections.abc import Iterable, Iterator

print(isinstance([], Iterable))   # True
print(isinstance({}, Iterable))   # True
print(isinstance(42, Iterable))   # False (int не итерируем)

# Проверка, является ли объект итератором
print(isinstance(iter([]), Iterator))  # True

True
True
False
True

Пример 6: Использование inspect для анализа сигнатуры и типов

Модуль inspect позволяет получить информацию о функциях, включая аннотации типов.

import inspect

def add(a: int, b: float) -> str:
    return str(a + b)

sig = inspect.signature(add)
for name, param in sig.parameters.items():
    print(f"{name}: {param.annotation}")
# a: <class 'int'>
# b: <class 'float'>
print(f"return: {sig.return_annotation}")  # return: <class 'str'>

a: <class 'int'>
b: <class 'float'>
return: <class 'str'>

Пример 7: Кастомный декоратор для проверки типов аргументов

На основе аннотаций можно написать простой декоратор, проверяющий соответствие типов во время выполнения.

from functools import wraps

def type_check(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        sig = inspect.signature(func)
        bound = sig.bind(*args, **kwargs)
        for name, value in bound.arguments.items():
            expected = sig.parameters[name].annotation
            if expected is not inspect.Parameter.empty:
                if not isinstance(value, expected):
                    raise TypeError(f"Аргумент {name!r} должен быть {expected}, получен {type(value)}")
        return func(*args, **kwargs)
    return wrapper

@type_check
def greet(name: str, age: int) -> str:
    return f"{name}, {age} лет"

print(greet("Анна", 25))         # Анна, 25 лет
# greet(123, 25)  # TypeError: Аргумент 'name' должен быть <class 'str'>, получен <class 'int'>

Анна, 25 лет

Пример 8: Работа с type() в наследовании и метаклассах

Метаклассы могут переопределять поведение type(). Например, можно создать класс, который автоматически проверяет типы всех атрибутов.

class TypedMeta(type):
    def __new__(cls, name, bases, namespace):
        for key, value in namespace.items():
            if isinstance(value, type) and not key.startswith('__'):
                # Замена дескриптором (упрощённо)
                pass
        return super().__new__(cls, name, bases, namespace)

# Применение метакласса
class MyClass(metaclass=TypedMeta):
    x: int = 10
    y: str = "привет"

print(MyClass.x)  # 10
print(type(MyClass.x) is int)  # True

10
True