python - 如何确定参数是对象还是内置参数？

Question

如何确定“变量”是否是内置的，如字符串、列表、字典或数字，而不是“对象”。我正在尝试为复制内置类型但忽略对象的字典做一个 deepcopy-ish 函数。

Answer 1

一切都是对象。如果您想确定某个对象是字符串、整数还是其他类型，请使用isinstance()：

>>> isinstance("hello!", str)
True
>>> isinstance("hello!", int)
False

因此，在您的情况下，您似乎只想使用字典调用函数：

>>> mylist = [3, "cabbage", 5.43, {'cat':'dog'}, {'horse':'elephant'}, ['another', 'list']]
>>> for i in mylist:
...     if isinstance(i, dict):
...         dostuff()

Answer 2

由于内置类型很少，您可以使用 if 进行检查：

if type(a)==int or type(a)==float or type(a)==str or type(a)==list or type(a)==dict:
        #do something

或使用isinstance()

if isinstance(a,(int,float,str,list,dict,set)):
    #do something

不知道这是否是正确的做法。但这是检查给定变量是否是任何内置数据类型的实例的方法之一

Answer 3

我认为使用包含定义类class.__module__的模块名称的属性是最好的方法：

>>> import __builtin__
>>> int.__module__ == __builtin__.__name__
True

请注意，虽然内置模块是自动导入的，但我们必须导入它以将其引入范围并获取其名称。

对于用户定义的类：

>>> class A: pass
...
>>> A.__module__
'__main__'

Answer 4

首先，一切都是对象，所以我想您想测试内置类型与用户定义类型。

选择要排除的内置变量并比较变量的类型()。

if type(yourvar) in [list,set,int,float,str,dict]:
    print "builtin"
else:
    print "object"

一般来说isinstance比比较type更受欢迎。但是，对于扩展内置类型的对象，isinstance 将为 True：

>>> class A(list):
    pass

>>> a = A()
>>> isinstance(a,list)
True

因此，如果您想要严格的内置类型，则不应使用 isinstance。

Answer 5

仅供参考，我采用了这个解决方案：（受此启发）

from six import integer_types, string_types, text_type

_copyable_types = (
    integer_types,
    string_types,
    text_type,
    list,
    dict,
    set,
)


def deepish_copy(org):
    '''
    Will copy a dict but ignore user objects at top level.
    '''
    out = {}

    for k, v in org.iteritems():
        if isinstance(v, _copyable_types):
            try:
                out[k] = v.copy()   # dicts, sets
            except AttributeError:
                try:
                    out[k] = v[:]   # lists, tuples, strings, unicode
                except TypeError:
                    out[k] = v      # ints

    return out

Answer 6

仅CPython的方法（也可以在其他实现中工作）：

import __builtin__

builtin_types = [x for x in __builtin__.__dict__.values() if isinstance(x, type)]
def is_builtin_type(x):
  for t in builtin_types:
    if isinstance(x, t):
       return True 

这涵盖了内置异常、字节数组、对象和其他几个，其他答案的人没有提到:-)

Answer 7

首先，在 Python 中，类和类型没有区别：

>>> type("234"), "234".__class__
(str, str)

那么测试一个对象的类型可以有两种不同的含义：

isinstance测试您的对象是给定类型还是子类型：

>>> class mystr(str): pass
>>> s = mystr(4)
>>> s
'4'
>>> ype(s)
__main__.mystr
>>> isinstance(s, str)
True

然而

>>> type(s) is str
False
>>> type(s)
<class '__main__.mystr'>

顺便说一句，你不应该写type(s) == str但是type(s) is str。

现在可能回答您的问题：内置类型的模块是__builtin__

>>> str.__module__
'__builtin__'
>>> mystr.__module__
'__main__'

所以你可能可以写

>>> def is_of_builtin_type(obj):
        return type(obj).__module__ == '__builtin__'
>>> is_of_builtin_type("4223")
True
>>> class mystr(str): pass
>>> is_of_builtin_type(mystr(223))
False

注意：我还没有测试过这有多强大。

Answer 8

直截了当

对于给定的变量var，使用该函数isinstance(var, type)返回Trueifvar是类型type，False否则返回。您可以在解释器中轻松检查：

>>> a = 2
>>> isinstance(a, int)
True
>>> b = 'correct'
>>> isinstance(b, int)
False
>>> c = [1,2,3,4]
>>> isinstance(c, list)
True

...等等。因此，如果您想检查这item是一个dict：

if isinstance(item, dict):
    # handle the dict, do your deep copy
else:
    # meh, whatever

或者

考虑使用types模块，它允许：

from types import DictType
def dictate(item):
    if isinstance(item, dict):
       # handle the dict
    else:
       # panic!