Question

如何确定“变量”是否构建为字符串，列表，字典或数字，而不是“对象”。我正在尝试为dicts执行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__属性，其中包含定义类的模块 name ，是最好的方法：

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

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

对于用户定义的类：

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

Answer 4

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

选择要排除的内置内容并比较变量的type（）。

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

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

这包括内置异常，bytearrays，对象和其他人，其他答案的人没有提到： - ）

Answer 6

首先，在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 7

仅供参考，我选择了这个解决方案:(灵感来自this）

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 8

<强>直截了当

对于给定变量var，如果isinstance(var, type)属于True，则使用函数var会返回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!

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

8 个答案: