Python3 面向对象作业练习

1.类变量和实例变量的区别？

class Dog:
    # 类变量(静态属性)
    kind = 'canine'

    def __init__(self, name):
        # 实例变量(对象属性)，self 表示类的实例
        self.name = name

dog = Dog("小黄")
print(dog.name) # 小黄
print(dog.kind) # canine
print(Dog.kind) # canine
print(Dog.name) # 报错：AttributeError: type object 'Dog' has no attribute 'name'

类变量和实例变量的区别在于：类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象。

2.super 的作用？

在子类中调用父类的方法。
使用场景：一般情况下，子类中有和父类相同的方法名。

3.isinstance 和 type 的区别并用代码举例说明？

class A:
    pass


class B(A):
    pass


b = B()
print(isinstance(b, B))  # True
print(isinstance(b, A))  # True
print(type(B))  # <class 'type'>
print(type(b))  # <class ‘__main__.B’>

• isinstance 能判断对象和类之间的继承关系。
  • 在调用 isinstance 方法时，会根据继承关系，自动找到一个继承链，而实例化的对象 b 本身肯定是一个 B 类型的对象，而对象 B(类)又继承了对象 A(类)，所以对象 b 又是一个 A 类型的对象。
• type 只能判断这个对象是哪个类创建出来的。不考虑继承关系。

4.补全代码

def func(arg):
    """
    判断arg是否可以被调用，如果可以则执行并打印七返回值，否则直接打印结果。
    :param arg: 传入的参数
    :return:
    """
    pass

补全后:

def func(arg):
    """
    判断arg是否可以被调用，如果可以则执行并打印七返回值，否则直接打印结果。
    :param arg: 传入的参数
    :return:
    """
    if callable(arg):
        ret = arg()
        print(ret)
    else:
        print('else:', arg)


class Foo: pass


func(Foo)  # 类可以被调用，而对象不行
obj = Foo()
func(obj)

# 输出：
# <__main__.Foo object at 0x00000000027D2470>
# else: <__main__.Foo object at 0x00000000027D2470>

5.补全代码

def func(*args):
    """
    判断args中函数、方法、Foo类的对象的个数，并返回给调用者。
    :param args: 传入的参数
    :return:
    """
    pass

补全后:

from types import MethodType, FunctionType


def func(*args):
    """
    判断args中函数、方法、Foo类的对象的个数，并返回给调用者。
    :param args: 传入的参数
    :return:
    """
    function_count = 0
    method_count = 0
    foo_obj = 0
    for item in args:
        if isinstance(item, FunctionType):
            function_count += 1
        elif isinstance(item, MethodType):
            method_count += 1
        elif isinstance(item, Foo):
            foo_obj += 1

    return {"function_count": function_count,
            "method_count": method_count,
            "foo_obj": foo_obj}


def func1(): pass


def func2(): pass


class Foo:
    def method1(self): pass

    def method2(self): pass

    def method3(self): pass


f = Foo()
ret = func(func1, func2, f.method1, Foo.method1, Foo(), Foo())  # 函数 函数 方法 函数 类对象 类对象
print(ret)  # {'function_count': 3, 'method_count': 1, 'foo_obj': 2}

6.看代码写结果并画图表示对象和类的关系以及执行流程

class StarkConfig(object):
    list_display = []

    def get_list_display(self):
        self.list_display.insert(0, 33)
        return self.list_display


class RoleConfig(StarkConfig):
    list_display = [11, 22]


s1 = StarkConfig()
s2 = StarkConfig()

result1 = s1.get_list_display()
print(result1)  # [33]

result2 = s2.get_list_display()
print(result2)  # [33, 33]

7.看代码写结果并画图表示对象和类的关系以及执行流程

class StarkConfig(object):
    list_display = []

    def get_list_display(self):
        self.list_display.insert(0, 33)
        return self.list_display


class RoleConfig(StarkConfig):
    list_display = [11, 22]


s1 = StarkConfig()
s2 = RoleConfig()

result1 = s1.get_list_display()
print(result1)  # [33]

result2 = s2.get_list_display()
print(result2)  # [33, 11, 22]

8.看代码写结果并画图表示对象和类的关系以及执行流程

class StarkConfig(object):
    list_display = []

    def get_list_display(self):
        self.list_display.insert(0, 33)
        return self.list_display


class RoleConfig(StarkConfig):
    list_display = [11, 22]


s1 = RoleConfig()
s2 = RoleConfig()

result1 = s1.get_list_display()
print(result1)  # [33, 11, 22]

result2 = s2.get_list_display()
print(result2)  # [33, 33, 11, 22]

9.看代码写结果

class Base(object):
    pass


class Foo(Base):
    pass


print(issubclass(Base, Foo))  # False