如何确定Python变量的类型？

Question

如何查看变量的类型,无论是无符号32位,带符号16位等等？

我该如何看待它？

Answer 1

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之间的区别消失了.

Answer 2

您可能正在寻找该type()功能.

请参阅下面的示例,但Python中没有像Java那样的"unsigned"类型.

正整数:

>>> 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'>

Answer 3

这很简单.你这样做.

print(type(variable_name))

Answer 4

如何在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)

整数和浮动的实现细节

如何查看变量的类型,无论是无符号32位,带符号16位等等？

在Python中,这些细节是实现细节.所以,一般来说,我们通常不会在Python中担心这一点.但是,满足你的好奇心......

在Python 2中,int通常是一个有符号整数,等于实现的字宽(受系统限制).它通常在C中实现为long.当整数大于此值时,我们通常将它们转换为Python longs(具有无限精度,不要与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的)long作为int,它具有无限的精度.

我们还可以获得有关Python浮点数的一些信息,这些浮点数通常在C中实现为double:

>>> 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的实现细节.我自己不必处理这个问题.你可能也不会,如果你真的这样做,你应该知道不要为这个答案寻找答案.

Answer 5

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

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

Answer 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.

Answer 7

使用的另一种方法__class__:

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

Answer 8

Python中简单类型检查的示例:

assert type(variable_name) == int

assert type(variable_name) == bool

assert type(variable_name) == list

Answer 9

这可能有点无关紧要.但你可以检查与对象的类型isinstance(object, type)提到这里.

Answer 10

这个问题有些含糊不清 - 我不确定你对"观点"的意思.如果您正在尝试查询本机Python对象的类型,@ atzz的答案将引导您朝着正确的方向前进.

但是,如果您尝试生成具有原始C类型(例如uint32_t,int16_t)的语义的Python对象,请使用该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

对于float数据和精度数据,请使用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)

Answer 11

你的意思是Python还是使用ctypes？

在第一种情况下,你根本不能 - 因为Python没有签名/无符号,16/32位整数.

在第二种情况下,您可以使用type():

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

有关ctypes及其类型的更多参考,请参阅官方文档.

Answer 12

Python没有您描述的类型.有两种类型用于表示整数值:int,它对应于C中平台的int类型long,它是一个任意精度整数(即它根据需要增长,没有上限).ints long如果表达式产生无法存储的结果,则静默转换为int.

Answer 13

当我刚接触 Python 时，我看到了这个（现在仍然是）：

x = ...
print(type(x))

Answer 14

这取决于你的意思.在Python 2.x中,由于历史原因,有两种整数类型int(约束为sys.maxint)和long(无限精度).在Python代码中,这应该没有什么区别,因为当数字太大时,解释器会自动转换为long.如果您想了解底层解释器中使用的实际数据类型,那将依赖于实现.(CPython位于Objects/intobject.c和Objects/longobject.c中.)要了解系统类型,请查看使用struct模块的cdleary答案.

Answer 15

简单,对于python 3.4及以上版本

print (type(variable_name))

Python 2.7及以上版本

print type(variable_name)

Answer 16

你应该使用该type()功能。就像这样：

my_variable = 5

print(type(my_variable)) # Would print out <class 'int'>

该函数将查看任何变量的类型，无论是列表还是类。检查此网站以获取更多信息：https ://www.w3schools.com/python/ref_func_type.asp

Answer 17

Python 是一种动态类型语言。最初创建为字符串的变量可以稍后重新分配为整数或浮点数。解释器不会\xe2\x80\x99t抱怨：

\n

name = "AnyValue"\n# Dynamically typed language lets you do this:\nname = 21\nname = None\nname = Exception()\n

\n

要检查变量的类型，可以使用type()或isinstance()内置函数。让\xe2\x80\x99s 看看它们的实际效果：

\n

Python3示例：

\n

variable = "hello_world"\nprint(type(variable) is str) # True\nprint(isinstance(variable, str)) # True\n

\n

让我们比较一下performancespython3 中的两种方法

\n

python3 -m timeit -s "variable = \'hello_world\'" "type(variable) is int"\n5000000 loops, best of 5: 54.5 nsec per loop\n\npython3 -m timeit -s "variable = \'hello_world\'" "isinstance(variable, str)"\n10000000 loops, best of 5: 39.2 nsec per loop\n

\n

类型大约慢 40% (54.5/39.2 = 1.390)。

\n

我们可以用type(variable) == str它来代替。它会起作用，但它\xe2\x80\x99s是一个坏主意：

\n

\n
• ==当您想要检查变量的值时应该使用。我们将使用它来查看变量的值是否等于“hello_world”。但是当我们想要检查变量是否是字符串时，is运算符更合适。有关何时使用其中一种的更详细说明，请查看这篇文章。
\n
• ==速度较慢：python3 -m timeit -s "variable = \'hello_world\'" "type(variable) == str" 5000000 loops, best of 5: 64.4 nsec per loop
\n

\n

isinstance 和 type 之间的区别

\n

速度并不是这两个功能之间的唯一区别。它们的工作方式实际上有一个重要的区别：

\n

\n
• type 仅返回对象的类型（它的类）。我们可以用它来检查变量是否是 str 类型。
\n
• isinstance检查给定对象（第一个参数）是否为：\n
  \n
  • 指定为第二个参数的类的实例。例如，variable 是 str 类的实例吗？
  \n
  • 或指定为第二个参数的类的子类的实例。换句话说 - 变量是 str 子类的实例吗？
  \n
  \n
\n

\n

这在实践中意味着什么？让\xe2\x80\x99s 说我们想要一个充当列表但有一些附加方法的自定义类。因此，我们可以对列表类型进行子类化并在其中添加自定义函数：

\n

class MyAwesomeList(list):\n    # Add additional functions here\n    pass\n

\n

但是现在，如果我们将这个新类与列表进行比较，则 type 和 isinstance 返回不同的结果！

\n

my_list = MyAwesomeList()\nprint(type(my_list) is list) # False\nprint(isinstance(my_list, list)) # True\n

\n

我们得到不同的结果，因为 isinstance 检查是否my_list是列表的实例（它\xe2\x80\x99s 不是）或列表的子类（因为MyAwesomeList是列表的子类）。如果您忘记了这种差异，则可能会导致代码中出现一些细微的错误。

\n

结论

\n

isinstance通常是比较类型的首选方法。它\xe2\x80\x99s 不仅更快，而且还考虑继承，这通常是所需的行为。在 Python 中，您通常想要检查给定对象的行为是否类似于字符串或列表，而不一定是它\xe2\x80\x99 是否恰好是一个字符串。因此，您可以只使用 isinstance，而不是检查字符串及其所有自定义子类。

\n

另一方面，当您想要显式检查给定变量是否属于特定类型（而不是其子类）时 - 请使用type. 当你使用它时，要这样使用：type(var) is some_type而不是这样：type(var) == some_type。

\n

Answer 18

对于python2.x，请使用

print type(variable_name)

对于python3.x，请使用

print(type(variable_name))