Как узнать тип объекта в python

type (тип)

Один аргумент:
obj — Объект, тип которого требуется определить.

Три аргумента:
name — Имя для создаваемого типа (становится атрибутом ‘__name__’);
bases — Кортеж с родительскими классами (становится атрибутом ‘__bases__’);
dict — Словарь, который будет являться пространством имён для тела класса (становится атрибутом ‘__dict__’).

Типы данных определяют способности своих объектов (аспекты поведения) и возможные значения для них.

Способности — это операции, которые поддерживает объект (например, может ли объект быть умножен на другой объект) и свойства объекта (например, есть у объекта длина, является ли он изменяемым).

На заметку
Важно понимать, что тип, как и другие сущности в Python, тоже является объектом.

type(object) # 
type(type) # 
type(int) # 
type(57) # 

class MyClass(object): pass
type(MyClass) # 
type(MyClass()) # 

isinstance(object, object) # True
isinstance(type, object) # True

type — это тип всех типов (для, которых не указан явно иной метакласс);
тип object — это база для остальных типов.

Пользовательские типы данных могут быть сконструированы налету (во время исполнения) при помощи вызова type() (с тремя аргументами) или определены в коде, например при помощи инструкции class.

Понятия класс и тип по сути являются синонимами, начиная с +py2.3 (см. описание в object).

Вызов type

1. Вызов type() с одним аргументом позволяет получить тип указанного [аргументом] объекта (обычно возвращается тот же тип, что хранится в атрибуте объекта __class__). Однако для проверки соответствия типа объекта какому-либо типу (или нескольким) рекомендуется воспользоваться функцией isinstance(), ввиду того, что она принимает во внимание иерархию типов.

 my_var = 1 
type(my_var) #

2. +py2.2 Вызов type() с тремя аргументами позволяет сконструировать новый объект типа во время исполнения.

 # Определение типа при помощи инструкции class 
class MyType: # Для Python 2 - MyType(object) 
a = 1 
 
# То же определение типа, но во время исполнения при помощи type() 
MyType = type('MyType', (object,), )

Класс type() в Python, возвращает тип объекта

Возвращает тип объекта и является собственным метаклассом языка Python

Синтаксис:

type(object) type(name, bases, dict)

Параметры:

object — объект, тип которого определяется
name — имя для создаваемого типа
bases — кортеж с родительскими классами
dict — словарь, будет являться пространством имён для тела класса

Возвращаемое значение:

тип объекта, при вызове с одним аргументом,
объект нового типа при вызове класса с тремя аргументами.

Вызов класса type() с одним аргументом:

Класс type() с одним аргументом object возвращает тип объекта. Возвращаемое значение — это как правило, тот же объект, что и возвращаемый object.__class__ .

Рекомендуется для проверки типа объекта использовать встроенную функцию isinstance() , так как она принимает во внимание подклассы.

Примеры использования класса type() при вызове с одним аргументом.

>>> x = 1 >>> type(x) # >>> x = [1, 2, 3] >>> type(x) # # проверка типа объекта >>> x = 1 >>> isinstance(x, int) # True >>> x = [1, 2, 3] >>> isinstance(x, list) # True

Вызов класса type() с тремя аргументами:

Класс type() с тремя аргументами вернет объект нового типа. Это по сути динамическая форма инструкции class , ее еще называют метакласс.

Другими словами класс type() , вызванный с тремя аргументами на самом деле является метаклассом! Класс type() это метакласс, который Python внутренне использует для создания всех классов.

Все, с чем имеем дело в Python, является объектом. Сюда входят функции и классы целые числа, строки и т.д. Все они объекты. И все они созданы из класса.

# type - это тип всех типов, для # которых не указан явно иной метакласс >>> type(type) # >>> type(object) # >>> type(list) # >>> type(int) # >>> class Bar(object): pass >>> type(Bar) #

В общем type — это класс всех классов в языке Python и является собственным метаклассом. Класс type() нельзя воспроизвести на чистом Python.

Аргумент name является именем класса и становится атрибутом __name__ . bases это кортеж, в котором перечисляются базовые классы, он становится атрибутом __bases__ . dict — это пространство имен, содержащее определения для тела класса, которое копируется в стандартный словарь и становится атрибутом __dict__ .

Понятия класс и тип по сути являются синонимами. Пользовательские типы данных могут быть сконструированы налету, во время исполнения, при помощи вызова type() с тремя аргументами или определены в коде, например при помощи инструкции class .

Важно понимать, что тип, как и другие сущности в Python, тоже является объектом.

Изменено в Python 3.6: подклассы, которые не переопределяют, type.__new__ больше не могут использовать форму с одним аргументом для получения типа объекта.

Примеры создания и изменения классов «на лету» при помощи type() :

Например, следующие два определения создают идентичные объекты.

>>> class Foo(object): . bar = True >>> Foo = type('Foo', (), 'bar':True>)

Класс Foo , созданный через метакласс type() можно использовать как обычный класс:

>>> Foo # >>> f = Foo() >>> f.bar # True # можно наследоваться от него >>> class FooChild(Foo): pass . >>> FooChild # >>> FooChild.bar # bar унаследован от Foo # True

Добавим методы в класс FooChild() . Для этого определим функцию и добавим ее как атрибут.

>>> def echo_bar(self): . print(self.bar) . >>> FooChild = type('FooChild', (Foo,), 'echo_bar': echo_bar>) >>> hasattr(Foo, 'echo_bar') # False >>> hasattr(FooChild, 'echo_bar') # True >>> my_foo = FooChild() >>> my_foo.echo_bar() # True # после динамического создания класса добавим еще один метод >>> def echo_bar_more(self): . print('yet another method') . >>> FooChild.echo_bar_more = echo_bar_more >>> hasattr(FooChild, 'echo_bar_more') # True

ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
Функция abs(), абсолютное значение числа
Функция all(), все элементы True
Функция any(), хотя бы один элемент True
Функция ascii(), преобразует строку в ASCII
Функция bin(), число в двоичную строку
Класс bool(), логическое значение объекта
Функция breakpoint(), отладчик кода
Класс bytearray(), преобразует в массив байтов
Класс bytes(), преобразует в строку байтов
Функция callable(), проверяет можно ли вызвать объект
Функция chr(), число в символ Юникода
Класс classmethod, делает функцию методом класса
Функция compile() компилирует блок кода Python
Класс complex(), преобразует в комплексное число
Функция delattr(), удаляет атрибут объекта
Класс dict() создает словарь
Функция dir(), все атрибуты объекта
Функция divmod(), делит числа с остатком
Функция enumerate(), счетчик элементов последовательности
Функция eval(), выполняет строку-выражение с кодом
Функция exec(), выполняет блок кода
Функция filter(), фильтрует список по условию
Класс float(), преобразует в вещественное число
Функция format(), форматирует значение переменной
Класс frozenset(), преобразует в неизменяемое множество
Функция getattr(), значение атрибута по имени
Функция globals(), переменные глобальной области
Функция hasattr(), наличие атрибута объекта
Функция hash(), хэш-значение объекта
Функция help(), справка по любому объекту
Функция hex(), число в шестнадцатеричную строку
Функция id(), идентификатор объекта
Функция input(), ввод данных с клавиатуры
Класс int(), преобразует в тип int
Функция isinstance(), принадлежность экземпляра к классу
Функция issubclass(), проверяет наследование класса
Функция iter(), создает итератор
Функция len(), количество элементов объекта
Класс list(), преобразовывает в список
Функция locals(), переменные локальной области
Функция map(), обработка последовательности без цикла
Функция max(), максимальное значение элемента
Класс memoryview(), ссылка на буфер обмена
Функция min(), минимальное значение элемента
Функция next(), следующий элемент итератора
Класс object(), возвращает безликий объект
Функция oct(), число в восьмеричную строку
Функция open(), открывает файл на чтение/запись
Функция ord(), число символа Unicode
Функция pow(), возводит число в степень
Функция print(), печатает объект
Класс property(), метод класса как свойство
Класс range(), генерирует арифметические последовательности
Функция repr(), описание объекта
Функция reversed(), разворачивает последовательность
Функция round(), округляет число
Класс set(), создает или преобразовывает в множество
Функция setattr(), создает атрибут объекта
Класс slice(), шаблон среза
Функция sorted(), выполняет сортировку
Декоратор staticmethod(), метод класса в статический метод
Класс str(), преобразует объект в строку
Функция sum(), сумма последовательности
Функция super(), доступ к унаследованным методам
Класс tuple(), создает или преобразует в кортеж
Класс type(), возвращает тип объекта
Функция vars(), словарь переменных объекта
Функция zip(), объединить элементы в список кортежей
Функция __import__(), находит и импортирует модуль
Функция aiter(), создает асинхронный итератор
Функция anext(), следующий элемент асинхронного итератора

Проверка типа объекта в Python

Часто в программировании возникает необходимость определить тип конкретного объекта. Это может быть полезно, например, при разработке функций, которые должны работать только с определенными типами данных. Рассмотрим пример: есть функция, которая принимает на вход строку и выполняет некоторые операции с этой строкой. Однако, если на вход придет число или список, функция может не справиться со своей задачей и выдать ошибку.

В Python есть несколько способов проверить тип объекта.

Использование функции type()

Один из самых простых и популярных способов проверить тип объекта в Python — использовать встроенную функцию type() . Эта функция возвращает тип объекта, который передается ей в качестве аргумента.

print(type('Hello, world!')) # <class 'str'> print(type(123)) # <class 'int'> print(type(3.14)) # <class 'float'> print(type(['apple', 'banana', 'cherry'])) # <class 'list'>

Однако, чтобы сравнить результат функции type() с определенным типом, нужно использовать конструкцию вида type(obj) is SomeType . Например:

if type('Hello, world!') is str: print('Это строка!')

Использование функции isinstance()

Еще один способ проверить тип объекта в Python — использовать функцию isinstance() . Эта функция принимает два аргумента: объект, тип которого нужно проверить, и тип (или кортеж типов), с которым следует сравнить тип объекта.

print(isinstance('Hello, world!', str)) # True print(isinstance(123, int)) # True print(isinstance(3.14, float)) # True print(isinstance(['apple', 'banana', 'cherry'], list)) # True

Функция isinstance() также позволяет проверить, является ли объект экземпляром определенного класса или его подкласса. Это может быть полезно при работе с объектно-ориентированным программированием в Python.

Вывод

Проверка типа объекта — полезный инструмент в арсенале программиста на Python. Но стоит помнить, что частое использование таких проверок может указывать на неправильное проектирование программы. В идеальном случае код должен быть написан так, чтобы он мог работать с любыми объектами, предоставляющими необходимый интерфейс, независимо от их конкретного типа.

Определяем типы данных в Python. Изменяемые и неизменяемые типы

В этой статье мы поговорим, как определить тип переменной в Python. Заодно, расскажем, почему одни переменные считают изменяемыми, а другие нет. И какие тут существуют тонкости, связанные с терминологией.

В некоторых случаях нужно определить тип данных переменной в Python. Проверить, к какому типу принадлежит та или иная переменная, можно посредством функции type:

 >>> a = 10 >>> b = [1,2,3] >>> type(a) == int True >>> type(b) == list True >>> type(a) == float False
Также мы можем определить тип данных переменной в Python посредством функции isinstance() :
 >>> isinstance(a,int) True >>> isinstance(b,list) True >>> isinstance(b,tuple) False >>> c = (4,5,6) >>> isinstance(c,tuple) True
Здесь стоит обратить внимание, что isinstance() в отличие от type даёт возможность проверять тип данных на принадлежность хотя бы одному типу из кортежа, который передан в качестве 2-го аргумента:
 >>> isinstance(a,(float, int, str)) True >>> isinstance(a,(list, tuple, dict)) False
Также следует упомянуть и другое, не менее значимое достоинство isinstance() — поддержка наследования. Для isinstance() экземпляр производного класса является экземпляром его базового класса:
 >>> class A (list): . pass . >>> a = A() >>> type(a) == list False >>> type(a) == A True >>> isinstance(a,A) True >>> isinstance(a,list) True
Проверка типов
Есть и ещё кое-что: во время преобразования типов данных переменных в Python нередко возникают следующие ошибки:
 In [1]: int('a') ------------------------------------------------------ ValueError Traceback (most recent call last) in () ----> 1 int('a') ValueError: invalid literal for int() with base 10: 'a'
Впрочем, ошибка является вполне логичной, ведь мы пробуем преобразовать в десятичный формат строку „a“.
Понятно, что на практике вы с такой ошибкой не столкнётесь. Однако бывает, что надо, к примеру, пробежаться по списку строк, преобразовав в числа те, которые уже содержат числа. Чтобы ошибки избежать, нужно сначала определить, с каким типом переменных мы имеем дело.
В Python соответствующие средства, конечно, имеются. К примеру, используя метод isdigit() , мы определим, состоит ли наша строка из одних только цифр:
 In [2]: "a".isdigit() Out[2]: False In [3]: "a10".isdigit() Out[3]: False In [4]: "10".isdigit() Out[4]: True
Есть и ещё один метод — isalpha() . Он проверит, состоит ли наша строка из одних лишь букв:
 In [7]: "a".isalpha() Out[7]: True In [8]: "a100".isalpha() Out[8]: False In [9]: "a-- ".isalpha() Out[9]: False In [10]: "a ".isalpha() Out[10]: False
А вот isalnum() определит, состоит ли наша строка из цифр или букв:
 In [11]: "a".isalnum() Out[1]: True In [12]: "a10".isalnum() Out[12]: True
Но давайте снова вернёмся к упомянутой в начале статьи функции type. Порой, в зависимости от результата, функция или библиотека может выводить различные типы объектов. К примеру, если объект только один, то возвращается строка, а если их несколько, то нам возвращается кортеж. Мы же хотим построить ход программы по иному, с учётом того, что было возвращено: строка либо кортеж. И здесь как раз и пригодится type:
 In [13]: type("string") Out[13]: str In [14]: type("string") is str Out[14]: True
То же самое и с кортежем, и с иными типами данных:
 In [15]: type((1,2,3)) Out[15]: tuple In [16]: type((1,2,3)) is tuple Out[16]: True In [17]: type((1,2,3)) is list Out[17]: False
Неизменяемые и изменяемые данные в Python
Считается, что все типы данных в языке программирования Python можно отнести к любой из двух категорий: — изменяемые (mutable); — неизменяемые (unmutable).
И многие из предопределённых типов являются типами неизменяемых объектов: — символьные строки (class 'str'); — числовые данные (int, float, complex); — кортежи (tuple).
Что касается других типов, то они определены как изменяемые: — множества (set), — списки (list), — словари (dict).
Кроме того, вновь определяемые пользователем классы (типы) тоже можно определить как изменяемые или неизменяемые. И вообще, изменяемость объектов какого-нибудь типа считается принципиально значимой характеристикой, которая определяет, способен ли объект такого типа выступать в виде ключа для словарей (dict) либо нет.
И тут есть один интересный нюанс, связанный с самой терминологией «изменяемый-неизменяемый» (именно она используется в русскоязычном переводе). На самом деле, такой вариант названия не совсем удачный, он вносит неоднозначность. Здесь скорее бы подошёл термин «мутирующий-немутирующий», т. к. он лучше отображает суть происходящего. А суть заключается в том, способен ли объект данного типа менять свою структурность? 
К примеру строка s = 'abcdef' относится к неизменяемому типу, ведь в Python нельзя (это вам не C/C++) поменять какой-нибудь одиночный символ в строке, допустим, через s[ 2 ] = 'z', и это не говоря о том, чтобы вставить символ внутрь строки. Однако мы можем сделать s = s[ :2 ] + 'z' = s[ 3: ] и получить в итоге нужную строку 'abzdef', но это будет абсолютно другая строка, размещённая по абсолютно другому адресу в памяти, то есть s — переустановленная ссылка на новую строку. Однако поменять строку либо её длину (структурность) по текущей ссылке нельзя. В этом, как раз, и заключается неизменяемость объекта — неконстантность, ведь его значение поменять можно, однако это уже будет ссылка на другой объект с новым значением.
На этом всё, если хотите прокачать навыки Python-программирования "по-врослому", записывайтесь на курсы в OTUS:

При подготовке статьи использовались следующие материалы:

Типизация в Python. Типы данных, переменные;
Синтаксис Python: type, isinstance — определяем тип переменной;
Проверка типов;
Тонкости использования языка Python: типы данных.

Читать:
Как сделать авс анализ в 1с