Запишите инструкцию для определения типа переменной a ответ запишите без пробелов

Содержание

Введение

В Python есть две функции
type()
и
isinstance()
с помощью которых можно проверить к какому типу данных относится переменная.

Разница между type() и isinstance()

type()

print(type(variable))

Пример использования type()

• 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))

<class ‘int’>
<class ‘float’>
<class ‘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))

<class ‘str’>
<class ‘bool’>
<class ‘list’>
<class ‘tuple’>
<class ‘range’>

Спецификацию функции type() вы можете прочитать на сайте

docs.python.org

Команда type

type python3

python3 is hashed (/usr/bin/python3)

type python

python3 is hashed (/usr/bin/python)

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

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")

Протестируем нашу функцию

print(f»var_list is {typeof(var_list)}»)

var_list is list

Принадлежность к одному из нескольких типов

print(isinstance(2.0, (int, float)))

True

Проверим несколько значений из списка

l3 = [1.5, —2, «www.heihei.ru»]

for item in l3:
print(isinstance(item, (int, float)))

Проверка списка или другого iterable

Часто бывает нужно проверить не одну переменную а целый список, множество, кортеж или какой-то другой объект.

Эту задачу можно решить с помощью isinstance() и функций:

• all()

• map()

• и лямбда функций

Проверить все ли элементы списка l1 int

l1 = [1, 2, 3]

if all(map(lambda p: isinstance(p, int), l1)):
print(«all int in l1»)

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()

  Читать статью: «Как определить тип переменной C++»

• C#

  :
  есть похожая функция

  GetType()

• Go

  :
  функция

  typeof()

  доступна из библиотеки reflect

• Java

  :
  оператор

  instanceof

• PHP

  :
  эту задачу решает

  gettype()

  Читать статью: «Как определить тип переменной PHP»

Похожие статьи

How to determine the variable type in Python?

So if you have a variable, for example:

one = 1

You want to know its type?

There are right ways and wrong ways to do just about everything in Python. Here’s the right way:

Use type

>>> type(one)
<type 'int'>

You can use the __name__ attribute to get the name of the object. (This is one of the few special attributes that you need to use the __dunder__ name to get to — there’s not even a method for it in the inspect module.)

>>> type(one).__name__
'int'

Don’t use __class__

In Python, names that start with underscores are semantically not a part of the public API, and it’s a best practice for users to avoid using them. (Except when absolutely necessary.)

Since type gives us the class of the object, we should avoid getting this directly. :

>>> one.__class__

This is usually the first idea people have when accessing the type of an object in a method — they’re already looking for attributes, so type seems weird. For example:

class Foo(object):
    def foo(self):
        self.__class__

Don’t. Instead, do type(self):

class Foo(object):
    def foo(self):
        type(self)

Implementation details of ints and floats

How do I see the type of a variable whether it is unsigned 32 bit, signed 16 bit, etc.?

In Python, these specifics are implementation details. So, in general, we don’t usually worry about this in Python. However, to sate your curiosity…

In Python 2, int is usually a signed integer equal to the implementation’s word width (limited by the system). It’s usually implemented as a long in C. When integers get bigger than this, we usually convert them to Python longs (with unlimited precision, not to be confused with C longs).

For example, in a 32 bit Python 2, we can deduce that int is a signed 32 bit integer:

>>> import sys

>>> format(sys.maxint, '032b')
'01111111111111111111111111111111'
>>> format(-sys.maxint - 1, '032b') # minimum value, see docs.
'-10000000000000000000000000000000'

In Python 3, the old int goes away, and we just use (Python’s) long as int, which has unlimited precision.

We can also get some information about Python’s floats, which are usually implemented as a double in C:

>>> sys.float_info
sys.floatinfo(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, 
min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, 
mant_dig=53, epsilon=2.2204460492503131e-16, radix=2, rounds=1)

Conclusion

Don’t use __class__, a semantically nonpublic API, to get the type of a variable. Use type instead.

And don’t worry too much about the implementation details of Python. I’ve not had to deal with issues around this myself. You probably won’t either, and if you really do, you should know enough not to be looking to this answer for what to do.

На чтение 4 мин Просмотров 4.9к. Опубликовано 28.03.2021

var_str = "Проверка типов с помощью функции Type"
print("Тип данных: ", type(var_str))

var_num = 7372189
print("Тип данных: ", type(var_num))

var_negative = -8213
print("Тип данных: ", type(var_negative))

var_float = 35.158
print("Тип данных: ", type(var_float))

var_complex = 1 + 5j
print("Тип данных: ", type(var_complex))

var_list = [20, 15, 14, 33, 12]
print("Тип данных: ", type(var_list))

var_tuple = (9, 12, 13, 12, 18, 133, 123)
print("Тип данных: ", type(var_tuple))

var_dict = {"а": 22, "б": 33, "в": 11}
print("Тип данных: ", type(var_dict))

var_set = {"а", "б", "в", "г"}
print("Тип данных: ", type(var_set))

Тип данных:  <class 'str'>
Тип данных:  <class 'int'>
Тип данных:  <class 'int'>
Тип данных:  <class 'float'>
Тип данных:  <class 'complex'>
Тип данных:  <class 'list'>
Тип данных:  <class 'tuple'>
Тип данных:  <class 'dict'>
Тип данных:  <class 'set'>

class TestClass:
    x = "Тестовая строка"
    y = 9999


test = type("NewClass", (TestClass,), dict(x="Тестовая строка", y=9999))
print(type(test))
print(vars(test))

<class 'type'>
{'x': 'Тестовая строка', 'y': 9999, '__module__': '__main__', '__doc__': None}

В этой статье мы поговорим, как определить тип переменной в 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)
<ipython-input-42-b3c3f4515dd4> in <module>()
----> 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: типы данных.

Код ниже использует шаблон if type(OBJECT) is types, для сравнения экземпляра пользовательского списка MyList, который наследуется от встроенного типа list. В данном случае, это НЕ предпочтительный шаблон для сравнения типов.

class  MyList(list):
    pass

lst = MyList('test')
print(lst)

# плохая практика
if type(lst) is list:
    print('Это список')
else:
    print('Это НЕ список')

# ['t', 'e', 's', 't']
# Это НЕ список

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

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

Класс type() лучше использовать для прямого сравнения типа (идентичности) экземпляра объекта:

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

class Circle:
    def __init__(self, radius):
        self.radius = radius

c = Circle(2)
r = Rectangle(3, 4)

if type(r) is type(c):
    print("Типы объектов совпадают")
else:
    print("Типы объектов не совпадают")

# Типы объектов не совпадают

Сравнение со встроенными типами.

Для сравнения типов переменных/объектов со встроенными типами Python лучше всего использовать функцию isinstance, так как она поддерживает наследование (экземпляр производного класса также является экземпляром базового класса), а проверка на равенство типов — нет (требуется идентичность типов и отклоняет экземпляры подтипов, также называемых подклассами).

Встроенная функция isinstance возвращает не тип объекта, а True в случае успеха, к тому же isinstance может сравнивать определенный тип с несколькими ожидаемыми типами.

class  MyList(list):
    pass

lst = MyList('test')
print(lst)
# ['t', 'e', 's', 't']

# Наилучшая практика
if isinstance(lst, list):
    print('Это список')
else:
    print('Это НЕ список')

Заметьте, использование isinstance — это не панацея, а по крайней мере лучше, чем просто проверка типов на равенство. Предпочтительное Pythonic решение почти всегда «утиная типизация».

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

>>> i, s = 10, "hello"
>>> type(i)
<class 'int'>
>>> 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 👈 

20 519