Functies in R-programmering (met voorbeeld)

Inhoudsopgave:

Anonim

Wat is een functie in R?

Een functie , in een programmeeromgeving, is een reeks instructies. Een programmeur bouwt een functie om herhaling van dezelfde taak te voorkomen of om de complexiteit te verminderen .

Een functie zou moeten zijn

  • geschreven om een ​​bepaalde taak uit te voeren
  • kan al dan niet argumenten bevatten
  • bevatten een lichaam
  • kan wel of niet een of meer waarden retourneren.

Een algemene benadering van een functie is om het argumentgedeelte als invoer te gebruiken , het lichaamsdeel te voeden en uiteindelijk een uitvoer te retourneren . De syntaxis van een functie is de volgende:

function (arglist) {#Function body}

In deze tutorial zullen we leren

  • R belangrijke ingebouwde functies
  • Algemene functies
  • Wiskundige functies
  • Statistische functies
  • Schrijf functie in R
  • Wanneer moeten we de functie schrijven?
  • Functioneert met conditie

R belangrijke ingebouwde functies

Er zijn veel ingebouwde functies in R. R komt overeen met uw invoerparameters met zijn functieargumenten, hetzij op waarde of op positie, en voert vervolgens de functie uit. Functieargumenten kunnen standaardwaarden hebben: als u deze argumenten niet specificeert, neemt R de standaardwaarde.

Opmerking : het is mogelijk om de broncode van een functie te zien door de naam van de functie zelf in de console uit te voeren.

We zullen drie functiegroepen in actie zien

  • Algemene functie
  • Wiskundige functie
  • Statistische functie

Algemene functies

We zijn al bekend met algemene functies zoals cbind (), rbind (), range (), sort (), order () functies. Elk van deze functies heeft een specifieke taak, heeft argumenten nodig om een ​​uitvoer te retourneren. Hieronder volgen belangrijke functies die u moet weten:

diff () functie

Als u aan tijdreeksen werkt , moet u de reeks stationair houden door hun vertragingswaarden te nemen . Een stationair proces maakt een constante gemiddelde, variantie en autocorrelatie in de tijd mogelijk. Dit verbetert vooral de voorspelling van een tijdreeks. Het kan eenvoudig worden gedaan met de functie diff (). We kunnen willekeurige tijdreeksgegevens met een trend opbouwen en vervolgens de functie diff () gebruiken om de reeks te stationeren. De functie diff () accepteert één argument, een vector, en retourneert een geschikt vertraagd en herhaald verschil.

Opmerking : we moeten vaak willekeurige gegevens creëren, maar om te leren en te vergelijken willen we dat de getallen op alle machines identiek zijn. Om ervoor te zorgen dat we allemaal dezelfde gegevens genereren, gebruiken we de functie set.seed () met willekeurige waarden van 123. De functie set.seed () wordt gegenereerd door het proces van een pseudowillekeurige nummergenerator die ervoor zorgt dat elke moderne computer dezelfde reeks heeft van nummers. Als we de functie set.seed () niet gebruiken, hebben we allemaal een andere reeks getallen.

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),)

length () functie

In veel gevallen willen we de lengte van een vector weten voor berekening of voor gebruik in een for-lus. De functie length () telt het aantal rijen in vector x. De volgende codes importeren de autodataset en retourneren het aantal rijen.

Opmerking : length () geeft het aantal elementen in een vector terug. Als de functie wordt doorgegeven aan een matrix of een dataframe, wordt het aantal kolommen geretourneerd.

dt <- cars## number columnslength(dt)

Uitgang:

## [1] 1
## number rowslength(dt[,1])

Uitgang:

## [1] 50

Wiskundige functies

R heeft een reeks wiskundige functies.

Operator Omschrijving
buikspieren (x) Neemt de absolute waarde van x
logboek (x, basis = y) Neemt de logaritme van x met grondtal y; als grondtal niet is opgegeven, retourneert de natuurlijke logaritme
exp (x) Retourneert de exponentiële waarde van x
sqrt (x) Retourneert de vierkantswortel van x
faculteit (x) Geeft als resultaat de faculteit van x (x!) 
# sequence of number from 44 to 55 both including incremented by 1x_vector <- seq(45,55, by = 1)#logarithmlog(x_vector)

Uitgang:

## [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)

Uitgang:

## [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)

Uitgang:

## [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

Statistische functies

De R-standaardinstallatie bevat een breed scala aan statistische functies. In deze tutorial kijken we kort naar de belangrijkste functie ...

Statistische basisfuncties

Operator

Omschrijving

gemiddelde (x)

Gemiddelde van x

mediaan (x)

Mediaan van x

var (x)

Variantie van x

sd (x)

Standaarddeviatie van x

schaal (x)

Standaardscores (z-scores) van x

kwantiel (x)

De kwartielen van x

samenvatting (x)

Samenvatting van x: gemiddelde, min, max enz ...

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

Uitgang:

## [1] 15.4
# Median speed of cars datasetmedian(speed)

Uitgang:

## [1] 15
# Variance speed of cars datasetvar(speed)

Uitgang:

## [1] 27.95918
# Standard deviation speed of cars datasetsd(speed)

Uitgang:

## [1] 5.287644
# Standardize vector speed of cars datasethead(scale(speed), 5)

Uitgang:

## [,1]## [1,] -2.155969## [2,] -2.155969## [3,] -1.588609## [4,] -1.588609## [5,] -1.399489
# Quantile speed of cars datasetquantile(speed)

Uitgang:

## 0% 25% 50% 75% 100%## 4 12 15 19 25
# Summary speed of cars datasetsummary(speed)

Uitgang:

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

Tot nu toe hebben we veel ingebouwde R-functies geleerd.

Opmerking : wees voorzichtig met de klasse van het argument, dwz numeriek, Booleaans of string. Als we bijvoorbeeld een stringwaarde moeten doorgeven, moeten we de string tussen aanhalingstekens plaatsen: "ABC".

Schrijf functie in R

Soms moeten we onze eigen functie schrijven omdat we een bepaalde taak moeten volbrengen en er geen kant-en-klare functie bestaat. Een door de gebruiker gedefinieerde functie omvat een naam , argumenten en een hoofdtekst .

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

Opmerking : het is een goede gewoonte om een ​​door de gebruiker gedefinieerde functie een andere naam te geven dan een ingebouwde functie. Het voorkomt verwarring.

Een argumentfunctie

In het volgende fragment definiëren we een eenvoudige vierkante functie. De functie accepteert een waarde en retourneert het kwadraat van de waarde.

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

Code Verklaring:

  • De functie heet square_function; het kan worden genoemd wat we willen.
  • Het ontvangt een argument "n". We hebben het type variabele niet gespecificeerd, zodat de gebruiker een geheel getal, een vector of een matrix kan doorgeven
  • De functie neemt de invoer "n" en geeft het kwadraat van de invoer terug.

    Als u klaar bent met het gebruiken van de functie, kunnen we deze verwijderen met de functie rm ().

# nadat u de functie heeft gemaakt 

rm(square_function)square_function

Op de console kunnen we een foutmelding zien: Fout: object 'square_function' niet gevonden om aan te geven dat de functie niet bestaat.

Omgeving Scoping

In R is de omgeving een verzameling objecten zoals functies, variabelen, dataframe, enz.

R opent een omgeving telkens wanneer Rstudio wordt gevraagd.

De omgeving op het hoogste niveau die beschikbaar is, is de globale omgeving , genaamd R_GlobalEnv. En we hebben de lokale omgeving.

We kunnen de inhoud van de huidige omgeving weergeven.

ls(environment())

Uitvoer

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

U kunt alle variabelen en functies zien die zijn gemaakt in de R_GlobalEnv.

De bovenstaande lijst zal voor u variëren op basis van de historische code die u in R Studio uitvoert.

Merk op dat n, het argument van de functie square_function niet in deze globale omgeving voorkomt .

Voor elke functie wordt een nieuwe omgeving gecreëerd. In het bovenstaande voorbeeld creëert de functie square_function () een nieuwe omgeving binnen de globale omgeving.

Laten we het volgende voorbeeld bestuderen om het verschil tussen mondiale en lokale omgeving te verduidelijken

Deze functie neemt een waarde x als argument en voegt deze toe aan y om buiten en binnen de functie te definiëren

De functie f retourneert de uitvoer 15. Dit komt doordat y is gedefinieerd in de globale omgeving. Elke variabele die in de globale omgeving is gedefinieerd, kan lokaal worden gebruikt. De variabele y heeft de waarde 10 tijdens alle functieaanroepen en is op elk moment toegankelijk.

Laten we eens kijken wat er gebeurt als de variabele y binnen de functie wordt gedefinieerd.

We moeten `y` verwijderen voordat we deze code uitvoeren met rm r

De uitvoer is ook 15 als we f (5) aanroepen, maar geeft een foutmelding als we proberen de waarde y af te drukken. De variabele y bevindt zich niet in de globale omgeving.

Ten slotte gebruikt R de meest recente variabeledefinitie om binnen de hoofdtekst van een functie te gaan. Laten we eens kijken naar het volgende voorbeeld:

R negeert de y-waarden die buiten de functie zijn gedefinieerd, omdat we expliciet een y-variabele hebben gemaakt in de hoofdtekst van de functie.

Multi argumenten functie

We kunnen een functie schrijven met meer dan één argument. Beschouw de functie genaamd "tijden". Het is een eenvoudige functie die twee variabelen vermenigvuldigt.

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

Uitgang:

## [1] 8

Wanneer moeten we de functie schrijven?

Datawetenschappers moeten veel repetitieve taken uitvoeren. Meestal kopiëren en plakken we stukjes code herhaaldelijk. Normalisatie van een variabele wordt bijvoorbeeld sterk aanbevolen voordat we een machine learning-algoritme uitvoeren. De formule om een ​​variabele te normaliseren is:

We weten al hoe we de functie min () en max () moeten gebruiken in R. We gebruiken de tibble-bibliotheek om het dataframe te maken. Tibble is tot dusver de handigste functie om vanaf nul een dataset te maken.

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),)

We gaan in twee stappen verder om de hierboven beschreven functie te berekenen. In de eerste stap zullen we een variabele maken met de naam c1_norm, wat de herschaling van c1 is. In stap twee kopiëren en plakken we de code van c1_norm en veranderen met c2 en c3.

Detail van de functie met de kolom c1:

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

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

Daarom kunnen we ze delen om de genormaliseerde waarde van kolom c1 te krijgen:

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

We kunnen c1_norm, c2_norm en c3_norm maken:

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)

Uitgang:

## [1] 0.3400113 0.4198788 0.8524394 0.4925860 0.5067991

Het werkt. We kunnen kopiëren en plakken

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

verander dan c1_norm in c2_norm en c1 in c2. We doen hetzelfde om c3_norm te maken

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))

We hebben de variabelen c1, c2 en c3 perfect herschaald.

Deze methode is echter vatbaar voor fouten. We kunnen kopiëren en vergeten de kolomnaam te wijzigen na het plakken. Daarom is het een goede gewoonte om een ​​functie te schrijven elke keer dat u dezelfde code meer dan twee keer moet plakken. We kunnen de code herschikken in een formule en deze aanroepen wanneer dat nodig is. Om onze eigen functie te schrijven, moeten we geven:

  • Naam: normaliseren.
  • het aantal argumenten: we hebben maar één argument nodig, dat is de kolom die we gebruiken in onze berekening.
  • Het lichaam: dit is gewoon de formule die we willen retourneren.

We zullen stap voor stap te werk gaan om de functie normaliseren te maken.

Stap 1) We maken de nominator , dat wil zeggen. In R kunnen we de nominator opslaan in een variabele zoals deze:

nominator <- x-min(x)

Stap 2) We berekenen de noemer: . We kunnen het idee van stap 1 repliceren en de berekening opslaan in een variabele:

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

Stap 3) We voeren de verdeling uit tussen de nominator en de noemer.

normalize <- nominator/denominator

Stap 4) Om waarde terug te geven aan de aanroepfunctie, moeten we normaliseren binnen return () doorgeven om de uitvoer van de functie te krijgen.

return(normalize)

Stap 5) We zijn klaar om de functie te gebruiken door alles in de beugel te wikkelen.

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)}

Laten we onze functie testen met de variabele c1:

normalize(data_frame$c1)

Het werkt perfect. We hebben onze eerste functie gecreëerd.

Functies zijn een uitgebreidere manier om een ​​repetitieve taak uit te voeren. We kunnen de normaliseerformule over verschillende kolommen gebruiken, zoals hieronder:

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)

Hoewel het voorbeeld eenvoudig is, kunnen we de kracht van een formule afleiden. De bovenstaande code is gemakkelijker te lezen en voorkomt vooral fouten bij het plakken van codes.

Functioneert met conditie

Soms moeten we voorwaarden in een functie opnemen om de code verschillende outputs te laten retourneren.

In Machine Learning-taken moeten we de dataset splitsen tussen een treinset en een testset. Met de treinset kan het algoritme leren van de gegevens. Om de prestaties van ons model te testen, kunnen we de testset gebruiken om de prestatiemaatstaf te retourneren. R heeft geen functie om twee datasets te maken. We kunnen onze eigen functie schrijven om dat te doen. Onze functie heeft twee argumenten en wordt split_data () genoemd. Het idee erachter is simpel, we vermenigvuldigen de lengte van de dataset (dwz het aantal waarnemingen) met 0,8. Als we bijvoorbeeld de dataset 80/20 willen splitsen, en onze dataset bevat 100 rijen, dan vermenigvuldigt onze functie 0,8 * 100 = 80. 80 rijen worden geselecteerd om onze trainingsdata te worden.

We zullen de gegevensset luchtkwaliteit gebruiken om onze door de gebruiker gedefinieerde functie te testen. De dataset van luchtkwaliteit heeft 153 rijen. We kunnen het zien met de onderstaande code:

nrow(airquality)

Uitgang:

## [1] 153

We gaan als volgt te werk:

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

Onze functie heeft twee argumenten. De argumenten-trein is een Booleaanse parameter. Als het is ingesteld op TRUE, maakt onze functie de treindataset aan, anders wordt de testdataset gemaakt.

We kunnen doorgaan zoals we deden met de functie normaliseren (). We schrijven de code alsof het maar een eenmalige code is en wikkelen dan alles met de voorwaarde in de body om de functie te creëren.

Stap 1:

We moeten de lengte van de dataset berekenen. Dit doe je met de functie nrow (). Nrow retourneert het totale aantal rijen in de gegevensset. We noemen de variabele lengte.

length<- nrow(airquality)length

Uitgang:

## [1] 153

Stap 2:

We vermenigvuldigen de lengte met 0,8. Het retourneert het aantal rijen dat moet worden geselecteerd. Het moet 153 * 0,8 = 122,4 zijn

total_row <- length*0.8total_row

Uitgang:

## [1] 122.4

We willen 122 rijen selecteren uit de 153 rijen in de luchtkwaliteitsdataset. We maken een lijst met waarden van 1 tot total_row. We slaan het resultaat op in de variabele split

split <- 1:total_rowsplit[1:5]

Uitgang:

## [1] 1 2 3 4 5

split kiest de eerste 122 rijen uit de dataset. We kunnen bijvoorbeeld zien dat onze variabele split de waarde 1, 2, 3, 4, 5 enzovoort verzamelt. Deze waarden vormen de index wanneer we de rijen selecteren die moeten worden geretourneerd.

Stap 3:

We moeten de rijen in de luchtkwaliteitsgegevensset selecteren op basis van de waarden die zijn opgeslagen in de splitvariabele. Dit doe je als volgt:

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

Uitgang:

##[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

Stap 4:

We kunnen de testgegevensset maken door de resterende rijen te gebruiken, 123: 153. Dit wordt gedaan door - voor de splitsing te gebruiken.

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

Uitgang:

##[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

Stap 5:

We kunnen de toestand in het lichaam van de functie creëren. Onthoud dat we een argumenttrein hebben die standaard een Booleaanse waarde is die is ingesteld op TRUE om de treinset te retourneren. Om de voorwaarde te creëren, gebruiken we de if-syntaxis:

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

Dit is het, we kunnen de functie schrijven. We hoeven alleen luchtkwaliteit te veranderen in df omdat we onze functie willen proberen op elk dataframe, niet alleen op luchtkwaliteit:

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)}}

Laten we onze functie uitproberen op de luchtkwaliteitsdataset. we zouden een treinset moeten hebben met 122 rijen en een testset met 31 rijen.

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

Uitgang:

## [1] 122 6
test <- split_data(airquality, train = FALSE)dim(test)

Uitgang:

## [1] 31 6