如何确定python变量的类型？


How to determine a Python variable's type?

如何查看变量的类型，不管它是无符号32位、有符号16位等？

如何查看？

Python没有和C/C++一样的类型，这似乎是你的问题。

试试这个：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> 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

不过，在Python3.0中，int和long之间的区别已经消失了。

相关讨论

您可能正在查找type()函数。

请参阅下面的示例，但Python中没有"无符号"类型，就像Java一样。

正整数：

1
2
3
>>> v = 10
>>> type(v)
<type 'int'>

大正整数：

1
2
3
>>> v = 100000000000000
>>> type(v)
<type 'long'>

负整数：

1
2
3
>>> v = -10
>>> type(v)
<type 'int'>

文字字符序列：

1
2
3
>>> v = 'hi'
>>> type(v)
<type 'str'>

浮点整数：

1
2
3
>>> v = 3.14159
>>> type(v)
<type 'float'>
相关讨论

这很简单。你这样做。

1
print(type(variable_name))

How to determine the variable type in Python?

因此，如果您有一个变量，例如：

1
one = 1

你想知道它的类型吗？

在Python中，有正确的方法和错误的方法可以做任何事情。这是正确的方法：

使用type。

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

您可以使用__name__属性来获取对象的名称。(这是您需要使用__dunder__名称才能访问的少数特殊属性之一—在inspect模块中甚至没有该名称的方法。)

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

不要使用__class__。

在python中，以下划线开头的名称在语义上不是公共API的一部分，用户最好避免使用它们。(除非绝对必要。)

由于type给了我们对象的类，我们应该避免直接得到它。：

1
>>> one.__class__

这通常是人们在访问方法中的对象类型时的第一个想法——他们已经在寻找属性，所以类型看起来很奇怪。例如：

1
2
3
class Foo(object):
    def foo(self):
        self.__class__

不要。相反，请键入(self)：

1
2
3
class Foo(object):
    def foo(self):
        type(self)

ints和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语言中实现为long。当整数大于此值时，我们通常将其转换为python long(精度不限，不要与C long混淆)。

例如，在32位python 2中，我们可以推断int是一个有符号的32位整数：

1
2
3
4
5
6
>>> import sys

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

在python 3中，旧的int消失了，我们只使用(python的)long as int，它具有无限的精度。

我们还可以获得一些关于python的float的信息，这些float通常在C中实现为double：

1
2
3
4
>>> 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)

结论

不要使用语义上非公共的API __class__来获取变量的类型。用type代替。

不要太担心Python的实现细节。我不必亲自处理这件事。你可能也不会这样做，如果你真的这样做了，你应该知道足够的不要去寻找这个答案来做什么。

相关讨论

1
print type(variable_name)

在处理这样的问题时，我也强烈推荐ipython交互式解释器。它允许您键入variable_name?，并返回关于对象的完整信息列表，包括类型和类型的文档字符串。

例如

1
2
3
4
5
6
7
8
9
In [9]: var = 123

In [10]: var?
Type:       int
Base Class: <type 'int'>
String Form:    123
Namespace:  Interactive
Docstring:
    int(x[, base]) -> integer

如果可能，将字符串或数字转换为整数。浮点参数将被截断为零(这不包括字符串浮点数的表示法！)转换字符串时，请使用可选的基。在转换时提供基是一个错误非字符串。如果参数超出整数范围，则为长对象将被返回。

相关讨论

使用__class__的另一种方法：

1
2
3
4
5
6
7
8
9
>>> a = [1, 2, 3, 4]
>>> a.__class__
<type 'list'>
>>> b = {'key1': 'val1'}
>>> b.__class__
<type 'dict'>
>>> c = 12
>>> c.__class__
<type 'int'>
相关讨论

python中的简单类型检查示例：

1
2
3
4
5
assert type(variable_name) == int

assert type(variable_name) == bool

assert type(variable_name) == list
相关讨论

这个问题有点模棱两可——我不确定你所说的"视图"是什么意思。如果您试图查询本地python对象的类型，@atzz的答案将引导您朝正确的方向前进。

但是，如果您试图生成具有原始C类型语义的python对象(如uint32_t、int16_t，请使用struct模块。您可以确定给定C类型原语中的位数，即：

1
2
3
4
5
6
7
8
>>> struct.calcsize('c') # char
1
>>> struct.calcsize('h') # short
2
>>> struct.calcsize('i') # int
4
>>> struct.calcsize('l') # long
4

这也反映在array模块中，该模块可以生成这些低级类型的数组：

1
2
>>> array.array('c').itemsize # char
1

支持的最大整数(python 2的int由sys.maxint给出。

1
2
3
>>> import sys, math
>>> math.ceil(math.log(sys.maxint, 2)) + 1 # Signedness
32.0

还有sys.getsizeof，它返回剩余内存中python对象的实际大小：

1
2
3
>>> a = 5
>>> sys.getsizeof(a) # Residual memory.
12

对于浮点数据和精度数据，请使用sys.float_info:

1
2
>>> 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)
相关讨论

这可能有点无关紧要。但是您可以使用这里提到的isinstance(object, type)检查对象的类型。

你是说在python中还是使用ctypes？

在第一种情况下，您完全不能-因为Python没有有符号/无符号16/32位整数。

在第二种情况下，您可以使用type()：

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

有关ITS类型ctypes的更多参考，请参阅官方文档。

python没有您描述的类型。用于表示整数值的类型有两种：int，对应于C中平台的in t类型；long，对应于任意精度整数(即根据需要增长，没有上限)。如果表达式产生的结果不能存储在int中，则ints将静默地转换为long。

简单，适用于python 3.4及更高版本

1
print (type(variable_name))

python 2.7及更高版本

1
print type(variable_name)

这真的取决于你的意思。在python 2.x中，由于历史原因，有两种整数类型：int(限制为sys.maxint)和long(无限精度)。在Python代码中，这不会有什么不同，因为当数字太大时，解释器会自动转换为long。如果您想了解底层解释器中使用的实际数据类型，这取决于实现。(cpython位于objects/intobject.c和objects/longobject.c中)要了解有关系统类型的信息，请参阅cdleary answer for using the struct模块。

对于python2.x，使用

1
print type(variable_name)

对于python3.x，使用

1
print(type(variable_name))
1
2
3
4
5
6
a ="cool"
type(a)
//result
<class 'str'>

or do `dir(a)` to see the list of inbuilt methods you can have on the variable.

只是不要这样做。要求某种东西的类型本身就是错误的。而是使用多态性。找到或者如果有必要，自己定义一个方法，它可以为任何可能的输入类型执行您想要的操作，只需调用它而不询问任何问题。如果需要使用内置类型或由第三方库定义的类型，则可以始终从这些类型继承并使用自己的派生。或者你可以把它们包装在你自己的班级里。这是解决此类问题的面向对象方法。

如果你坚持要检查准确的类型，在这里或那里放一些脏的if，你可以使用__class__属性或type函数来完成，但是很快你就会发现你自己每两三次提交就更新这些if，并添加额外的案例。使用OO方法可以避免这种情况，并且只允许为新类型的输入定义一个新类。

相关讨论