Statische Methoden in Python?

Question

Ist es möglich, statische Methoden in Python zu haben, die ich aufrufen könnte, ohne eine Klasse zu initialisieren, wie:

ClassName.static_method()

Answer 1

Am einfachsten ist es vielleicht, diese Funktionen außerhalb der Klasse zu platzieren:

class Dog(object):
    def __init__(self, name):
        self.name = name

    def bark(self):
        if self.name == "Doggy":
            return barking_sound()
        else:
            return "yip yip"

def barking_sound():
    return "woof woof"

Mit dieser Methode können Funktionen, die den internen Objektzustand verändern oder verwenden (Seiteneffekte haben), in der Klasse verbleiben, und die wiederverwendbaren Dienstfunktionen können nach außen verlagert werden.

Nehmen wir an, diese Datei heißt dogs.py . Um diese zu verwenden, müssen Sie dogs.barking_sound() anstelle von dogs.Dog.barking_sound .

Wenn Sie eine statische Methode wirklich als Teil der Klasse benötigen, können Sie die staticmethod Dekorateur.

Answer 2

Abgesehen von der Besonderheit, wie statische Methodenobjekte Wenn es darum geht, den Code auf Modulebene zu organisieren, kann man mit ihnen eine gewisse Schönheit erreichen.

# garden.py
def trim(a):
    pass

def strip(a):
    pass

def bunch(a, b):
    pass

def _foo(foo):
    pass

class powertools(object):
    """
    Provides much regarded gardening power tools.
    """
    @staticmethod
    def answer_to_the_ultimate_question_of_life_the_universe_and_everything():
        return 42

    @staticmethod
    def random():
        return 13

    @staticmethod
    def promise():
        return True

def _bar(baz, quux):
    pass

class _Dice(object):
    pass

class _6d(_Dice):
    pass

class _12d(_Dice):
    pass

class _Smarter:
    pass

class _MagicalPonies:
    pass

class _Samurai:
    pass

class Foo(_6d, _Samurai):
    pass

class Bar(_12d, _Smarter, _MagicalPonies):
    pass

...

# tests.py
import unittest
import garden

class GardenTests(unittest.TestCase):
    pass

class PowertoolsTests(unittest.TestCase):
    pass

class FooTests(unittest.TestCase):
    pass

class BarTests(unittest.TestCase):
    pass

...

# interactive.py
from garden import trim, bunch, Foo

f = trim(Foo())
bunch(f, Foo())

...

# my_garden.py
import garden
from garden import powertools

class _Cowboy(garden._Samurai):
    def hit():
        return powertools.promise() and powertools.random() or 0

class Foo(_Cowboy, garden.Foo):
    pass

Es wird nun etwas intuitiver und selbstdokumentierender, in welchem Kontext bestimmte Komponenten verwendet werden sollen, und es eignet sich ideal für die Benennung eindeutiger Testfälle sowie für Puristen, die einen einfachen Ansatz für die Zuordnung von Testmodulen zu den tatsächlichen Modulen unter den Tests haben.

Ich finde es häufig sinnvoll, diesen Ansatz auf die Organisation des Programmcodes eines Projekts anzuwenden. Oftmals erstellen die Leute in aller Eile eine utils Paket und habe am Ende 9 Module, von denen eines 120 LOC hat und der Rest bestenfalls zwei Dutzend LOC. Ich ziehe es vor, damit zu beginnen und es in ein Paket umzuwandeln und Module nur für die Biester zu erstellen, die sie wirklich verdienen:

# utils.py
class socket(object):
    @staticmethod
    def check_if_port_available(port):
        pass

    @staticmethod
    def get_free_port(port)
        pass

class image(object):
    @staticmethod
    def to_rgb(image):
        pass

    @staticmethod
    def to_cmyk(image):
        pass

Answer 3

Statische Methoden sind also die Methoden, die aufgerufen werden können, ohne dass ein Objekt einer Klasse erstellt wird. Zum Beispiel :-

    @staticmethod
    def add(a, b):
        return a + b

b = A.add(12,12)
print b

In der obigen Beispielmethode add wird durch den Klassennamen aufgerufen A nicht den Objektnamen.

Answer 4

Wenn man die Antworten der anderen zusammenfasst und hinzufügt, gibt es viele Möglichkeiten, statische Methoden oder Variablen in python .

1. Verwendung von staticmethod() als Dekorateur: Man kann einfach einen Dekorator über eine deklarierte Methode (Funktion) setzen, um sie zu einer statischen Methode zu machen. Zum Beispiel.

   class Calculator: @staticmethod def multiply(n1, n2, args): Res = 1 for num in args: Res = num return n1 n2 Res

   print(Calculator.multiply(1, 2, 3, 4)) # 24

2. Verwendung von staticmethod() als eine Parameterfunktion: Diese Methode kann ein Argument vom Typ Funktion erhalten und gibt eine statische Version der übergebenen Funktion zurück. Zum Beispiel.

   class Calculator: def add(n1, n2, *args): return n1 + n2 + sum(args)

   Calculator.add = staticmethod(Calculator.add) print(Calculator.add(1, 2, 3, 4)) # 10

3. Verwendung von classmethod() als Dekorateur: @classmethod hat eine ähnliche Wirkung auf eine Funktion wie @staticmethod, aber dieses Mal wird ein zusätzliches Argument benötigt, um in der Funktion akzeptiert zu werden (ähnlich dem self-Parameter für Instanzvariablen). Zum Beispiel.

   class Calculator: num = 0 def init(self, digits) -> None: Calculator.num = int(''.join(digits))

   @classmethod
   def get_digits(cls, num):
       digits = list(str(num))
       calc = cls(digits)
       return calc.num

   print(Calculator.get_digits(314159)) # 314159

4. Verwendung von classmethod() als Parameterfunktion: @classmethod kann auch als Parameterfunktion verwendet werden, wenn man die Klassendefinition nicht ändern möchte. Zum Beispiel.

   class Calculator: def divide(cls, n1, n2, args): Res = 1 for num in args: Res = num return n1 / n2 / Res

   Calculator.divide = classmethod(Calculator.divide)

   print(Calculator.divide(15, 3, 5)) # 1.0

5. Direkte Erklärung Eine Methode/Variable, die außerhalb aller anderen Methoden, aber innerhalb einer Klasse deklariert wird, ist automatisch statisch.

   class Calculator:
   def subtract(n1, n2, *args): return n1 - n2 - sum(args)

   print(Calculator.subtract(10, 2, 3, 4)) # 1

Das gesamte Programm

class Calculator:
    num = 0
    def __init__(self, digits) -> None:
        Calculator.num = int(''.join(digits))

    @staticmethod
    def multiply(n1, n2, *args):
        Res = 1
        for num in args: Res *= num
        return n1 * n2 * Res

    def add(n1, n2, *args):
        return n1 + n2 + sum(args)

    @classmethod
    def get_digits(cls, num):
        digits = list(str(num))
        calc = cls(digits)
        return calc.num

    def divide(cls, n1, n2, *args):
        Res = 1
        for num in args: Res *= num
        return n1 / n2 / Res

    def subtract(n1, n2, *args):
        return n1 - n2 - sum(args)

Calculator.add = staticmethod(Calculator.add)
Calculator.divide = classmethod(Calculator.divide)

print(Calculator.multiply(1, 2, 3, 4))              # 24
print(Calculator.add(1, 2, 3, 4))                   # 10
print(Calculator.get_digits(314159))                # 314159
print(Calculator.divide(15, 3, 5))                  # 1.0
print(Calculator.subtract(10, 2, 3, 4))             # 1

Siehe Python-Dokumentation für die Beherrschung von OOP in Python.

Answer 5

Python Statische Methoden können auf zwei Arten erstellt werden.

1. Verwendung von staticmethod()

   class Arithmetic:
       def add(x, y):
           return x + y
   # create add static method
   Arithmetic.add = staticmethod(Arithmetic.add)
   
   print('Result:', Arithmetic.add(15, 10))

Ausgabe:

Ergebnis: 25

2. Verwendung von @staticmethod

   class Arithmetic:
   
   # create add static method
   @staticmethod
   def add(x, y):
       return x + y
   
   print('Result:', Arithmetic.add(15, 10))

Ausgabe:

Ergebnis: 25