python面向对象三大核心详解
面向对象的三大特性
一、继承
单继承：一个类只继承一个父类
抽离 ： 先有多个有共同点的类，抽离出共性形成的类 =》父类
派生： 通过已有的父类，再去定义该类的子类，这种方式就叫派生
继承 ：继承是一种关系，子类可以通过父类获取属性和方法，能获得的根据就是继承
SRE实战 互联网时代守护先锋，助力企业售后服务体系运筹帷幄！一键直达领取阿里云限量特价优惠。继承的语法：
class Sup: pass class Sub(Sup): pass # 继承父类的方法：子类没有明文书写父类的方法，通过继承关系拿到父类的属性方法 class Sup: def test(self): print(self) # 父类对象调用就是父类对象，子类对象调用就是当前调用的子类对象 class Sub(Sup): pass Sub().test() # 重写父类的方法：子类明文书写父类同名的方法名，并且实现体自定义 class Sup: def test(self): print(self) # 父类对象调用的就是父类对象，子类对象调用的就是当前调用的子类对象 class Sub(Sup): def test(self): print('自己的方法',self) Sub().test() # 重用父类的方法：子类明文书写父类同名的方法，有自己的实现体，但也用父类原有的功能 class Sup: def test(self): print(self) class Sub(Sup): def test(self): super().test() # 本质 super(Sub,self).test() python2中必须这么书写 print('自己的方法',self) Sub().test()
了解：重用概念
# java中存在方法的重用 def fn(): pass def fn(num): pass # fn()调用不传参调用第一个fn # fn(10)调用传入一个参数到第二个fn
super关键字：
class Sup: def __init__(self,name): self.name = name def test(self): print(self) class Sub(Sup): # 默认父级的__init__可以被继承过来，但是会出现子类对象的属性比父类多 def __init__(self,name,salary): super().__init__(name) # 父类有的共性功能通过super（）交给父级做 self.salary = salary # 子类特有的属性由自己完成 # 有继承关系下，只要名字相同，及时参数不同，还是属于同一个方法 def test(self,num): super().test() # 使用父级的方法 print(num) # 外界通过Sub对象来调用test方法，一定先找自己的test方法（属性的查找顺序） # 重点： ''' 1.super()可以得到调用父级功能的对象，调用者还是子类对象 2.super()只能在子类的方法中使用 3.super()本质 super（子类类名，当前对象） 4.super().父类普通方法 | super().__init__() |super()能调用父类所有可继承方法 '''
多继承：
# 属性的查找顺序：优先找自己的，如果没有，就按照继承先后查找父级 class A: name = 'A' num = 10 class B: name = 'B' count = 100 # 子类可以继承父类的所有可继承属性 class C(A,B): name = 'c' pass # 重点：python3中都是新式类：所有没有继承的类都默认继承object的类 python2 中没有继承任何类的类称之为经典类，可直接或间接继承object类转为新式类 # 新式类的继承顺序遵循广度优先：从左至右 # 经典类的继承遵循深度优先：一条线查到头 #python3中可通过 类.mro()查看继承顺序
二、反射
反射：用字符串类型的名字去操作变量
getattr与hasattr搭配使用
getattr在反射中应用场景
# 反射对象中的属性和方法 #hasattr getattr setattr delattr class A: def func(self): print('in func') a = A() a.name = 'Alex' # 反射对象的属性 ret = getattr(a,'name') # 通过变量名的字符串形式取到的值 print(ret) >>Alex # 反射对象里面的方法 class A: def func(self): print('in func') ret = getattr(a,'func') ret() # 反射类的属性 class A: price = 20 def func(self): print('in func') # A.prince print(getattr(A,'price')) >>20 # 反射类的方法 # A.func() if hasattr(A,'func'): #如果存在这个方法 hanattr用于配合其它几个方法使用判断 getattr(A,'func')() # 反射模块的属性 import my # print(my.day) print(getattr(my,'day')) # 反射模块的方法 getattr(my.'wahaha')() >>内置模块也能使用 # 反射自己模块中的变量 import sys def qqxing(): print('qqxing') year = 2018 print(getattr(sys.modules['__main__'].year)) >>2018 # 反射自己模块中的函数 getattr(sys.moudles['__main__'],'qqxing')() # 要反射的函数有参数怎么办？ import time # print(time.strftime('%Y-%m_%d')) print(getattr(time,'strftime')('%Y-%m_%d')) # 一个模块中的类能不能反射得到 import my print(getattr(my,'C'))()View Code
setattr 设置修改变量：
class A: pass a = A setattr(a,'name','nezha') # 在对象中添加 setattr(A,'name','alex') # 在类中添加
delattr 删除一个变量：
class A: pass a = A setattr(a,'name','nezha') # 在对象中添加 setattr(A,'name','alex') # 在类中添加 delattr(a,'name') #删除对象中变量 delattr(A,'name') #删除类中变量
三、封装
封装：对外隐藏类中一些属性与方法的实现细节
优点：外界不能直接访问，让内部的属性与方法具有安全保障
''' class A: # 类的属性：__开头的方法，在外界不能通过 cord | __cord 直接访问：对外隐藏了 __cord = '0100000' # 类的方法：__开头的方法，在外界不能通过 get_money | __get_money 直接访问 @classmethod def __get_money(cls): print('输入密码，取出100w零花钱') # 对象的方法：在内部可以使用 def __test(self): pass # 对象的属性：封装目的 # 1、对象的属性值一般都来源于外界，外界是有权利再次访问的 # 2、封装的目的不是让外界无法访问，而是不让其直接访问，可以在完成安全处理后再访问 # 3、如何做到外界还是通过变量名来对属性进行取值赋值，但是是走的方法间接拿到的值 # __money被封装，外界还是可以通过 对象.money 取值赋值 def __init__(self,money): self.__money = money # 取值 @property #在外界可以 对象.money 进行取值 def money(self): # print('走方法拿到的money) return self.__money # 赋值 @money.setter # 在外界可以 对象.money = 新值 进行赋值 def money(self,money): self.__money = money # 删除 @money.deleter def money(self,money): self.__money = moneyView Code
重点：
1.类的属性如何定义，类的方法如何定义
2.对象的属性如何定义，对象的方法如何定义
3.什么时候定义类方法与对象方法
4.封装的语法与原理
5.封装的目的
面向对象进阶知识
组合：
组合：自定义类的对象作为另一个类的属性
class Teacher: def __init__(self,name,sge): self.name = name self.age = age t1 = Teacher('Ben',17) class Student: # 学生可以有 老师属性 def __init__(self,name,age,teacher): self.name = name self.age = age # 组合 self.teacher = teacher stu = Student('Bob',18,t1) # 访问老师具体的信息 print(stu.teacher.name) print(stu.teacher.age)View Code
isinstance和issubclass：
# issinstance（obj，cls） 检查这个对象是否是类的的对象 class A:pass a=A print(isinstance(a,A)) >>Ture # issubclass(Sub,Sup) 判断这个子类是不是这个父类的子类 class A:pass class B(A):pass print(issubclass(B,A)) >>Ture
接口：
接口：建立关联的桥梁，方便管理代码
接口类：用来定义功能的类，为继承它的子类提供功能的，该类的功能方法一般不需要有实现体，实现体有继承它的子类自己去实现
# 提供所有宠物应该有的功能 class PetInterface: def close_master(self): pass # 提供所有看门应该有的功能 class WatchInterface: def watch_door(self): pass # 没有去继承PetInterface，WatchInterface的Dog就是普通的Dog类 # 但继承了PetInterface，该Dog就可以作为宠物狗，同理继承WatchInterface就可以作为看门狗 class Dog(PetInterface, WatchInterface): def jiao(self): pass def chi(self): pass def pao(self): pass # 一定要重写接口的方法 pass # 可以作为宠物及看门猫 class Cat(PetInterface, WatchInterface): passView Code
抽象父类：
抽象父类：拥有抽象方法(子类共有的方法，但是父类不能有具体的实现体)的父类
抽象方法：方法名是具体的，但是实现体是抽象的(在子类中重写来具象化)
注意点：有抽象方法的父类不能被实例化（假设能被实例化，就可以调用自己的抽象方法，没有任何意义）
实现抽象父类的语法：
import abs# abstract base class class Sup(metaclass=abc.ABCMeta): # 抽象父类中的抽象方法，在继承它的子类中必须有自己的实现体 # -- 抽象父类中的抽象方法实现体就没有意义，实现与不实现都是pass填充 @abc.abstractmethod def func(self): pass class Sub(Sup): def func(self): # 必须重写父类的抽象方法 # 案例 import abc class Quan(metaclass=abc.ABCMeta): def __init__(self, name): self.name = name # 共有方法，子类继承就可以了 def run(self): print(self.name + 'running') # 抽象方法：子类必须重写 @abc.abstractmethod def chi(self): pass @abc.abstractmethod def jiao(self): pass class Dog(Quan): def kanmen(self): print(self.name + '看门') def chi(self): super().chi() print(self.name + '狗粮') def jiao(self): print('汪汪汪') class Wolf(Quan): def bulie(self): print(self.name + '捕猎') def chi(self): print(self.name + '肉') def jiao(self): print('嗷嗷嗷') dog = Dog('来福') wolf = Wolf('呵呵') dog.jiao() wolf.jiao() dog.run() wolf.run()View Code
多态：
多态：对象的多种状态 - 父类对象的多种(子类对象)状态
多态的体现：功能或是需求，需要父类的对象，可以传入父类对象或任意子类对象
注：一般都是规定需要父类对象，传入子类对象
示例：
import abc class People(metaclass=abc.ABCMeta): def __init__(self, name): self.name = name @abc.abstractmethod def speak(self): pass class Chinese(People): def speak(self): print('说中国话') class England(People): def speak(self): print('说英国话') if __name__ == '__main__': # 多态的体现：功能或是需求，需要父类的对象，可以传入父类对象或任意子类对象 # 注：一般都是规定需要父类对象，传入子类对象 def ask_someone(obj): print('让%s上台演讲' % obj.name) # 父类提供，自己直接继承 obj.speak() # 父类提供，只不过子类重写了 ch = Chinese('王大锤') en = England('Tom') # 传入Chinese | England均可以，因为都是People的一种状态(体现方式) ask_someone(ch) ask_someone(en) # 传入str不可以，因为str的对象没有name和speak # s = str('白骨精') # ask_someone(s) # p = People('kkk')View Code
鸭子类型：
需求：需要一个对象，该对象有name属性及speak方法，就可以作为一种状态的体现被传入
def ask_someone(obj): print('让%s上台演讲' % obj.name) obj.speak()
1.先规定：有什么属性及什么方法的类的类型叫鸭子类型
2.这些类实例化出的对象，都称之为鸭子，都可以作为需求对象的一种具体体现
class A: # 能有自己特有的属性和方法，可以和B完全不一样，但是必须有鸭子类型规定的属性和方法，不然就不是鸭子类型 def __init__(self, name): self.name = name def speak(self): print('说AAAA') class B: # 能有自己特有的属性和方法，可以和A完全不一样，但是必须有鸭子类型规定的属性和方法，不然就不是鸭子类型 def __init__(self, name): self.name = name def speak(self): print('说BBBB') ask_someone(B('B'))View Code
格式化方法与析构方法：
格式化方法：在外界打印该类对象是被调用
格式化外界直接打印该类对象的字符串表示结果
class A: def __init__(self, name, age): self.name = name self.age = age
def __str__(self):
return 'abc' # 外界打印A类的对象，都打印 字符串 abc
return super().__str__() # 系统默认的在父类中返回的是对象存放的地址信息
return '<name:%s | age:%s>' % (self.name, self.age) # 根据对象实际的属性格式化具体的输出内容
析构方法：在对象被消耗的那一刹那被调用，在被消耗前可以做一些事情
def __del__(self): # del会在self代表的对象被消耗的时候被调用 # 我们可以在析构函数中释放该对象持有的其他资源， # 或者将一些持有资源持久化(保存到文件或数据库中) del self.name # 也可以将name存起来 a = A('老王', 88) print(a, type(a)) import time time.sleep(5) print('文件马上执行完毕，a就会被销毁')
了解补充：
class B: # 了解：对象.语法的内部实现 def __setattr__(self, key, value): self.__dict__[key] = value # 系统默认实现，在名称空间添加名字 # self.__dict__[key] = value.lower() # 可以自定义处理一些内容 # 了了解：将对象添加属性的方式可以同字典形式 def __setitem__(self, key, value): self.__dict__[key] = value b = B() # 设置 b.name = 'BBB' # 内部走的是 __setattr__ b['age'] = 18 # 内部走的是 __setitem__ # 访问 print(b.name) print(b.age)
更多精彩
