Detaillierte Beispiele der vier objektorientierten Funktionen von Python

Dieser Artikel bringt Ihnen relevantes Wissen über Python, das hauptsächlich die relevanten Inhalte zur Objektorientierung vorstellt. Zu den vier Merkmalen der Objektorientierung gehören Abstraktion, Kapselung, Vererbung und Polymorphismus alle.

Empfohlenes Lernen: Python-Video-Tutorial

1. Abstraktion

Abstraktion ist die Kunst, überflüssige Details zu verbergen. Im objektorientierten Konzept ist die direkte Darstellung der Abstraktion normalerweise eine Klasse. Python bietet grundsätzlich alle Elemente einer objektorientierten Programmiersprache. Wenn Sie mindestens eine objektorientierte Sprache beherrschen, ist es recht einfach, Python für die objektorientierte Programmierung zu verwenden.

Ignorieren Sie die Dinge in einem Thema, die nicht mit dem aktuellen Ziel zusammenhängen, und konzentrieren Sie sich auf die Aspekte, die mit dem aktuellen Ziel zusammenhängen (Es bedeutet, eine bestimmte Art von Dingen in der realen Welt zu extrahieren und sie mit Programmcode auszudrücken. Das Abstrahierte

Abstraktion zielt nicht darauf ab, das gesamte Problem zu verstehen, sondern nur einen Teil davon auszuwählen, und einige Details werden vorerst nicht verwendet, einer davon ist die Datenabstraktion , und das andere ist Prozessabstraktion --> Darstellung der Welt Die Eigenschaften einer Art von Ding in der Welt sind die Attribute des Objekts. Zum Beispiel hat ein Vogel Flügel, Federn usw. (Eigenschaften von Die Klasse)

Prozedurale Abstraktion --> Das Verhalten eines Objekts, das beispielsweise fliegen kann, wird als (Klassenmethode) bezeichnet

2

Bei der objektorientierten Programmierung kombiniert eine bestimmte Klasse die erforderlichen Daten (die auch als Attribute der Klasse bezeichnet werden können) und die Operationen an den Daten (die auch als das Verhalten einer Klasse bezeichnet werden können). in der Klasse gekapselt, die als Mitgliedsvariablen bzw. Methoden (oder Mitgliedsfunktionen) der Klasse bezeichnet werden. Diese Programmierfunktion zum Kapseln von Mitgliedsvariablen und Mitgliedsfunktionen wird als Kapselung bezeichnet.

2.1 Öffentliche Mitgliedsvariablen und private Mitgliedsvariablen

In Python wird der Name der Mitgliedsvariablen verwendet, um zu unterscheiden, ob es sich um eine öffentliche Mitgliedsvariable oder eine private Mitgliedsvariable handelt.

In Python sind Variablen, die mit zwei Unterstrichen „_ _“ beginnen, private Mitgliedsvariablen, während die übrigen Variablen öffentliche Mitgliedsvariablen sind.

Unter diesen kann auf private Mitgliedsvariablen nur innerhalb der Klasse zugegriffen werden, während auf gemeinsam genutzte öffentliche Mitgliedsvariablen außerhalb der Klasse zugegriffen werden kann.

2.2 Öffentliche Methoden und private Methoden

Die Methode einer Klasse ist eine Kapselung des Klassenverhaltens.

Klassenmethoden werden auch in öffentliche Methoden und private Methoden unterteilt.

Auf private Methoden einer Klasse kann nur innerhalb der Klasse über den Objektnamen zugegriffen werden (der innerhalb der Klasse „self“ ist). Auf öffentliche Methoden kann von außerhalb der Klasse über den Objektnamen zugegriffen werden. Ebenso werden öffentliche Member-Methoden und private Member-Methoden durch ihren Namen unterschieden. Methoden, die mit einem doppelten Unterstrich „__“ beginnen, sind private Member-Methoden.

Private Methode: Der Zugriff ist nur innerhalb der Klasse möglich, nicht innerhalb des Objekts.

Private Attribute: Verbessern Sie die Codesicherheit und erlauben Sie anderen nicht, ihn nach Belieben zu ändern.

class Test(object):
    #私有方法
    def __test2(self):
        print("私有方法，__test2")
    #普通方法
    def test(self):
        print("普通方法test")
    #普通方法
    def _test1(self):
        print("普通方法_test1方法")
        #在类内部调用私有方法
        #t.__test2()
        self.__test2()
t = Test()
t.test()
t._test1()
#t.__test2() #调用时会报错

#Anwendungsszenario für private Methoden – Senden von Textnachrichten

Definieren Sie ein Klasse Person, Klasse Es gibt private Methoden und allgemeine Methoden, private Eigenschaften und gemeinsame Eigenschaften

Sie können private Methoden über allgemeine Methoden aufrufen und private Eigenschaften auch über allgemeine Methoden ändern.

#私有方法应用场景--发短信
class Test:
    #核心私有方法，用于发送短信
    def __sendMsg(self):
        print("---正在发送短信---")
    #公共方法
    def sendMsg(self,newMoney):
        if newMoney>10000: #余额大于10000才可以调用发短信功能
            self.__sendMsg()
        else:
            print("抱歉，余额不足，请先充值！")
t = Test()
t.sendMsg(1000000000)

3.

Vererbung3.1 Das Konzept der Vererbung

In einem Programm beschreibt Vererbung das Eigentumsverhältnis zwischen Dingen. Katzen und Hunde sind beispielsweise Tiere und können als Katzen beschrieben werden Das Programm. Und Hunde erben beide von Tieren; Perserkatzen und Balinesen erben beide von Katzen, während Shar-Pei und Dalmatiner beide von Hunden erben

#多继承
class Animal(object):
    def eat(self):
        print("----吃----")
    def dirk(self):
        print("----喝----")
    def run(self):
        print("----跑----")
    def sleep(self):
        print("----睡觉----")
class Dog(Animal):
    def call(self):
        print("旺旺叫...")
class XiaoTq(Dog):
    def fly(self):
        print("----飞喽-------")
xtq = XiaoTq()
xtq.fly()
xtq.call()
xtq.eat()

class Cat(object):
    def __init__(self,name,color="白色"):
        self.name = name
        self.color = color
    def run(self):
        print("%s -- 在跑"%self.name)
class Bosi(Cat):
    def setName(self,newName):
        self.name = newName
    def eat(self):
        print("%s -- 在吃"%self.name)
bs = Bosi("印度猫")
print(bs.name)
print(bs.color)
bs.eat()
bs.setName("波斯猫")
bs.run()

 3.2重写父类方法与调用父类方法

所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法.

使用super调用父类的方法：可以直接调用父类方法，不需要通过 父类名.父类方法名 的方式

class Cat(object):
    def sayHello(self,name):
        print("hello---1")
class Bosi(Cat):
    def sayHello(self):
        print("hello---2")
        #Cat.sayHello(self)
        super().sayHello("Zhangsan")
bs = Bosi()
bs.sayHello()

 3.3多继承

多继承举例：

class Base(object):
    def test(self):
        print("----Base-----")
class A(Base):
    def test(self):
        print("----test1-----")
class B(Base):
    def test(self):
        print("----test2-----")
class C(A,B):
    pass
c = C()
c.test()
print(C.__mro__) #可以查看C类的搜索方法时的先后顺序

4.多态

4.1多态的定义

所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态。

多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）。

当子类和父类都存在相同的print_self()方法时，我们说，子类的print_self()覆盖了父类的print_self()，在代码运行的时候，总是会调用子类的print_self()。这样，我们就获得了继承的另一个好处： 多态。

class Dog(object):
    def printSelf(self):
        print("大家好，我是xxx，请大家多多关照！")
class XiaoTq(Dog):
    def printSelf(self):
        print("Hello,ereybody,我是你们的老大，我是哮天神犬！")

#定义一个执行函数
def exec(obj):

    """

    #定义时的类型并不知道要调用哪个类的方法，

    当运行时才能确定调用哪个类的方法，这种情况，我们就叫做多态

    """

    obj.printSelf()
dog = Dog()
exec(dog)
xtq = XiaoTq()
exec(xtq)

4.2新式类和经典类的区别

新式类都从 object 继承，经典类不需要

Python 2.x中默认都是经典类，只有显式继承了object

Python 3.x中默认都是新式类,经典类被移除，不必显式的继承object

#新式类和经典类的区别

class A:
    def __init__(self):
        print('a')
class B(A):
    def __init__(self):
        A().__init__()
        print('b')
b = B()
print(type(b))

class A():
    def __init__(self):
        pass
    def save(self):
        print("This is from A")
class B(A):
    def __init__(self):
        pass
class C(A):
    def __init__(self):
        pass
    def save(self):
        print("This is from C")
class D(B,C):
    def __init__(self):
        pass
fun = D()
fun.save()

推荐学习：python视频教程

Das obige ist der detaillierte Inhalt vonDetaillierte Beispiele der vier objektorientierten Funktionen von Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!