Statiske metoder kan påkalles direkte via klassens navn uten at det er nødvendig å instansiere klassen. Denne egenskapen i Python staticmethod muliggjør en tydelig separasjon mellom klasselogikk og instansdata.

Hva brukes Python staticmethod til?

Python staticmethod er både en funksjon og en dekorator. Den brukes til å betegne metoder som fungerer uavhengig av klasseinstanser. Dekoratorer i Python er funksjoner som endrer oppførselen til andre metoder ved å legge til tilleggsfunksjonalitet før eller etter utførelsen, uten å endre den opprinnelige funksjonskoden. I motsetning til instansmetoder krever statiske funksjoner ikke en implisitt parameter som self.

Bruken av staticmethod i Python gir en fokusert tilnærming til strukturering av funksjoner innenfor klasser som ikke krever tilgang til instansdata. Siden de ikke er bundet til en instans, kan de ikke endre tilstanden til et objekt. Innenfor klasser fungerer de som verdifulle verktøy for å utføre vanlige oppgaver eller tilby global funksjonalitet. De kan for eksempel inneholde verktøyprogrammer, konverteringsrutiner og generelle hjelpefunksjoner som kan påkalles uten instansdata.

Hva er syntaksen til Python staticmethod?

Det er to måter å lage statiske metoder på i Python. Du kan bruke funksjonen staticmethod() eller dekoratoren @staticmethod.

staticmethod()

staticmethod() er en innebygd Python-funksjon som gjør en metode i en klasse statisk. Returverdien av Python staticmethod() er en statisk metode for funksjonen som sendes 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
python

Ved å overføre funksjonen staticmethodFunc() definert i klassen Class som et argument til staticmethod(), kan vi nå kalle den tilpassede metoden direkte via klassens navn.

@staticmethod

Dekoratoren @staticmethod er en kortere og mer vanlig metode for å merke en funksjon som statisk. Dekoratoren plasseres over metoden i klassedefinisjonen. Syntaksen er:

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

Dekoratoren @staticmethod signaliserer til tolken at den definerte funksjonen skal behandles som en statisk metode.

Python staticmethod kodeeksempler

Du kan bruke statiske metoder til en rekke oppgaver. Nedenfor finner du noen praktiske eksempler på hvordan du kan bruke statiske metoder.

Konvertering av enheter

Python staticmethod er veldig nyttig for å konvertere enheter.

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.
python

I dette eksemplet har klasse Converter to statiske metoder for å konvertere mellom timer og minutter. Metoden hoursToMinutes() konverterer timer til minutter, mens minutesToHours() konverterer minutter til timer.

Vi kan kalle opp de statiske metodene via klassens navn uten å måtte opprette en instans av klassen. De nås via Converter.hoursToMinutes() eller Converter.minutesToHours(), hvor Converter er klassens navn. Vi skriver ut resultatet i en f-streng, et Python-strengformat som kobler sammen uttrykk.

Hjelpefunksjoner for matematiske beregninger

Du kan også bruke Pythons staticmethod() til å definere hjelpefunksjoner for sekundære beregninger.

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.
python

Kodeeksemplet viser klassen Calculator med statiske metoder for å beregne kvadratet og kvadratroten av et tall. Vi bruker dekoratoren @staticmethod til å merke square() og sqroot() som statiske metoder. Uten å opprette en instans av klassen, kaller vi metodene via klassens navn. Vi sammenføyer resultatene av Calculator.square() og Calculator.sqroot() i en f-streng.

Validering av oppføringer

En annen bruk av Pythons staticmethod er validering av inndata.

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
python

Klasse Validator består av to statiske metoder: isInteger() og isDecimal(). Disse funksjonene sjekker om en gitt inndata er et heltall eller et desimaltall. Den statiske metoden isInteger() i Python tar en inndata og prøver å konvertere den til et heltall (int(num)). Hvis dette lykkes, returneres True. Ellers får vi False hvis en unntak ValueError blir fanget opp, noe som skjer når validering ikke er mulig.

Vi bruker metoden isDecimal() til å konvertere inndataene til et desimaltall (float(num)). Hvis dette lykkes, returneres True, ellers False. Deretter bruker vi de statiske metodene isInteger() og isDecimal() i klassen Validator til å sjekke inndataene "123" og "3.14". Resultatene er sanne for begge funksjonene.

Manipulering av strenger

I eksemplet nedenfor definerer vi klassen StringManipulation med den statiske metoden reverseText(). Denne tar en tekst som parameter og bruker slicing-syntaksen [::-1] til å reversere teksten "Hello World!" og returnere resultatet.

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
python
Go to Main Menu