Как определить тип переменной Python?
Как узнать тип переменной: 32-разрядная без знака, 16-разрядная со знаком и т. Д.?
Как мне это увидеть?
23 ответа
Python не имеет те же типы, что и C/C++, что кажется вашим вопросом.
Попробуй это:
>>> i = 123
>>> type(i)
<type 'int'>
>>> type(i) is int
True
>>> i = 123456789L
>>> type(i)
<type 'long'>
>>> type(i) is long
True
>>> i = 123.456
>>> type(i)
<type 'float'>
>>> type(i) is float
True
Однако в Python 3.0 различие между int и long исчезает.
Вы можете искать type() функция.
См. Примеры ниже, но в Python нет такого типа "без знака", как в Java.
Положительное число:
>>> v = 10
>>> type(v)
<type 'int'>
Большое положительное целое число:
>>> v = 100000000000000
>>> type(v)
<type 'long'>
Отрицательное целое число:
>>> v = -10
>>> type(v)
<type 'int'>
Буквенная последовательность символов:
>>> v = 'hi'
>>> type(v)
<type 'str'>
Целое число с плавающей точкой:
>>> v = 3.14159
>>> type(v)
<type 'float'>
Это так просто. Вы делаете это так.
print(type(variable_name))
Как определить тип переменной в Python?
Так что если у вас есть переменная, например:
one = 1
Вы хотите знать его тип?
В Python есть правильные и неправильные способы делать практически все. Вот правильный путь:
использование type
>>> type(one)
<type 'int'>
Вы можете использовать __name__ атрибут, чтобы получить имя объекта. (Это один из немногих специальных атрибутов, которые необходимо использовать для __dunder__ имя, чтобы добраться до - нет даже метода для этого в inspect модуль).
>>> type(one).__name__
'int'
Не использовать __class__
В Python имена, начинающиеся с подчеркиваний, семантически не являются частью общедоступного API, и пользователям рекомендуется избегать их использования. (За исключением случаев, когда это абсолютно необходимо.)
поскольку type дает нам класс объекта, мы должны избегать его получения напрямую.:
>>> one.__class__
Обычно это первая идея, которую люди имеют при доступе к типу объекта в методе - они уже ищут атрибуты, поэтому тип кажется странным. Например:
class Foo(object):
def foo(self):
self.__class__
Не. Вместо этого, введите type(self):
class Foo(object):
def foo(self):
type(self)
Детали реализации целых и чисел
Как узнать тип переменной: 32-разрядная без знака, 16-разрядная со знаком и т. Д.?
В Python эти особенности являются деталями реализации. Итак, в общем, мы обычно не беспокоимся об этом в Python. Однако, чтобы удовлетворить ваше любопытство...
В Python 2 int обычно представляет собой целое число со знаком, равное ширине слова реализации (ограничено системой). Обычно это реализовано как long в C. Когда целые числа становятся больше этого значения, мы обычно конвертируем их в длинные Python (с неограниченной точностью, не путать с длинными C).
Например, в 32-битном Python 2 мы можем вывести, что int является 32-битным целым числом со знаком:
>>> import sys
>>> format(sys.maxint, '032b')
'01111111111111111111111111111111'
>>> format(-sys.maxint - 1, '032b') # minimum value, see docs.
'-10000000000000000000000000000000'
В Python 3 старый int исчезает, и мы просто используем (Python) long как int, который имеет неограниченную точность.
Мы также можем получить некоторую информацию о числах с плавающей точкой Python, которые обычно реализуются как двойные в 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)
Заключение
Не использовать __class__семантически непубличный API, чтобы получить тип переменной. использование type вместо.
И не беспокойтесь о деталях реализации Python. Я сам не сталкивался с проблемами вокруг этого. Вы, вероятно, тоже не будете, и если вы действительно это сделаете, вы должны знать достаточно, чтобы не искать этот ответ для того, что делать.
print type(variable_name)
Я также настоятельно рекомендую интерактивный переводчик IPython при решении таких вопросов. Это позволяет вам печатать variable_name? и вернет полный список информации об объекте, включая тип и строку документа для типа.
например
In [9]: var = 123
In [10]: var?
Type: int
Base Class: <type 'int'>
String Form: 123
Namespace: Interactive
Docstring:
int(x[, base]) -> integer
Преобразуйте строку или число в целое число, если это возможно. Аргумент с плавающей запятой будет усечен до нуля (это не включает строковое представление числа с плавающей запятой!) При преобразовании строки используйте необязательную базу. Неправильно указывать базу при преобразовании не-строки. Если аргумент находится за пределами целочисленного диапазона, вместо него будет возвращен длинный объект.
a = "cool"
type(a)
//result
<class 'str'>
or do `dir(a)` to see the list of inbuilt methods you can have on the variable.
Примеры простой проверки типов в Python:
assert type(variable_name) == int
assert type(variable_name) == bool
assert type(variable_name) == list
Еще один способ использования __class__:
>>> a = [1, 2, 3, 4]
>>> a.__class__
<type 'list'>
>>> b = {'key1': 'val1'}
>>> b.__class__
<type 'dict'>
>>> c = 12
>>> c.__class__
<type 'int'>
Это может быть немного неактуально. но вы можете проверить типы объекта с isinstance(object, type) как уже упоминалось здесь.
Вопрос несколько двусмысленный - я не уверен, что вы подразумеваете под "взглядом". Если вы пытаетесь запросить тип нативного объекта Python, ответ @atzz направит вас в правильном направлении.
Однако, если вы пытаетесь сгенерировать объекты Python, имеющие семантику примитивных C-типов (например, uint32_t, int16_t), использовать struct модуль. Вы можете определить количество битов в данном примитиве C-типа следующим образом:
>>> struct.calcsize('c') # char
1
>>> struct.calcsize('h') # short
2
>>> struct.calcsize('i') # int
4
>>> struct.calcsize('l') # long
4
Это также отражено в array модуль, который может создавать массивы следующих типов нижнего уровня:
>>> array.array('c').itemsize # char
1
Максимальное поддерживаемое целое число (Python 2's int) предоставляется sys.maxint.
>>> import sys, math
>>> math.ceil(math.log(sys.maxint, 2)) + 1 # Signedness
32.0
Существует также sys.getsizeof, который возвращает фактический размер объекта Python в остаточной памяти:
>>> a = 5
>>> sys.getsizeof(a) # Residual memory.
12
Для данных с плавающей запятой и точных данных используйте sys.float_info:
>>> 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)
Вы имеете в виду Python или использование ctypes?
В первом случае вы просто не можете - потому что у Python нет 16/32-битных целых чисел со знаком / без знака.
Во втором случае вы можете использовать type():
>>> import ctypes
>>> a = ctypes.c_uint() # unsigned int
>>> type(a)
<class 'ctypes.c_ulong'>
Для получения дополнительной информации о ctypes и его типе см. Официальную документацию.
Python не имеет таких типов, как вы описываете. Есть два типа, используемые для представления интегральных значений: int, что соответствует типу int платформы в C, и long, которое является произвольным целым числом точности (т.е. оно растет по мере необходимости и не имеет верхнего предела). intс молча превращаются в long если выражение дает результат, который не может быть сохранен в int,
Простой, для питона 3.4 и выше
print (type(variable_name))
Python 2.7 и выше
print type(variable_name)
Это действительно зависит от того, какой уровень вы имеете в виду. В Python 2.x есть два целочисленных типа, int (ограничено sys.maxint) а также long (неограниченная точность), по историческим причинам. В коде Python это не должно иметь большого значения, потому что интерпретатор автоматически конвертирует в long, когда число слишком велико. Если вы хотите узнать о фактических типах данных, используемых в базовом интерпретаторе, это зависит от реализации. (CPython находятся в Objects/intobject.c и Objects/longobject.c.) Чтобы узнать о типах систем, посмотрите ответ cdleary для использования модуля struct.
Я видел это, когда был новичком в Python (я все еще им):
x = …
print(type(x))```
Для python2.x используйте
print type(variable_name)
Для python3.x используйте
print(type(variable_name))
Вы должны использовать
type()функция. Вот так:
my_variable = 5
print(type(my_variable)) # Would print out <class 'int'>
Эта функция будет просматривать тип любой переменной, будь то список или класс. Посетите этот веб-сайт для получения дополнительной информации: https://www.w3schools.com/python/ref_func_type.asp
Python — это язык с динамической типизацией. Переменной, изначально созданной как строка, позже можно присвоить целое число или число с плавающей запятой. И переводчик не будет жаловаться:
name = "AnyValue"
# Dynamically typed language lets you do this:
name = 21
name = None
name = Exception()
Чтобы проверить тип переменной, вы можете использовать встроенную функцию type() или isinstance() .Давайте посмотрим на них в действии:
Пример Python3:
variable = "hello_world"
print(type(variable) is str) # True
print(isinstance(variable, str)) # True
Давайте сравним оба метода
performancesв питоне3
python3 -m timeit -s "variable = 'hello_world'" "type(variable) is int"
5000000 loops, best of 5: 54.5 nsec per loop
python3 -m timeit -s "variable = 'hello_world'" "isinstance(variable, str)"
10000000 loops, best of 5: 39.2 nsec per loop
type примерно на 40% медленнее (54,5/39,2 =1,390).
Мы могли бы использовать
type(variable) == strвместо. Это сработает, но это плохая идея:
- следует использовать, когда вы хотите проверить значение переменной. Мы бы использовали его, чтобы увидеть, равно ли значение переменной «hello_world». Но когда мы хотим проверить, является ли переменная строкой, оператор is является более подходящим. Более подробное объяснение того, когда использовать тот или иной метод, см. в этой статье .
-
==медленнее:python3 -m timeit -s "variable = 'hello_world'" "type(variable) == str" 5000000 loops, best of 5: 64.4 nsec per loop
Разница между экземпляром и типом
Скорость — не единственная разница между этими двумя функциями. На самом деле существует важное различие между тем, как они работают:
- type возвращает только тип объекта (его класс). Мы можем использовать его, чтобы проверить, имеет ли переменная тип str.
- проверяет, является ли данный объект (первый параметр):
- экземпляр класса, указанный в качестве второго параметра. Например, является ли переменная экземпляром класса str?
- или экземпляр подкласса класса, указанного в качестве второго параметра. Другими словами, является ли переменная экземпляром подкласса str?
Что это означает на практике? Допустим, мы хотим иметь собственный класс, который действует как список, но имеет некоторые дополнительные методы. Таким образом, мы могли бы создать подкласс типа списка и добавить пользовательские функции внутри:
class MyAwesomeList(list):
# Add additional functions here
pass
Но теперь тип и isinstance возвращают разные результаты, если мы сравним этот новый класс со списком!
my_list = MyAwesomeList()
print(type(my_list) is list) # False
print(isinstance(my_list, list)) # True
Мы получаем разные результаты, потому что isinstance проверяет,
my_listявляется экземпляром списка (это не так) или подклассом списка (это потому, что
MyAwesomeListявляется подклассом списка). Если вы забудете об этом различии, это может привести к некоторым незаметным ошибкам в вашем коде.
Выводы
isinstanceобычно является предпочтительным способом сравнения типов. Это не только быстрее, но и учитывает наследование, что часто является желаемым поведением. В Python вы обычно хотите проверить, ведет ли себя данный объект как строку или список, не обязательно, если это именно строка. Поэтому вместо проверки строки и всех ее пользовательских подклассов вы можете просто использовать isinstance.
С другой стороны, когда вы хотите явно проверить, что данная переменная имеет определенный тип (а не его подкласс) - используйте
type. И когда вы его используете, используйте его так:
type(var) is some_typeне так:
type(var) == some_type.
Там нет 32-битных и 64-битных и 16-битных, python простой. Посмотрите, как проверить тип:
integer = 1
print(type(integer)) # Result: <class 'int'>, and if it's a string then class will be string and so on.
# Checking the type
test = 1.3
print(type(test) == float) # True
Если вы хотите проверить и сравнить тип переменной, вы можете использовать функцию isinstance(). Я получил это несколько лет назад с этого сайта
>>> a = []
>>> b = ()
>>> c = {}
>>> isinstance(a, int)
False
>>> isinstance(a, list)
True
>>> isinstance(b, list)
False
>>> isinstance(b, tuple)
True
>>> isinstance(c, dict)
True
И другой способ проверки типа None:
>>> a is None
False
В python есть много типов данных, таких как:
Text Type: str
Numeric Types: int, float, complex
Sequence Types: list, tuple, range
Mapping Type: dict
Set Types: set, frozenset
Boolean Type: bool
Binary Types: bytes, bytearray, memoryview
None Type: NoneType
Здесь я написал код, содержащий список, содержащий пример всех типов типов данных, и печатающий их тип.
L = [
"Hello World",
20,
20.5,
1j,
["apple", "banana", "cherry"],
("apple", "banana", "cherry"),
range(6),
{"name" : "John", "age" : 36},
{"apple", "banana", "cherry"},
frozenset({"apple", "banana", "cherry"}),
True,
b"Hello",
bytearray(5),
memoryview(bytes(5)),
None
]
for _ in range(len(L)):
print(type(L[_]))
ВЫХОД:
<class 'str'>
<class 'int'>
<class 'float'>
<class 'complex'>
<class 'list'>
<class 'tuple'>
<class 'range'>
<class 'dict'>
<class 'set'>
<class 'frozenset'>
<class 'bool'>
<class 'bytes'>
<class 'bytearray'>
<class 'memoryview'>
<class 'NoneType'>
Для этого в Python есть функция type(). Вы можете просто использовать его следующим образом:
variable = "I love apples."
print(type(variable)) # Output will be <class 'str'>
Это означает, что ваша переменная является строкой.
Вы можете попробовать это сами с целыми числами, числами с плавающей запятой, списками и т. д.
Также с использованием таких библиотек, как numpy, вы можете увидеть другие типы данных, например:
import numpy as np
matrix = np.ones(shape=(3,3), dtype="uint8")
print(type(matrix)) # Output will be <class 'numpy.ndarray'>
print(type(matrix[0][0])) # Outpu will be <class 'numpy.uint8'>
Вы можете узнать больше о типах данных в Python здесь .
Только не делай этого. Просить что-то типа неправильно само по себе. Вместо этого используйте полиморфизм. Найдите или, при необходимости, определите самостоятельно метод, который делает то, что вы хотите для любого возможного типа ввода, и просто вызывайте его, ничего не спрашивая. Если вам нужно работать со встроенными типами или типами, определенными сторонней библиотекой, вы всегда можете наследовать их и использовать вместо этого собственные производные. Или вы можете обернуть их в своем классе. Это объектно-ориентированный способ решения таких проблем.
Если вы настаиваете на проверке точного типа и размещении грязных ifS здесь и там, вы можете использовать __class__ собственность или type функция, чтобы сделать это, но вскоре вы обнаружите, что обновляете все эти ifс дополнительными случаями каждые два или три коммита. Делая это, OO предотвращает это и позволяет вам определять новый класс только для нового типа ввода.