Python学习笔记（六）面向对象编程

最近准备HCIE的考试，用空余时间高强度学习python

介绍了Python中面向对象编程的基本概念，包括类、类的属性、类的方法、类的方法中实例方法、类方法、静态方法，在类与对象中动态添加属性和方法，以及继承、类变量、多态等概念

类（类对象）：为了做区分而创建的一些特性的群体
子类：通过继承创建，为了在类下做更清晰的区分
对象：建立在类的基础上，在某一类或子类下的个体
实例：约等于对象，xx对象是xx类的实例化

在python中，一切都是对象；凡是对象，都是某个类的实例
使用面向对象编程，在做好细分之后，能够更快实现功能，更容易维护 类越细分，对象就越精细

类1 → 对象1，对象2
↓
子类1 → 对象1，对象2
子类2...
子类3...

面向对象有三大特征：封装、继承、多态

类、类的属性、类的方法

#创建类————使用class关键字
#class 类名() 括号代表要继承，在规范上，类名的首字母要大写
class Ws:pass
class Xhy:pass#创建对象——根据类创建一个属于这个类的对象
v1 = Ws() #v1是由Ws这个类实例化生成的对象，v1这个对象是Ws类的实例
v2 = Ws()
v3 = Ws()#类————管理员、用户
#类的属性————是类里的变量。反映该类对象的信息，例如账号、密码、名字等
#类的方法————是类里的函数。反映该类对象能做的事，例如账号权限、添加用户、修改密码等，是一种方法，比如list.append，是自己定义的函数#添加类的属性，一般都是类的可变属性
#添加一个不变的属性
class User_info: #通过__init__构造方法def __init__(self):  #self代表要被实例化的对象self.username = 'ws'  #为其赋值self.age = '24'self.password = 'ws111'
user1 = User_info()
print(user1.password)
#ws111
#添加类的可变属性，这样可以适用更多user
class User_info:def __init__(self,username,age,password):self.username = usernameself.age = ageself.password = passworduser1 = User_info('ws',24,'ws111')
user2 = User_info('xhy',23,'xhy111')
print(user1.username)
print(user2.password)
#ws
#xhy111#添加类的方法，在创建了对象之后，就可以直接使用类的方法
class User_info:def __init__(self,name,password,age):self.name = nameself.password = passwordself.age = agedef show(self):print(self.name, self.password)def show_age(self):print(self.age)
user1 = User_info('ws','ws111',age=24)
user1.show()
#ws ws111
user1.show_age()
#24
#在方法中定义的类的属性，可以在全局进行调用
class User_info:def __init__(self,name):self.name = namedef show_age(self):self.age = 24  ####在方法中定义类的属性print(self.age)
user1.show_age()
#24

实例方法、类方法、静态方法

#实例方法————首个参数为self的方法，绑定给该类的实例调用，类本身不能调用
class User_info:def __init__(self,name):self.name = namedef show(self):pass
user1 = User_info('ws') #在实例方法中，必须要创建一个实例，才能使用类中的方法
user1.show()
#无法用类来直接调用，像User_info.show这样的用法#类方法————首个参数为cls，并且以classmethod装饰的方法
#可以直接使用类来调用如User_info.show，但无法调用类的参数
class User_info:def __init__(self,name):self.name = name@classmethoddef show(cls):print('ws')@classmethoddef show_name(cls):print(self.name)
User_info.show()
#ws
User_info.show_name()
#报错，无法调用类的参数
#如果需要则需要额外在类方法中传入参数
class User_info:def __init__(self, name, age):self.name = nameself.age = age@classmethod #类方法的装饰器def show_name(cls, age):print(age)
User_info.show_name(24)
#24#静态方法————不需要cls或self，使用staticmethod装饰，可以直接调用，但无法使用类的属性
class User_info:def __init__(self, name):self.name = name@staticmethoddef show_name(): #需要传参则定义形参print('11111')
User_info.show_name()
#11111

面向对象的动态特性

动态添加属性、修改属性

#动态的添加对象和类的属性
# 添加到对象只会影响对象本身，而为类添加的属性会应用给所有对象
class User_info:def __init__(self, name):self.name = nameself.username = 'ws' #添加一个固定的类的属性值
if __name__ == '__main__':user1 = User_info('ws') #创建了一个实例/对象user1user1.age = 24          #age这个属性只属于user1这个对象中，而不属于User_info的类print(user1.age)#24user1.age = 25          #动态修改对象的属性值print(user1.age)# 25User_info.password = 'ws111' #为类添加属性，如果没有会添加到user1中，且值是可修改print(user1.password)#ws111User_info.password = 'xhy111' #为类添加属性，如果原本有值就会修改print(user1.password)#xhy111User_info.username= 'xhy' #无法动态修改类中原本就有的属性值，实例化后的对象继承了类的值，不会变化print(user1.username)#ws

动态添加方法

添加实例方法、添加类方法、添加静态方法

#添加实例方法————只能单独为对象添加，不能为类添加
import types        #导入types模块
class User_info:pass
def show(self):     #准备一个实例方法print('111')
if __name__ == '__main__':user1 = User_info() #实例化一个对象#目标实例的方法 = types.MethodType(待添加函数名,目标函数名）user1.show = types.MethodType(show,user1)user1.show()#111#添加类方法———只能为类添加
class User_info:pass
@classmethod
def show(cls):print('111')
if __name__ == '__main__':User_info.show = show #直接赋值就行，不要调用User_info.show()#111#添加静态方法————只能为类添加
class User_info:pass
@staticmethod
def show():print('111')
if __name__ == '__main__':User_info.show = showUser_info.show()#111

继承

子类继承父类之后可以直接使用父类定义好的属性和方法

#最简单的继承性质说明
class User():def __init__(self,name):self.name = namedef show(self):print('111')
#class 子类名（父类名）
class U001(User):def age(self): #可以在子类里定义新的方法，只属于这个子类可用的print('123')def show(self):  #可以在子类里重写父类的方法，会盖掉父类的方法print('222')
if __name__ == '__main__':user1 = U001('ws')user1.show()#222#super函数————调用父类的 方法#继承父类方法————可以在子类的方法中调用父类的任意方法
class User:def __init__(self):self.age = 24def show(self,name):print(f'{self.age}岁,{name},是学生') #调用age
class U01(User):def __init__(self):self.age = 26def show2(self):print('222')        #多加一行显示区别super().show('ws')  #调用了父类中的方法show，并且原函数需要传参，所以这里也传参
if __name__ == '__main__':user1 = U01()user1.show2()           #调用的类的属性26岁是本类的属性，而不是父类的属性24岁#222#26岁,ws,是学生#继承父类属性————分多种情况
1、全部保留属性，不新增
2、全部替换，只用自己的
3、保留部分属性，不新增
4、保留部分属性，有新增#全部保留属性，不新增
class User_info:def __init__(self, username, password, email):self.username = usernameself.password = passwordself.email = email
class User(User_info):pass        #最简单，直接什么都不用动，不重写则全部保留if __name__ == '__main__':user1 = User('ws','ws111','1320')print(user1.username)#ws#全部替换，只用自己的
class User_info:def __init__(self, username, password, email):self.username = usernameself.password = passwordself.email = email
class User(User_info): def __init__(self,age,job): #重写构造函数self.age = ageself.job = jobif __name__ == '__main__':user1 = User('ws','ws111')print(user1.age)#wsprint(user1.username)# 报错#保留部分属性，不新增
class User_info:def __init__(self, username, password, email):self.username = usernameself.password = passwordself.email = email
class User(User_info):def __init__(self,username,password):# 使用super,重跑一遍父类构造函数的形参，并且只赋值自己要的，不要的空着super().__init__(username=username,password=password,email=None)#这样就只传了name和password两个属性
if __name__ == '__main__':user1 = User('ws','ws111')print(user1.username)#ws#保留部分属性，有新增
class User_info:def __init__(self, username, password, email):self.username = usernameself.password = passwordself.email = email
class User(User_info):def __init__(self,username,password,job):self.job = job  #新增一个job属性super().__init__(username=username,password=password,email=None)
if __name__ == '__main__':user1 = User('ws','ws111','student')print(user1.username,user1.job)#ws student

类变量

在类中设置的变量，但不是类的属性

先介绍python中使用的查找算法

#Python的查找算法（包括变量的查找、类变量的查找、super函数调用）
#原则是自下而上，从里到外#变量的查找
def fun():v1 = 0def fun1():v1 = 1       #先找最里层，即fun1中的v1print(v1)
if __name__ == '__main__':v1 = 2fun()#1
#super函数的调用
class fun:def show(self):pass
class fun1(fun):pass
class fun2(fun1)def show2(self):super().show() #这条super的对函数的调用首先会在fun1中寻找，然后去fun中寻找
if __name__ == '__main__':pass#mro查找算法——应对多继承的情况下的查找
#应用于一个类继承了多个类的情况
#mro采用的算制为C3，融合了DFS（深度查询）和BFS（广度查询）
class fun():pass
class fun1():pass
class fun2(fun,fun1):pass
if __name__ == '__main__':v1 = fun2()print(v1.var)  #DFS按顺序，首先查找fun以及fun的父类，再查询fun1以及fun1的父类#类变量
#类变量可以使用类来访问和修改
class User_info():v1 = 0def __init__(self,name):self.name = name
if __name__ == '__main__':user1 = User_info('ws')User_info.v1 = 1 #只使用类来访问和修改print(User_info.v1)#1#如果user1中没有v1的变量，则去user1的父类User_info中找v1print(user1.v1)#1user1.v1 = 2     #为对象动态添加了一个属性print(user1.v1)  #优先使用user1的v1#2print(User_info.v1)#1

多态

用来控制对象的行为

不同的对象调用同一个方法，表现出不同的状态

#多态需要有继承，只发生在父类和子类之间，需要有重写
#仅需一个函数，传递不同的对象，就能使用不同子类中的制定函数
#可扩展性和可维护性都增加了
class Version:def what(self):print('Version')
class V1(Version):def what(self):print('v1')
class V2(Version):def what(self):print('v2')
class V3(Version):def what(self):print('v3')
def fun(object):object.what()
if __name__ == '__main__':v1 = V1()v2 = V2()v3 = V3()fun(v1)fun(v2)fun(v3)
#v1
#v2
#v3