如何确定Python变量的类型?-Python 实用宝典

如何确定Python变量的类型?

我如何查看变量的类型(无符号32位,带符号16位等)? 我怎么看?

问题:如何确定Python变量的类型?

我如何查看变量的类型(无符号32位,带符号16位等)?

我怎么看?

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

How do I view it?


回答 0

使用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 ++的类型不同,这似乎是您的问题。

Use the type() builtin function:

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

To check if a variable is of a given type, use isinstance:

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

Note that Python doesn't have the same types as C/C++, which appears to be your question.


回答 1

您可能正在寻找内置功能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'>

You may be looking for the type() built-in function.

See the examples below, but there's no "unsigned" type in Python just like Java.

Positive integer:

>>> v = 10
>>> type(v)
<type 'int'>

Large positive integer:

>>> v = 100000000000000
>>> type(v)
<type 'long'>

Negative integer:

>>> v = -10
>>> type(v)
<type 'int'>

Literal sequence of characters:

>>> v = 'hi'
>>> type(v)
<type 'str'>

Floating point integer:

>>> v = 3.14159
>>> type(v)
<type 'float'>

回答 2

很简单。你是这样做的。

print(type(variable_name))

It is so simple. You do it like this.

print(type(variable_name))

回答 3

如何在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通常是一个有符号整数,等于实现的宽(受系统限制)。通常在C中实现为long。当整数变得更大时,我们通常将它们转换为Python long(精度不受限制,不要与C long混淆)。

例如,在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的实现细节。我自己不必处理这个问题。您可能也不会这样做,而且如果您确实做到了,那么您应该了解得足够多,不要去寻找该答案的答案。

How to determine the variable type in Python?

So if you have a variable, for example:

one = 1

You want to know its type?

There are right ways and wrong ways to do just about everything in Python. Here's the right way:

Use type

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

You can use the __name__ attribute to get the name of the object. (This is one of the few special attributes that you need to use the __dunder__ name to get to - there's not even a method for it in the inspect module.)

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

Don't use __class__

In Python, names that start with underscores are semantically not a part of the public API, and it's a best practice for users to avoid using them. (Except when absolutely necessary.)

Since type gives us the class of the object, we should avoid getting this directly. :

>>> one.__class__

This is usually the first idea people have when accessing the type of an object in a method - they're already looking for attributes, so type seems weird. For example:

class Foo(object):
    def foo(self):
        self.__class__

Don't. Instead, do type(self):

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

Implementation details of ints and floats

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

In Python, these specifics are implementation details. So, in general, we don't usually worry about this in Python. However, to sate your curiosity...

In Python 2, int is usually a signed integer equal to the implementation's word width (limited by the system). It's usually implemented as a long in C. When integers get bigger than this, we usually convert them to Python longs (with unlimited precision, not to be confused with C longs).

For example, in a 32 bit Python 2, we can deduce that int is a signed 32 bit integer:

>>> import sys

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

In Python 3, the old int goes away, and we just use (Python's) long as int, which has unlimited precision.

We can also get some information about Python's floats, which are usually implemented as a double in 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)

Conclusion

Don't use __class__, a semantically nonpublic API, to get the type of a variable. Use type instead.

And don't worry too much about the implementation details of Python. I've not had to deal with issues around this myself. You probably won't either, and if you really do, you should know enough not to be looking to this answer for what to do.


回答 4

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

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

print type(variable_name)

I also highly recommend the IPython interactive interpreter when dealing with questions like this. It lets you type variable_name? and will return a whole list of information about the object including the type and the doc string for the type.

e.g.

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.


回答 5

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

回答 6

另一种使用方式__class__

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

One more way using __class__:

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

回答 7

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

assert type(variable_name) == int

assert type(variable_name) == bool

assert type(variable_name) == list

Examples of simple type checking in Python:

assert type(variable_name) == int

assert type(variable_name) == bool

assert type(variable_name) == list

回答 8

可能没什么关系。但是您可以isinstance(object, type)此处所述检查对象的类型。

It may be little irrelevant. but you can check types of an object with isinstance(object, type) as mentioned here.


回答 9

这个问题有点模棱两可-我不确定您所说的“视图”是什么意思。如果您要查询本机Python对象的类型,@ atzz的答案将引导您朝正确的方向发展。

但是,如果您尝试生成具有原始C型语义(例如uint32_tint16_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

sys.maxintint给出了支持的最大整数(Python 2 )。

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

The question is somewhat ambiguous -- I'm not sure what you mean by "view". If you are trying to query the type of a native Python object, @atzz's answer will steer you in the right direction.

However, if you are trying to generate Python objects that have the semantics of primitive C-types, (such as uint32_t, int16_t), use the struct module. You can determine the number of bits in a given C-type primitive thusly:

>>> struct.calcsize('c') # char
1
>>> struct.calcsize('h') # short
2
>>> struct.calcsize('i') # int
4
>>> struct.calcsize('l') # long
4

This is also reflected in the array module, which can make arrays of these lower-level types:

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

The maximum integer supported (Python 2's int) is given by sys.maxint.

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

There is also sys.getsizeof, which returns the actual size of the Python object in residual memory:

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

For float data and precision data, use 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)

回答 10

您是在Python还是使用ctypes

在第一种情况下,您根本无法-因为Python没有带符号/无符号的16/32位整数。

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

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

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

Do you mean in Python or using ctypes?

In the first case, you simply cannot - because Python does not have signed/unsigned, 16/32 bit integers.

In the second case, you can use type():

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

For more reference on ctypes, an its type, see the official documentation.


回答 11

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

Python doesn't have such types as you describe. There are two types used to represent integral values: int, which corresponds to platform's int type in C, and long, which is an arbitrary precision integer (i.e. it grows as needed and doesn't have an upper limit). ints are silently converted to long if an expression produces result which cannot be stored in int.


回答 12

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

print (type(variable_name))

Python 2.7及更高版本

print type(variable_name)

Simple, for python 3.4 and above

print (type(variable_name))

Python 2.7 and above

print type(variable_name)

回答 13

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

It really depends on what level you mean. In Python 2.x, there are two integer types, int (constrained to sys.maxint) and long (unlimited precision), for historical reasons. In Python code, this shouldn't make a bit of difference because the interpreter automatically converts to long when a number is too large. If you want to know about the actual data types used in the underlying interpreter, that's implementation dependent. (CPython's are located in Objects/intobject.c and Objects/longobject.c.) To find out about the systems types look at cdleary answer for using the struct module.


回答 14

对于python2.x,请使用

print type(variable_name)

对于python3.x,请使用

print(type(variable_name))

For python2.x, use

print type(variable_name)

For python3.x, use

print(type(variable_name))

回答 15

只是不要这样做。要求某种类型本身是错误的。而是使用多态。查找或根据需要自己定义对任何可能的输入类型都可以执行所需操作的方法,然后直接调用它而无需询问任何内容。如果需要使用内置类型或第三方库定义的类型,则始终可以从它们继承并使用自己的派生类。或者,您也可以将它们包装在自己的类中。这是解决此类问题的面向对象的方法。

如果您坚持检查确切的类型并在各处乱放一些ifs,则可以使用__class__property或typefunction来做到这一点,但是很快您将发现自己if每隔两到三次提交就用所有其他情况来更新所有这些s。OO方法可以防止这种情况的发生,而只能让您为新的输入类型定义新的类。

Just do not do it. Asking for something's type is wrong in itself. Instead use polymorphism. Find or if necessary define by yourself the method that does what you want for any possible type of input and just call it without asking about anything. If you need to work with built-in types or types defined by a third-party library, you can always inherit from them and use your own derivatives instead. Or you can wrap them inside your own class. This is the object-oriented way to resolve such problems.

If you insist on checking exact type and placing some dirty ifs here and there, you can use __class__ property or type function to do it, but soon you will find yourself updating all these ifs with additional cases every two or three commits. Doing it the OO way prevents that and lets you only define a new class for a new type of input instead.


本文由 Python 实用宝典 作者:Python实用宝典 发表,其版权均为 Python 实用宝典 所有,文章内容系作者个人观点,不代表 Python 实用宝典 对观点赞同或支持。如需转载,请注明文章来源。
4

抱歉,评论已关闭!