【Python】类的封装、继承 & 多态

最新推荐文章于 2024-02-27 22:12:50 发布

JS.Huang

最新推荐文章于 2024-02-27 22:12:50 发布

阅读量395

点赞数 1

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/Superman_H/article/details/108394957

版权

Python 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

类的封装、继承 & 多态

类的基本使用
类的封装
类的继承
类的多态
- 对象之间没有继承关系的情况
- 对象之间有继承关系的情况

类的基本使用

【Python】类的基本使用

类的封装

封装的操作

用于设置对象的私有数据 ( 属性 ) / 行为 ( 方法 ) ，使其不能被修改。

在定义类时，在数据 ( 属性 ) / 行为 ( 方法 ) 前面加两个下划线，表示对该属性 / 方法进行隐藏，只有类的内部成员可以直接调用，一般情况下外部无法访问
在定义类时，这种 __ 数据名 会被转化为 _ 类名 __ 数据名，所以在类的外面，我们还是可以通过 对象名 . _ 类名 __ 数据名 的形式强行访问私有数据，但是一般不推荐这样使用

class Dog():
    def __init__(self, DogName):
        self.__name = DogName  # 定义私有数据

    def set_name(self, name):
        self.__name = name

    def __get_name(self):  # 定义私有函数
        return self.__name

    def get_fun(self):
        return self.__get_name()


dog1 = Dog('中华田园犬')
print(dog1.get_fun())
dog1.set_name('二哈')
print(dog1.get_fun())

print(f'强行调用私有函数输出{dog1._Dog__get_name()}')  # 不推荐强行调用
print(f'强行调用私有数据输出{dog1._Dog__name}')
# ---------- 输出 ----------
# 中华田园犬
# 二哈
# 强行调用私有函数输出二哈
# 强行调用私有数据输出二哈

一般我们会在数据名前加一个下划线，来表示这是一个私有数据。就是说它其实还是一般的数据，只是我们以这种方式来告诉别人这是私有数据，不希望被修改。

装饰器的使用

让我们能以调用数据的方式调用行为函数。方便我们后续的操作。

装饰器 @property

一般用于查询私有数据。我们可以在类的函数前使用 @property ，property装饰器会将行为 ( 方法 ) 转换为同名的数据 ( 属性 ) 。这样我们就可以用访问数据 ( 属性 ) 的形式调用行为 ( 方法 ) 。

class Dog():
    def __init__(self, dogName):
        self.__name = dogName

    @property
    def name(self):
        print('执行property后面的函数', end='   ')
        return self.__name


dog1 = Dog('little_black')
print(dog1.name)
# ---------- 输出 ----------
# 执行property后面的函数   little_black

装饰器 @函数名 . setter

一般用于修改 @property 修饰的函数的值。在进行修改操作的函数前面添加 @函数名 . setter 装饰器，该函数就会转化为同名属性，对该属性进行赋值，就是修改 @property 后面的函数的值。

装饰器修饰的函数名建议保持一致

class Dog():
    def __init__(self, dogName):
        self.__name = dogName

    @property
    def name(self):
        print('执行property后面的函数', end='  ')
        return self.__name

    @name.setter
    def name(self, newName):
        print('执行setter后面的函数')
        self.__name = newName


dog1 = Dog('little_black')
print(dog1.name)
dog1.name = 'big_dog'
print(dog1.name)
# ---------- 输出 ----------
# 执行property后面的函数  little_black
# 执行setter后面的函数
# 执行property后面的函数  big_dog

装饰器@函数名 . deleter

一般用于删除 @property 后面的函数的值。在进行删除操作的函数前面添加 @函数名 . deleter 装饰器，该函数就会转化为同名属性，对该属性进行删除操作，就是删除 @property 后面的函数的值。

装饰器修饰的函数名建议保持一致

class Dog():
    def __init__(self, dogName):
        self.__name = dogName

    @property
    def name(self):
        print('执行property后面的函数', end='  ')
        return self.__name

    @name.deleter
    def name(self):
        print('执行deleter后面的函数')
        del self.__name


dog1 = Dog('little_black')
print(dog1.name)
del dog1.name
# ---------- 输出 ----------
# 执行property后面的函数  little_black
# 执行deleter后面的函数

类的继承

特点：可以提高代码的重复利用率；符合 OCP 原则 (在不修改原代码的情况下，增加功能)。
通过继承，我们可以获取到其他类的属性和方法

继承的操作

在定义类的时候，在类名后面的括号里，填写当前类的父类 ( 超类、基类 )。这样当前类就可以调用父类里面的属性和行为了。

class Animals():
    name = 'animals'
    def run(self):
        print('Animals can run')

class Dog(Animals):
    pass

dog1 = Dog()
print(dog1.name, end=':')
dog1.run()
# ---------- 输出 ----------
# animals:Animals can run

如果当前类与父类都有一样的行为 / 数据，当前类的值会覆盖父类的值

class Animals():
    name = 'animals'
    def run(self):
        print('Animals can run')

class Dog(Animals):
    name = 'dog'
    def run(self):
        print('Dog can run')

dog1 = Dog()
print(dog1.name, end=':')
dog1.run()
# ---------- 输出 ----------
# dog:Dog can run

多重继承，一般不推荐用；因为开发中要求解耦合，即不希望不同的代码之间产生太多的牵连。
- 子类对象调用的函数，会先在子类里面找；如果没有，就到第一个继承的父类里面找；如果再没有就到下一个继承的父类里面找…

class Father():
    def dancing(self):
        print('dadadada', end='  ')

class Mother():
    def singing(self):
        print('lalalala')

class Son(Father, Mother):
    pass

boy = Son()
boy.dancing()
boy.singing()
# ---------- 输出 ----------
# dadadada  lalalala

issubclass(class1, class2)

用于判断 class1 是否是 class2 的子类；若是则返回 True，否则返回 False

所有类的父类都是 object

class Animals(object):
    pass

class Dog(Animals):
    pass

print(issubclass(Dog, Animals), end='  ')
print(issubclass(Animals, object))

print(issubclass(type, object), end='  ')
print(issubclass(int, object))
# ---------- 输出 ----------
# True  True
# True  True

className . bases

会返回该类的所有父类

class Father(object):
    pass

class Son(Father):
   pass

print(Son.__bases__)
# ---------- 输出 ----------
# (<class '__main__.Father'>,)

super ( Class, self ) 函数

Python 3 可以直-接使用 super().xxx 代替 super ( Class, self ) . xxx

单继承

用于在当前类的函数中调用父类中的同名函数
super ( ) ：找到该类的父类，把该类的对象转换为父类的对象
super ( ) 调用的函数不用写 self 形参

class Animals(object):
    def __init__(self, AnimalName):
        print('enter Animals-init')
        self.name = AnimalName
        print('leave Animals-init')

    def run(self, object1):
        print('enter Animals-run')
        print('%s can run' %object1)
        print('leave Animals-run')

        
class Dog(Animals):
    def __init__(self, DogName, DogAge):
        print('enter Dog-init')
        self.age = DogAge
        super(Dog, self).__init__(DogName)
 # 等价于Animals.__init__(self, DogName)
        print('leave Dog-init')

    def run(self, object1):
        print('enter Dog-run')
        super(Dog, self).run(object1)
 # 等价于Animals.run(self, object1)
        print('leave Dog-run')


dog1 = Dog('哈士奇', 5)
print(dog1.name, dog1.age)
dog1.run('二哈')
# ---------- 输出 ----------
# enter Dog-init
# enter Animals-init
# leave Animals-init
# leave Dog-init
# 哈士奇 5
# enter Dog-run
# enter Animals-run
# 二哈 can run
# leave Animals-run
# leave Dog-run

多继承

先继承的父级，先执行；后继承的父级，后执行。

class Grandfather(object):
    def __init__(self):
        print('enter Grandfather')
        print('leave Grandfather')

class Father(Grandfather):
    def __init__(self):
        print('enter Father')
        super(Father, self).__init__()
        print('leave Father')

class Mother(Grandfather):
    def __init__(self):
        print('enter Mother')
        super(Mother, self).__init__()
        print('leave Mother')

class Son(Father, Mother):
    def __init__(self):
        print('enter Son')
        super(Son, self).__init__()
        print('leave Son')

boy = Son()
# ---------- 输出 ----------
# enter Son
# enter Father
# enter Mother
# enter Grandfather
# leave Grandfather
# leave Mother
# leave Father
# leave Son

等价于以下写法，但是这种写法会导致父类被调用多次，而 super ( ) 可以减少这样的开销。

class Grandfather(object):
    def __init__(self):
        print('enter Grandfather')
        print('leave Grandfather')

class Father(Grandfather):
    def __init__(self):
        print('enter Father')
# 等价于super(Father, self).__init__()
        Grandfather.__init__(self)
        print('leave Father')

class Mother(Grandfather):
    def __init__(self):
        print('enter Mother')
# 等价于super(Mother, self).__init__()
        Grandfather.__init__(self)
        print('leave Mother')

class Son(Father, Mother):
    def __init__(self):
        print('enter Son')
        Father.__init__(self)
        Mother.__init__(self)
# 等价于super(Son, self).__init__()
        print('leave Son')
        
boy = Son()
# ---------- 输出 ----------
# enter Son
# enter Father
# enter Grandfather
# leave Grandfather
# leave Father
# enter Mother
# enter Grandfather
# leave Grandfather
# leave Mother
# leave Son

类的多态

具有不同功能的函数，可以使用相同的函数名；这样就可以用一个函数名，调用不同功能的函数。

对象之间没有继承关系的情况

class Dog(object):
    def run(self):
        print('Dog is running')

class Cat(object):
    def run(self):
        print('Cat is running')

class Lion(object):
    def run(self):
        print('Lion is running')

def run(obj):
    obj.run()

dog1 = Dog()
cat1 = Cat()
lion1 = Lion()
run(dog1)
run(cat1)
run(lion1)
# ---------- 输出 ----------
# Dog is running
# Cat is running
# Lion is running

对象之间有继承关系的情况

class Grandfather(object):
    def __init__(self, money):
        self.money = money

class Father(Grandfather):
    def __init__(self, money, job):
        self.job = job
        super(Father, self).__init__(money)

class Mother(Grandfather):
    def __init__(self, money, job):
        self.job = job
        super(Mother, self).__init__(money)

def job(obj):
    print(obj.job, end='   ')

def money(obj):
    print(obj.money, end='   ')

person1 = Grandfather(3000)
person2 = Father(10000, 'programmer')
person3 = Mother(8000, 'teacher')
job(person2)
job(person3)
money(person1)
money(person2)
money(person3)
# ---------- 输出 ----------
# programmer   teacher   3000   10000   8000

JS.Huang

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【Python】类的封装、继承 & 多态

类的封装、继承 & 多态类的基本使用类的封装封装的操作装饰器的使用装饰器@property装饰器@函数名 . setter装饰器@函数名 . deleter类的继承继承的操作issubclass(class1, class2)className . __ bases __super(Class, self) 函数单继承多继承类的多态对象之间没有继承关系的情况对象之间有继承关系的情况类的基本使用类的封装封装的操作用于设置对象中的私有数据(属性) / 行为(方法)，使其不能被修改。在定义类时
复制链接

扫一扫