Umgang mit Klassen beim Erstellen eines eigenen MTV-Modells Ich werde es als Memo hinterlassen, weil ich es gelernt habe.
Der Inhalt ist ein rudimentärer Inhalt während des Elementarprozesses. Ich werde von Zeit zu Zeit aktualisieren, was ich gelernt habe.
sample.py
class Person(object):
def eat(self):
print('eat')
person = Person()
person.eat()
Ausgabeergebnis
eat
Das Argumentobjekt muss nicht sein, aber es ist besser, es als Rest des Python2-Systems (als Codestil) zu beschreiben.
Klassen können mit person = Person () aufgerufen werden.
sample.py
class Person(object):
"""Konstrukteur"""
def __init__(self, food):
self.food = food
print('Food is ready')
def eat(self):
print('eat {}'.format(self.food))
"""Zerstörer"""
def __del__(self):
print('Thanks for the food')
person = Person('apple')
person.eat()
del person #Kann auch explizit geschrieben werden
Ausgabeergebnis
Food is ready
eat apple
Thanks for the food
Der Konstruktor ist das erste, was beim Erstellen eines Objekts aufgerufen wird.
Destruktoren hingegen werden aufgerufen, wenn ein Objekt leer ist.
Da die Methode __init__ des Konstruktors ganz am Anfang aufgerufen wird, wird sie bei der Beschreibung der Anfangseinstellungen verwendet.
Es gibt andere Methoden wie die Methode "new".
self.food kann auch mit anderen Methoden aufgerufen werden.
sample.py
class Animal(object):
def eat(self):
print('eat')
class Monkey(Animal):
def eat(self, food):
self.food = food
print('eat {}'.format(self.food))
class Cheetah(Animal):
def run(self):
print('run')
animal = Animal()
animal.eat()
print('###########')
monkey = Monkey()
monkey.eat('banana') #Methodenüberschreibung
print('###########')
cheetah = Cheetah()
cheetah.eat() #Klassenvererbung
cheetah.run() #Funktionserweiterung
Ausgabeergebnis
eat
###########
eat banana
###########
eat
run
Wenn Sie die übergeordnete Klasse an das Argument der untergeordneten Klasse übergeben, können Sie die Funktionen der übergeordneten Klasse verwenden. Es kann verwendet werden, wenn Sie die Funktion der übergeordneten Klasse nur in einem bestimmten Fall erweitern möchten. Sie können die Funktion auch mit einer untergeordneten Klasse überschreiben.
sample.py
class Animal(object):
def __init__(self, food=None):
self.food = food
def eat(self):
print('eat')
class Monkey(Animal):
def __init__(self, food):
super().__init__(food)
def eat(self):
print('eat {}'.format(self.food))
animal = Animal()
animal.eat()
print('###########')
monkey = Monkey('banana')
monkey.eat()
Ausgabeergebnis
eat
###########
eat banana
Nach der init wird die Funktion der übergeordneten Klasse von super () aufgerufen
Die Funktion init der untergeordneten Klasse wird ausgeführt.
sample.py
class Animal(object):
def __init__(self, food=None, password=None):
self._food = food
self.password = password
"""getter"""
@property
def food(self):
return self._food
"""setter"""
@food.setter
def food(self, food):
if self.password == 'pass':
self._food = food
else:
# raise ValueError
print("Error") #Zur Bestätigung
animal = Animal('banana', password='pass')
print(animal.food)
animal.food = "orange"
print(animal.food)
print("##############")
animal2 = Animal('banana')
print(animal2.food)
animal2.food = "orange"
print(animal2.food)
Ausgabeergebnis
banana
orange
##############
banana
Error
Mithilfe von Eigenschaften können Sie Variablen lesen, die nicht von außen überschrieben werden sollen. Es wird gesagt, dass es explizit ausgedrückt werden kann, wenn Sie nicht möchten, dass der Wert neu geschrieben wird. Es ist möglich, eine Situation zu verhindern, in der ein Dritter eine vom Designer nicht beabsichtigte Operation ausführt und ein Fehler auftritt. Durch Hinzufügen eines Unterstrichs "_variable name" Es wird gesagt, dass es sinnvoll ist, es von außen zu verstecken. Da es fast keine Auswirkung auf den tatsächlichen Betrieb hat, ist es möglich, direkt auf die Variable zu verweisen.
Der Getter fügt "@ property" hinzu und macht den Funktionsnamen zum Namen der Zielvariablen.
Der Setter kann mit .setter auf den Funktionsnamen gesetzt werden, für den die Eigenschaft gesetzt ist.
Es wird gesagt, dass es verwendet wird, wenn es akzeptabel ist, nur unter bestimmten Bedingungen zu überschreiben.
__ Variablenname Es gibt auch eine Methode zum Hinzufügen von zwei Unterstrichen, jedoch in der übergeordneten Klasse und der untergeordneten Klasse
Wenn der Methodenname dupliziert wird, wird er im Allgemeinen verwendet, um Konflikte zu vermeiden.
Bitte überprüfen Sie hier für Details.
sample.py
class Person(object):
eated_list = [] #Klassenvariable
def eat(self, food):
print('eat {}'.format(food))
self.eated_list.append(food)
personA = Person()
personA.eat("apple")
print(personA.eated_list)
personB = Person()
personB.eat("orange")
print(personB.eated_list)
Ausgabeergebnis
eat apple
['apple']
eat orange
['apple', 'orange']
Eine Klassenvariable ist eine Variable, die von allen generierten Objekten gemeinsam genutzt werden kann. Daher besteht das Risiko, dass Informationen, die Sie nicht zwischen Objekten teilen möchten, wie im obigen Code geteilt werden. Um dies zu vermeiden, bringen Sie die Variable in die Methode init und Jedes Mal, wenn ein Objekt erstellt wird, muss der Initialisierungsprozess der Variablen beschrieben werden.
Recommended Posts