面向对象的编程思想和Python的类，访问和属性，继承 在上一文中我们了解到了，私有的属性的访问方式：实例名._类名__私有属性名。

一、私有的属性如何对外提供公有的取值和赋值方法呢？提供公有的方法作为接口进行取值

例如：

class Avg_Score:# 平均成绩类

def __init__(self,num1,num2,num3):

self.set_num(num1,num2,num3)

def num_avg(self): #计算机求平均数的方法

return (self.__num3+self.__num2+self.__num1)/3 #返回平均成绩

def get_num(self):

return self.num1,self.num2,self.num3

def set_num(self, num1,num2,num3):#赋值方法

if 0 <= num1 <= 120:

self.__num1 = num1

if 0 <= num2 <= 120:

self.__num2 = num2

if 0 <= num3 <= 120:

self.__num3 = num3

else:

raise ValueError('您输入的成绩不在范围内，请重新输入')

avg=Avg_Score(9,6,7)#创建类的实例

print('三科成绩之和为：',avg.num_avg())#类的实例，调用属性，得到属性值

print('语文成绩为：',avg._Avg_Score__num1)#进行私有属性的取值

二、多继承的执行顺序

Python支持多继承。例如一个子类，可以继承多个父类。就像人类，你可以同时继承父亲和母亲的基因。一个子类同时继承两个父类，其中的方法相同时的解析顺序

class F_Person:

def age(self):

print('这个是父亲的年龄')

class M_Person:

def age(self):

print('这个是母亲的年龄')

class Children(M_Person,F_Person):

pass

real=Children()

real.age()

print('子类的执行顺序为：',Children.__mro__)#查看方法的解析顺序

由上图可见，先继承那个，程序会先解析那个父类

三、Python中的布尔类型可以和数字进行运算

由上图中，通过mro()方法可以看出：bool类继承int类，int类继承了object类

四、super()方法，可以调用父类的方法

class Avg_Score():# 平均成绩类

def __init__(self,num1,num2,num3):

self.num1=num1 #英语成绩

self.num2=num2 #语文成绩

self.num3=num3 #数学成绩

def num_avg(self): #计算机求平均数的方法

print((self.num3+self.num2+self.num1)/3) #返回平均成绩

class Rewrite_Avg_Score(Avg_Score):#继承父类

def __init__(self,num1,num2,num3,num4):

super().__init__(num1,num2,num3)

self.num4=num4

def num_avg(self):#重写父类的方法

super().num_avg()#调用父类的方法

print(self.num4)

avg=Rewrite_Avg_Score(60,50,90,69)

avg.num_avg()

结果如图：

五、多态就是“具有多种形态”它指的是“即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态地决定调用哪个对象中的方法。

class Fruit():#水果类

def flavor(self):

print("水果很美味")

class Banana(Fruit):#香蕉类

def flavor(self):#重写flavor

print("香蕉很甜")

class Apple(Fruit):#苹果类

def flavor(self):#重写flavor

print("苹果脆甜")

class Noodles:#面条类

def flavor(self):

print("面条有营养")

def fun(q):

q.flavor()

fun(Fruit())#水果类

fun(Banana())#香蕉类

fun(Apple())#苹果类

fun(Noodles())#面条类

动态语言不关心对象的类型，只关心对象的行为，类型可以根据值来改变。

六、自定义类对象实列特殊方法

(一)用__add__()方法，可以实现两个自定义类对象的实例对象之间的相加操作

class Add:

def __add__(self,other):#用add方法实现两个类对象的相加

return self.name+other.name

def __init__(self,name):

self.name=name

#创建了两个自定义类的对象

a1=Add(1)

a2=Add(3)

print(a1+a2) #当使用+时，会自动调用类对象中的特殊方法__add__()

(二)用__len__()方法，可以实现计算自定义对象的长度

class Add:

def __add__(self,other):#用add方法实现两个类对象的相加

return self.name+'和'+other.name

def __init__(self,name):

self.name=name

def __len__(self):#用len方法计算类对象的长度

return len(self.name)

#创建了两个自定义类的对象

a1=Add('张三')

a2=Add('李四')

print(len(a1+a2))#当重写了系统中的方法后，就可以进行计算类对象的长度。否则注释掉后不能够实现计算类对象的长度

七、对象的引用计数，如何知道对象有没有被使用，通过跟踪计数的方式进行确定。

(一)对象引用加1的情况

()class Add:

pass

a=Add() #第一种情况：对象赋值给变量，引用加1

c=a #第二种情况：引用对象的变量赋值给另一个变量，加1

list=[6,8,a] #第三种情况：对象作列表中的元素,加1

import sys

#使用sys.getrefcount()函数查看引用次数，使用该方法查看时会被引用一次

print(sys.getrefcount(a))#第四中情况：对象作为函数调用时的实参。调用该方法时，输出的结果为4，说明第一个创建MyClass()的实例对象有4个引用

print(sys.getrefcount(Add())) #输出结果为1 ，对象作为方法的参数传入引用计数加1，执行完毕，引用计数减1

(二)•对象引用减1的情况。

import sys

class Add:

pass

print(sys.getrefcount(Add()))#情况一，对象离开它的作用域，例如：对象所在的函数执行完毕

a=Add() #对象赋值给变量，引用加1

c=a #引用对象的变量赋值给另一个变量，加1

print(sys.getrefcount(a))#对象的引用为3

del c #情况二：对象的引用被显示销毁,c=a被销毁，所以减1

print(sys.getrefcount(a))#对象的引用为2，说明减1

list=[6,8,a] #对象作列表中的元素,加1

print(sys.getrefcount(a))#对象的引用为3

list=[6,8]#情况三：从容器中删除对象，或对象所在的容器被销毁

print(sys.getrefcount(a))#对象的引用为2，说明减1

当对象的应用机制减到零的时候，就等待垃圾回收机制进行回收。

以上分析了属性的取值和赋值方法；并通过实例分析了多继承的执行顺序；多态；特殊方法：__add__()和__len__()方法的重写实现类对象的相加和计算长度；对象的引用计数：加减情况。