Funcții în programarea R (cu exemplu)

Ce este o funcție în R?

O funcție , într-un mediu de programare, este un set de instrucțiuni. Un programator construiește o funcție pentru a evita repetarea aceleiași sarcini sau pentru a reduce complexitatea.

O funcție ar trebui să fie

• scris pentru a îndeplini o sarcini specificate
• poate include sau nu argumente
• conține un corp
• poate sau nu să returneze una sau mai multe valori.

O abordare generală a unei funcții este de a folosi partea argument ca intrări , de a alimenta partea corpului și, în cele din urmă, de a returna o ieșire . Sintaxa unei funcții este următoarea:

function (arglist) {#Function body}

În acest tutorial, vom învăța

• R funcții încorporate importante
• Funcții generale
• Funcții matematice
• Funcții statistice
• Funcția de scriere în R
• Când ar trebui să scriem funcția?
• Funcții cu condiție

R funcții încorporate importante

Există o mulțime de funcții încorporate în R. R corespunde parametrilor de intrare cu argumentele funcției sale, fie după valoare, fie după poziție, apoi execută corpul funcției. Argumentele funcționale pot avea valori implicite: dacă nu specificați aceste argumente, R va lua valoarea implicită.

Notă : Este posibil să vedeți codul sursă al unei funcții executând numele funcției în consolă.

Vom vedea trei grupuri de funcții în acțiune

• Funcția generală
• Funcția matematică
• Funcția statistică

Funcții generale

Suntem deja familiarizați cu funcțiile generale precum funcțiile cbind (), rbind (), range (), sort (), order (). Fiecare dintre aceste funcții are o sarcină specifică, ia argumente pentru a returna o ieșire. Următoarele sunt funcții importante pe care trebuie să le cunoașteți-

funcția diff ()

Dacă lucrați la serii cronologice , trebuie să staționați seria luând valorile lor de întârziere . Un proces staționar permite media constantă, varianța și autocorelația în timp. Acest lucru îmbunătățește în principal predicția unei serii cronologice. Poate fi realizat cu ușurință cu funcția diff (). Putem construi o serie de date aleatorii cu o tendință și apoi folosim funcția diff () pentru a staționa seria. Funcția diff () acceptă un argument, un vector și returnează diferența adecvată întârziată și iterată.

Notă : Adesea trebuie să creăm date aleatorii, dar pentru învățare și comparație dorim ca numerele să fie identice între mașini. Pentru a ne asigura că toți generăm aceleași date, folosim funcția set.seed () cu valori arbitrare de 123. Funcția set.seed () este generată prin procesul de generare de numere pseudorandom care fac ca toate computerele moderne să aibă aceeași secvență de numere. Dacă nu folosim funcția set.seed (), vom avea cu toții o succesiune diferită de numere.

set.seed(123)## Create the datax = rnorm(1000)ts <- cumsum(x)## Stationary the seriediff_ts <- diff(ts)par(mfrow=c(1,2))## Plot the seriesplot(ts,)plot(diff(ts),)

funcția length ()

În multe cazuri, vrem să știm lungimea unui vector pentru calcul sau să fie utilizat într-o buclă for. Funcția length () contorizează numărul de rânduri din vectorul x. Următoarele coduri importă setul de date pentru mașini și returnează numărul de rânduri.

Notă : length () returnează numărul de elemente dintr-un vector. Dacă funcția este trecută într-o matrice sau un cadru de date, se returnează numărul de coloane.

dt <- cars## number columnslength(dt)

Ieșire:

## [1] 1

## number rowslength(dt[,1])

Ieșire:

## [1] 50

Funcții matematice

R are o serie de funcții matematice.

Operator	Descriere
abs (x)	Ia valoarea absolută a lui x
jurnal (x, bază = y)	Ia logaritmul lui x cu baza y; dacă baza nu este specificată, returnează logaritmul natural
exp (x)	Returnează exponențialul lui x
sqrt (x)	Returnează rădăcina pătrată a lui x
factorial (x)	Returnează factorialul lui x (x!)

# sequence of number from 44 to 55 both including incremented by 1x_vector <- seq(45,55, by = 1)#logarithmlog(x_vector)

Ieșire:

## [1] 3.806662 3.828641 3.850148 3.871201 3.891820 3.912023 3.931826## [8] 3.951244 3.970292 3.988984 4.007333

#exponentialexp(x_vector)

#squared rootsqrt(x_vector)

Ieșire:

## [1] 6.708204 6.782330 6.855655 6.928203 7.000000 7.071068 7.141428## [8] 7.211103 7.280110 7.348469 7.416198

#factorialfactorial(x_vector)

Ieșire:

## [1] 1.196222e+56 5.502622e+57 2.586232e+59 1.241392e+61 6.082819e+62## [6] 3.041409e+64 1.551119e+66 8.065818e+67 4.274883e+69 2.308437e+71## [11] 1.269640e+73

Funcții statistice

Instalarea standard R conține o gamă largă de funcții statistice. În acest tutorial, vom analiza pe scurt cea mai importantă funcție ...

Funcții statistice de bază

Operator	Descriere
medie (x)	Media x
mediană (x)	Mediana lui x
var (x)	Varianța lui x
sd (x)	Abaterea standard a x
scară (x)	Scorurile standard (scorurile z) ale x
cuantil (x)	Cvartilele lui x
rezumat (x)	Rezumatul lui x: medie, min, maxim etc ...

speed <- dt$speedspeed# Mean speed of cars datasetmean(speed)

Ieșire:

## [1] 15.4

# Median speed of cars datasetmedian(speed)

Ieșire:

## [1] 15

# Variance speed of cars datasetvar(speed)

Ieșire:

## [1] 27.95918

# Standard deviation speed of cars datasetsd(speed)

Ieșire:

## [1] 5.287644

# Standardize vector speed of cars datasethead(scale(speed), 5)

Ieșire:

## [,1]## [1,] -2.155969## [2,] -2.155969## [3,] -1.588609## [4,] -1.588609## [5,] -1.399489

# Quantile speed of cars datasetquantile(speed)

Ieșire:

## 0% 25% 50% 75% 100%## 4 12 15 19 25

# Summary speed of cars datasetsummary(speed)

Ieșire:

## Min. 1st Qu. Median Mean 3rd Qu. Max.## 4.0 12.0 15.0 15.4 19.0 25.0

Până în acest moment, am învățat o mulțime de funcții încorporate R.

Notă : Aveți grijă la clasa argumentului, adică numerică, booleană sau șir. De exemplu, dacă trebuie să trecem o valoare șir, trebuie să includem șirul între ghilimele: „ABC”.

Funcția de scriere în R

În unele ocazii, trebuie să ne scriem propria funcție, deoarece trebuie să îndeplinim o anumită sarcină și nu există nicio funcție gata pregătită. O funcție definită de utilizator implică un nume , argumente și un corp .

function.name <- function(arguments){computations on the argumentssome other code}

Notă : O bună practică este de a denumi o funcție definită de utilizator diferită de o funcție încorporată. Evită confuzia.

O funcție de argument

În următorul fragment, definim o funcție pătrată simplă. Funcția acceptă o valoare și returnează pătratul valorii.

square_function<- function(n){# compute the square of integer `n`n^2}# calling the function and passing value 4square_function(4)

Explicatie cod:

• Funcția se numește funcție pătrată; se poate numi orice vrem.
• Primește un argument „n”. Nu am specificat tipul variabilei astfel încât utilizatorul să poată trece un număr întreg, un vector sau o matrice
• Funcția preia intrarea „n” și returnează pătratul intrării.

  Când ați terminat de utilizat funcția, o putem elimina cu funcția rm ().

# după ce creați funcția

rm(square_function)square_function

Pe consolă, putem vedea un mesaj de eroare: Eroare: obiectul „funcție_pătrat” nu a fost găsit spunând că funcția nu există.

Domeniul de aplicare al mediului

În R, mediul este o colecție de obiecte precum funcții, variabile, cadru de date etc.

R deschide un mediu de fiecare dată când este solicitat Rstudio.

Mediul de nivel superior disponibil este mediul global , numit R_GlobalEnv. Și avem mediul local.

Putem enumera conținutul mediului actual.

ls(environment())

Ieșire

## [1] "diff_ts" "dt" "speed" "square_function"## [5] "ts" "x" "x_vector"

Puteți vedea toate variabilele și funcțiile create în R_GlobalEnv.

Lista de mai sus va varia în funcție de codul istoric pe care îl executați în R Studio.

Rețineți că n, argumentul funcției square_function nu se află în acest mediu global .

Se creează un mediu nou pentru fiecare funcție. În exemplul de mai sus, funcția square_function () creează un mediu nou în interiorul mediului global.

Pentru a clarifica diferența dintre mediul global și local , să studiem următorul exemplu

Aceste funcții iau o valoare x ca argument și o adaugă la y definește în afara și în interiorul funcției

Funcția f returnează ieșirea 15. Acest lucru se datorează faptului că y este definit în mediul global. Orice variabilă definită în mediul global poate fi utilizată local. Variabila y are valoarea 10 în timpul tuturor apelurilor funcționale și este accesibilă în orice moment.

Să vedem ce se întâmplă dacă variabila y este definită în interiorul funcției.

Trebuie să renunțăm la „y” înainte de a rula acest cod folosind rm r

Ieșirea este, de asemenea, 15 când apelăm f (5), dar returnează o eroare atunci când încercăm să imprimăm valoarea y. Variabila y nu se află în mediul global.

În cele din urmă, R utilizează cea mai recentă definiție a variabilei pentru a trece în corpul unei funcții. Să luăm în considerare următorul exemplu:

R ignoră valorile y definite în afara funcției, deoarece am creat în mod explicit o variabilă ay în corpul funcției.

Funcția multi argumente

Putem scrie o funcție cu mai multe argumente. Luați în considerare funcția numită „ori”. Este o funcție simplă care înmulțește două variabile.

times <- function(x,y) {x*y}times(2,4)

Ieșire:

## [1] 8

Când ar trebui să scriem funcția?

Omul de știință al datelor trebuie să facă multe sarcini repetitive. De cele mai multe ori, copiem și lipim bucăți de cod în mod repetat. De exemplu, normalizarea unei variabile este foarte recomandată înainte de a rula un algoritm de învățare automată. Formula pentru normalizarea unei variabile este:

Știm deja cum să folosim funcțiile min () și max () în R. Folosim biblioteca tibble pentru a crea cadrul de date. Tibble este până acum cea mai convenabilă funcție pentru a crea un set de date de la zero.

library(tibble)# Create a data framedata_frame <- tibble(c1 = rnorm(50, 5, 1.5),c2 = rnorm(50, 5, 1.5),c3 = rnorm(50, 5, 1.5),)

Vom proceda în doi pași pentru a calcula funcția descrisă mai sus. În primul pas, vom crea o variabilă numită c1_norm, care este redimensionarea c1. La pasul doi, copiem și lipim codul c1_norm și schimbăm cu c2 și c3.

Detaliu al funcției cu coloana c1:

Nominalizator:: data_frame $ c1 -min (data_frame $ c1))

Denumitor: max (data_frame $ c1) -min (data_frame $ c1))

Prin urmare, le putem împărți pentru a obține valoarea normalizată a coloanei c1:

(data_frame$c1 -min(data_frame$c1))/(max(data_frame$c1)-min(data_frame$c1)) 

Putem crea c1_norm, c2_norm și c3_norm:

Create c1_norm: rescaling of c1data_frame$c1_norm <- (data_frame$c1 -min(data_frame$c1))/(max(data_frame$c1)-min(data_frame$c1))# show the first five valueshead(data_frame$c1_norm, 5)

Ieșire:

## [1] 0.3400113 0.4198788 0.8524394 0.4925860 0.5067991

Functioneaza. Putem copia și lipi

data_frame$c1_norm <- (data_frame$c1 -min(data_frame$c1))/(max(data_frame$c1)-min(data_frame$c1))

apoi schimbați c1_norm în c2_norm și c1 în c2. Facem același lucru pentru a crea c3_norm

data_frame$c2_norm <- (data_frame$c2 - min(data_frame$c2))/(max(data_frame$c2)-min(data_frame$c2))data_frame$c3_norm <- (data_frame$c3 - min(data_frame$c3))/(max(data_frame$c3)-min(data_frame$c3))

Am redescensionat perfect variabilele c1, c2 și c3.

Cu toate acestea, această metodă este predispusă la greșeli. Am putea copia și uita să schimbăm numele coloanei după lipire. Prin urmare, o practică bună este să scrieți o funcție de fiecare dată când trebuie să lipiți același cod de mai multe ori. Putem rearanja codul într-o formulă și îl putem apela ori de câte ori este nevoie. Pentru a scrie propria noastră funcție, trebuie să oferim:

• Nume: normalizare.
• numărul de argumente: avem nevoie doar de un argument, care este coloana pe care o folosim în calculul nostru.
• Corpul: aceasta este pur și simplu formula pe care vrem să o returnăm.

Vom continua pas cu pas pentru a crea funcția de normalizare.

Pasul 1) Creăm nominalizatorul , care este. În R, putem stoca nominalizatorul într-o variabilă ca aceasta:

nominator <- x-min(x)

Etapa 2) calculăm numitorul: . Putem replica ideea pasului 1 și putem stoca calculul într-o variabilă:

denominator <- max(x)-min(x)

Pasul 3) Efectuăm împărțirea între nominalizator și numitor.

normalize <- nominator/denominator

Pasul 4) Pentru a returna valoarea funcției de apelare, trebuie să trecem normalize în interiorul return () pentru a obține ieșirea funcției.

return(normalize)

Pasul 5) Suntem gata să folosim funcția înfășurând totul în paranteză.

normalize <- function(x){# step 1: create the nominatornominator <- x-min(x)# step 2: create the denominatordenominator <- max(x)-min(x)# step 3: divide nominator by denominatornormalize <- nominator/denominator# return the valuereturn(normalize)}

Să ne testăm funcția cu variabila c1:

normalize(data_frame$c1)

Functioneaza perfect. Am creat prima noastră funcție.

Funcțiile sunt o modalitate mai cuprinzătoare de a efectua o sarcină repetitivă. Putem folosi formula de normalizare pe diferite coloane, cum ar fi mai jos:

data_frame$c1_norm_function <- normalize (data_frame$c1)data_frame$c2_norm_function <- normalize (data_frame$c2)data_frame$c3_norm_function <- normalize (data_frame$c3)

Chiar dacă exemplul este simplu, putem deduce puterea unei formule. Codul de mai sus este mai ușor de citit și, în special, evita greșelile la lipirea codurilor.

Funcții cu condiție

Uneori, trebuie să includem condiții într-o funcție pentru a permite codului să returneze diferite ieșiri.

În sarcinile de învățare automată, trebuie să împărțim setul de date între un set de trenuri și un set de teste. Setul de trenuri permite algoritmului să învețe din date. Pentru a testa performanța modelului nostru, putem folosi setul de testare pentru a returna măsurarea performanței. R nu are o funcție pentru a crea două seturi de date. Ne putem scrie propria funcție pentru a face asta. Funcția noastră ia două argumente și se numește split_data (). Ideea din spatele este simplă, înmulțim lungimea setului de date (adică numărul de observații) cu 0,8. De exemplu, dacă dorim să împărțim setul de date 80/20, iar setul nostru de date conține 100 de rânduri, atunci funcția noastră se va înmulți 0,8 * 100 = 80. 80 de rânduri vor fi selectate pentru a deveni datele noastre de antrenament.

Vom folosi setul de date aer de calitate pentru a testa funcția definită de utilizator. Setul de date privind calitatea aerului are 153 de rânduri. O putem vedea cu codul de mai jos:

nrow(airquality)

Ieșire:

## [1] 153 

Vom proceda după cum urmează:

split_data <- function(df, train = TRUE)Arguments:-df: Define the dataset-train: Specify if the function returns the train set or test set. By default, set to TRUE

Funcția noastră are două argumente. Trenul de argumente este un parametru boolean. Dacă este setat la TRUE, funcția noastră creează setul de date de tren, altfel, creează setul de date de testare.

Putem continua așa cum am făcut-o și am funcția normalize (). Scriem codul ca și când ar fi fost doar un singur cod și apoi înfășurăm totul cu condiția în corp pentru a crea funcția.

Pasul 1:

Trebuie să calculăm lungimea setului de date. Acest lucru se face cu funcția nrow (). Nrow returnează numărul total de rânduri din setul de date. Numim lungimea variabilă.

length<- nrow(airquality)length

Ieșire:

## [1] 153

Pasul 2:

Înmulțim lungimea cu 0,8. Se va returna numărul de rânduri de selectat. Ar trebui să fie 153 * 0,8 = 122,4

total_row <- length*0.8total_row

Ieșire:

## [1] 122.4

Vrem să selectăm 122 de rânduri dintre cele 153 de rânduri din setul de date de calitate aeriană. Creăm o listă care conține valori de la 1 la total_row. Rezultatul îl stocăm în variabila numită split

split <- 1:total_rowsplit[1:5] 

Ieșire:

## [1] 1 2 3 4 5

split alege primele 122 de rânduri din setul de date. De exemplu, putem vedea că diviziunea noastră variabilă adună valoarea 1, 2, 3, 4, 5 și așa mai departe. Aceste valori vor fi indicele atunci când vom selecta rândurile de returnat.

Pasul 3:

Trebuie să selectăm rândurile din setul de date airquality pe baza valorilor stocate în variabila divizată. Acest lucru se face astfel:

train_df <- airquality[split, ]head(train_df)

Ieșire:

##[1] Ozone Solar.R Wind Temp Month Day##[2] 51 13 137 10.3 76 6 20##[3] 15 18 65 13.2 58 5 15##[4] 64 32 236 9.2 81 7 3##[5] 27 NA NA 8.0 57 5 27##[6] 58 NA 47 10.3 73 6 27##[7] 44 23 148 8.0 82 6 13

Pasul 4:

Putem crea setul de date de testare folosind rândurile rămase, 123: 153. Acest lucru se face folosind - în fața divizării.

test_df <- airquality[-split, ]head(test_df)

Ieșire:

##[1] Ozone Solar.R Wind Temp Month Day##[2] 123 85 188 6.3 94 8 31##[3] 124 96 167 6.9 91 9 1##[4] 125 78 197 5.1 92 9 2##[5] 126 73 183 2.8 93 9 3##[6] 127 91 189 4.6 93 9 4##[7] 128 47 95 7.4 87 9 5

Pasul 5:

Putem crea starea în corpul funcției. Amintiți-vă, avem un tren argument care este un set boolean setat la TRUE în mod implicit pentru a returna setul trenului. Pentru a crea condiția, folosim sintaxa if:

if (train ==TRUE){train_df <- airquality[split, ]return(train)} else {test_df <- airquality[-split, ]return(test)}

Acesta este, putem scrie funcția. Trebuie doar să schimbăm calitatea aerului în df, deoarece vrem să încercăm funcția noastră cu orice cadru de date, nu numai calitatea aerului:

split_data <- function(df, train = TRUE){length<- nrow(df)total_row <- length *0.8split <- 1:total_rowif (train ==TRUE){train_df <- df[split, ]return(train_df)} else {test_df <- df[-split, ]return(test_df)}}

Să încercăm funcția noastră pe setul de date de calitate aeriană. ar trebui să avem un set de trenuri cu 122 de rânduri și un set de testare cu 31 de rânduri.

train <- split_data(airquality, train = TRUE)dim(train)

Ieșire:

## [1] 122 6

test <- split_data(airquality, train = FALSE)dim(test)

Ieșire:

## [1] 31 6