Возможно, вы ищете 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)

Я также настоятельно рекомендую интерактивный интерпретатор 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

Если возможно, преобразуйте строку или число в целое число. Аргумент с плавающей запятой будет усечен до нуля (это не включает строку представление числа с плавающей запятой!) При преобразовании строки используйте необязательную базу. Неправильно указывать базу при преобразовании нестроковый. Если аргумент находится за пределами целочисленного диапазона, длинный объект будет возвращен вместо этого.

Вопрос несколько двусмысленный - я не совсем понимаю, что вы имеете в виду под словом «взгляд». Если вы пытаетесь сделать запрос типом собственного объекта 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

Максимальное поддерживаемое целое число (int Python 2) задается параметром 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.

Используйте встроенную функцию type():

>>> i = 123
>>> type(i)
<type 'int'>
>>> type(i) is int
True
>>> i = 123.456
>>> type(i)
<type 'float'>
>>> type(i) is float
True

Чтобы проверить, принадлежит ли переменная заданному типу, используйте isinstance:

>>> i = 123
>>> isinstance(i, int)
True
>>> isinstance(i, (float, str, set, dict))
False

Обратите внимание, что у Python нет тех же типов, что и у C / C++, и это, похоже, ваш вопрос.

Это действительно зависит от того, какой уровень вы имеете в виду. В Python 2.x существует два целочисленных типа: int (ограничено sys.maxint) и long (неограниченная точность) по историческим причинам. В коде Python это не должно иметь большого значения, потому что интерпретатор автоматически преобразуется в long, когда число слишком велико. Если вы хотите знать о фактических типах данных, используемых в базовом интерпретаторе, это зависит от реализации. (CPython находятся в Objects / intobject.c и Objects / longobject.c.) Чтобы узнать о типах систем, посмотрите простой ответ на использование модуля struct.

Это может быть немного неактуальным. но вы можете проверить типы объекта с помощью isinstance(object, type), как упомянуто здесь.

Еще один способ использования __class__:

>>> a = [1, 2, 3, 4]
>>> a.__class__
<type 'list'>
>>> b = {'key1': 'val1'}
>>> b.__class__
<type 'dict'>
>>> c = 12
>>> c.__class__
<type 'int'>

Это так просто. Вы делаете это вот так.

print(type(variable_name))

How to determine the variable type in 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__

Не надо. Вместо этого введите (self):

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

Детали реализации int и float

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

В Python эти особенности являются деталями реализации. Итак, в Python мы обычно не беспокоимся об этом. Однако, чтобы удовлетворить ваше любопытство ...

В Python 2 int обычно представляет собой целое число со знаком, равное ширине слово реализации (ограничено системой). Обычно это реализуется как долго в 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. Мне самому не приходилось сталкиваться с проблемами, связанными с этим. Вы, вероятно, тоже этого не сделаете, и если вы действительно это сделаете, вы должны знать достаточно, чтобы не искать этот ответ, чтобы узнать, что делать.

Примеры простой проверки типов в Python:

assert type(variable_name) == int

assert type(variable_name) == bool

assert type(variable_name) == list

Просто, для Python 3.4 и выше

print (type(variable_name))

Python 2.7 и выше

print type(variable_name)

Для python2.x используйте

print type(variable_name)

Для python3.x используйте

print(type(variable_name))

Только не делай этого. Спрашивать о типе чего-то неправильно само по себе. Вместо этого используйте полиморфизм. Найдите или, если необходимо, определите самостоятельно метод, который делает то, что вы хотите для любого возможного типа ввода, и просто вызовите его, ни о чем не спрашивая. Если вам нужно работать со встроенными типами или типами, определенными сторонней библиотекой, вы всегда можете наследовать от них и вместо этого использовать свои собственные производные. Или вы можете обернуть их в свой собственный класс. Это объектно-ориентированный способ решения таких проблем.

Если вы настаиваете на проверке точного типа и размещении грязных if здесь и там, вы можете использовать для этого свойство __class__ или функцию type, но вскоре вы обнаружите, что обновляете все эти if с дополнительными кейсами каждые два или три коммита. Использование объектно-ориентированного подхода предотвращает это и позволяет вам вместо этого определять новый класс только для нового типа ввода.

a = "cool"
type(a)

//result 'str'
<class 'str'>
or 
do 
`dir(a)` 
to see the list of inbuilt methods you can have on the variable.