issubclass

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class A(object):
    pass


class B(object):
    pass


class C(object):
    pass


class D(A):
    pass


print(issubclass(D, A))  # True
print(issubclass(D, B))  # False

print(issubclass(D, (B, A, C)))  # True
print(issubclass(D, (B, C)))  # False

print(issubclass(bool, int))  # True
print(issubclass(bool, str))  # False

print(issubclass(bool, (str, int, dict)))  # True
print(issubclass(bool, (str, list, dict)))  # False

print(isinstance(D(), D))  # True
print(isinstance(D(), A))  # True

print(isinstance(D(), (D, B, C)))  # True
print(isinstance(D(), (B, A, C)))  # True

  • issubclass用于判断是否是子类
  • 第一个参数是类对象，第二个参数是类对象或者元组，如果第二个参数是元组的时候，第一个类对象如果是元组中任意一个元素的子类的时候就会返回True
  • isinstance方法于上面类似

type

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
class MyClass(object):
    pass


mc = MyClass()

print(type(mc))  # <class '__main__.MyClass'>

print(type(18))  # <class 'int'>

print(type('abc'))  # <class 'str'>

print(type(MyClass))  # <class 'type'>

print(type(int))  # <class 'type'>

print(type(str))  # <class 'type'>


def do_sth():
    pass


print(type(do_sth))  # <class 'function'>

print(type(print))  # <class 'builtin_function_or_method'>

print(type(18) == int)  # True
print(type('abc') == str)  # True

# print(type(do_sth) == function)
# print(type(print) == builtin_function_or_method)
# 不能直接判断，这两个类型中types里面有定义

import types

print(type(do_sth) == types.FunctionType)  # True
print(type(print) == types.BuiltinFunctionType)  # True
  • type用来查看对象类型
  • 类对象的类型是type，也就是说类对象是type的一个实例
  • 自定义方法的类型是FunctionType
  • 内置方法的类型是BuiltinFunctionType

dir

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class MyClass(object):
    ca = "ca"

    def __init__(self):
        self.ia = "ia"

    def im(self):
        pass

    @classmethod
    def cm(cls):
        pass

    @staticmethod
    def sm():
        pass

print(dir(MyClass))
# 输出
['__class__', '__delattr__', '__dict__', '__dir__' ... 'ca', 'cm', 'im', 'sm']

print(dir(MyClass()))
# 输出
['__class__', '__delattr__', '__dict__', '__dir__' ... 'ca', 'cm', 'ia', 'im', 'sm']
  • dir可以获取到类对象或者实例对象可访问到的方法和属性（包括父类资源）的列表
  • ==类对象中不能查看到实例属性，但能看到实例方法，这是为什么呢==