python比较之面向对象

Posted 2021-03-15 和而同

python是面向对象语言，因此它具有面向对象封装、继承、多态等特点。

简单了解下面向对象术语

类：具有相同属性和方法的对象的集合，对象是实例化后的类。

方法：类中定义的函数，使用def定义，同时参数里面默认要带上self

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

局部变量：定义在方法中的变量，只作用于当前实例的类。

实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

实例化：创建一个类的实例，类的具体对象。

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。 

python中定义类格式如下：

class ClassName():

　　def 方法名(self):

　　　　pass

类名一般建议使用驼峰命名方式，即：每个单词首字母大写。

 1 class Person(object):
 2     name1 = ‘admin‘   #name1类变量
 3     __age = ‘18‘   #私有变量，以__开头，私有属性在类外部无法直接进行访问
 4     def __init__(self,age,sex):  #age sex为实例变量
 5         self.name = self.name1
 6         self.age = age
 7         self.sex = sex
 8 
 9     def info(self):
10         print(‘你的名字是{0},年龄{1}岁，性别是{2}‘.format(self.name,self.age,self.sex))
11 
12 if __name__ == ‘__main__‘:
13     p = Person(‘20‘,‘男‘)
14     p.info()

python继承，允许同时继承多个父类，在调用方法时，先寻找子类如果没有则寻找父类从左到右，再从下到上找

 1 class Person():
 2     def __init__(self,name):
 3         self.name = name
 4 
 5     def show(self):
 6         print(‘你的名字是{0}‘.format(self.name))
 7 
 8     def aa(self):
 9         print(‘我是父类Person‘)
10 
11 class PA():
12     def __init__(self,name):
13         self.name = name
14 
15     def show(self):
16         print(‘PA:你的名字是{0}‘.format(self.name))
17 
18     def aa(self):
19         print(‘我是父类PA‘)
20 
21     def bb(self):
22         print(‘我是类PA中的bb方法‘)
23 
24 class PsersonA(Person):
25     def __init__(self,name,age):
26         Person.__init__(self,name)
27         self.age = age
28     #
29     # def show(self):
30     #     print(‘你的名字是{0},年龄{1}岁‘.format(self.name, self.age))
31 
32 class PsersonB(PA):
33     def __init__(self,name,sex):
34         super(PsersonB,self).__init__(name)
35         self.sex = sex
36 
37     def show(self):
38         print(‘你的名字是{0},性别是{1}‘.format(self.name, self.sex))
39 
40     def info(self):
41         print(‘我是类PsersonB‘)
42 
43 class C(PsersonA,PsersonB):
44     def __init__(self,name,age,sex):
45         PsersonA.__init__(self,name,age)
46         PsersonB.__init__(self, name, sex)
47 
48     def info(self):
49         print(‘我是子类C‘)
50 
51 
52 if __name__ == ‘__main__‘:
53     p = C(‘ADMIN‘,‘20‘,‘男‘)
54     p.info()  #子类与父类存在相同方法，优先使用子类
55     p.show()   #子类方法不存在，则从父类中寻找，顺序 从左到右，从下到上，就先寻找第一个父类，如果没有继续找第一个父类的父类，如果还没有找第二个父类
56     p.aa()   #方法aa,C类中没有，找第一个父类 PsersonA 中也没有，找 PsersonA 的父类 Person 有方法aa
57     p.bb()

类的专有方法：

__init__ : 构造函数，在生成对象时调用

__del__ : 析构函数，释放对象时使用

__call__: 函数调用，对象后面()，触发调用　

__str__：改变对象的字符串显示

__doc__:类的描述信息

 1 class P():
 2     ‘‘‘类描述信息嘀嗒‘‘‘
 3     def __init__(self):
 4         print(‘我是构造函数，在生成对象时时执行‘)
 5 
 6     def __del__(self):
 7         print(‘我是虚构函数，最后执行‘)
 8 
 9     def info(self):
10         print(‘个人信息‘)
11 
12     def __call__(self, *args, **kwargs):
13         print(‘对象后面()，触发调用‘)
14         self.info()
15 
16     def __str__(self):
17         return ‘改变对象字符串显示‘
18 
19 if __name__ == ‘__main__‘:
20     obj = P()
21     print(obj())
22     print(obj.__doc__)
23     print(obj)
24         

在类中方法有普通方法、静态方法、特性方法、类方法等

 1 class P(object):    
 2     def info(self):
 3         print(‘我是普通方法‘)  
 4     
 5     @property   #加property装饰器，为特性方法，在调用函数时无需加()
 6     def info1(self): 
 7         print(‘我是特性方法‘)
 8     
 9     @staticmethod  #加staticmethod装饰器，为静态方法，可由类名直接调用
10     def info2():
11         print(‘我是静态方法‘)
12     
13     @classmethod    #加classmethod装饰器，为静态方法，属于类，可由类直接调用
14     def info3(cls):
15         print(‘我是类方法‘)
16  
17         
18 if __name__ == ‘__main__‘:
19     obj = P()
20     obj.info()
21     obj.info1
22     P.info2()
23     P.info3()
24