你可能正在寻找#0内建函数。

请参阅下面的示例，但是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?并返回有关对象的完整信息列表，包括类型和类型的文档字符串。

e. g.

In [9]: var = 123
In [10]: var?Type:       intBase Class: <type 'int'>String Form:    123Namespace:  InteractiveDocstring:int(x[, base]) -> integer

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

这个问题有点模棱两可——我不确定你所说的“视图”是什么意思。如果您尝试查询本机Python对象的类型，@阿特兹的答案将引导您朝着正确的方向前进。

但是，如果您尝试生成具有原始C类型语义学的Python对象（例如uint32_t、int16_t），请使用#2模块。您可以通过以下方式确定给定C类型原语中的位数：

>>> struct.calcsize('c') # char1>>> struct.calcsize('h') # short2>>> struct.calcsize('i') # int4>>> struct.calcsize('l') # long4

这也反映在array模块中，它可以制作这些低级类型的数组：

>>> array.array('c').itemsize # char1

支持的最大整数（Python 2的int）由sys.maxint给出。

>>> import sys, math>>> math.ceil(math.log(sys.maxint, 2)) + 1 # Signedness32.0

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

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

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

>>> sys.float_infosys.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还是使用ctype？

在第一种情况下，你根本不能——因为Python没有有符号/无符号的16/32位整数。

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

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

有关ctype及其类型的更多参考，请参阅官方留档。

Python没有您所描述的类型。有两种类型用于表示整数值：int，它对应于C中平台的int类型，long，它是一个任意精度整数（即它根据需要增长并且没有上限）。如果表达式产生的结果不能存储在int中，则int会静默转换为long。

使用#0内置函数：

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

要检查变量是否属于给定类型，请使用#0：

>>> 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的位于Object/intject. c和Object/Longobject. c中。）要了解系统类型，请查看使用struct模块的cdleary答案。

这可能有点不相关。但您可以检查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))

如何确定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。当整数大于此时，我们通常将其转换为Python long s（精度无限，不要与C long s混淆）。

例如，在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 as int，它具有无限精度。

我们还可以获得一些关于Python的浮点数的信息，这些浮点数通常在C中实现为双倍：

>>> sys.float_infosys.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。以OO的方式这样做可以防止这种情况，并允许你只为新类型的输入定义一个新类。

a = "cool"type(a)
//result 'str'<class 'str'>ordo`dir(a)`to see the list of inbuilt methods you can have on the variable.

您应该使用type()函数。如下所示：

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

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

没有32位和64位和16位，python很简单，你不必担心。看看如何检查类型：

integer = 1print(type(integer))  # Result: <class 'int'>, and if it's a string then class will be str and so on.
# Checking the typefloat_class = 1.3print(isinstance(float_class, float))  # True

但是如果你真的需要，你可以使用ctype库，它有像无符号整数这样的类型。

类型留档

你可以像这样使用它：

from ctypes import *uint = c_uint(1)  # Unsigned integerprint(uint)  # Output: c_uint(1)
# To actually get the value, you have to call .valueprint(uint.value)
# Change valueuint.value = 2print(uint.value)  # 2

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

name = "AnyValue"# Dynamically typed language lets you do this:name = 21name = Nonename = Exception()

要检查变量的类型，您可以使用type（）或实例内置函数。让我们看看它们的实际效果：

Python3示例：

variable = "hello_world"print(type(variable) is str) # Trueprint(isinstance(variable, str)) # True

让我们比较python3中的两个方法performances

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

类型大约慢40%（54.5/39.2=1.390）。

我们可以使用type(variable) == str代替。它会起作用，但这是个坏主意：

• 当你想检查变量的值时，应该使用==。我们会用它来查看变量的值是否等于“hello_world”。但是当我们想检查变量是否是字符串时，是运算符更合适。有关何时使用一个或另一个的更详细解释，请查看此文章。
• ==比较慢：python3 -m timeit -s "variable = 'hello_world'" "type(variable) == str" 5000000 loops, best of 5: 64.4 nsec per loop

is实例和type的区别

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

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

这在实践中意味着什么？假设我们想要一个充当列表但有一些额外方法的自定义类。所以我们可以对列表类型进行子类化并在其中添加自定义函数：

class MyAwesomeList(list):# Add additional functions herepass

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

my_list = MyAwesomeList()print(type(my_list) is list) # Falseprint(isinstance(my_list, list)) # True

我们得到不同的结果，因为is实例检查my_list是列表的实例（不是）还是列表的子类（这是因为MyAwesomeList是列表的子类）。如果你忘记了这个区别，它会导致你的代码中出现一些微妙的错误。

结论

isinstance通常是比较类型的首选方式。它不仅更快，而且还考虑了继承，这通常是所需的行为。在Python中，您通常希望检查给定对象的行为是否像字符串或列表，而不一定是它是否完全是字符串。因此，无需检查字符串及其所有自定义子类，您可以只使用is实例。

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

Python中有许多数据类型，例如：

Text Type:  strNumeric Types:  int, float, complexSequence Types: list, tuple, rangeMapping Type:   dictSet Types:  set, frozensetBoolean Type:   boolBinary Types:   bytes, bytearray, memoryviewNone 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时，我看到了这个（我仍然是）：

x = …print(type(x))```