Funzioni R
Una funzione è un blocco di codice che viene eseguito solo quando viene chiamata.
È possibile passare dati, noti come parametri, in una funzione.
Una funzione può restituire dati come risultato.
Creazione di una funzione
Per creare una funzione, utilizzare la function()parola chiave:
Esempio
my_function <- function() { # create a function with the name my_function
print("Hello World!")
}
Chiama una funzione
Per chiamare una funzione, usa il nome della funzione seguito da parentesi, come my_function() :
Esempio
my_function <- function() {
print("Hello World!")
}
my_function() # call the function named my_function
argomenti
Le informazioni possono essere passate alle funzioni come argomenti.
Gli argomenti sono specificati dopo il nome della funzione, tra parentesi. Puoi aggiungere tutti gli argomenti che vuoi, separandoli semplicemente con una virgola.
L'esempio seguente ha una funzione con un argomento (fname). Quando la funzione viene chiamata, si passa un nome, che viene utilizzato all'interno della funzione per stampare il nome completo:
Esempio
my_function <- function(fname) {
paste(fname, "Griffin")
}
my_function("Peter")
my_function("Lois")
my_function("Stewie")
Parametri o argomenti?
I termini "parametro" e "argomento" possono essere usati per la stessa cosa: informazioni che vengono passate in una funzione.
Dal punto di vista di una funzione:
Un parametro è la variabile elencata tra parentesi nella definizione della funzione.
Un argomento è il valore che viene inviato alla funzione quando viene chiamata.
Numero di argomenti
Per impostazione predefinita, una funzione deve essere chiamata con il numero corretto di argomenti. Ciò significa che se la tua funzione prevede 2 argomenti, devi chiamare la funzione con 2 argomenti, non più e non meno:
Esempio
Questa funzione prevede 2 argomenti e ottiene 2 argomenti:
my_function <- function(fname, lname) {
paste(fname, lname)
}
my_function("Peter", "Griffin")
Se provi a chiamare la funzione con 1 o 3 argomenti, otterrai un errore:
Esempio
Questa funzione prevede 2 argomenti e ottiene 1 argomento:
my_function <- function(fname, lname) {
paste(fname, lname)
}
my_function("Peter")
Valore parametro predefinito
L'esempio seguente mostra come utilizzare un valore di parametro predefinito.
Se chiamiamo la funzione senza un argomento, utilizza il valore predefinito:
Esempio
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")
Valori di ritorno
Per consentire a una funzione di restituire un risultato, utilizzare la return()funzione:
Esempio
my_function <- function(x) {
return (5 * x)
}
print(my_function(3))
print(my_function(5))
print(my_function(9))
L'output del codice sopra sarà:
[1] 15
[1] 25
[1] 45
Funzioni annidate
Esistono due modi per creare una funzione nidificata:
- Chiama una funzione all'interno di un'altra funzione.
- Scrivi una funzione all'interno di una funzione.
Esempio
Chiama una funzione all'interno di un'altra funzione:
Nested_function <- function(x, y) {
a <- x + y
return(a)
}
Nested_function(Nested_function(2,2), Nested_function(3,3))
Esempio spiegato
La funzione dice a x di aggiungere y.
Il primo input Nested_function(2,2) è "x" della funzione principale.
Il secondo input Nested_function(3,3) è "y" della funzione principale.
L'uscita è quindi (2+2) + (3+3) = 10 .
Esempio
Scrivi una funzione all'interno di una funzione:
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)
Esempio spiegato
Non puoi chiamare direttamente la funzione perché Inner_func è stato definito (nidificato) all'interno di Outer_func.
Dobbiamo chiamare prima Outer_func per chiamare Inner_func come secondo passaggio.
Dobbiamo creare una nuova variabile chiamata output e assegnarle un valore, che qui è 3.
Quindi stampiamo l'output con il valore desiderato di "y", che in questo caso è 5.
L'uscita è quindi 8 (3 + 5).
ricorsione
R accetta anche la ricorsione della funzione, il che significa che una funzione definita può chiamare se stessa.
La ricorsione è un concetto matematico e di programmazione comune. Significa che una funzione chiama se stessa. Questo ha il vantaggio di significare che puoi scorrere i dati per raggiungere un risultato.
Lo sviluppatore dovrebbe prestare molta attenzione con la ricorsione in quanto può essere abbastanza facile inserire nella scrittura una funzione che non termina mai o una che utilizza quantità eccessive di memoria o potenza del processore. Tuttavia, se scritta correttamente, la ricorsione può essere un approccio alla programmazione molto efficiente e matematicamente elegante.
In questo esempio, tri_recursion()è una funzione che abbiamo definito per chiamare se stessa ("ricorrenza"). Usiamo la
kvariabile come dati, che diminuisce ( -1) ogni volta che ricorriamo. La ricorsione termina quando la condizione non è maggiore di 0 (cioè quando è 0).
Per un nuovo sviluppatore può volerci del tempo per capire come funziona esattamente, il modo migliore per scoprirlo è testarlo e modificarlo.
Esempio
tri_recursion <- function(k) {
if (k > 0) {
result <- k + tri_recursion(k - 1)
print(result)
} else {
result = 0
return(result)
}
}
tri_recursion(6)