Python-funktioner: Så anropar och skriver du funktioner

Standardargument

Standardargument är de som får ett standardvärde om inget argumentvärde skickas vid funktionsanropet. Du kan tilldela detta standardvärde med tilldelningsoperatorn =, precis som i följande exempel:

Obligatoriska argument

Som namnet antyder är de obligatoriska argumenten i en UDF sådana som måste vara med. Dessa argument behöver skickas vid funktionsanrop och i exakt rätt ordning, precis som i följande exempel:

Du behöver argument som mappar till både parametern a och b för att anropa funktionen utan att få fel. Om du byter plats på a och b blir resultatet inte annorlunda, men det kan det bli om du ändrar plus() till följande:

Nyckelordsargument

Om du vill försäkra dig om att du anropar alla parametrar i rätt ordning kan du använda nyckelordsargument i funktionsanropet. Du använder dessa för att identifiera argumenten med deras parameternamn. Låt oss ta exemplet ovan för att göra detta tydligare:

Observera att genom att använda nyckelordsargument kan du också byta ordning på parametrarna och ändå få samma resultat när du kör din funktion:

Variabelt antal argument

I fall där du inte vet det exakta antalet argument du vill skicka till en funktion kan du använda följande syntax med *args:

Asterisken (*) placeras före variabelnamnet som håller värdena för alla icke‑nyckelordsargument. Notera här att du lika gärna hade kunnat skicka *varint, *var_int_args eller något annat namn till funktionen plus().

Tips: prova att ersätta *args med ett annat namn som inkluderar asterisken. Du kommer att se att koden ovan fortsätter att fungera!

Du ser att funktionen ovan använder den inbyggda Python-funktionen sum() för att summera alla argument som skickas till plus(). 

Globala vs. lokala variabler

Generellt har variabler som definieras inne i en funktionskropp ett lokalt omfång (scope), och de som definieras utanför har ett globalt omfång. Det betyder att lokala variabler definieras inom ett funktionsblock och bara kan nås inuti den funktionen, medan globala variabler kan nås av alla funktioner som kan finnas i ditt skript:

Du kommer att se att du får ett NameError som säger att name 'total' is not defined när du försöker skriva ut den lokala variabeln total som definierades inne i funktionskroppen. Variabeln init, å andra sidan, kan skrivas ut utan problem.

Endast positionella och endast nyckelordsparametrar

Sedan Python 3.8 kan du ta mer kontroll över hur argument måste skickas genom att använda två speciella markörer i din funktionssignatur: / och *. Allt före / kan endast skickas positionellt; allt efter * kan endast skickas som nyckelord.

def greet(name, /, greeting="Hello", *, punctuation="!"):
    print(f"{greeting} {name}{punctuation}")

 Så här spelar det ut vid anropsplatsen:

greet("Alice")                          # works
greet("Alice", greeting="Hi")           # works
greet("Alice", "Hi", punctuation="?")   # works

greet(name="Alice")                     # TypeError: name is positional-only
greet("Alice", "Hi", "?")               # TypeError: punctuation is keyword-only

Varför skulle du vilja detta? Två huvudskäl.

För det första låter endast positionella parametrar dig byta namn på dem senare utan att bryta någons kod — eftersom ingen får använda parameternamnet som nyckelord kan du fritt ändra det.

För det andra tvingar endast nyckelords parametrar anropare att vara explicita med vad de skickar, vilket gör anrop mer läsbara när du har flera valfria flaggor eller inställningar.

Kort sagt: det är ett rent sätt att upprätthålla avsikt.

Anonyma funktioner i Python

Anonyma funktioner kallas också lambda-funktioner i Python eftersom du istället för att deklarera dem med det vanliga nyckelordet def använder nyckelordet lambda.

I DataCamp Light-blocket ovan är lambda x: x*2 den anonyma eller lambda-funktionen. x är argumentet, och x*2 är uttrycket eller instruktionen som utvärderas och returneras. Det speciella med den här funktionen är att den saknar namn, till skillnad från exemplen du har sett i den första delen av den här funktionshandledningen. Om du skulle skriva ovanstående funktion som en UDF skulle resultatet bli följande:

def double(x):
  return x*2

Låt oss titta på ett annat exempel på en lambda-funktion där du arbetar med två argument:

Du använder anonyma funktioner när du behöver en namnlös funktion under en kort period som skapas vid körning. Specifika sammanhang där detta är relevant är när du arbetar med filter(), map() och reduce():

Funktionen filter() filtrerar, som namnet antyder, den ursprungliga indata­listan my_list baserat på kriteriet >10. Med map() å andra sidan tillämpar du en funktion på alla element i listan my_list. I detta fall multiplicerar du alla element med 2.

Observera att funktionen reduce() är en del av biblioteket functools. Du använder denna funktion kumulativt på elementen i listan my_list, från vänster till höger, och reducerar sekvensen till ett enda värde, 55, i det här fallet.

Att använda main() som en funktion i Python

Om du har erfarenhet av andra programmeringsspråk som Java vet du att funktionen main krävs för att köra funktioner. Som du har sett i exemplen ovan är detta inte nödvändigt i Python. Men att inkludera en main()-funktion i ditt Python-program kan vara praktiskt för att strukturera din kod logiskt – alla de viktigaste komponenterna samlas i den här funktionen main().

Du kan enkelt definiera en main()-funktion och anropa den precis som du har gjort med alla andra funktioner ovan:

Men som det är nu kommer koden i din main()-funktion att köras när du importerar den som en modul. För att se till att detta inte händer anropar du funktionen main() när __name__ == '__main__'.

Det betyder att koden i blocket ovan blir:

Observera att förutom funktionen __main__ finns också funktionen __init__ som initierar en instans av en klass eller ett objekt. Enkelt uttryckt fungerar den som en konstruktor eller initialiserare och anropas automatiskt när du skapar en ny instans av en klass. Med den funktionen tilldelas det nyss skapade objektet parametern self, vilket du såg tidigare i den här handledningen. Ta en titt på följande exempel:

class Dog:
    """A simple Dog class.

    Args:
        legs: Number of legs so that the dog can walk.
        color: The color of the fur.
    """

    def __init__(self, legs: int, color: str) -> None:
        self.legs = legs
        self.color = color

    def bark(self) -> str:
        return "bark" * 2

if __name__ == "__main__":
    dog = Dog(4, "brown")
    print(dog.bark())