Узнать тип данных переменной 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() с помощью которых можно проверить к какому типу данных относится переменная.
 
Разница между type() и isinstance()
 
type() возвращает тип объекта
 
isinstance() возвращает boolean значение - принадлежит объект данному типу или нет
 
type()
 
Встроенная функция type() это самый простой способ выяснить тип объекта. В Python всё является объектом, объекты делятся на изменяемые и неизменяемые .
 
Вы можете воспользоваться type() следующим образом.
 
Пример использования type()
 
В Python четырнадцать типов данных.
 
Для начала рассмотрим три численных типа (Numeric Types):
 
 
int (signed integers)
 
float (вещественные числа с плавающей точкой)
 
complex (комплексные числа)
 
 
Создайте три переменные разного численного типа и проверьте работу функции:
 
var_int = 1380 var_float = 3.14 var_complex = 2.0-3.0j print (type(var_int)) print (type(var_float)) print (type(var_complex))
 
Рассмотрим ещё несколько примеров
 
# Text Type: var_str = 'heihei.ru' # Boolean Type: var_bool = True # Sequence Types: var_list = [ 'heihei.ru' , 'topbicycle.ru' , 'urn.su' ] var_tuple = ( 'andreyolegovich.ru' , 'aredel.com' ) var_range = range(0,9) print (type(var_str)) print (type(var_bool)) print (type(var_list)) print (type(var_tuple)) print (type(var_range))
 
Спецификацию функции type() вы можете прочитать на сайте docs.python.org 
 
Команда type
 
Есть ещё полезная команда type которая решает другую задачу.
 
С помощью команды type можно, например, определить куда установлен Python.
 
Подробнее об этом можете прочитать здесь 
 
python3 is hashed (/usr/bin/python3)
 
python3 is hashed (/usr/bin/python)
 
isinstance()
 
Кроме type() в Python есть функция isinstance(), с помощью которой можно проверить не относится ли переменная к какому-то определённому типу.
 
Иногда это очень удобно, а если нужно - всегда можно на основе isinstance() написать свою функцию.
 
Пример использования
 
Создадим пять переменных разного типа и проверим работу функции
 
var_int = 1380 var_str = 'heihei.ru' var_bool = True var_list = [ 'heihei.ru' , 'topbicycle.ru' , 'urn.su' ] var_tuple = ( 'andreyolegovich.ru' , 'aredel.com' ) if ( isinstance (var_int , int )): print ( f" < var_int >is int" ) else : print ( f" < var_int >is not int" ) if ( isinstance (var_str , str )): print ( f" < var_str >is str" ) else : print ( f" < var_str >is not str" ) if ( isinstance (var_bool , bool )): print ( f" < var_bool >is bool" ) else : print ( f" < var_bool >is not bool" ) if ( isinstance (var_list , list )): print ( f" < var_list >is list" ) else : print ( f" < var_list >is not list" ) if ( isinstance (var_tuple , tuple)): print ( f" < var_tuple >is tuple" ) else : print ( f" < var_tuple >is not tuple" )
 
1380 is int heihei.ru is str True is bool ['heihei.ru', 'topbicycle.ru', 'urn.su'] is list ('andreyolegovich.ru', 'aredel.com') is tuple
 
Из isinstance() можно сделать аналог type()
 
Напишем свою фукнцию по определению типа typeof() на базе isinstance 
 
def typeof(your_var): if ( isinstance (your_var, int)): return 'int' elif ( isinstance (your_var, bool)): return 'bool' elif ( isinstance (your_var, str)): return 'str' elif ( isinstance (your_var, list)): return 'list' elif ( isinstance (your_var, tuple)): return 'tuple' else : print("type is unknown")
 
Протестируем нашу функцию
 
Принадлежность к одному из нескольких типов
 
Если нужно проверить принадлежит ли объект не к какому-то одному, а к группе типов, эти типы можно перечислить в скобках.
 
Часто бывает нужно проверить является ли объект числом, то есть подойдёт как int, так и float 
 
print ( isinstance ( 2.0 , ( int , float )))
 
Проверим несколько значений из списка
 
l3 = [ 1.5 , - 2 , "www.heihei.ru" ] for item in l3: print ( isinstance (item, ( int , float )))
 
Проверка списка или другого iterable
 
Часто бывает нужно проверить не одну переменную а целый список, множество, кортеж или какой-то другой объект.
 
Эту задачу можно решить с помощью isinstance() и функций:
 
Проверить все ли элементы списка l1 int
 
l1 = [ 1 , 2 , 3 ] if all ( map ( lambda p: isinstance (p, int ), l1)): print ( "all int in l1" )
 
Проверить несколько списков на int и float
 
l1 = [ 3 , - 4.0 , 5.5 , - 6.2 ] l2 = [ 1 , - 2 , "test" ] def verif_list (l): return ( all ( map ( lambda p: isinstance (p, ( int , float )), l))) if __name__ == "__main__" : print (verif_list(l1)) print (verif_list(l2))
 
Помимо isinstance() в Python есть функция issubclass() с помощью которой проверяется является один класс производным от другого.
 
В других языках
 
 
Си: такой функции нет.
 
C++: похожую задачу решает функция typeid() 
 
 
Источник
 
Как определить тип переменной в Python
 
Узнайте о различных способах определения типа переменной в Python с помощью функций type(), isinstance() и аннотаций типов, чтобы улучшить ваш код!
 
 
Определение типа переменной в Python является важным аспектом при работе с данными, особенно для новичков, которые только начинают изучать этот язык программирования. В этой статье мы рассмотрим основные методы определения типа переменной в Python. 😊
 
Использование функции type()
 
Один из самых простых и распространенных способов определить тип переменной в Python — использовать встроенную функцию type() . Вот как это работает:
 
В этом примере переменная x имеет тип int (целое число).
 
Использование isinstance()
 
Еще один способ определения типа переменной — использовать функцию isinstance() . Она проверяет, является ли объект экземпляром указанного класса или кортежа классов. Вот пример:
 
x = "hello" if isinstance(x, str): print("x is a string") else: print("x is not a string")
 
Аннотации типов
 
Начиная с Python 3.5, вы можете использовать аннотации типов для указания ожидаемого типа переменной. Это не влияет на выполнение кода, но может помочь в проверке кода и автодополнении в редакторах кода. Вот пример:
 
def greet(name: str) -> str: return "Hello, " + name x = "world" print(greet(x))
 
В этом примере функция greet ожидает, что аргумент name будет типа str и также возвращает строку.
 
Обратите внимание, что аннотации типов не являются обязательными и не влияют на выполнение кода. Их главная цель — помочь программистам лучше понимать код и предотвратить ошибки.
 
Заключение
 
Теперь вы знаете основные способы определения типа переменной в Python. Используйте функции type() и isinstance() для определения типа переменных, а также аннотации типов для улучшения читаемости кода.
 
Не забывайте практиковаться и изучать больше о Python, чтобы стать успешным разработчиком! 😃
 
Источник
 
Читайте также:  Php sql как создать базу