Sådan bruges Python sta­ti­c­met­hod()

Statiske metoder kan kaldes direkte via klassens navn uden at skulle in­stan­si­e­re klassen. Denne egenskab ved Python staticmethod muliggør en klar ad­skil­lel­se af klas­se­lo­gik og in­stans­da­ta.

Hvad bruges Python staticmethod til?

Python staticmethod er både en funktion og en dekorator. Den bruges til at udpege metoder, der fungerer uaf­hæn­gigt af klas­se­in­stan­ser. De­ko­ra­to­rer i Python er funk­tio­ner, der ændrer andre metoders adfærd ved at tilføje sup­ple­ren­de funk­tio­na­li­tet før eller efter deres udførelse uden at ændre den op­rin­de­li­ge funk­tions­ko­de. I mod­sæt­ning til in­stans­me­to­der kræver statiske funk­tio­ner ikke en implicit parameter som f.eks. self.

Brugen af staticmethod i Python giver en fokuseret tilgang til struk­tu­re­ring af funk­tio­ner inden for klasser, der ikke kræver adgang til in­stans­da­ta. Da de ikke er bundet til en instans, kan de ikke ændre et objekts tilstand. Inden for klasser fungerer de som vær­di­ful­de værktøjer til udførelse af al­min­de­li­ge opgaver eller til at tilbyde global funk­tio­na­li­tet. De kan f.eks. indeholde hjæl­pe­pro­gram­mer, kon­ver­te­rings­ru­ti­ner og generelle hjæl­pe­funk­tio­ner, der kan påkaldes uden in­stans­da­ta.

Hvad er syntaksen i Python staticmethod?

Der er to måder at oprette statiske metoder i Python. Du kan bruge funk­tio­nen staticmethod() eller de­ko­ra­to­ren @staticmethod.

staticmethod()

staticmethod() er en indbygget Python-funktion, der gør en metode i en klasse statisk. Re­tur­vær­di­en af Python staticmethod() er en statisk metode for den funktion, der overføres som et argument. Syntaksen er:

class Class:
    def staticmethodFunc(x,y):
        return x + y
Class.staticmethodFunc = staticmethod(Class.staticmethodFunc)
print('Sum = ', Class.staticmethodFunc(5,7)) # Output: Sum = 12

Ved at vi­de­re­gi­ve den staticmethodFunc() funktion, der er defineret i Class klassen, som et argument til staticmethod(), kan vi nu kalde den bru­ger­de­fi­ne­re­de metode direkte via klassens navn.

@staticmethod

@staticmethod er en kortere og mere al­min­de­lig metode til at markere en funktion som statisk. De­ko­ra­to­ren placeres over metoden i klas­se­de­fi­ni­tio­nen. Syntaksen er:

class Class:
    @staticmethod
    def staticmethodFunc(x, y):
        return x + y
print('Sum = ', Class.staticmethodFunc(5,7)) # Output: Sum = 12

@staticmethod sig­na­le­rer til for­tol­ke­ren, at den de­fi­ne­re­de funktion skal behandles som en statisk metode.

Python staticmethod ko­de­ek­semp­ler

Du kan bruge statiske metoder til en række for­skel­li­ge opgaver. Nedenfor er nogle praktiske eksempler på, hvordan du kan bruge statiske metoder.

Kon­ver­te­ring af enheder

Python staticmethod er meget nyttigt til at kon­ver­te­re enheder.

class Converter:
    @staticmethod
    def hoursToMinutes(hours):
        return hours * 60
    @staticmethod
    def minutesToHours(minutes):
        return minutes / 60
hours = 3
converted_minutes = Converter.hoursToMinutes(hours)
print(f"{hours} hours are {converted_minutes} minutes.") # Output: 3 hours are 180 minutes.
minutes = 180
converted_hours = Converter.minutesToHours(minutes)
print(f"{minutes} minutes are {converted_hours} hours.") # Output: 180 minutes are 3 hours.

I dette eksempel har klasse Converter to statiske metoder til at kon­ver­te­re mellem timer og minutter. Metoden hoursToMinutes() kon­ver­te­rer timer til minutter, mens minutesToHours() kon­ver­te­rer minutter til timer.

Vi kan kalde de statiske metoder via klassens navn uden at skulle oprette en instans af klassen. De tilgås via Converter.hoursToMinutes() eller Converter.minutesToHours(), hvor Converter er klassens navn. Vi udskriver re­sul­ta­tet i en f-streng, et Python-streng­for­mat, der forbinder udtryk.

Hjæl­pe­funk­tio­ner til ma­te­ma­ti­ske be­reg­nin­ger

Du kan også bruge Pythons sta­ti­c­met­hod() til at definere hjæl­pe­funk­tio­ner til sekundære be­reg­nin­ger.

class Calculator:
    @staticmethod
    def square(x):
        return x * x
    @staticmethod
    def sqroot(x):
        return x ** 0.5
num = 9
square = Calculator.square(num)
print(f"The square of {num} is {square}.") # Output: The square of 9 is 81.
root = Calculator.sqroot(num)
print(f"The square root of {num} is {root}.") # Output: The square root of 9 is 3.

Ko­de­ek­semp­let viser klassen Calculator med statiske metoder til beregning af kvadratet og kva­dra­tro­den af et tal. Vi bruger de­ko­ra­to­ren @staticmethod til at markere square() og sqroot() som statiske metoder. Uden at oprette en instans af klassen kalder vi metoderne via klassens navn. Vi sam­men­kæ­der re­sul­ta­ter­ne af Calculator.square() og Calculator.sqroot() i en f-streng.

Va­li­de­ring af ind­tast­nin­ger

En anden an­ven­del­se af Pythons sta­ti­c­met­hod er va­li­de­ring af input.

class Validator:
    @staticmethod
    def isInteger(num):
        try:
            int(num)
            return True
        except ValueError:
            return False
    @staticmethod
    def isDecimal(num):
        try:
            float(num)
            return True
        except ValueError:
            return False
input = "123"
is_integer = Validator.isInteger(input)
print(f"Is '{input}' an integer? {is_integer}") # Output: Is '123' an integer? True
input = "3.14"
is_dec = Validator.isDecimal(input)
print(f"Is '{input}' a decimal number? {is_dec}") # Output: Is '3.14' a decimal number? True

Klasse Validator består af de to statiske metoder: isInteger() og isDecimal(). Disse funk­tio­ner kon­trol­le­rer, om en given ind­tast­ning er et heltal eller et de­ci­mal­tal. Den statiske metode isInteger() i Python tager en ind­tast­ning og forsøger at kon­ver­te­re den til et heltal (int(num)). Hvis det lykkes, re­tur­ne­res True. Ellers får vi False, hvis der opstår en und­ta­gel­se ValueError, hvilket sker, når va­li­de­ring ikke er mulig.

Vi bruger metoden isDecimal() til at kon­ver­te­re inputtet til et de­ci­mal­tal (float(num)). Hvis det lykkes, re­tur­ne­res True, ellers False. Derefter bruger vi de statiske metoder isInteger() og isDecimal() i klassen Validator til at kon­trol­le­re inputtene "123" og "3.14". Re­sul­ta­ter­ne er sande for begge funk­tio­ner.

Ma­ni­pu­la­tion af strenge

I eksemplet nedenfor definerer vi klassen StringManipulation med den statiske metode reverseText(). Denne tager en tekst som parameter og bruger slicing-syntaksen [::-1] til at vende teksten "Hello World!" og returnere re­sul­ta­tet.

class StringManipulation:
    @staticmethod
    def reverseText(text):
        return text[::-1]
input_text = "Hello World!"
result = StringManipulation.reverseText(input_text)
print(f"Reversed text of '{input_text}': {result}") # Output: Reversed text of 'Hello World!': !dlroW olleH