1.封装
封装，就是把客观事物封装成抽象的类，并规定类中的数据和方法只让可信的类或对象操作。封装可分为两个层面：
（1）第一层面的封装，创建类和对象时，分别创建两者的名称，只能通过类名或者对象名加“.”的方式访问内部的成员和方法，前面介绍的例子其实都是这一层面的封装。
（2）第二层面的封装，类中把某些成员和方法隐藏起来，或者定义为私有，只在类的内部使用，在类的外部无法访问，或者留下少量的接口（方法）供外部访问。
私有化方法：在准备私有化的数据成员或方法的名字前面加两个下划线“__”即可。
注意：
Python目前的私有机制其实是伪私有，实际上，在外部可以通过“_类名__属性”访问私有变量和方法。
对于这一层面的封装（隐藏），我们需要在类中定义一个方法（也称接口函数），在它内部访问被隐藏的属性和方法，然后外部可以通过接口函数进行访问。
例：在类中增加一个方法（接口函数），实现通过调用该方法访问内部成员及内部方法。
class A: #定义类
def __init__(self):
self.__X = 10 #定义私有变量并赋值为10
def __foo(self): #定义私有方法
print(‘from A‘)
def bar(self): #定义接口函数
self.__foo() #类内部访问私有方法
return self.__X #返回私有变量__X的值
a = A() #创建对象
b = a.bar() #调用接口函数，将返回值赋给b
print(b) #输出b的值
程序运行效果：
2.继承
在程序中，继承描述的是事物之间的从属关系。在继承关系中，已有的、设计好的类称为父类或基类，新设计的类称为子类或派生类。继承可以分为单继承和多继承两大类。
1.单继承
在Python中，当一个子类只有一个父类时称为单继承。子类的定义如下所示：
class 子类名(父类名):
子类可以继承父类的所有公有成员和公有方法，但不能继承其私有成员和私有方法。
2.多继承
多继承指一个子类可以有多个父类，它继承了多个父类的特性。多继承可以看作是对单继承的扩展，其语法格式如下：
class 子类名(父类名1,父类名2…):
#定义沙发父类
class Sofa:
def printA(self):
print (‘----这是沙发----‘)
#定义床父类
class Bed:
def printB(self):
print(‘----这是床----‘)
#定义一个子类，继承自Sofa和Bed
class Sofabed(Sofa,Bed):
def printC(self):
print(‘----这是沙发床----‘)
obj_C = Sofabed() #创建对象
obj_C.printA() #调用Sofa父类中的方法
obj_C.printB() #调用Bed父类中的方法
obj_C.printC() #调用自身的方法
程序运行效果：
注意：
在Python中，如果两个父类中有同名的方法，调用该同名方法时会调用先继承类中的方法。
3.重写父类方法与调用父类方法
1.重写父类方法
在继承关系中，子类会自动继承父类中定义的方法，但如果父类中的方法功能不能满足需求，就可以在子类中重写父类的方法。即子类中的方法会覆盖父类中同名的方法，这也称为重载。
例：
#定义一个父类
class Person:
def speak(self): #定义方法用于输出
print (‘我是一个人类‘)
#定义一个子类
class Stu(Person):
def speak(self): #定义方法用于输出
print (‘我是一个学生‘)
student = Stu() #创建学生对象
student.speak() #调用同名方法
程序运行效果：
2.调用父类方法
如果需要在子类中调用父类的方法，可以使用内置函数super()或通过“父类名.方法名()”的方式来实现。
例：子类调用父类的方法示例。
#定义父类
class Person():
def __init__(self, name, sex):
self.name = name
self.sex = sex
#定义子类
class Stu(Person):
def __init__(self, name, sex, score):
super().__init__(name, sex) #调用父类中的__init__方法
self.score = score
#创建对象实例
student = Stu(‘Jack‘,‘Male‘,90)
print("姓名:%s，性别:%s，成绩: %s"%(student.name,student.sex,student.score))
程序运行效果：
3.多态
多态指的是一类事物有多种形态，如一个父类有多个子类。
在面向对象方法中一般是这样描述多态性的：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。
例：多态实例。
#定义父类
class Person:
def __init__(self, name, gender):
self.name = name
self.gender = gender
def who(self): #定义who方法
print(‘I am a Person, my name is %s‘ % self.name)
#定义学生子类
class Student(Person):
def __init__(self, name, gender, score):
super().__init__(name, gender)
self.score = score
def who(self): #重写父类方法
print(‘I am a Student, my name is %s‘ % self.name)
#定义教师子类
class Teacher(Person):
def __init__(self, name, gender, course):
super().__init__(name, gender)
self.course = course
def who(self): #重写父类方法
print(‘I am a Teacher, my name is %s‘ % self.name)
#定义函数用于接收对象
def fun(x):
x.who() #调用who方法
#创建对象
p = Person(‘Jack‘, ‘Male‘)
s = Student(‘Tom‘, ‘Male‘, 88)
t = Teacher(‘Lily‘, ‘Female‘, ‘English‘)
#调用函数
fun(p)
fun(s)
fun(t)
程序运行效果：