Python >> Tutoriel Python >  >> Python

Python staticmethod()

Les méthodes statiques sont des cas particuliers de méthodes de classe. Ils sont liés à une classe plutôt qu'à une instance, ils sont donc indépendants de l'état de toute instance. La fonction intégrée de Python staticmethod () préfixe une définition de méthode comme une annotation @staticmethod . Cette annotation transforme une méthode d'instance normale en une méthode statique. La différence entre les méthodes statiques (de classe) et les méthodes d'instance est qu'elles ne nécessitent pas qu'une instance soit appelable.

Dans ce tutoriel, je vais vous montrer l'un des secrets peu connus de Python qui sépare les intermédiaires des experts :méthodes statiques . Une méthode statique est un cas particulier d'une cclasse méthode . Vous connaissez peut-être la différence entre une méthode d'instance et une méthode de classe conceptuellement. (Si vous ne le faites pas, ce tutoriel est pour vous.) Mais savez-vous aussi comment créer une méthode statique en Python ?

Sinon, continuez à lire, car ce tutoriel vous le montrera !

Méthode statique de syntaxe

Syntax: 
staticmethod(function)    # <- – This is considered unpythonic
@staticmethod                        # <- – As a prefix before the used method

Vous pouvez déclarer une méthode statique avec la syntaxe de décorateur suivante, c'est la manière la plus Pythonique :

class C:
    @staticmethod
    def f(arg1, arg2, ...):
        None

C.f(arg1, arg2, ...)

Comment appeler une méthode statique ?

Il existe deux manières d'appeler une méthode statique :

  • Vous pouvez l'appeler sur une classe telle que C.f(arg1, arg2, ...) , ou
  • Vous pouvez l'appeler sur une instance telle que C().f(arg1, arg2, ...) .

Contrairement à une méthode de classe, Python ne transmet pas implicitement une référence à la classe elle-même comme premier argument.

Application de la méthode statique – Modèle d'usine

Vous pouvez utiliser la méthode statique pour permettre aux utilisateurs de créer différentes variantes d'un Coffee classe :

class Coffee:

  def __init__(self, milk, beans):
    self.milk = milk # percentage
    self.coffee = 100-milk # percentage
    self.beans = beans


  def __repr__(self):
    return f'Milk={self.milk}% Coffee={self.coffee}% Beans={self.beans}'


  @staticmethod
  def cappuccino():
    return Coffee(80, 'Arrabica')
  

  @staticmethod
  def espresso_macchiato():
    return Coffee(30, 'Robusta')
  

  @staticmethod
  def latte():
    return Coffee(95, 'Arrabica')


print(Coffee.cappuccino())
print(Coffee.espresso_macchiato())
print(Coffee.latte())

C'est ce qu'on appelle le modèle d'usine :les méthodes statiques sont des fabriques d'instances — elles produisent de nouvelles instances en fonction de leurs implémentations. Par exemple, le Coffee.cappuccino() méthode crée un type spécial de Coffee avec une première sélection de lait 80% et de fèves Arrabica.

Le résultat de cet extrait de code est :

Milk=80% Coffee=20% Beans=Arrabica
Milk=30% Coffee=70% Beans=Robusta
Milk=95% Coffee=5% Beans=Arrabica

Méthode statique d'exemple interactif

Le shell de code interactif suivant vous permet de jouer avec cet exemple et d'approfondir vos compétences.

Exercice :Pouvez-vous créer une autre spécialité de café ?

La méthode statique est un décorateur de fonction

Les décorateurs aident à ajouter des fonctionnalités au code existant sans avoir à modifier le code lui-même. Les décorateurs sont appelés ainsi parce qu'ils décorent le code, ils ne modifient pas le code, mais ils font en sorte que le code fasse différentes choses en utilisant la décoration. Maintenant que nous avons compris les fermetures, nous pouvons progresser étape par étape pour comprendre et utiliser les décorateurs.

Le @staticmethod est un décorateur de fonction. C'est l'abréviation d'appeler staticmethod(m) pour la méthode m que tu décorerais.

Voici un exemple sans utiliser de décorateur et en utilisant staticmethod() à la place :

class Coffee:

  def __init__(self, milk, beans):
    self.milk = milk # percentage
    self.coffee = 100-milk # percentage
    self.beans = beans


  def __repr__(self):
    return f'Milk={self.milk}% Coffee={self.coffee}% Beans={self.beans}'


  def cappuccino():
    return Coffee(80, 'Arrabica')

  cappuccino = staticmethod(cappuccino)

print(Coffee.cappuccino())

Le résultat est le même :

Milk=80% Coffee=20% Beans=Arrabica

Cependant, ce n'est pas la méthode recommandée :utilisez plutôt un décorateur avec l'annotation @ !

Article connexe : Décorateurs

Méthode statique vs méthode d'instance

Si vous n'utilisez pas le @staticmethod annotateur, vous obtenez une méthode d'instance par défaut. La méthode d'instance nécessite que le premier argument self est une référence à l'instance elle-même sur laquelle la méthode est appelée. La méthode statique ne transmet aucun argument implicite. Ainsi, la différence entre les méthodes statiques et les méthodes d'instance est que Python ne transmet rien dans le premier cas tout en passant l'instance (objet) comme premier argument implicite dans le second cas.

Voici un exemple minimal d'une méthode statique et d'une méthode d'instance :

class C:

    @staticmethod
    def f():
        print('hi')


    # instance method
    def g(self):
        None



# call static method:
C.f()

# call instance method:
C().g()

Méthode statique vs méthode de classe

Vous connaissez peut-être les méthodes statiques des langages de programmation tels que C++ ou Java. Ce sont des méthodes qui existent indépendamment du fait que vous ayez ou non créé une instance de la classe. C'est pourquoi ils n'utilisent aucune variable d'instance dans le corps de la méthode. Si vous souhaitez utiliser une méthode statique en Python, vous devez utiliser le @staticmethod annotation plutôt que le @classmethod annotation. La différence est que les méthodes statiques n'attendent pas une référence à l'instance ou à la classe comme premier argument implicite.

Voici un exemple comparant les méthodes de classe, les méthodes d'instance et les méthodes statiques :

class C:

    @classmethod
    def f(cls):
        None


    # instance method
    def g(self):
        None


    @staticmethod
    def h():
        None


# call class method:
C.f()

# call instance method:
C().g()


# call static method:
C.h()

Méthode statique vs méthode de classe vs méthode d'instance

Pour résumer, voici la différence entre les trois différents types de méthodes :

  • Méthodes statiques,
  • Méthodes de classe, et
  • Méthodes d'instance.
Méthode d'instance Méthode de classe Méthode statique
Définition def f(self, arg1, arg2): ... def f(cls, arg1, arg2): ... def f(arg1, arg2): ...
Premier argument Référence à l'instance Référence à la classe Aucune référence
Utilisation Sur l'instance :C().f(arg1, arg2) En classe :C.f(arg1, arg2) En classe :C.f(arg1, arg2)
Candidature Travailler sur les données d'une instance spécifique Fonctionne indépendamment des données d'instance, mais dépend de la classe (par exemple, l'usine). Travailler indépendamment des données d'instance et des données de classe (par exemple, calcul général)

Vidéo associée :Méthode de classe Python

Résumé

Les méthodes statiques sont des cas particuliers de méthodes de classe. Ils sont liés à une classe plutôt qu'à une instance, ils sont donc indépendants de l'état de toute instance.

La fonction intégrée de Python staticmethod () préfixe une définition de méthode comme une annotation @staticmethod . Cette annotation transforme une méthode d'instance normale en une méthode statique.


Voulez-vous améliorer vos compétences Python d'une manière amusante et facile à consommer ? Considérez les ressources suivantes et devenez un maître codeur !