Python-Funktionsparametertyp

1. Python-Funktionsparametertypen
2. Was ist eine Funktion in Python
3. Standard- und flexible Argumente in Python
4. Abschluss

In diesem Python-Artikel lernen wir die in Python verwendeten Funktionsparametertypen kennen. Wir werden auch lernen, wie man eine Python-Funktion ohne Parameter schreibt.

Wir werden sehen, wie wir in Python eine Funktion mit einem oder mehreren Parametern schreiben können. Wir müssen eine Funktion verstehen und wissen, wie man eine Funktion in Python schreibt.

Beginnen wir damit, die Konzepte von Parametertypen in Python zu verstehen.

Python-Funktionsparametertypen

Python-Funktionsparameter stellen Daten bereit, die die Funktionen verwenden, wenn sie ausgeführt werden. Wir können Parameter unterschiedlich angeben, aber nicht alle Methoden werden in jeder Funktion benötigt.

Es hängt von den Funktionalitäten der Funktion ab, und wir entscheiden entsprechend den Umständen.

Wenn wir Parameter angeben, können ihnen Datentypen zugewiesen werden, und diese Typen müssen mit den Erwartungen übereinstimmen, oder der Code wird nicht ordnungsgemäß ausgeführt.

Die Parameterdeklarationsmethoden default, **kwargs und **args sind die Parameter, mit denen wir arbeiten, wenn wir an einer Funktion in Python arbeiten.

Aber bevor wir in unser Hauptthema eintauchen, werden wir uns zuerst mit den Grundlagen von Funktionen befassen, damit es einfacher ist, mit Funktionsparametern zu arbeiten.

Was ist eine Funktion in Python

Eine Funktion in Python kann als eine Liste von Anweisungen definiert werden, die ausgeführt werden, wenn die Funktion aufgerufen wird. Wir können eine Funktion definieren, indem wir das Schlüsselwort def verwenden und ihr einen Namen zuweisen.

In diesem Artikel werden wir die unten genannten Bereiche nacheinander mit Beispielen behandeln.

1. Schreiben einer Funktion
2. Funktion ohne Parameter
3. Funktionen mit einem Parameter
4. Eine Funktion, die einen Wert zurückgibt
5. Mehrere Argumente, mehrere Rückgabewerte

Schreiben einer Funktion

Zuerst schreiben wir eine Funktion unseres Bedarfs, die nach unseren Anforderungen funktioniert, wann immer wir sie aufrufen.

Angenommen, wir wollen eine Funktion, die eine beliebige Zahl nimmt und uns das Quadrat der Zahl liefert. Wisse, dass es einfach ist, eine Funktion zu definieren.

Jetzt müssen wir nur noch das Schlüsselwort def verwenden, gefolgt vom Namen unserer Funktion, gefolgt von Klammern () und gefolgt von einem Doppelpunkt :.

Beispielcode:

def my_first_function():

Funktion ohne Parameter

In unserem Szenario möchten wir eine Funktion, die Zahlen quadriert, um unsere Funktion Quadrat zu nennen. So können wir unsere Quadrat-Funktion definieren.

Beispielcode:

def square():

Wenn wir nun möchten, dass unsere Funktion die von uns angegebene Zahl quadriert, müssen wir diese Funktionalität unserer Funktion Quadrat zuweisen.

1. Wir definieren die Funktion
2. Multiplizieren Sie die Zahl mit 2 und weisen Sie sie einer Variablen zu
3. Drucken Sie die Variable innerhalb der Funktion
4. Rufen Sie die Funktion auf, denn wenn wir die Funktion nicht aufrufen, können wir die Ausgabe nicht erhalten.

Beispielcode:

def square():
    value = 2 ** 2
    print(value)

Denken Sie daran, dass wir die Funktion niemals innerhalb der Funktion aufrufen; wir nennen es außerhalb der Funktion.

square()

Ausgang:

4

Aber was ist, wenn wir der Funktion verschiedene Zahlen geben wollen, damit wir je nach Situation das Quadrat verschiedener Zahlen finden können?

Funktionen mit einem Parameter

Hier kommt der Parameter ins Spiel. Wir werden einen Parameter in der Funktion übergeben.

Wann immer wir also das Quadrat einer Zahl wissen wollen, rufen wir die Funktion auf und übergeben diese Zahl an die Funktion.

Innerhalb von Nanosekunden haben wir das Quadrat eines beliebigen Wertes. Versuchen wir es mit einem Beispiel und definieren wir die Funktion Quadrat noch einmal mit einem Parameter.

Beispielcode:

def square(number):

    value = number ** 2
    print(value)

Jetzt rufen wir die Funktion auf und geben ihr einige Zufallszahlen, um zu sehen, ob sie die richtigen Quadrate zurückgibt.

square(5)

Ausgang:

25

Um das Quadrat von 25 zu finden, nennen wir unsere Funktion Quadrat und geben ihr den Wert 25.

square(25)

Ausgang:

625

Funktion, die einen Wert zurückgibt

Wenn wir den Wert nicht direkt drucken, wollen wir ihn zurückgeben und einer anderen Variablen zuweisen. Wir verwenden das Schlüsselwort return.

Siehe das Beispiel unten.

def square(number):
    values = number ** 2
    return values

Jetzt werden wir unsere Funktion einer Variablen zuweisen, die wir außerhalb der Funktion haben.

values = square(3)

Um die Ausgabe des obigen Codes zu sehen, drucken wir die von uns erstellte Variable.

print(values)

Ausgang:

9

Mehrere Argumente und mehrere Rückgabewerte

Jetzt werden wir sehen:

1. Wie eine Funktion mehr als einen Parameter akzeptiert
2. Wie können wir mehrere Argumente an eine Funktion übergeben
3. Wie können wir mehrere Rückgabewerte erhalten?

Lassen Sie uns all dies anhand eines Beispiels tun. Wir werden eine Funktion definieren, die mehr als einen Parameter akzeptiert und mehrere Argumente und mehrere Rückgabewerte akzeptiert.

Beispielcode:

def raise_to_power(val, val2):
    return val ** val2

Nun rufen wir die Funktion auf und übergeben zwei Werte für die in der Funktion genannten Parameter val, val2.

print(raise_to_power(3, 5))

Ausgang:

243

Standard- und flexible Argumente in Python

Nehmen wir an, wir schreiben eine Funktion, die mehrere Parameter akzeptiert, und es gibt auch einen gemeinsamen Wert für einige dieser Parameter.

In diesem Fall möchten wir eine Funktion aufrufen, ohne jede Funktion anzugeben. Manchmal möchten wir, dass für einige Parameter Standardargumente verwendet werden, wenn nichts anderes angegeben ist.

Jetzt werden wir lernen:

1. Wie man eine Funktion mit einem Standardargument schreibt
2. *args - Flexible Argumente erlauben es uns, eine beliebige Anzahl von Argumenten in der Funktion zu übergeben.
3. **kwargs - Schlüsselwortargumente

Definieren Sie eine Funktion mit einem Standardargumentwert; Folgen Sie im Funktionsheader dem interessierenden Parameter mit einem Gleichheitszeichen und einem Standardargumentwert.

Beispielcode:

def power(word, pow=1):
    words = word ** pow
    return words

Nun nennen wir unsere Funktion power und übergeben nur ein Argument für den Parameter word.

print(power(3))

Ausgang:

3

Der zweite Parameter in der Funktion hat einen Standardwert von 1 und 3 Potenz 1 = 3.

Flexibles Argument *args in der Python-Funktion

Wenn wir uns über die Anzahl der Argumente unserer Funktion nicht sicher sind, fügen wir in der Funktionsspezifikation vor dem Parameternamen ein * hinzu.

Nehmen wir an, wir möchten eine Funktion schreiben, sind uns aber nicht sicher, wie viele Argumente ein Benutzer übergeben wird. Wir werden eine Funktion definieren, die int und floats nimmt und sie hinzufügt.

Beispielcode:

def add_all(*number):
    sum_all = 0
    # apply for loop to sum all the parameter
    for num in number:
        sum_all += num
    return sum_all

Jetzt rufen wir die Funktion auf und übergeben einige Argumente.

print(add_all(2, 45, 3.2, 45))

Ausgang:

95.2

Keyword-Argumente **kwargs

In der Funktion fügen wir vor der Deklaration des Parameternamens zwei Sternchen ** hinzu, wenn wir uns nicht sicher sind, wie viele Schlüsselwortargumente in unserer Funktion bereitgestellt werden.

Dadurch kann die Funktion nach Erhalt eines Wörterbuchs mit Argumenten entsprechend auf die Elemente zugreifen.

Beispielcode:

def my_function(**name):
    print("The child's last name is " + name["last_name"])

Nun rufen wir die Funktion auf und übergeben einige Argumente.

my_function(first_name="Abid", last_name="Orakzai")

Ausgang:

The child's last name is Orakzai

Abschluss

So erfahren wir, dass es drei verschiedene Arten von Parametern gibt, die die Python-Funktion akzeptieren kann. Dies sind die willkürlichen *args, das Schlüsselwort **kwargs und Standardparameter.

Während Schlüsselwortargumente es uns ermöglichen, eine beliebige Reihenfolge zu verwenden, helfen uns Standardargumente dabei, mit dem Fehlen von Werten umzugehen. Schließlich sind Pythons willkürliche Argumente *args praktisch, wenn wir nicht wissen, wie viele Argumente wir bekommen werden.

Wir hoffen, dass Sie diesen Artikel hilfreich finden, um die Grundidee der in Python verwendeten Funktionsparametertypen zu verstehen.