R -Funktionen
Eine Funktion ist ein Codeblock, der nur ausgeführt wird, wenn er aufgerufen wird.
Sie können Daten, sogenannte Parameter, an eine Funktion übergeben.
Eine Funktion kann als Ergebnis Daten zurückgeben.
Erstellen einer Funktion
Verwenden Sie zum Erstellen einer Funktion das function()Schlüsselwort:
Beispiel
my_function <- function() { # create a function with the name my_function
print("Hello World!")
}
Rufen Sie eine Funktion auf
Um eine Funktion aufzurufen, verwenden Sie den Funktionsnamen gefolgt von Klammern, wie z. B. my_function() :
Beispiel
my_function <- function() {
print("Hello World!")
}
my_function() # call the function named my_function
Argumente
Informationen können als Argumente an Funktionen übergeben werden.
Argumente werden nach dem Funktionsnamen innerhalb der Klammern angegeben. Sie können beliebig viele Argumente hinzufügen, trennen Sie sie einfach durch ein Komma.
Das folgende Beispiel hat eine Funktion mit einem Argument (fname). Wenn die Funktion aufgerufen wird, übergeben wir einen Vornamen, der innerhalb der Funktion verwendet wird, um den vollständigen Namen auszugeben:
Beispiel
my_function <- function(fname) {
paste(fname, "Griffin")
}
my_function("Peter")
my_function("Lois")
my_function("Stewie")
Parameter oder Argumente?
Die Begriffe "Parameter" und "Argument" können für dasselbe verwendet werden: Informationen, die an eine Funktion übergeben werden.
Aus Sicht einer Funktion:
Ein Parameter ist die Variable, die in der Funktionsdefinition in Klammern aufgeführt ist.
Ein Argument ist der Wert, der an die Funktion gesendet wird, wenn sie aufgerufen wird.
Anzahl der Argumente
Standardmäßig muss eine Funktion mit der richtigen Anzahl von Argumenten aufgerufen werden. Das heißt, wenn Ihre Funktion 2 Argumente erwartet, müssen Sie die Funktion mit 2 Argumenten aufrufen, nicht mehr und nicht weniger:
Beispiel
Diese Funktion erwartet 2 Argumente und erhält 2 Argumente:
my_function <- function(fname, lname) {
paste(fname, lname)
}
my_function("Peter", "Griffin")
Wenn Sie versuchen, die Funktion mit 1 oder 3 Argumenten aufzurufen, erhalten Sie eine Fehlermeldung:
Beispiel
Diese Funktion erwartet 2 Argumente und erhält 1 Argument:
my_function <- function(fname, lname) {
paste(fname, lname)
}
my_function("Peter")
Standardparameterwert
Das folgende Beispiel zeigt, wie ein Standardparameterwert verwendet wird.
Wenn wir die Funktion ohne Argument aufrufen, verwendet sie den Standardwert:
Beispiel
my_function <- function(country = "Norway") {
paste("I am
from", country)
}
my_function("Sweden")
my_function("India")
my_function()
# will get the default value, which is Norway
my_function("USA")
Rückgabewerte
Um eine Funktion ein Ergebnis zurückgeben zu lassen, verwenden Sie die return()Funktion:
Beispiel
my_function <- function(x) {
return (5 * x)
}
print(my_function(3))
print(my_function(5))
print(my_function(9))
Die Ausgabe des obigen Codes lautet:
[1] 15
[1] 25
[1] 45
Verschachtelte Funktionen
Es gibt zwei Möglichkeiten, eine verschachtelte Funktion zu erstellen:
- Rufen Sie eine Funktion innerhalb einer anderen Funktion auf.
- Schreiben Sie eine Funktion innerhalb einer Funktion.
Beispiel
Aufruf einer Funktion innerhalb einer anderen Funktion:
Nested_function <- function(x, y) {
a <- x + y
return(a)
}
Nested_function(Nested_function(2,2), Nested_function(3,3))
Beispiel erklärt
Die Funktion weist x an, y hinzuzufügen.
Die erste Eingabe Nested_function(2,2) ist "x" der Hauptfunktion.
Die zweite Eingabe Nested_function(3,3) ist "y" der Hauptfunktion.
Die Ausgabe ist daher (2+2) + (3+3) = 10 .
Beispiel
Schreiben Sie eine Funktion innerhalb einer Funktion:
Outer_func <- function(x) {
Inner_func <- function(y) {
a <- x + y
return(a)
}
return
(Inner_func)
}
output <- Outer_func(3) # To
call the Outer_func
output(5)
Beispiel erklärt
Sie können die Funktion nicht direkt aufrufen, da Inner_func innerhalb von Outer_func definiert (verschachtelt) wurde.
Wir müssen zuerst Outer_func aufrufen, um im zweiten Schritt Inner_func aufzurufen.
Wir müssen eine neue Variable namens output erstellen und ihr einen Wert zuweisen, der hier 3 ist.
Wir drucken dann die Ausgabe mit dem gewünschten Wert von "y", der in diesem Fall 5 ist.
Die Ausgabe ist daher 8 (3 + 5).
Rekursion
R akzeptiert auch Funktionsrekursion, was bedeutet, dass eine definierte Funktion sich selbst aufrufen kann.
Rekursion ist ein allgemeines mathematisches und Programmierkonzept. Es bedeutet, dass eine Funktion sich selbst aufruft. Dies hat den Vorteil, dass Sie Daten durchlaufen können, um zu einem Ergebnis zu gelangen.
Der Entwickler sollte mit der Rekursion sehr vorsichtig sein, da es ziemlich einfach sein kann, eine Funktion zu schreiben, die niemals beendet wird, oder eine Funktion, die übermäßig viel Speicher oder Prozessorleistung verbraucht. Richtig geschrieben kann Rekursion jedoch ein sehr effizienter und mathematisch eleganter Programmieransatz sein.
In diesem Beispiel tri_recursion()ist eine Funktion, die wir so definiert haben, dass sie sich selbst aufruft ("recurse"). Wir verwenden die
kVariable als Daten, die bei -1jeder Rekursion dekrementiert ( ) wird. Die Rekursion endet, wenn die Bedingung nicht größer als 0 ist (dh wenn sie 0 ist).
Für einen neuen Entwickler kann es einige Zeit dauern, bis er herausfindet, wie genau dies funktioniert. Der beste Weg, dies herauszufinden, besteht darin, ihn zu testen und zu modifizieren.
Beispiel
tri_recursion <- function(k) {
if (k > 0) {
result <- k + tri_recursion(k - 1)
print(result)
} else {
result = 0
return(result)
}
}
tri_recursion(6)