python3 uper(),继承实现原理,封装

抽象类:本身不能被实例化,也不应该不实例化,它的作用就定义标准,并不用具体实现
import abc
class Parent(metaclass=abc.ABCMeta):
    x=1
    @abc.abstractmethod
    def foo(self):
        pass
    @abc.abstractmethod
    def bar(self):
        pass

class Child(Parent):
    def foo(self):
        pass
    def bar(self):
        pass
新式类与经典类在这种继承结构下,属性的查找顺序完全一样:从做到右,一个分支接着一个分支地找

print(mro())    # 查看属性查找顺序,只在新式类中适用
新式类的在这中继承结构下,属性的查找关系,H->E->B->F->C-G-D-A 广度优先
经典类的在这中继承结构下,属性的查找关系H-E-B-A-F-C-G-D 深度优先

子类调用父类的方法,uper()函数
class People:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def foo(self):
        print(‘from parent‘)

class Teacher(People):
    def __init__(self,name,age,sex,salary,level):
        # People.__init__(self,name,age,sex)  # 指名道姓地调用People类的__init__函数

        # 在python3中
        super().__init__(name,age,sex)  # 调用父类的__init__的功能,实际上用的是绑定方法
        # super()函数一般只用于继承一个父类,如果是多个父类,只能找一个,多个的话,还是用指名道姓的方法
        # 在python2中
        # super(Teacher,self).__init__(name,age,sex)

        self.salary = salary
        self.level = level

    def foo(self):
        super().foo()
        print(‘from child‘)

t = Teacher(‘egon‘,18,‘male‘,3000,10)
print(t.name,t.age,t.sex,t.salary,t.level)
t.foo()
封装*封装数据*封装功能
class Teacher:
    __school = ‘oldboy‘ # _Teacher__school
    def __init__(self,name,salary):
        self.name = name
        self.__salary = salary

    def __foo(self):
        print(‘====>‘)
t = Teacher(‘egon‘,3000)

# python里面没有绝对的封装
# print(t.__school)     # 不能调用
print(Teacher.__dict__) # 查看后发现变形了
print(t._Teacher__school)   #可以查看变形后的
t._Teacher__foo()

# 这种变形操作只在定义阶段发生
Teacher.__N = 12345
print(Teacher.__dict__) # 没有变形

在类的外部,无法直接使用变形的属性,但是在类的内部可以直接使用
class Teacher:
    __school = ‘oldboy‘ # _Teacher__school
    def __init__(self,name,salary):
        self.name = name
        self.__salary = salary #self._Teacher__salary

    def foo(self):
        print(‘====>‘,self.__salary)    # 这里直接调用了,所以外部t.foo()有结果
t = Teacher(‘egon‘,3000)

print(t._Teacher__salary)
t.foo()
一个例子
class A:
    def foo(self):
        print(‘from A.foo‘)
        self.__bar() #self._A__bar()

    def __bar(self): #_A__bar()
        print(‘from A.bar‘)

class B(A):
    def __bar(self):  #_B__bar
        print(‘from B.bar‘)
    pass

b = B()
b.foo()

封装应用

class People:
    def __init__(self,name,age,sex,height,weight):
        self.__name = name
        self.__age = age
        self.__sex = sex
        self.__height = height
        self.__weight = weight

    def tell_name(self):
        print(self.__name)

    def set_name(self,val):
        if not isinstance(val,str):
            raise TypeError(‘名称必须为字符串类型‘)
        self.__name = val

    def tell_info(self):
        print(‘‘‘
        ---------%s info--------
        NAME:%s
        AGE:%s
        SEX:%s
        HEIGHT:%s
        WEIGHT:%s
        ‘‘‘ %(self.__name,
              self.__name,
              self.__age,
              self.__sex,
              self.__height,
              self.__weight))

egon = People(‘egon‘,18,‘mail‘,‘178cm‘,‘70kg‘)
egon.tell_name()
egon.tell_info()
egon.set_name(‘EGON‘)
# egon.set_name(123)
egon.tell_info()

property的应用

定义People类,将name,age,sex,height,weight属性都隐藏起来

对外提供接口,可以访问人的详细信息

对外提供访问姓名,修改姓名,删除姓名的接口,在修改姓名时加上类型检查

对外提供接口,访问人的BMI指数,并且用property装饰

class People:
    def __init__(self,name,age,sex,height,weight,permission=False):
        self.__name = name
        self.__age = age
        self.__sex = sex
        self.__height = height
        self.__weight = weight
        self.permission = permission

    @property
    def info(self):
        print(‘‘‘
        ---------%s info--------
        NAME:%s
        AGE:%s
        SEX:%s
        HEIGHT:%s
        WEIGHT:%s
        ‘‘‘ %(self.__name,
              self.__name,
              self.__age,
              self.__sex,
              self.__height,
              self.__weight))

    @property
    def dmi(self):
        print(self.__weight / (self.__height ** 2))

    @property
    def name(self):
        print(self.__name)
        return self.__name

    @name.setter
    def name(self, val):
        if not isinstance(val, str):
            raise TypeError(‘must be str‘)
        self.__name = val

    @name.deleter
    def name(self):
        if not self.permission:
            raise PermissionError(‘do not del‘)
        del self.__name

egon = People(‘egon‘,18,‘mail‘,78,70)
egon.info
egon.dmi
egon.info
egon.name = ‘EGON‘
# del egon.name
egon.info
时间: 07-04

python3 uper(),继承实现原理,封装的相关文章

python基础之继承实现原理、子类调用父类的方法、封装

继承实现原理 python中的类可以同时继承多个父类,继承的顺序有两种:深度优先和广度优先. 一般来讲,经典类在多继承的情况下会按照深度优先的方式查找,新式类会按照广度优先的方式查找 示例解析: 没有共同头部父类的类型 1 class E: 2 def test(self): 3 print('from E') 4 # pass 5 class F: 6 def test(self): 7 print('from F') 8 # pass 9 10 class C: 11 def test(se

Atitit.实现继承的原理and方法java javascript .net c# php ...

Atitit.实现继承的原理and方法java javascript .net c# php ... 1. 实现继承的问题 1 2. 如何拷贝基类方法?采用prototype原型方式,通过冒充对象 1 3. 2.属性如何继承? 2 4. 几种继承方式的比较    2 5. 常用的apply ,call方法 3 6. 参考 3 1. 实现继承的问题 JavaScript中要实现继承,其实就是实现三层含义: 1.子类的实例可以共享父类的方法: 2.子类可以覆盖父类的方法或者扩展新的方法: 3.子类和

为什么说继承破坏了封装

//继承破坏了封装性   因为修饰符的不同 封装:通过公有化方法访问私有化属性,使得数据不容易被任意窜改,常用private修饰属性: 继承:通过子类继承父类从而获得父类的属性和方法,正常情况下,用protected修饰属性,专门用于给子类继承的,权限一般在本包下和子类里: 继承破坏了封装:是因为属性的访问修饰符被修改,使得属性在本包和子类里可以任意修改属性的数据,数据的安全性从而得不到保障.

javascript继承(八)-封装

这个系列主要探讨的是javascript面向对象的编程,前面已经着重介绍了一下js的继承,下面想简单的说一下js如何实现封装的特性. 我们知道面向对象的语言实现封装是把成员变量和方法用一个类包围起来,对类中变量的访问只能通过已定义的接口.封装可以算是一种信息隐藏技术,java通过private修饰符将成员变量私有化,并提供对外修改的接口,以控制类中的成员变量的访问和修改.当然在这些方法中可以对数据进行一些加工. 在前面文章已经介绍了js的属性问题,那么在js中如何实现对类的属性隐藏呢?这里封装有

走入计算机的第三十天(继承实现原理和封装)

一 继承的实现原理 1 继承的实现顺序 从左到有依次查找,     每一个分支查找完了才进行下一个分支的查找 在新式类中每个分支属于同一个父类的时候查找的顺序是如下 这种属于广度优先,就是在新式类中,查找从左到右每个分支依次查找完毕过后,最后在查找他们共同的父类. 在经典类中每个分支属于同一个父类的时候查找的顺序是如下 这种属于深度查找,就是在经典类中,从左到右,每个分支查找到底,在进行下一个分支的查找,但是在他们共同父类第一次查找过后,就不会在查找他们共同的父类了. 1 class A(obj

python3 面向对象编程--类的封装和继承

#python3import refrom urllib import requestimport os class PosterSpider(object):     def __init__(self, path='./'):           self.path = path #the entry of this process def getStart(self, url):           page = self.reqPage(url) page = page.decode('

JavaScript是如何工作的:深入类和继承内部原理 + Babel和TypeScript之间转换

现在构建任何类型的软件项目最流行的方法这是使用类.在这篇文章中,探讨用 JavaScript 实现类的不同方法,以及如何构建类的结构.首先从深入研究原型工作原理,并分析在流行库中模拟基于类的继承的方法. 接下来是讲如何将新的语法转制为浏览器识别的语法,以及在 Babel 和 TypeScript 中使用它来引入ECMAScript 2015类的支持.最后,将以一些在 V8 中如何本机实现类的示例来结束本文. 概述 在 JavaScript 中,没有基本类型,创建的所有东西都是对象.例如,创建一个

类继承super原理

super 原理 super 的工作原理如下: def super(cls, inst): mro = inst.__class__.mro() return mro[mro.index(cls) + 1] 其中,cls 代表类,inst 代表实例,上面的代码做了两件事: 获取 inst 的 MRO 列表 查找 cls 在当前 MRO 列表中的 index, 并返回它的下一个类,即 mro[index + 1] 当你使用 super(cls, inst) 时,Python 会在 inst 的 M

javascript中__proto__与prototype的关系及原型继承的原理

1.__proto__与prototype的关系 所有对象的__proto__都指向其构造器的prototype var a = {"test":'mico',"age":"18"}; var b = function(){}; var c = new Date(); var d = /^[\d]$/; alert(a.__proto__ == Object.prototype); //true alert(b.__proto__ == Func