Comment gérer les classes lors de la création de votre propre modèle MTV Je vais le laisser comme mémo parce que je l'ai appris.
Le contenu est un contenu rudimentaire au cours du processus élémentaire. Je mettrai à jour ce que j'ai appris de temps en temps.
sample.py
class Person(object):
def eat(self):
print('eat')
person = Person()
person.eat()
Résultat de sortie
eat
Il n'est pas nécessaire d'avoir l'objet comme argument, mais il vaut mieux le décrire comme un vestige du système python2 (comme un style de code).
Vous pouvez appeler la classe avec person = Person ().
sample.py
class Person(object):
"""constructeur"""
def __init__(self, food):
self.food = food
print('Food is ready')
def eat(self):
print('eat {}'.format(self.food))
"""Destructeur"""
def __del__(self):
print('Thanks for the food')
person = Person('apple')
person.eat()
del person #Peut également être écrit explicitement
Résultat de sortie
Food is ready
eat apple
Thanks for the food
Le constructeur est la première chose appelée lors de la création d'un objet.
Les destructeurs, en revanche, sont appelés lorsqu'un objet est épuisé.
Puisque la méthode __init__ du constructeur est appelée au tout début, elle est utilisée lors de la description des paramètres initiaux.
Il existe d'autres méthodes telles que la méthode «new».
self.food peut également être appelé à partir d'autres méthodes.
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') #Remplacement de méthode
print('###########')
cheetah = Cheetah()
cheetah.eat() #Héritage de classe
cheetah.run() #Expansion fonctionnelle
Résultat de sortie
eat
###########
eat banana
###########
eat
run
Si vous passez la classe parente à l'argument de la classe enfant, vous pouvez utiliser les fonctions de la classe parente. Il peut être utilisé lorsque vous souhaitez étendre la fonction de la classe parente uniquement dans un certain cas. Vous pouvez également remplacer la fonction par une classe enfant.
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()
Résultat de sortie
eat
###########
eat banana
Après que la fonction init de la classe parent soit appelée par super ()
La fonction init de la classe enfant est exécutée.
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("Erreur") #Pour confirmation
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)
Résultat de sortie
banana
orange
##############
banana
Erreur
En utilisant les propriétés, vous pouvez lire les variables que vous ne souhaitez pas écraser de l'extérieur.
On dit qu'elle peut être explicitement exprimée lorsque vous ne souhaitez pas que la valeur soit réécrite.
Il est possible d'éviter une situation dans laquelle un tiers exécute une opération non prévue par le concepteur et une erreur se produit.
_Nom de la variable En ajoutant un trait de soulignement
On dit qu'il est logique de le cacher de l'extérieur.
Comme cela n'a pratiquement aucun effet sur le fonctionnement réel, il est possible de se référer directement à la variable.
Le getter ajoute @ property et fait du nom de la fonction le nom de la variable cible.
Le setter peut être défini avec .setter sur le nom de la fonction pour laquelle la propriété est définie.
On dit qu'il est utilisé lorsqu'il n'est acceptable d'écraser que sous certaines conditions.
__ Nom de la variable Il existe également une méthode pour ajouter deux traits de soulignement, mais dans la classe parent et la classe enfant
Lorsque le nom de la méthode est dupliqué, il est généralement utilisé dans le but d'éviter les conflits.
Veuillez consulter ici pour plus de détails.
sample.py
class Person(object):
eated_list = [] #Variable de classe
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)
Résultat de sortie
eat apple
['apple']
eat orange
['apple', 'orange']
Une variable de classe est une variable qui peut être partagée par tous les objets générés.
Par conséquent, il existe un risque que les informations que vous ne souhaitez pas partager entre les objets soient partagées comme le code ci-dessus.
Pour éviter cela, introduisez la variable dans la méthode __init__ et
Chaque fois qu'un objet est créé, il est nécessaire de décrire le processus d'initialisation de la variable.
Recommended Posts