La différence entre les méthodes orientées objet Python

Python est depuis le début un langage orienté objet. De ce fait, il est facile de créer des classes et des objets en Python.

Les méthodes incluent : les méthodes d'instance, les méthodes statiques et les méthodes de classe. Les trois méthodes appartiennent à des classes en mémoire. La différence réside dans les différentes méthodes d'appel.

Méthode d'instance : appelée par l'objet ; au moins un paramètre self ; lors de l'exécution d'une méthode normale, l'objet appelant la méthode est automatiquement attribué à self ;

Méthode de classe : appelée par la classe ; ; au moins un paramètre cls ; lors de l'exécution d'une méthode de classe, la classe appelant la méthode est automatiquement copiée dans cls ;

Méthode statique : appelée par la classe ;

Méthode d'instance

class Kls(object):
    def __init__(self, data):
        self.data = data
    def printd(self):
        print(self.data)
ik1 = Kls('leo')
ik2 = Kls('lee')
ik1.printd()
ik2.printd()

Sortie :

leo 
lee

Dans l'exemple ci-dessus, printd est un méthode d'instance. Le premier paramètre de la méthode d'instance est self Lorsque la méthode d'instance est appelée à l'aide de ik1.printd(), l'instance ik1 sera transmise au paramètre self, afin que le paramètre self puisse faire référence à l'instance qui appelle actuellement l'instance. méthode. Tirant parti de cette fonctionnalité des méthodes d'instance, le code ci-dessus génère correctement les données membres des deux instances.

Recommandations associées : "Tutoriel vidéo Python"

Méthode de classe

La méthode de classe de Python utilise le décorateur @classmethod For. définition, regardons directement l'exemple.

class Kls(object):
    num_inst = 0
    def __init__(self):
        Kls.num_inst = Kls.num_inst + 1
    @classmethod
    def get_no_of_instance(cls):
        return cls.num_inst
ik1 = Kls()
ik2 = Kls()
print ik1.get_no_of_instance()
print Kls.get_no_of_instance()

Sortie :

2 
2

Dans l'exemple ci-dessus, nous devons compter le nombre d'instances de la classe Kls, donc une variable de classe num_inst est définie pour stocker le nombre d'instances. Grâce à l'utilisation du décorateur @classmethod, la méthode get_no_of_instance est définie comme une méthode de classe. Lors de l'appel d'une méthode de classe, Python transmettra la classe (classe Kls) à cls, afin que la variable de classe num_inst puisse être référencée dans get_no_of_instance.

Étant donné que lors de l'appel d'une méthode de classe, il vous suffit de transmettre le type lui-même à la méthode de classe, par conséquent, la méthode de classe peut être appelée soit via la classe, soit via l'instance.

Méthode statique

En développement, nous avons souvent besoin de définir certaines méthodes, qui sont liées à la classe, mais n'ont pas besoin de référencer la classe ou l'instance lors de l'implémentation , tels que , définir des variables d'environnement, modifier les variables d'une autre classe, etc. Pour le moment, nous pouvons utiliser des méthodes statiques.

Python utilise le décorateur @staticmethod pour définir une méthode statique.

IND = 'ON'

class Kls(object):
    def __init__(self, data):
        self.data = data
    @staticmethod
    def checkind():
        return IND == 'ON'
    def do_reset(self):
        if self.checkind():
            print('Reset done for: %s' % self.data)
    def set_db(self):
        if self.checkind():
            print('DB connection made for: %s' % self.data)
ik1 = Kls(24)
ik1.do_reset()
ik1.set_db()

Sortie :

Reset done for: 24 
DB connection made for: 24

Dans le code, on définit une variable globale IND Puisque IND est lié à la classe Kls, on ajoute la variable globale IND. La méthode Checkind est placée et définie dans la classe Kls. La méthode checkind doit uniquement vérifier la valeur de IND sans référencer la classe ou l'instance. Par conséquent, nous définissons la méthode checkind comme une méthode statique.

Pour les méthodes statiques, Python n'a pas besoin de transmettre des classes ou des instances, vous pouvez donc utiliser des classes ou des instances pour appeler des méthodes statiques.

La différence entre les méthodes d'instance, les méthodes de classe et les méthodes statiques

Nous utilisons du code pour illustrer les différences entre les méthodes d'instance, les méthodes de classe et les méthodes statiques. Faites attention à la définition et à l'utilisation des méthodes foo, class_foo et static_foo dans le code suivant.

class Kls(object):
    def foo(self, x):
        print('executing foo(%s,%s)' % (self, x))
    @classmethod
    def class_foo(cls,x):
        print('executing class_foo(%s,%s)' % (cls,x))
    @staticmethod
    def static_foo(x):
        print('executing static_foo(%s)' % x)
ik = Kls()
# 实例方法
ik.foo(1)
print(ik.foo)
print('==========================================')
# 类方法
ik.class_foo(1)
Kls.class_foo(1)
print(ik.class_foo)
print('==========================================')
# 静态方法
ik.static_foo(1)
Kls.static_foo('hi')
print(ik.static_foo)

Sortie :

executing foo(<__main__.Kls object at 0x0551E190>,1)
<bound method Kls.foo of <__main__.Kls object at 0x0551E190>>
==========================================
executing class_foo(<class &#39;__main__.Kls&#39;>,1)
executing class_foo(<class &#39;__main__.Kls&#39;>,1)
<bound method type.class_foo of <class &#39;__main__.Kls&#39;>>
==========================================
executing static_foo(1)
executing static_foo(hi)
<function static_foo at 0x055238B0>

Pour les méthodes d'instance, l'instance ik sera transmise comme premier paramètre au paramètre self lors de son appel. Par conséquent, appeler ik.foo(1) imprime l’adresse de l’instance ik.

Pour les méthodes de classe, la classe Kls sera passée au paramètre cls comme premier paramètre lors de l'appel. Par conséquent, les informations de type Kls sont affichées lors de l'appel de ik.class_foo(1).

Comme mentionné précédemment, les méthodes de classe peuvent être appelées via des classes ou des instances. Dans le code ci-dessus, nous l'avons vérifié à nouveau.

Pour les méthodes statiques, il n'est pas nécessaire de transmettre une classe ou une instance lors de l'appel. En fait, les méthodes statiques sont très similaires aux fonctions que nous définissons en dehors de la classe, sauf que les méthodes statiques peuvent être appelées via des classes ou des instances.

Il convient de noter que dans l'exemple ci-dessus, foo n'est qu'une fonction, mais lors de l'appel de ik.foo, nous obtenons une fonction qui a été liée à l'instance ik. L'appel de foo nécessite deux arguments, mais l'appel de ik.foo ne nécessite qu'un seul argument. foo est lié à ik, donc lorsque nous imprimons ik.foo, nous verrons le résultat suivant :

<bound method Kls.foo of <__main__.Kls object at 0x0551E190>>

Lorsque ik.class_foo est appelé, puisque class_foo est une méthode de classe, class_foo est lié à Kls Bind (au lieu de liaison à ik). Lorsque nous imprimons ik.class_foo, le résultat est :

<bound method type.class_foo of <class &#39;__main__.Kls&#39;>>

Lors de l'appel de ik.static_foo, la méthode statique n'est pas liée à la classe ou à l'instance, par conséquent, lors de l'impression de ik.static_foo (ou Kls.static_foo), le résultat :

<function static_foo at 0x055238B0>

En résumé, qu'il soit lié à une classe ou à une instance, c'est la différence entre les méthodes d'instance, les méthodes de classe et les méthodes statiques.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!