Как узнать тип переменной python

Узнать тип type() и проверить тип isinstance()

В Python у нас утиная динамическая типизация, поэтому бывает что нужно узнать тип переменной. Функция type() возвращает тип аргумента или, учитывая, что в Python – все класс, то класс аргумента. Результат можно сравнить с известным типом:

>>> i, s = 10, "hello" >>> type(i) >>> type(i) is int True >>> type(s) is str True >>> class A: pass . >>> a = A() >>> type(a) is A True

Можно создать экземпляр объекта того же класса, что и переменная:

>>> new_a = type(a)() >>> type(new_a) == type(a) True

⚠️ Нужно знать! type() не принимает во внимание наследование. Тип наследника отличается от типа родителя:

>>> class B(A): pass . >>> type(A()) is type(B()) False

Лучший способ проверить типы – функция isinstance(x, type) (instance англ. – экземпляр). Она возвращает True, если первый аргумент является экземпляром класса во втором аргументе:

>>> isinstance(i, int) True >>> isinstance(s, str) True >>> isinstance(a, A) True

Функция поддерживает наследование:

class A: pass class B(A): pass b = B() >>> isinstance(b, A) True

И самое крутое: вторым аргументом допускается передать кортеж из типов, и isinstance вернет True , если хоть один из типов в кортеже подходит:

>>> isinstance(i, (int, float)) True >>> isinstance(a, (A, B)) True

class A: . a = A() class A: . print(isinstance(a, A))

Правильный ответ был False!

Объяснение. Динамическая натура Python позволяет переопределить класс во время интерпретации. Помните, как недавно я рассказывал про декораторы класса? Там мы подменяли один класс другим. Вот это из той же оперы. Тут мы подменили один класс, другим классом, отвязав имя А от старого класса и привязав его к новому. Старый класс А остался жив только как класс объекта в переменной a . Старого и нового классов разные адреса ( id ):

class A: . print(id(A)) # 140479777819720 a = A() class A: . print(id(A)) # 140479777809672 isinstance(a, A) # False

Специально для канала @pyway. Подписывайтесь на мой канал в Телеграм @pyway ��

Определяем типы данных в 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: типы данных.

Python. Урок 3. Типы и модель данных
 
В данном уроке разберем как Python работает с переменными и определим какие типы данных можно использовать в рамках этого языка. Подробно рассмотрим модель данных Python, а также механизмы создания и изменения значения переменных.
Немного о типизации языков программирования
Если достаточно формально подходить к вопросу о типизации языка Python, то можно сказать, что он относится к языкам с неявной сильной динамической типизацией.
Неявная типизация означает, что при объявлении переменной вам не нужно указывать её тип, при явной – это делать необходимо. В качестве примера языков с явной типизацией можно привести Java, C++. Вот как будет выглядеть объявление целочисленной переменной в Java и Python.
int a = 1;
a = 1 
Также языки бывают с динамической и статической типизацией. В первом случае тип переменной определяется непосредственно при выполнении программы, во втором – на этапе компиляции (о компиляции и интерпретации кратко рассказано в уроке 2). Как уже было сказано Python – это динамически типизированный язык, такие языки как С, C#, Java – статически типизированные.
Сильная типизация не позволяет производить операции в выражениях с данными различных типов, слабая – позволяет. В языках с сильной типизацией вы не можете складывать например строки и числа, нужно все приводить к одному типу. К первой группе можно отнести Python, Java, ко второй – С и С++.
За более подробным разъяснением данного вопроса советуем обратиться к статье “Ликбез по типизации в языках программирования” .
Типы данных в Python
В Python типы данных можно разделить на встроенные в интерпретатор (built-in) и не встроенные, которые можно использовать при импортировании соответствующих модулей.
К основным встроенным типам относятся:

None (неопределенное значение переменной)
Логические переменные (Boolean Type)
Числа (Numeric Type)

int – целое число
float – число с плавающей точкой
complex – комплексное число


list – список
tuple – кортеж
range – диапазон


str


bytes – байты
bytearray – массивы байт
memoryview – специальные объекты для доступа к внутренним данным объекта через protocol buffer


set – множество
frozenset – неизменяемое множество


dict – словарь

Модель данных
Рассмотрим как создаются объекты в памяти, их устройство, процесс объявления новых переменных и работу операции присваивания.
Для того, чтобы объявить и сразу инициализировать переменную необходимо написать её имя, потом поставить знак равенства и значение, с которым эта переменная будет создана. Например строка:
b = 5 
объявляет переменную b и присваивает ей значение 5.
Целочисленное значение 5 в рамках языка Python по сути своей является объектом. Объект, в данном случае – это абстракция для представления данных, данные – это числа, списки, строки и т.п. При этом, под данными следует понимать как непосредственно сами объекты, так и отношения между ними (об этом чуть позже). Каждый объект имеет три атрибута – это идентификатор, значение и тип. Идентификатор – это уникальный признак объекта, позволяющий отличать объекты друг от друга, а значение – непосредственно информация, хранящаяся в памяти, которой управляет интерпретатор.
При инициализации переменной, на уровне интерпретатора, происходит следующее:

создается целочисленный объект 5 (можно представить, что в этот момент создается ячейка и 5 кладется в эту ячейку);
данный объект имеет некоторый идентификатор, значение: 5, и тип: целое число;
посредством оператора “=” создается ссылка между переменной b и целочисленным объектом 5 (переменная b ссылается на объект 5).

Имя переменной не должно совпадать с ключевыми словами интерпретатора Python. Список ключевых слов можно найти здесь . Также его можно получить непосредственно в программе, для этого нужно подключить модуль keyword и воспользоваться командой keyword.kwlist. 
>>> import keyword >>> print("Python keywords: ", keyword.kwlist)
Проверить является или нет идентификатор ключевым словом можно так:
>>> keyword.iskeyword("try") True >>> keyword.iskeyword("b") False 
Для того, чтобы посмотреть на объект с каким идентификатором ссылается данная переменная, можно использовать функцию id().
>>> a = 4 >>> b = 5 >>> id(a) 1829984576 >>> id(b) 1829984592 >>> a = b >>> id(a) 1829984592 
Как видно из примера, идентификатор – это некоторое целочисленное значение, посредством которого уникально адресуется объект. Изначально переменная a ссылается на объект 4 с идентификатором 1829984576, переменная b – на объект с id = 1829984592. После выполнения операции присваивания a = b, переменная a стала ссылаться на тот же объект, что и b.

Тип переменной можно определить с помощью функции type(). Пример использования приведен ниже.
>>> a = 10 >>> b = "hello" >>> c = (1, 2) >>> type(a) class 'int'> >>> type(b) class 'str'> >>> type(c) class 'tuple'> 
Изменяемые и неизменяемые типы данных
В Python существуют изменяемые и неизменяемые типы.
К неизменяемым (immutable) типам относятся: целые числа (int), числа с плавающей точкой (float), комплексные числа (complex), логические переменные (bool), кортежи (tuple), строки (str) и неизменяемые множества (frozen set).
К изменяемым (mutable) типам относятся: списки (list), множества (set), словари (dict).
Как уже было сказано ранее, при создании переменной, вначале создается объект, который имеет уникальный идентификатор, тип и значение, после этого переменная может ссылаться на созданный объект.
Неизменяемость типа данных означает, что созданный объект больше не изменяется. Например, если мы объявим переменную k = 15, то будет создан объект со значением 15, типа int и идентификатором, который можно узнать с помощью функции id().
>>> k = 15 >>> id(k) 1672501744 >>> type(k) class 'int'> 
Объект с id = 1672501744 будет иметь значение 15 и изменить его уже нельзя.
Если тип данных изменяемый, то можно менять значение объекта. Например, создадим список [1, 2], а потом заменим второй элемент на 3.
>>> a = [1, 2] >>> id(a) 47997336 >>> a[1] = 3 >>> a [1, 3] >>> id(a) 47997336 
Как видно, объект на который ссылается переменная a, был изменен. Это можно проиллюстрировать следующим рисунком.

В рассмотренном случае, в качестве данных списка, выступают не объекты, а отношения между объектами. Т.е. в переменной a хранятся ссылки на объекты содержащие числа 1 и 3, а не непосредственно сами эти числа.
P.S.
Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.  
Раздел: Python Уроки по Python Метки: Python, Уроки Python
Python. Урок 3. Типы и модель данных : 12 комментариев

Артем 25.04.2018 У Вас в коде 
>>> print “Python keywords: “, keyword.kwlist 
не хватает круглых скобок: 
>>> print(“Python keywords: “, keyword.kwlist)


writer 25.04.2018 Спасибо! Поправил.

Как узнать тип переменной в PyCharm Python
В python узнать тип переменной a можно, вписав команду print(type(a)) . Можно ли в PyCharm узнать тип переменной, наведя на неё мышкой или другим быстрым способом, не набирая строки кода для каждой переменной?
Отслеживать

4,071 1 1 золотой знак 11 11 серебряных знаков 36 36 бронзовых знаков

задан 17 июн 2021 в 22:54

konstantinmakovsky konstantinmakovsky

61 1 1 серебряный знак 6 6 бронзовых знаков

Можно использовать дебаггер в PyCharm и его панель с переменными (jetbrains.com/help/pycharm/…)

17 июн 2021 в 23:19
2 ответа 2
Сортировка: Сброс на вариант по умолчанию
Ставишь каретку на переменную -> Ctrl+Shift+P (View -> Type Info). Если не сможет вывести тип будет Any .

Отслеживать

ответ дан 18 июн 2021 в 10:33

Pavel Karateev Pavel Karateev

1,967 1 1 золотой знак 12 12 серебряных знаков 16 16 бронзовых знаков

А не, действительно не так работает, как если просто мышкой навести.

19 июн 2021 в 9:10
Можно использовать типизацию и модуль typing для более сложных типов.
Как пример имеем функцию с описанными типами переменных (их описывать можно не только в функции). PyCharm будет понимать, какая переменная кем является, и предлагать методы для этого типа. Спомощью модуля typing можно описать какие ожидаются элементы внутри iterable объектов, Union типы (когда несколько типов может быть) и тд.

Понимает что переменная строка и предлагает методы для строки. 

Понимает что переменная dict и показывает методы для него 

Понимает что ключ переменно - tuple и показывает методы для него.  и тд

Так же если ввести в функцию недопустимые типы, PyCharm подскажет Вам. 

С собственной структурой, аналогично знает что это за переменная и предлагает её атрибуты. 
Читать:
Как выбрать мотоцикл по росту и весу таблица эндуро