SSdR - Python Article - 概念认知，集合论，面向对象

面向对象编程是概念式认知在编程世界的应用，正如数学世界的集合论是概念式认知的另一个应用。在最底层，这源于概念式认知。

人的大脑，得益于比较高度的进化，具有比较完善的理性思维能力，即抽象思维能力和数学思维能力。源于抽象思维，诞生了『概念』的概念，进而生成了概念式认知；源于数学思维，诞生了『集合』的概念，从而得到了集合论。

概念式认知原本是一种人类大脑认识客观现实的方式，基于此这个人可以更准确的调整自己的行为，以便更高效的利用自然。通过对一系列客体的共有特征的抽象，人们得以形成一个概念，进而产生针对这一概念的知识、理解和行为。

相似的过程也存在于数学问题中。人们从一系列具体的数学对象里抽象出共同特征，从而形成一个集合。比如，『与一个给定的点的距离相同的点的集合』，这是一个球面。有了集合论，所有数学问题都不再局限于一个数学对象，其解法也能适用于这一集合里的所有元素。

再后来，就是面向对象编程。在面向对象编程的概念里，有『类』和『对象』。一个类就相当于概念认知里的一个概念，或者集合论里的一个集合；一个对象则等同于一个现实世界的实体，或者一个数学里的元素。

面向对象里的类可以继承：在一个类中定义更具体的属性或方法，就会形成它的子类，本身则成为超类。子类必须具有超类的所有属性和方法，所以在任何一个程序中的任何一个用到超类的实例的地方，用子类的实例替代，一定不应该改变程序的功能，或妨碍程序的运行，否则说明程序的设计有错误。

同理，在概念认知中，一个概念被定义之后，若其中的某些实体具有更具体的特征，可以把这些特征再次抽象，得到更具体的属性，从而在已有的概念的基础上得到子概念。在任何一个真命题里，如果把使用上层概念的地方替换为子概念，不会改变这个命题的真实性。（之前为真之后亦为真，之前为假之后亦为假。）在集合论里，这种关系叫做包含，对应的集合被叫做『超集』和『(真)子集』。在之前的例子里，有一些点位于同一个平面里，则它们可以形成一个子集，『同一平面内与一个给定的点的距离相同的点的集合』，这是一个圆。

概念认知里有一个最高级的概念，其他所有概念都是它的子概念，所有实体都属于此概念，称为『存在』。集合论中也有一个最高级的集合，所有数学对象都是它的元素，叫做『全集』（针对整个数学领域）。在面向对象编程里，等价的概念被叫做『基类』。Python 里，这个类被称作 object。当我需要构建一个类（不从其他类继承）：

Code Area 1

class Speghetti(object):

def sayHi(self):

print ("[They don't speak.]")

在这里，超类的名称，object，语法上是可以省略的，但是它的出现确实能说明一个问题，即 Spaghetti 类是 object 类的子类。任何类都适用这个规则，就是说任何类都是 object 的子类。

（这也表达了唯物主义，不过以后再说）

所以，这大概就是面向对象强项，它贴合了人的大脑认识世界的过程。反过来，面向对象也非常能帮助理解概念认知和集合论。我只要知道世界上的每一个事物都是对象，每一个对象都可以被抽象成为一个类。数学里的每一个事物也是同样。

只不过，面向对象编程的思维里有一个非常严重的失误，即重写。一旦超类的方法被子类更改，它们之间就不再有继承关系。超类的实例就不一定可以使用子类实例替代（取决于重写的具体实现）。尽管这种错误可以通过严格的规定参数和返回值的种类避开，不过这完全是额外的负担。如果需要，则必须在子类里定义一个新的方法，无论与超类的对应方法如何相似。超类的方法无论如何应该保留，即使在子类中完全用不到。

在概念化认知里，一个概念可以是多个没有推导关系的概念的子概念；在集合论里，一个集合可以是多个没有包含关系的集合的真子集。同理，面向对象里，一个类可以是多个没有继承关系的超类的子类。

用Python演示（脚本下载：https://drive.google.com/file/d/1dNamiHFfVYw4-TJXAVFolDR87HspOmcP/view?usp=sharing ）

Code Area 2

class Animal(object):

def __init__(self, *args, **kwargs):

self.objName = kwargs['objName']

self.isAnimal = True

self.animalStr = "%s is not a programmer." %(self.objName)

def getIsAnimal(self):

return self.isAnimal

def describeAnimal(self):

print (self.animalStr)

class Mammal(Animal):

def __init__(self, *args, **kwargs):

if kwargs['b_prop']:

# use b_prop to call every superclass __init__

# at the same time, avoid duplicated calls

kwargs['b_prop'] = False

for eachSuperClass in Mammal.__mro__[-2:0:-1]:

# reverse because a subclass could define attributes more accurately

eachSuperClass.__init__(self, **kwargs)

self.objName = kwargs['objName']

self.isMammal = True

self.mamStr = "%s indeed is a mammal." %(self.objName)

def getIsMammal(self):

return self.isMammal

def describeMammal(self):

print (self.mamStr)

class LandedAnimal(Animal):

def __init__(self, *args, **kwargs):

if kwargs['b_prop']:

kwargs['b_prop'] = False

for eachSuperClass in LandedAnimal.__mro__[-2:0:-1]:

eachSuperClass.__init__(self, **kwargs)

self.objName = kwargs['objName']

self.isOnLand = True

self.landedStr = "%s lives happily on land." %(self.objName)

def getIsOnLand(self):

return self.isOnLand

def describeOnLand(self):

print (self.landedStr)

class LeggedAnimal(LandedAnimal):

def __init__(self, *args, **kwargs):

if kwargs['b_prop']:

kwargs['b_prop'] = False

for eachSuperClass in LeggedAnimal.__mro__[-2:0:-1]:

eachSuperClass.__init__(self, **kwargs)

self.objName = kwargs['objName']

self.legCnt = kwargs['legCnt']

self.legStr = "%s indeed has %s leg(s)." %(self.objName, self.legCnt)

def getLegCnt(self):

return self.legCnt

def describeLeg(self):

print (self.legStr)

class DogPlus(Mammal, LeggedAnimal):

def __init__(self, *args, **kwargs):

if kwargs['b_prop']:

kwargs['b_prop'] = False

for eachSuperClass in DogPlus.__mro__[-2:0:-1]:

eachSuperClass.__init__(self, **kwargs)

self.objName = kwargs['objName']

self.greetingStr = kwargs['greetingStr']

self.farewellStr = kwargs['farewellStr']

def greeting(self):

print (self.greetingStr)

def farewell(self):

print (self.farewellStr)

macconnell = DogPlus(b_prop=True, \

objName="MacConnell", legCnt=4, \

greetingStr="Hi there sweety.", farewellStr="Till next time sweety.")

if macconnell.isAnimal:

macconnell.describeAnimal() # It moves too!

if macconnell.isMammal:

macconnell.describeMammal() # MacConnell is indeed a mammal.

if macconnell.isOnLand:

macconnell.describeOnLand() # MacConnell lives happily on land.

if macconnell.legCnt:

macconnell.describeLeg() # MacConnell indeed has 4 leg(s).

else:

print ("NO LEGS!")

macconnell.greeting() # Hi there sweety.

macconnell.farewell() # Till next time sweety.

确实，它的语法设计比较差。使用时，这些命令容易让人疑惑、犯错，且低效。尽管没有逻辑上的不足，我仍然不会倾向于使用这种多继承。这也再次体现了方法的重写是一个非常差劲的想法。要我说，多继承中的问题80%由重写引起。如果不是有了MRO，Method Resolution Order，这一数字可能达到99%。

幸好多继承只用作逻辑完整性的弥补就够了。如果在实际运用中有必须用到多继承的情形，我更愿意寻找替代方法，比如整合（Composition）。在我看来，多继承的用意只在于补全逻辑完整性，而逻辑完整性的却比实际运用更重要。

最后我必须说明，这篇文章只是基于个人经验，可能会有一些技术性错误，不过我确实从这些经验中获得了极大益处。希望这些经验也能帮助到你。