您当前的位置： 首页 >  Python

IT之一小佬

暂无认证

  • 0浏览

    0关注

    1192博文

    0收益

  • 0浏览

    0点赞

    0打赏

    0留言

私信
关注
热门博文

python⾯向对象之继承和私有权限详解

IT之一小佬 发布时间：2021-01-31 00:01:12 ，浏览量：0

⼀. 继承的概念
⽣活中的继承，⼀般指的是⼦⼥继承⽗辈的财产。
拓展 1 ：经典类或旧式类
不由任意内置类型派⽣出的类，称之为经典类。 
class 类名:
   代码
   ......
拓展 2 ：新式类 
class 类名(object):
   代码
Python ⾯向对象的继承指的是多个类之间的所属关系，即⼦类默认继承⽗类的所有属性和⽅法，具体如下： 
# ⽗类A
class A(object):
    def __init__(self):
        self.num = 1

    def info_print(self):
        print(self.num)


# ⼦类B
class B(A):
    pass


result = B()
result.info_print()  # 1
在 Python 中，所有类默认继承 object 类， object 类是顶级类或基类；其他⼦类叫做派⽣类。
⼆. 单继承
故事主线：⼀个煎饼果⼦⽼师傅，在煎饼果⼦界摸爬滚打多年，研发了⼀套精湛的摊煎饼果⼦的技术。师⽗要把这套技术传授给他的唯⼀的最得意的徒弟。
分析：徒弟是不是要继承师⽗的所有技术？ 
# 1. 师⽗类
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


# 2. 徒弟类
class Prentice(Master):
    pass


# 3. 创建对象daqiu
daqiu = Prentice()
# 4. 对象访问实例属性
print(daqiu.kongfu)
# 5. 对象调⽤实例⽅法
daqiu.make_cake()
三. 多继承
故事推进： daqiu 是个爱学习的好孩⼦，想学习更多的煎饼果⼦技术，于是，在百度搜索到⿊⻢程序员，报班学习煎饼果⼦技术。
所谓多继承意思就是⼀个类同时继承了多个⽗类。 
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


# 创建学校类
class School(object):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class Prentice(School, Master):
    pass


daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
运行效果：
注意：当⼀个类有多个⽗类的时候，默认使⽤第⼀个⽗类的同名属性和⽅法。
四. ⼦类重写⽗类同名⽅法和属性
故事： daqiu 掌握了师⽗和培训的技术后，⾃⼰潜⼼钻研出⾃⼰的独⻔配⽅的⼀套全新的煎饼果⼦技术。 
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class School(object):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


# 独创配⽅
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
print(Prentice.__mro__)  # 查看继承关系

运行效果：

⼦类和⽗类具有同名属性和⽅法，默认使⽤⼦类的同名属性和⽅法。

五. ⼦类调⽤⽗类的同名⽅法和属性
故事：很多顾客都希望也能吃到古法和⿊⻢的技术的煎饼果⼦。 
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class School(object):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果⼦配⽅]'

    def make_cake(self):
        # 如果是先调⽤了⽗类的属性和⽅法，⽗类属性会覆盖⼦类属性，故在调⽤属性前，先调⽤⾃⼰⼦类的初始化
        self.__init__()  # 此处没有写self,前面有self
        print(f'运⽤{self.kongfu}制作煎饼果⼦')

    # 调⽤⽗类⽅法，但是为保证调⽤到的也是⽗类的属性，必须在调⽤⽅法前调⽤⽗类的初始化
    def make_master_cake(self):
        Master.__init__(self)  # 此行代码相当于Master中的属性重置
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)  # 写self，为了能接收对象
        School.make_cake(self)


daqiu = Prentice()
daqiu.make_cake()
daqiu.make_master_cake()
daqiu.make_school_cake()
daqiu.make_cake()

运行效果：

六. 多层继承
故事： N 年后， daqiu ⽼了，想要把所有技术传承给⾃⼰的徒弟。 
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class School(object):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果⼦配⽅]'

    def make_cake(self):
        self.__init__()
        print(f'运⽤{self.kongfu}制作煎饼果⼦')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)


# 徒孙类
class Tusun(Prentice):
    pass


xiaoqiu = Tusun()
xiaoqiu.make_cake()
xiaoqiu.make_school_cake()
xiaoqiu.make_master_cake()

运行效果：

七. super()调⽤⽗类⽅法

示例代码1： 

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class School(Master):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')
        # ⽅法2.1
        # super(School, self).__init__()
        # super(School, self).make_cake()
        # ⽅法2.2
        super().__init__()
        super().make_cake()


class Prentice(School):
    def __init__(self):
        self.kongfu = '[独创煎饼果⼦技术]'

    def make_cake(self):
        self.__init__()
        print(f'运⽤{self.kongfu}制作煎饼果⼦')

    # ⼦类调⽤⽗类的同名⽅法和属性：把⽗类的同名属性和⽅法再次封装
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)
        # ⼀次性调⽤⽗类的同名属性和⽅法

    def make_old_cake(self):
        # ⽅法⼀：代码冗余；⽗类类名如果变化，这⾥代码需要频繁修改
        # Master.__init__(self)
        # Master.make_cake(self)
        # School.__init__(self)
        # School.make_cake(self)
        # ⽅法⼆: super()
        # ⽅法2.1 super(当前类名, self).函数()
        # super(Prentice, self).__init__()
        # super(Prentice, self).make_cake()
        # ⽅法2.2 super().函数()
        super().__init__()
        super().make_cake()


daqiu = Prentice()
daqiu.make_old_cake()

运行效果：

示例代码2：

class BaseClass(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def run(self):
        print(f"x:{self.x},y:{self.y}")


class SubClass(BaseClass):
    def __init__(self, x, y, z):
        # super().__init__(x, y)  # 父类中有传参，这儿也必须要传参
        super().__init__(x + 1, y + 1)  # 父类中有传参，这儿也必须要传参
        self.z = z

    def func(self):
        return self.x + self.y + self.z


class SubClass2(BaseClass):
    def __int__(self, x, y):
        super(SubClass2, self).run()


obj = SubClass(1, 2, 5)
obj.run()
res = obj.func()
print(res)

obj2 = SubClass2(66, 88)
obj2.run()

运行结果：

注意： 使⽤ super() 可以⾃动查找⽗类。调⽤顺序遵循 __mro__ 类属性的顺序。⽐较适合单继承使⽤。
⼋. 私有权限 8.1 定义私有属性和⽅法
在 Python 中，可以为实例属性和⽅法设置私有权限，即设置某个实例属性或实例⽅法不继承给⼦类。
故事： daqiu 把技术传承给徒弟的同时，不想把⾃⼰的钱 (2000000 个亿 ) 继承给徒弟，这个时候就要为 钱 这个实例属性设置私有权限。
设置私有权限的⽅法： 在属性名和⽅法名 前⾯ 加上两个下划线 __。 
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class School(object):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果⼦配⽅]'
        # 定义私有属性
        self.__money = 2000000

    # 定义私有⽅法
    def __info_print(self):
        print(self.kongfu)
        print(self.__money)

    def make_cake(self):
        self.__init__()
        print(f'运⽤{self.kongfu}制作煎饼果⼦')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)


# 徒孙类
class Tusun(Prentice):
    pass


daqiu = Prentice()
# 对象不能访问私有属性和私有⽅法
# print(daqiu.__money)
# daqiu.__info_print()
xiaoqiu = Tusun()
# ⼦类⽆法继承⽗类的私有属性和私有⽅法
# print(xiaoqiu.__money) # ⽆法访问实例属性__money
# xiaoqiu.__info_print()
注意： 私有属性和私有⽅法只能在类⾥⾯访问和修改。
8.2 获取和修改私有属性值
在 Python 中，⼀般定义函数名 get_xx ⽤来获取私有属性，定义 set_xx ⽤来修改私有属性值。 
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class School(object):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果⼦配⽅]'
        self.__money = 2000000

    # 获取私有属性
    def get_money(self):
        return self.__money

    # 修改私有属性
    def set_money(self):
        self.__money = 500

    def __info_print(self):
        print(self.kongfu)
        print(self.__money)

    def make_cake(self):
        self.__init__()
        print(f'运⽤{self.kongfu}制作煎饼果⼦')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)


# 徒孙类
class Tusun(Prentice):
    pass


daqiu = Prentice()
xiaoqiu = Tusun()
# 调⽤get_money函数获取私有属性money的值
print(xiaoqiu.get_money())
# 调⽤set_money函数修改私有属性money的值
xiaoqiu.set_money()
print(xiaoqiu.get_money())

运行效果：

九. 总结
继承的特点
  • ⼦类默认拥有⽗类的所有属性和⽅法
  • ⼦类重写⽗类同名⽅法和属性
  • ⼦类调⽤⽗类同名⽅法和属性
super() ⽅法快速调⽤⽗类⽅法
私有权限
  • 不能继承给⼦类的属性和⽅法需要添加私有权限
  • 语法
class 类名():
   # 私有属性
   __属性名 = 值
   # 私有⽅法
   def __函数名(self):
      代码
关注
打赏
1665675218
查看更多评论

最近更新

热门博客

[ 申请 ]友情链接：

ClashX教程 绘画宝宝 配音宝宝
立即登录/注册

微信扫码登录

0.0511s