面向对象基础总结

继承

什么是继承?

继承是一种新建类的方式 新建类称为 子类 /派生类 被继承的类称之为 父类/基类/超类

继承的 特性: 子类可以遗传/重用父类的属性

1.python中一个子类可以同时继承多个父类

2.在继承背景下说 python中的类分为 两种,新式类,经典类

​ 新式类:但凡继承了object的类 以及该类的子类 都是 新式类(可以用到 object的方法)在python中一个类即便是没有显示的继承任何类 默认就会继承object

​ 经典类:没有继承object的类,以及该类的子类 .. 都是经典类 python2 中才会区分新式类和经典类 在python中一个类即便是没有显示的继承任何类 也不会继承object

class Foo(object):  python3和python2 中都可以用的新式类
    pass

print(Foo.__bases__) # 查看基类符 父类

为何要是用继承?

减少类与类之间的代码冗余

class Foo(object):
    x = 111

class Sub(Foo):
    x = 222
f = Sub()
f.x = 333
print(f.x)

在子类派生的新方法中重用父类功能的方式一

指名道姓的方式: 指名道姓的引用某一个;类的函数
    # 总结 和继承没有关系 2.访问的是类的函数 没有自动传值得效果
class Oldboy:
    def __init__(self, name, age, sex):
        self.name = name 
        self.age = age 
        self.sex = sex
        
class Student(Oldboy):
    def __init__(self,name, age, sex, score):
        Oldboy.__init__(self,name, age, sex)
        self.score = score

菱形继承问题:

新式类:广度优先,从左往右一个分支一个分支的查找,最后一个分支才去顶级查找

经典类:深度优先查找,从左往右有个分支一个分支的查找,在第一个分支就去顶级查找

 f.mto() #等于f.__mro__ 查看顺序 mro列表就是一个简单的所有基类的线性顺序
class A:
    pass

class B(A):
    pass

class C(B):
    pass

print(C.mro())

# [<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

在子类派生的新方法中重用父类功能的方式二super

super(自己的类名,自己的  对象)必须在类中使用
#在python2中 :super(自己的类名,自己的对象)
#在python3中 :super()
#调用该函数会得到一个返回值 是一个特殊的对象 对象访问一个功能 就是绑定方法 自动传值  该对象专门用来父类中的属性!!!
                             
完全参照mro列表查找    严格依赖继承 mro列表 访问的是一个绑定方法 有自动传值的方法

class Oldboy:
    def __init__(self, name, age, sex):
        self.name = name 
        self.age = age 
        self.sex = sex
        
class Student(Oldboy):
    def __init__(self,name, age, sex, score):
        
        Oldboy.__init__(self,name, age, sex)
        super(Oldboy,self).__init__(name, age, sex)
        super().__init__(name, age, sex) 
        
        self.score = score

组合

组合指的是某一个对象拥有一个属性,这个属性是另外一个类的对象

多态

什么是多态?

同一种事物分不同的形态

class Animal: #动物有了就全都有了
    def speak(self):
        pass
class dog(Animal):
    pass
class pig(Animal):
    pass
class people(Animal):
    pass
obj = dog()
obj1 = pig()
obj2 = people()

obj.speak()
obj1.speak()
obj2.speak()

为什么使用多态

多态性:在多态的背景下,可以不用考虑对象具体类型的前提下而直接使用对象

模块abc 强制子类遵循父类的规范

 import abc
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def speak(self):
        pass

class People(Animal):
    def speak(self):
        print('say helllo')


class pig(Animal):
    def speak(self):
        print('henehnehen')


class dog(Animal):
    def speak(self):
        print('wannwanwna')

obj = People()
obj2 = pig()
obj3 = dog()

python中 不推崇限制你 崇尚鸭子类型 只要你长得像 你就是

封装

什么是封装? 装 :往名称空间里/容器里存入名字

封: 代表 将存放于名称空间的名字隐藏起来 对外 不对内

如何装?

在类定的属性前加__开头 没有结尾 (****)

class A:
    __x = 123
    def __init__(self, name, age):
        self.__name = name
        self.__age = age
    def get__(self):  #通过函数是可以访问的
        print(self.__name, self.__age)
        
# 对外隐藏  内部是可以访问到的

#__ 到底如何实现了隐藏 
只要是__开头的 他就会把你的开头改成  _A__X : 123 仅仅只是语法意义上的变形 并不会真正的限制类外部的访问

#如何实现的对外隐藏 对内开放
改变形操作 只会在类定义阶段 检测语法时 执行一次,类定义阶段之后新增的__开头的属性并不会变形  

为什么要封装?

封数据属性 : 将数据属性隐藏起来 类外部无法直接操作属性 需要类内部开辟一个接口 可以使外部间接的操作属性 (可以在接口上定义任意的控制逻辑 从而严格的控制属性)

封函数属性 :隔离复杂度 还是不能直接给外部使用 需要开个接口来调用

property装饰器 是用来将类中的函数属性装饰成数据属性

class D:
    def __init__(self, name, height, weight):
        self.__name = name
        self.height = height 
        self.weight = weight
	@property
    def bim(self):
        return self.weight / (self.height**2)
     
    @bin.setter
    def bin(self,obj)
        if type(obj) is not str:
            print('输入字符串呀')
    	self.__name == obj
       
    @bin.deleter
    def bin(self)
    	del self.__name
  
  s = D()
s.bim  #就可以调用了
s.bim = 'engon'
del s.bin

bin = property(get_bin, set_bin, del_bin)

绑定方法 与 非绑定方法

两大类 三小种

绑定方法 绑定给谁 就会把谁当做第一个参数传入

绑定给对象的 类中定义的函数都是绑定给对象的

classmethod 会将类作为第一个参数自动传入 (需要类名或其他 )

staticmethod 非绑定方法 既不与类绑定 又不与对象绑定 普通函数没有自动传值的效果

class A:
	def index(self):
		print('我是对象绑定')
		
	@classmethod
	def f2 (cls):
		print('我是绑定给类的')

import uuid 
uuid.uuid4()  生成一个第一无二的编号

面向对象高级(边边脚脚)

isinstance () 判断一个对象是否是一个类的实例 返回true false

print(isinstance([1,23,4], list))

issubclass() 判断是否是子类 (父类, 子类)

反射 属性操作 通过字符串 反射或者映射到对象或者类的属性上

hasarrt 本质 'name' in obj.__dict __判断有没有

getattr 本质 obj.dict['name'] 获取属性的值 没有报错 第三个参数有的话找不到返回

setattr 设置值 修改值 setattr(obj,'name', 'egon') 存在修改 不存在 添加

delattr delattr(obj, 'name') 删除

内置方法 str del

# 内置方法是  满足某种条件下自动触发
__str__ 在对象被打印时自动触发,可以用来定义对象被打印时的输出信息
__del__ 在对象被删除时先自动触发  可以用来回收对象以外的其他相关资源 
__call__ (self, *args, **kwargs)  在对象被调用时先自动触发  可以用来回收对象以外的其他相关资源