Как определить тип переменной Python?

Как я вижу тип переменной, является ли она неподписанной 32-разрядной, подписанной 16 бит и т.д.?

Как просмотреть его?

881
задан user46646 31 дек. '09 в 10:58
источник поделиться
14 ответов

Python не имеет те же типы, что и 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

Однако различие между int и long уходит в Python 3.0.

791
ответ дан gregjor 31 дек. '09 в 13:43
источник поделиться

Возможно, вы ищете функцию 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'>
233
ответ дан Srikanth 31 дек. '09 в 11:02
источник поделиться

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

print(type(variable_name))
115
ответ дан Vaibhav 01 окт. '15 в 14:02
источник поделиться

Как определить тип переменной в 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)

Сведения о реализации int и float

Как я вижу тип переменной, является ли она неподписанной 32-разрядной, подписанной 16 бит и т.д.?

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

В Python 2 int обычно представляет собой целое число со знаком, равное реализации word width (ограничено системой). Обычно он реализуется как длиной в C. Когда целые числа становятся больше, чем это, мы обычно конвертируем их в длинные Python (с неограниченной точностью, чтобы не путать с C longs).

Например, в 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's) long как int, который неограниченную точность.

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

54
ответ дан Aaron Hall 07 окт. '16 в 19:02
источник поделиться

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

>>> a = [1, 2, 3, 4]
>>> a.__class__
<type 'list'>
>>> b = {'key1': 'val1'}
>>> b.__class__
<type 'dict'>
>>> c = 12
>>> c.__class__
<type 'int'>
33
ответ дан アレックス 18 марта '15 в 5:48
источник поделиться

Вопрос несколько неоднозначен - я не уверен, что вы подразумеваете под "представлением". Если вы пытаетесь запросить тип родного объекта 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 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)
23
ответ дан cdleary 31 дек. '09 в 11:08
источник поделиться

Вы имеете в виду Python или используя ctypes?

В первом случае вы просто не можете - потому что у Python нет подписанных /unsigned, 16/32 битных целых чисел.

Во втором случае вы можете использовать type():

>>> import ctypes
>>> a = ctypes.c_uint() # unsigned int
>>> type(a)
<class 'ctypes.c_ulong'>

Подробнее о типах ctypes см. официальную документацию.

16
ответ дан Roberto Liffredo 31 дек. '09 в 11:10
источник поделиться
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

    Convert a string or number to an integer, if possible.  A floating point
    argument will be truncated towards zero (this does not include a string
    representation of a floating point number!)  When converting a string, use
    the optional base.  It is an error to supply a base when converting a
    non-string. If the argument is outside the integer range a long object
    will be returned instead.
16
ответ дан Lawrence Johnston 31 дек. '09 в 11:02
источник поделиться

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

15
ответ дан skjoshi 14 авг. '13 в 9:39
источник поделиться

У Python нет таких типов, которые вы описываете. Для представления интегральных значений используются два типа: int, что соответствует типу платформы int в C и long, который представляет собой произвольное целое число точности (т.е. Растет по мере необходимости и не имеет верхнего предела). int молча преобразуются в long, если выражение создает результат, который не может быть сохранен в int.

13
ответ дан atzz 31 дек. '09 в 11:12
источник поделиться

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

assert type(variable_name) == int

assert type(variable_name) == bool

assert type(variable_name) == list
13
ответ дан anh_ng8 12 янв. '17 в 4:08
источник поделиться

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

print (type(variable_name))

Python 2.7 и выше

print type(variable_name)
10
ответ дан Priyansh 09 апр. '17 в 12:39
источник поделиться

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

8
ответ дан Benjamin Peterson 31 дек. '09 в 17:36
источник поделиться

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

print type(variable_name)

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

print(type(variable_name))
3
ответ дан Prince Dhadwal 28 сент. '17 в 9:58
источник поделиться

Другие вопросы по меткам