Ein Artikel zum Verständnis der objektorientierten Vererbung in Python

1. Was ist Vererbung?

Vererbung bezieht sich auf die Beziehung zwischen Klassen, eine Was-ist-Beziehung, und eine ihrer Funktionen besteht darin, das Problem der Code-Wiederverwendung zu lösen.

Vererbung ist eine Möglichkeit, eine neue Klasse zu erstellen. In Python kann die übergeordnete Klasse auch als Basisklasse oder Superklasse bezeichnet werden Als abgeleitete Klasse oder Unterklasse wird die Vererbung in Einzelvererbung und Mehrfachvererbung unterteilt.

class ParentClass1: #定义父类
    pass
class ParentClass2: #定义父类
    pass
class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
    pass
class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
    pass
print(Son1.__bases__)  # 查看所有继承的父类
print(Son2.__bases__)
===============
(<class &#39;__main__.Father1&#39;>,)
(<class &#39;__main__.Father1&#39;>, <class &#39;__main__.Father2&#39;>)

2. Vererbung und Abstraktion

Abstraktion ist in zwei Ebenen unterteilt:

1. Die Teile, die Obama und Messi vergleichen, werden in Kategorien unterteilt.

2. Extrahieren Sie die ähnlicheren Teile der drei Kategorien Menschen, Schweine und Hunde in übergeordnete Kategorien.

Die Hauptaufgabe der Abstraktion besteht darin, Kategorien zu unterteilen (kann Bedenken isolieren und die Komplexität reduzieren)

Vererbung:

basiert auf dem Ergebnis der Abstraktion. Um es durch eine Programmiersprache zu implementieren, müssen Sie zunächst den Abstraktionsprozess durchlaufen, bevor Sie die abstrakte Struktur durch Vererbung ausdrücken können.

Abstraktion ist lediglich eine Aktion oder eine Technik im Analyse- und Designprozess, durch die Klassen erlangt werden können.

class animal():   # 定义父类
    country  =  'china'     # 这个叫类的变量
    def __init__(self,name,age):
        self.name=name   # 这些又叫数据属性
        self.age=age
    def walk(self):         # 类的函数，方法，动态属性
        print('%s is walking'%self.name)
    def say(self):
        pass
class people(animal):  # 子类继承父类
    pass
class pig(animal):    # 子类继承父类
    pass
class dog(animal):  # 子类继承父类
    pass
aobama=people('aobama',60)   # 实例化一个对象
print(aobama.name)
aobama.walk()
===================
aobama
aobama is walking

3. Abgeleitet

1. Generieren Sie eine Unterklasse basierend auf der übergeordneten Klasse. Die generierte Unterklasse wird als abgeleitete Klasse bezeichnet .

2. Methoden, die nicht in der übergeordneten Klasse vorkommen, werden in der Unterklasse genannt.

3. Methoden, die in der übergeordneten Klasse und auch in der untergeordneten Klasse vorhanden sind, werden als Methodenumschreiben bezeichnet (dh das Umschreiben der Methoden in der übergeordneten Klasse).

Verwandte Empfehlungen: „Python-Video-Tutorial“

Beispiel 1

class Hero:
    def __init__(self, nickname,
                 aggressivity,
                 life_value):
        self.nickname = nickname
        self.aggressivity = aggressivity
        self.life_value = life_value
    def attack(self, enemy):
        enemy.life_value -= self.aggressivity
class Garen(Hero):   # 子类继承  hero 父类
    camp='Demacia'   # 子类衍生出的变量
    def attack(self, enemy):   ＃　跟父类的 attack 重名，对象调用的时候以子类的为准
        pass
    def fire(self):    # 父类没有 fire，这里 fire 属于派生出来的东西
        print('%s is firing' %self.nickname)
class Riven(Hero):
    camp='Noxus'
g1=Garen('garen',18,200)
r1=Riven('rivren',18,200)
# print(g1.camp)
# print(r1.camp)
# g1.fire()
g1.attack(g1)

Beispiel 2

class Hero:
    def __init__(self, nickname,aggressivity,life_value):
        self.nickname = nickname
        self.aggressivity = aggressivity
        self.life_value = life_value
    def attack(self, enemy):
        print('Hero attack')
class Garen(Hero):
    camp = 'Demacia'
    def attack(self, enemy): #self=g1,enemy=r1
        # self.attack(enemy) #g1.attack(r1)，这里相当于无限递归
        Hero.attack(self,enemy)  # 引用 父类的 attack，对象会去跑 父类的 attack
        print('from garen attack')  # 再回来这里
    def fire(self):
        print('%s is firing' % self.nickname)
class Riven(Hero):
    camp = 'Noxus'
g1 = Garen('garen', 18, 200)
r1 = Riven('rivren', 18, 200)
g1.attack(r1)
# print(g1.camp)
# print(r1.camp)
# g1.fire()

4 Und Wiederverwendbarkeit

Wiederverwendbarkeit:

Methode 1: Attribute ohne Vererbung wiederverwenden und die Attribute der zu verwendenden Klasse benennen.

class Hero:
    def __init__(self,nickname,gongji,life):
        self.nickname=nickname
        self.gongji=gongji
        self.life=life
    def attack(self,obj):
        print('from Hero attack')
class Garen:
    def __init__(self,nickname,gongji,life,script):
        Hero.__init__(self,nickname,gongji,life)   # 这里引用Hero类的 init，不用再自己从新定义一遍 init
        self.script=script   # 父类 init 没有 script，这里是新加进来的属性
    def attack(self,obj):  # 在这里自己定义新的 attack，不再使用父类的 attack
        print('from Garen attack')
    def fire(self):  # 在这里定义新的功能
        print('from Garen fire')
g1=Garen('garen',18,200,'人在塔在')
print(g1.script)
人在塔在

Tipp: Erstellen Sie eine neue Klasse unter Verwendung einer vorhandenen Klasse und verwenden Sie so einen Teil oder sogar den größten Teil der vorhandenen Software. Dies wird oft als Software-Wiederverwendung bezeichnet Sie können auch andere Klassen erben, z. B. die Standardbibliothek, um neue Datentypen anzupassen. Dies verkürzt den Softwareentwicklungszyklus erheblich, was für die Softwareentwicklung im großen Maßstab von großer Bedeutung ist.

Hinweis: Bei Attributreferenzen wie g1.life wird das Leben zuerst von der Instanz, dann von der Klasse, dann von der übergeordneten Klasse bis zur übergeordneten Klasse der obersten Ebene gefunden.

Methode 2: Durch Vererbung

Beispiel 1

class Hero():
    def __init__(self, nickname, gongji, life):
        self.nickname = nickname
        self.gongji = gongji
        self.life = life
    def attack(self, obj):
        print('from Hero attack')
        obj.life -= self.gongji
class Garen(Hero):   # 使用 super方式需要继承
    camp = 'Demacia'
    def __init__(self, nickname, gongji, life):
        super().__init__(nickname, gongji, life)
    def attack(self, obj):  # 在这里自己定义新的 attack，不再使用父类的 attack
        super(Garen, self).attack(obj)  # PY3中super可以不给参数，PY2中第一个参数必须是自己的类,self，可以使用
        父类的方法，方法需要给参数就给参数
    def fire(self):  # 在这里定义新的功能
        print('from Garen fire')
g1 = Garen('garen1', 18, 200)
g2 = Garen('garen2', 20, 100)
print(g2.life)
g1.attack(g2)
print(g2.life)
100
from Hero attack
82

Beispiel 2

class A:
    def f1(self):
        print('from A')
        super().f1()    
        # 这种不需要继承也可以使用到 super，为什么，要看 C的 MRO表
class B:
    def f1(self):
        print('from B')
class C(A,B):
    pass
print(C.mro())
#[<class &#39;__main__.C&#39;>,
# <class &#39;__main__.A&#39;>,
# <class &#39;__main__.B&#39;>, #  B在A的后面，当A指定 super().f1 会找到 B的 f1
# <class &#39;object&#39;>]
c=C()
c.f1()

Kombination:

Software Neben der Vererbung gibt es noch eine weitere wichtige Möglichkeit der Wiederverwendung, nämlich die Komposition.

Zusammensetzung: Das Datenattribut eines Objekts ist ein anderes Objekt, das als Zusammensetzung bezeichnet wird.

class Equip: #武器装备类
    def fire(self):
        print('release Fire skill')
class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类
    camp='Noxus'
    def __init__(self,nickname):
        self.nickname=nickname
        self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性
r1=Riven('锐雯雯')
r1.equip.fire() #可以使用组合的类产生的对象所持有的方法
release Fire skill

Möglichkeiten der Kombination:

Sowohl Kombination als auch Vererbung sind wichtige Methoden, um die Ressourcen vorhandener Klassen effektiv zu nutzen. Allerdings sind die Konzepte und Nutzungsszenarien der beiden unterschiedlich.

1. Vererbungsmethode

Die Beziehung zwischen der abgeleiteten Klasse und der Basisklasse wird durch Vererbung hergestellt. Es handelt sich um eine Ist-Beziehung, so wie ein weißes Pferd ein Pferd ist Der Mensch ist ein Tier.

Wenn es viele ähnliche Funktionen zwischen Klassen gibt, ist es besser, diese gemeinsamen Funktionen zu extrahieren und sie in Basisklassen umzuwandeln. Es ist beispielsweise besser, Vererbung zu verwenden >

2. Kombinationsmethode

Die Beziehung zwischen Klassen und kombinierten Klassen wird durch Kombination hergestellt. Es handelt sich beispielsweise um eine „Haben“-Beziehung, der Professor unterrichtet Python- und Linux-Kurse , und der Professor hat Studenten s1 und s2 , s3...

rrree

5. Schnittstelle und normalisiertes Design

a.

Die Schnittstelle extrahiert eine Gruppe von Funktionen, die jeder Klasse gemeinsam sind. Die Schnittstelle kann als eine Sammlung von Funktionen betrachtet werden.

Lassen Sie dann die Unterklasse die Funktionen in der Schnittstelle implementieren.

Die Bedeutung dieser Normalisierung besteht darin, dass die von allen diesen Klassen generierten Objekte auf die gleiche Weise verwendet werden.

Der Vorteil der Normalisierung ist:

Durch die Normalisierung müssen sich Benutzer nicht um die Klasse des Objekts kümmern. Sie müssen nur wissen, dass diese Objekte bestimmte Funktionen haben. Die Erde verringert die Nutzungsschwierigkeiten für Benutzer.

class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
class Course:
    def __init__(self,name,period,price):
        self.name=name
        self.period=period
        self.price=price
    def tell_info(self):
        print(&#39;<%s %s %s>&#39; %(self.name,self.period,self.price))
class Teacher(People):
    def __init__(self,name,age,sex,job_title):
        People.__init__(self,name,age,sex)
        self.job_title=job_title
        self.course=[]
        self.students=[]
class Student(People):
    def __init__(self,name,age,sex):
        People.__init__(self,name,age,sex)
        self.course=[]
egon=Teacher(&#39;egon&#39;,18,&#39;male&#39;,&#39;沙河霸道金牌讲师&#39;)
s1=Student(&#39;牛榴弹&#39;,18,&#39;female&#39;)
python=Course(&#39;python&#39;,&#39;3mons&#39;,3000.0)
linux=Course(&#39;python&#39;,&#39;3mons&#39;,3000.0)
#为老师egon和学生s1添加课程
egon.course.append(python)
egon.course.append(linux)
s1.course.append(python)
#为老师egon添加学生s1
egon.students.append(s1)
#使用
for obj in egon.course:
    obj.tell_info()

Der obige Code sieht nur wie eine Schnittstelle aus, spielt aber tatsächlich nicht die Rolle einer Schnittstelle. Unterklassen müssen die Schnittstelle überhaupt nicht implementieren, daher werden abstrakte Klassen verwendet.

6. Abstrakte Klasse

Unterklassen müssen die Methoden abstrakter Klassen erben, andernfalls wird ein Fehler gemeldet.

Was ist eine abstrakte Klasse?

Python hat wie Java auch das Konzept einer abstrakten Klasse, muss aber auch mit Hilfe von Modulen implementiert werden. Seine Besonderheit besteht darin, dass es nur sein kann vererbt und kann nicht instanziiert werden

Warum brauchen wir abstrakte Klassen?

Wenn eine Klasse aus einer Reihe von Objekten mit demselben Inhalt extrahiert wird, wird eine abstrakte Klasse aus einer Reihe von Klassen mit demselben Inhalt extrahiert, einschließlich Datenattributen und Funktionsattributen.

比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子。你永远无法吃到一个叫做水果的东西。

从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。

从实现角度来看，抽象类与普通类的不同之处在于：抽象类中只能有抽象方法（没有实现功能），该类不能被实例化，只能被继承，且子类必须实现抽象方法。

抽象类与接口

抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如all_type）和函数属性（如read、write），而接口只强调函数属性的相似性。

抽象类是一个介于类和接口直接的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计。

例1

import abc
#抽象类：本质还是类，与普通类额外的特点的是：加了装饰器的函数，子类必须实现他们
class Animal(metaclass=abc.ABCMeta):   # 抽象类是用来被子类继承的，不是用来实例化的
    tag='123123123123123'
    @abc.abstractmethod   # 如果子类没有我这个函数，主动抛出异常
    def run(self):
        pass
    @abc.abstractmethod
    def speak(self):
        pass
class People(Animal):
    def run(self):   # 子类必须有抽象类里的装饰器下面的函数
        pass
    def speak(self):
        pass
peo1=People()   # 实例化出来一个人
print(peo1.tag)

例2

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
#一切皆文件
import abc #利用abc模块实现抽象类
class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def read(self):
        '子类必须定义读功能'
        pass
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def write(self):
        '子类必须定义写功能'
        pass
# class Txt(All_file):
#     pass
#
# t1=Txt() #报错,子类没有定义抽象方法
class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('文本数据的读取方法')
    def write(self):
        print('文本数据的读取方法')
class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('硬盘数据的读取方法')
    def write(self):
        print('硬盘数据的读取方法')
class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('进程数据的读取方法')
    def write(self):
        print('进程数据的读取方法')
wenbenwenjian=Txt()
yingpanwenjian=Sata()
jinchengwenjian=Process()
#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()
print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

Das obige ist der detaillierte Inhalt vonEin Artikel zum Verständnis der objektorientierten Vererbung in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!