Objektorientiert für Fortgeschrittene

Objektorientierter erweiterter Syntaxteil

Von @staticmethod Der Dekorateur kann die dekorierte Methode in eine statische Methode umwandeln. Tatsächlich ist es nicht schwer zu verstehen, dass gewöhnliche Methoden direkt nach der Instanziierung aufgerufen werden können und Instanzvariablen oder Klassenvariablen über self in der Methode aufgerufen werden können, statische Methoden jedoch nicht auf Instanzvariablen oder Klassenvariablen zugreifen können Die Methoden von Variablen und Klassenvariablen haben eigentlich nichts mit der Klasse selbst zu tun. Der einzige Zusammenhang mit der Klasse besteht darin, dass die Methode über den Klassennamen aufgerufen werden muss.

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    member_nums = 0def introduce(self):
        print("My name is %s,and I am %s year old." %(self.name,self.age))

    @staticmethod
    def talk():
        print("I like to study python")class Teacher(SchoolMember):
    def __init__(self,name,age,sex,course,salary):
        super(Teacher,self).__init__(name,age,sex)
        self.course = course
        self.salary = salary

    def Teaching(self):
        print("Teacher %s is teaching %s." %(self.name,self.course))



s1 = Teacher("alex",22,"Femal","python",10000)

print("before:",s1.member_nums)
SchoolMember.member_nums = 12print("before:",s1.member_nums)


s1.member_nums = 666     #是在类中重新生成一个变量

print("after:",s1.member_nums)
SchoolMember.member_nums = 12print("after:",s1.member_nums)

Im obigen Code ist member_nums eine Klassenvariable. Wenn s1.member_nums direkt aufgerufen wird, wird der Wert in der Klasse aufgerufen .member_nums = 666, was dem Hinzufügen einer neuen Variablen zur Instanz entspricht. Wenn Sie den Wert der Klasse ändern, hat dies keinen Einfluss auf den Wert der Variablen in der Instanz. Die Ausgabe des obigen Codes lautet wie folgt:

vorher: 0
vorher: 12
nach: 666
nach: 666

Statische Methode der Klasse @staticmethon:

 SchoolMember(====  %  % %= SchoolMember(,,

Wenn im obigen Code kein @staticmethon vorhanden ist, wird es definitiv kein @staticmethon geben Problem bei der Codeausführung, aber wenn @staticmethod verwendet wird, meldet das System, dass ein Parameter fehlt. Wenn wir eine Methode in eine statische Methode umwandeln, dann hat diese Methode wenig mit der Instanz zu tun.

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    member_nums = 0def introduce(self):
        print("My name is %s,and I am %s year old." %(self.name,self.age))

    @classmethod        #类方法，不能访问实例变量
    def talk(self):
        print("%s like to study python"  %SchoolMember.member_nums)

    @staticmethod        #让方法在类中剥离，与类没有关系，调用要传递参数
    def walk(self):
        print("%s is walking......" %self)


#SchoolMember.talk()    #不能调用，类是没有办法访问实例变量，只能访问自己
s1 = SchoolMember("Alex",22,"Female")  #实例化
s1.walk("alex")

@staticmethod Die statische Methode besteht darin, die Methode in der Klasse nicht mit der Klasse in Beziehung zu setzen, und kann nur dann aufgerufen werden, wenn Parameter übergeben werden Berufung.

Klassenmethode

Klassenmethode übergibt @classmethod Decorator-Implementierung, die Der Unterschied zwischen Klassenmethoden und gewöhnlichen Methoden besteht darin, dass Klassenmethoden nur auf Klassenvariablen und nicht auf Instanzvariablen zugreifen können

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    member_nums = 0def introduce(self):
        print("My name is %s,and I am %s year old." %(self.name,self.age))

    #@classmethod        #类方法，不能访问实例变量
    def talk(self):
        print("%s like to study python"  %self.name)

SchoolMember.member_nums
#SchoolMember.talk()    #不能调用，类是没有办法访问实例变量，只能访问自己
s1 = SchoolMember("Alex",22,"Female")  #实例化
s1.talk()

Im obigen Code (1) Klassen können nicht direkt auf die Attribute in Instanzen zugreifen ; (2) @classmethod wird verwendet, um dem Programm nur den Zugriff auf Variablen in der Klasse zu ermöglichen, wie z. B. SchoolMember im obigen Code .member_nums, Dies ist eine Klassenmethode. Wir können in Talk darauf zugreifen, aber wir können nicht auf self.name zugreifen, da @classmethod nur auf Klassenattribute zugreifen kann.

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    member_nums = 0def introduce(self):
        print("My name is %s,and I am %s year old." %(self.name,self.age))

    @classmethod        #类方法，不能访问实例变量
    def talk(self):
        print("%s like to study python"  %self.name)

SchoolMember.member_nums
#SchoolMember.talk()    #不能调用，类是没有办法访问实例变量，只能访问自己
s1 = SchoolMember("Alex",22,"Female")  #实例化
s1.talk()

运行结果如下：
Traceback (most recent call last):
  File "/home/zhuzhu/day7/staticmethon方法.py", line 18, in <module>s1.talk()
  File "/home/zhuzhu/day7/staticmethon方法.py", line 13, in talk
    print("%s like to study python"  %self.name)
AttributeError: type object 'SchoolMember' has no attribute 'name'

Wie oben zu sehen ist, verbietet der obige Code @classmethon Instanzen im Klassenvariablen, es können nur Klassenvariablen verwendet werden. Das heißt, self.name, self.age und self.sex können nicht verwendet werden, sondern nur Variablen der Klassen self.nember_nums und SchoolMember.member_nums. Wie folgt:

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    member_nums = 0def introduce(self):
        print("My name is %s,and I am %s year old." %(self.name,self.age))

    @classmethod        #类方法，不能访问实例变量
    def talk(self):
        print("%s like to study python"  %SchoolMember.member_nums)

SchoolMember.member_nums
#SchoolMember.talk()    #不能调用，类是没有办法访问实例变量，只能访问自己
s1 = SchoolMember("Alex",22,"Female")  #实例化
s1.talk()

运行结果如下：0 like to study python

Attributmethode

Attribut Die Funktion der Methode besteht darin, eine Methode über @property in eine statische Eigenschaft umzuwandeln

 SchoolMember(====  %  % %= SchoolMember(,,

Wenn @property nicht hinzugefügt wird, kann das Programm ausgeführt werden Normalerweise tritt nach dem Hinzufügen von @property ein Fehler auf, wenn das Programm ausgeführt wird. Da @property Klassenmethoden in Klassenattribute umwandelt, müssen wir beim Aufruf nur s1.walk() ohne das Hinzufügen von Klammern wie folgt ausführen:

 SchoolMember(====  %  % %= SchoolMember(,,

Im obigen Code verwandelt @property die Klassenmethode in eine Membereigenschaft. Wir können sie direkt mit s1.walk aufrufen.

Klassischer vs. neuer Stil

class A:             #经典类的写法，新式类是A(object)尽量少用经典类，都用新式类现在
    def __init__(self,name):
        self.name = name

    def f1(self):
        print("f1,搞基")class B(A):
    def __init__(self,name):
        super(B,self).__init__(name)

    # def f1(self):
    #     print("f1,来呀")class C(A):
    def __init__(self,name):
        super(C,self).__init__(name)

    #def f1(self):
        #print("f1,一起搞！")class D(B,C):
    pass

d = D("Alex")
d.f1()

Im obigen Code erbt Klasse D Klasse B und Klasse C. Wenn wir die Methode in Klasse D ausführen, suchen wir zuerst in Klasse B. Diese klassische Klasse und die neue Klasse The Wenn die Suche nicht gefunden werden kann, wird die klassische Klasse in Klasse A gesucht, während die neue Klasse in Klasse C gesucht wird. Das Beispiel sieht wie folgt aus: (Hinweis: Der Unterschied muss in Version 2 ausgeführt werden. X. 3 Wenn . (Neue Stilklasse) Führen Sie zuerst die Klasse derselben Ebene aus

(2 ) Klassische Klasse (führen Sie die vorherige erste Level-Klasse aus)

Das obige ist der detaillierte Inhalt vonObjektorientiert für Fortgeschrittene. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!