Python面向对象编程-进阶篇-阿里云开发者社区

前言

在上一篇《Python面向对象编程-初级篇》中，主要介绍了面向对象相关概念、面向对象相关术语、获取或添加对象属性、魔法方法以及Python的内置属性，本篇内容则继续介绍面向对象进阶部分的内容：

面向对象的三大特性：封装、继承、多态
类中的三类变量：类变量、成员变量、局部变量
类中的私有方法和私有属性
类的三类方法：实例方法、类方法、静态方法

一、面向对象的三大特性：封装、继承、多态

1.封装

封装就是把内容封装到某个地方，后面再从某处调用被封装的内容

函数式编程的封装

defwork(name, age, work):
print(f"我叫{name}，我今年{age}岁了，我的工作是{work}")
definterest(name, age, interest):
print(f"我叫{name}，我今年{age}岁了，我的爱好是{interest}")
defcity(name, age, city):
print(f"我叫{name}，我今年{age}岁了，我的家乡是{city}")
work('小明', 28, '司机')
interest('小明', 28, '滑雪')
city('小明', 28, '北京')

面向对象编程的封装

classIntroduction(object):
def__init__(self, name, age, city, work, interest)
self.name=nameself.age=ageself.city=cityself.work=workself.interest=interestdefintro(self):
print(f"我叫{self.name}，我今年{self.age}岁了，我的家乡是{self.city}，工作是{self.work}，爱好是{self.interest}")
intro1=Introduction("小明", 28, "北京", "司机", "滑雪")
intro1.intro()
intro2=Introduction("小华", 22, "上海", "学生", "篮球")
intro2.intro()

上述对比可以看出，如果使用函数式编程，需要在每次执行函数时传入相同的参数，如果参数较多，则需要多次复制粘贴；而对于面向对象，只需要在创建对象时，将所有需要的参数封装到当前对象中，之后再次使用时，通过self间接去当前对象中取值即可。使用面向对象的思想可以更好地模拟现实生活中的事物。

2.继承

通过继承创建的类称为子类或派生类，被继承的类称为基类、父类或超类，子类可以继承父类的内容，调用父类中的属性或方法。

1）子类继承父类

如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法，或者不重写父类的构造方法

classParentObject(object):
def__init__(self, height):
self.name="当当"self.age=5defparent_func(self):
print("这是父类中的方法")
classChildObject(ParentObject):
defchild_func(self):
print("这是子类中的方法")
child=ChildObject()
child.parent_func()  # 这是父类中的方法child.child_func()  # 这是子类中的方法print(ChildObject.__bases__)  # (<class '__main__.ParentObject'>,)

2）子类继承父类中的构造方法

如下案例：子类ChildObject继承了父类ParentObject，如果想要在子类的构造方法中继承父类构造方法中的属性，可以有以下几种写法：

ParentObject.__init__(self,height='115cm')

super().__init__(height='115cm')

super(ChildObject, self).__init__(height='115cm')

classParentObject(object):
def__init__(self, height):
self.name="当当"self.age=5self.height=heightdefparent_func(self):
print("这是父类中的方法")
classChildObject(ParentObject):
def__init__(self):
# ParentObject.__init__(self,height='115cm')  # 子类继承父类的构造方法，写法一super().__init__(height='115cm')  # 子类继承父类的构造方法，写法二# super(ChildObject, self).__init__('115cm')  # 子类继承父类的构造方法，写法三

3）类的多继承：深度优先和广度优先

Python中一个子类可以继承多个父类，寻找方法有两种，分别是：深度优先（Python2）和广度优先（Python3）

在Python2中，经典类遵循的是深度优先的原则，新式类遵循的是广度优先的原则；而在Python3中，无论是经典类还是新式类，都遵循广度优先

classA(object):
name="Asia"def__init__(self):
print("class A")
classB(A):
def__init__(self):
print("class B")
classC(A):
def__init__(self):
print("class C")
classD(B, C):  
# D类继承了B、C，会先从B类开始查找指定属性，B不存在时再从C开始查找，C也不存在时再从B的父类查找def__init__(self):
print("class D")
obj=D()
print(obj.name) # Asia

由于D类继承了B、C，会先从B类开始查找name属性，B不存在，所以会再从C开始查找，由于C也不存在，所以会再从B的父类开始查找，最后在B的父类A中找到了name属性，打印结果为Asia。

4）子类重写父类方法

在子类中，使用与父类中相同的变量名或方法名，或重写父类的属性或方法

classParent:
def__init__(self):
self.name='Lucy'deffun_a(self):
print("this is a function in class Parent")
classSon(Parent):
def__init__(self):
super().__init__()
self.name='Tom'# 子类重写父类属性deffun_a(self):  # 子类重写父类方法print("this is a function in class Son")
son=Son()
print(son.name)  # Tomson.fun_a()  # this is a function in class Son

3.多态

不同的子类对象，调用相同的父类方法，产生不同的结果，一种事物的多种体现形式，函数的重写其实就是多态的一种体现

classAnimals(object):
deftalk(self):
print("animals")
classPerson(Animals):
deftalk(self):
print("person")
classCat(Animals):
deftalk(self):
print("cat")
classDog(Animals):
deftalk(self):
print("dog")
Person().talk()  # personCat().talk()  # catDog().talk()  # dog

如上图所示，Person、Dog、Cat分别继承了Animals类，但是分别重写了talk方法，当这三个类分别被调用时会执行自己类中所定义的talk方法，而非父类Animals中的talk方法

二、类变量、成员变量、局部变量

1.类变量

类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。可以由类名直接调用，也可由对象来调用。

# 类变量classA:
name='Tony'deffun_a(self):
print('this is a test function in class A')
print(A.name)  # Tonyprint(A().name)  # Tony

2.实例变量（成员变量）

在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的，在构造方法中以self. 开头来定义。实例变量只能通过对象来调用，不能通过类名调用。

# 实例变量（成员变量）classB:
def__init__(self):
self.city='suzhou'# 实例变量self.street='松涛街'# 实例变量# 在构造方法中提前声明了一个方法，这个方法中所包含的变量也属于成员变量self.vars()  
defvars(self):
self.home="月亮湾壹号"self.house="1幢一单元108"print(B().city)  # suzhouprint(B().street)  # 松涛街print(B().__dict__)  # {'city': 'suzhou', 'street': '松涛街', 'home': '月亮湾壹号', 'house': '1幢一单元108'}

3.局部变量

定义在方法中的变量，只作用于当前实例的类。如以下方法中的mobile就属于局部变量。

definfo(self):
self.number=227# 局部变量self.phone=15252162666# 局部变量

三、类中私有方法和私有属性

1.类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs

# 私有属性classParentObject(object):
mobile=15252162666# 类变量__private_mobile=15252162666# 私有变量deffun(self):
print("打印私有变量{}".format(self.__private_mobile))
deffunc(self):
returnself.__fun()
po=ParentObject()
po.fun()  # 打印私有变量15252162666

2.类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods

def__fun(self):
print("这是一个私有化方法")
deffunc(self):
returnself.__fun()

3.外部调用类中的私有属性或方法

通常私有属性和私有方法只能在类的内部被调用，外部是不可以调用的。但如果强行调用，也是可以的，相当于Python中开了个后门：

外部调用类的私有属性：对象名._类名__属性名

外部调用类的私有方法：对象名._类名__方法名

# 外部调用类的私有属性：对象名._类名__属性名print(po._ParentObject__private_mobile)
# 外部调用类的私有方法：对象名._类名__方法名po._ParentObject__fun()

四、类的三类方法：实例方法、类方法、静态方法

1.实例方法

第一个参数必须是实例对象，该参数一般约定为self，通过它来传递实例的属性和方法（也可以传类的属性和方法），只能由实例对象调用

# 实例方法classExample:
deffun_a(self):
print("这是一个实例方法")
# 调用实例方法，只能由实例对象调用ex=Example()
ex.fun_a()  # 这是一个实例方法

2.类方法

使用装饰器@classmethod，第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法（不能传实例的属性和方法），类和实例对象都可以调用

@classmethoddeffun_b(self):
print("这是一个类方法")
# 调用类方法，实例对象和类名都可以调用，使用类名直接调用时，不会执行类中的构造方法ex.fun_b()  # 这是一个类方法Example.fun_b()  # 这是一个类方法

注：使用类名直接调用时，不会执行类中的构造方法

3.静态方法

使用装饰器@staticmethod修饰，参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法，一般用于和类本身无太多关联但又会绑定在类中的场景（不可使用类中的属性和方法），如获取时间等等。类和实例对象都可以调用

@staticmethoddeffun_c():
print("这是一个静态方法")
# 调用静态方法，实例对象和类名都可以调用，不能使用类或实例的任何属性和方法ex.fun_c()  # 这是一个静态方法Example.fun_c()  # 这是一个静态方法

小结

类别	调用方式	注意事项
类变量	实例对象和类都可以调用
实例变量(成员变量)	只能通过实例对象调用
局部变量	只能在方法内部调用
类的私有属性：__private_attrs	只能在类的内部调用：self.__private_attrs	外部强行调用类的私有属性：对象名._类名__属性名
类的私有方法：__private_method	只能在类的内部调用：self.__private_methods	外部强行调用类的私有方法：对象名._类名__方法名
实例方法	只能由实例对象调用
静态方法：@staticmethod

Python面向对象编程-进阶篇

前言