Python关于面向对象的6个问题

本文写给初学 Python 的朋友，试图讲明白以下问题：

0、什么是类和对象？

1、即然有了函数，为什么还要有类？

2、Python 如何定义 公有/保护/私有 属性/方法？私有是否是真正的私有，这样做的目的是什么？

3、如何定义类函数、成员函数、静态函数，他们的作用分别是什么？

4、类可以被继承，如何让子类必须重写父类的函数才能使用，否则抛出异常？

5、有以下继承关系: A，B(A),C(A),D(B,C) 那么 D 在初始化的时候，A，B，C 的初始化顺序是怎么样的？A 是否会初始化两次？

以下是我的回答，供参考。

0. 什么是类和对象

先说对象，对象通常有两层意思，指行动或思考时作为目标的事物或特指恋爱的对方。在编程的世界里，对象就是客观世界中存在的人、事、物体等实体在计算机逻辑中的映射。

编程时，你可以将对象映射成任何你想映射的东西，只不过，映射的如果更符常规时，代码更容易使用和理解，也更有利于后续的快速迭代和扩展。在 Python 的世界里，万物皆对象。

再说说类，类就是分类的类，代表着一群有着相似性的事物的集合，对应 Python 关键字 class。

对象是类中一个具体的事物，是由类初始化后生成的，通常也叫 object，或者实体，比如女人是一个类，而你的女朋友就是一个对象。

属性：对象的某个静态特征，比如你女朋友的肤色，民族，血型等。

函数：对象的某个动态能力，比如你女朋友会唱歌、弹琴等。

虽然举的例子可能不太恰当，但希望能加深你的理解，其实更为确切的定义如下：

类是一群有着相同属性和函数的对象的集合。

1. 即然有了函数，为什么还要有类？

函数是为了解决代码复用的，但是函数是过程思维，太具体，太具体的东西就会有很多重复，因此我们还需要对问题进行抽象，而类就是一种抽象，抽象的类，其可复用性更高，更容易面对复杂的业务逻辑，也会减轻程序员编程时的记忆压力。

如果没有类，我们更容易写出屎山一样的代码，牵一发而动全身，不敢修改。有了类，我们更容易写出易读、易维护、可扩展的代码。

2. Python 如何定义 公有/保护/私有 属性/方法？私有是否是真正的私有，这样做的目的是什么？

Python 以以下形式约定保护/私有的属性/方法：

• __ 表示私有
• _ 表示保护
• 除前两者外就是公有

所谓约定，就是你看到双下划线或单下划线开头的变量或方法时就自觉不要在类的外部修改或访问它，换句话说 Python 并不会阻碍程序员去访问类的私有属性或私有方法，Python 选择相信程序员。

访问公有属性和访问保护属性没有区别，要访问私有的话需要这样：

object._ClassName__PrivateMember

3. 如何定义类函数、成员函数、静态函数，他们的作用分别是什么？

看注释吧：

class Document():     
    WELCOME_STR = 'Welcome! The context for this book is {}.'     
    def __init__(self, title, author, context):         print('__init__函数被调用')
        self.title = title
        self.author = author
        self.__context = context
    
    #类函数     @classmethod     def create_empty_book(cls, title, author):         return cls(title=title, author=author, context='nothing')
    
    # 成员函数     def get_context_length(self):         return len(self.__context)
    
    # 静态函数     @staticmethod     def get_welcome(context):         return Document.WELCOME_STR.format(context)
empty_book = Document.create_empty_book('What Every Man Thinks About Apart from Sex', 'Professor Sheridan Simove')
print(empty_book.get_context_length())
print(empty_book.get_welcome('indeed nothing'))

类函数以 @classmethod 装饰，第一个参数必须为 cls，代表类本身，也就是说，我们可以在 classmethod 函数里面调用类的构造函数 cls()，从而生成一个新的实例。从这一点，可以推断出它的使用场景：

• 当我们需要再次调用构造函数时，也就是创建新的实例对象时
• 需要不修改现有实例的情况下返回一个新的实例。

成员函数很普通，就是对象可以直接调用的方法，第一个参数必须是 self。

静态函数，以 @staticmethod 装饰，通常就表示这个函数的计算不涉及类的变量，不需要类的实例化就可以使用，也就是说该函数和这个类的关系不是很近，换句话说，使用 staticmethod 装饰的函数，也可以定义在类的外面。

4. 类可以被继承，如何让子类必须重写父类的函数才能使用，否则抛出异常？

两种方法，推荐第二种。

第一种：

class A:     def fun(self):         raise Exception("not implement") class B(A):     pass b = B()
b.fun()

第二种：

from abc import ABCMeta,abstractmethod class A(metaclass = ABCMeta):     @abstractmethod     def fun(self):         pass class B(A):     pass b = B()
b.fun()

5. 有以下继承关系: A，B(A),C(A),D(B,C) 那么 D 在初始化的时候，A，B，C 的初始化顺序是怎么样的？A 是否会初始化两次？

    ---> B---
A-            -->D
    ---> C---

A，B，C 的初始化顺序是怎么样的，不妨写代码看看。

有两种方式，第一种 A 是会初始化两次，第二种不会。

第一种：

class A:     def __init__(self):         print("A is called")class B(A):     def __init__(self):         print("B is called")
        A.__init__(self)class C(A):     def __init__(self):         print("C is called")
        A.__init__(self)class D(B,C):     def __init__(self):         print("D is called")
        B.__init__(self)
        C.__init__(self)

d = D()

输出

D is called
B is called
A is called
C is called
A is called

第二种

class A:     def __init__(self):         print("enter A")
        print("levave A")class B(A):     def __init__(self):         print("enter B")
        super().__init__()
        print("levave B")class C(A):     def __init__(self):         print("enter C")
        super().__init__()
        print("levave C")class D(B,C):     def __init__(self):         print("enter D")
        super().__init__()
        print("levave D")

d = D()

输出

enter D
enter B
enter C
enter A
levave A
levave C
levave B
levave D

第一种方法非常明确的表明了菱形继承潜在的问题：一个基类的初始化函数可能被调用两次。在一般的工程中，这显然不是我们所希望的。

正确的做法应该是使用 super 来召唤父类的构造函数，而且 python 使用一种叫做方法解析顺序的算法（具体实现算法叫做 C3），来保证一个类只会被初始化一次。

也就是说，能用 super，就用 super。

以上就是“Python关于面向对象的6个问题”的详细内容，想要了解更多关于Python教程欢迎持续关注编程学习网