Python 객체지향에서 상속이 무엇인지 이해하는 기사

1. 상속이란 무엇인가요?

상속이란 클래스 간의 관계, 즉 실체 관계를 말하며, 그 기능 중 하나는 코드 재사용 문제를 해결하는 것입니다.

상속은 새 클래스를 생성하는 방법입니다. Python에서 새로 생성된 클래스는 하나 이상의 상위 클래스를 상속할 수 있으며, 상위 클래스는 기본 클래스 또는 슈퍼 클래스라고 할 수도 있으며 새로 생성된 클래스를 파생 클래스라고 합니다. 클래스 또는 하위 클래스, 상속은 단일 상속과 다중 상속으로 구분됩니다.

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. 상속과 추상화

추상화는 두 가지 수준으로 나뉩니다.

1. 인간, 돼지, 개의 세 가지 개체를 카테고리로 추출합니다. 각 클래스와 더 유사한 부분이 상위 클래스로 추출됩니다.

추상화의 주요 기능은 범주를 나누는 것입니다(관심사를 격리하고 복잡성을 줄일 수 있음)

상속:

추상화 결과를 기반으로 프로그래밍 언어를 통해 구현하려면 먼저 경험해야 합니다. 추상화 프로세스는 상속을 통해 추상 구조를 표현할 수 있습니다.

추상화는 분석과 설계 과정에서 일어나는 행위나 기법일 뿐입니다. 추상화를 통해 수업을 얻을 수 있습니다.

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. Derived

1. 상위 클래스를 기반으로 하위 클래스를 생성하고, 생성된 하위 클래스를 파생 클래스라고 합니다.

2. 상위 클래스에 없는 메서드는 하위 클래스에 있습니다. 이러한 메서드를 파생 메서드라고 합니다.

3. 상위 클래스에 존재하고 하위 클래스에도 존재하는 메서드를 메서드 재작성(즉, 상위 클래스의 메서드 재작성)이라고 합니다.

관련 권장 사항: "

Python 비디오 튜토리얼

"예제 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)

예제 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. 조합 및 재사용성

재사용성:

방법 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')
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)
人在塔在

팁: 기존 클래스를 사용하여 새 클래스를 생성하면 기존 소프트웨어의 일부 또는 대부분을 재사용하여 프로그래밍 작업 부하를 크게 줄일 수 있습니다. 이를 종종 소프트웨어 재사용이라고 합니다. 클래스는 다른 클래스도 상속할 수 있습니다. 표준 라이브러리와 같은 사람들의 클래스를 사용하여 새로운 데이터 유형을 사용자 정의합니다. 이는 소프트웨어 개발 주기를 크게 단축하며 이는 대규모 소프트웨어 개발에 매우 ​​중요합니다.

참고: g1.life와 같은 속성 참조의 경우 먼저 인스턴스에서 생명을 찾은 다음 클래스에서, 그 다음 부모 클래스에서... 최상위 부모 클래스까지 찾습니다.

방법 2: 상속을 통해

예제 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

예제 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()

구성:

상속 외에도 소프트웨어 재사용의 또 다른 중요한 방법, 즉 구성이 있습니다.

구성: 한 개체의 데이터 속성은 다른 개체이며 이를 구성이라고 합니다.

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

조합 방법:

구성과 상속은 기존 클래스의 리소스를 효과적으로 활용하는 중요한 방법입니다. 그러나 둘의 개념과 사용 시나리오는 다릅니다.

1. 상속의 방식

상속을 통해 파생 클래스와 기본 클래스의 관계가 성립됩니다. 즉, 백마는 말이고 인간은 동물입니다.

클래스 간에 유사한 기능이 많은 경우 이러한 공통 기능을 추출하여 기본 클래스로 만드는 것이 좋습니다. 예를 들어 교사는 사람이고 학생은 사람입니다.

2. 조합 방법으로 생성됩니다. 수업과 결합 수업의 관계는 'have' 관계입니다. 예를 들어, 교수는 생일이 있고, 교수는 Python 및 Linux 과정을 가르치고, 교수는 학생 s1, s2, s3...

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()

5과의 인터페이스입니다. 표준화된 디자인

a, 왜 인터페이스를 사용하나요? 인터페이스는 클래스에 공통되는 함수들의 집합을 추출하며, 인터페이스는 함수들의 집합이라고 볼 수 있습니다.

그런 다음 하위 클래스가 인터페이스에서 함수를 구현하도록 합니다.

정규화의 의미는 클래스가 동일한 인터페이스를 기반으로 구현되는 한 모든 클래스에서 생성된 객체가 동일한 방식으로 사용된다는 것입니다.

정규화의 이점은 다음과 같습니다.

정규화를 사용하면 사용자는 객체의 클래스에 신경 쓸 필요가 없으며 이러한 객체에 특정 기능이 있다는 것만 알면 되므로 사용자의 사용 난이도가 크게 줄어듭니다.

class Interface:#定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。
    def read(self): #定接口函数read
        pass
    def write(self): #定义接口函数write
        pass
class Txt(Interface): #文本，具体实现read和write
    def read(self):
        print('文本数据的读取方法')
    def write(self):
        print('文本数据的读取方法')
class Sata(Interface): #磁盘，具体实现read和write
    def read(self):
        print('硬盘数据的读取方法')
    def write(self):
        print('硬盘数据的读取方法')
class Process(Interface):
    def read(self):
        print('进程数据的读取方法')
    def write(self):
        print('进程数据的读取方法')

위 코드는 인터페이스처럼 보이지만 실제로는 인터페이스 역할을 하지 않습니다. 서브클래스는 인터페이스를 전혀 구현할 필요가 없으므로 추상 클래스를 사용합니다.

6. 추상 클래스

하위 클래스는 추상 클래스의 메서드를 상속해야 합니다. 그렇지 않으면 오류가 보고됩니다.

추상 클래스란 무엇인가요?

Java와 마찬가지로 Python에도 추상 클래스 개념이 있지만 모듈의 도움으로 구현해야 합니다. 추상 클래스는 상속만 가능하고 인스턴스화할 수 없다는 것이 특징입니다.

추상화는 왜 있는 걸까요?

동일한 내용을 가진 여러 객체에서 클래스가 추출되면 데이터 속성 및 함수 속성을 포함하여 동일한 내용을 가진 여러 클래스에서 추상 클래스가 추출됩니다.

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

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

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

抽象类与接口

抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如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)

위 내용은 Python 객체지향에서 상속이 무엇인지 이해하는 기사의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!