For Loop in R - How For Loop Works in R sammen med eksempler og syntaks

Innholdsfortegnelse:

Anonim

Introduksjon til For Loop

En For Loop-tilstand utføres for å gjøre det mulig for et sett å gjenta seg selv til den nødvendige tilstanden er nådd. For sløyfe er veldig nyttige i tilfelle, et stort utvalg av elementer eller heltall må iteres. For loop kan brukes over dataramme, vektor eller hvilket som helst objekt. I en situasjon hvor man må utføre en lignende funksjon gjentatte ganger, for loop brukes til å redusere innsatsen og tiden. For eksempel, hvis det kreves å skrive ut 100 tilfeldig tall fra 1 til 1000, kan vi bruke for-loop-tilstanden for å enkelt oppnå dette uten å måtte bruke utskriftsoppgaven 100 ganger. I dette emnet skal vi lære om For Loop i R.

For Loop Syntax

Syntaks for for loop i R ligner på python eller andre språk. Nedenfor er syntaks for for loop i R.

syntaks:

for (val in sequence) (
Statement
)

I ovenstående syntaks er vektoren representert ved sekvens og val er verdien av vektoren under For Loop.

La oss nå se prosessen som er utført for sløyfetilstand ved hjelp av flytskjema. For hvert element i sekvensen gjentar loopen seg selv til ønsket betingelse er nådd. Tilstanden blir sjekket, og når det siste elementet er nådd finnes kompilatoren.

Strukturen består av initialisering vist som "init", romb som er avgjørelsesboks og rektangulær boks som er kroppen til for en løkke. Når du utfører et sett med kommandoer under for loop-tilstand, starter ikke kompilatoren loopen før tilstanden er spesifisert. Hvis det ikke er noen betingelse tilgjengelig, vil neste instruksjon etter løkken bli utført. For hvert element i sekvensen blir betingelsen matchet. Inntil tilstanden ikke stemmer overens, går loopen om og om igjen. Når det siste elementet eller betingelsen er oppfylt, eksisterer kompilatoren i løkken.

Hvordan fungerer Loop i R?

Før vi lærer hvordan For Loop fungerer i R, la oss se hva en loop eller looping er. Sløyfe eller iterasjon, som i utgangspunktet er en instruksjon for å gjenta, har sin opprinnelse datert lenge tilbake. Enkelt sagt automatiserer det prosessen ved å gruppere visse nødvendige funksjoner i en rekke deler. Det meste av det moderne programmeringsspråket har en innebygd looping-funksjon som gjør det mulig å bygge en funksjon for automatisering. Løyfefunksjonene kan deles i to deler, løkker som er kontrollert og kan utføres, ønsket antall ganger faller under for sløyfe-familien. På den annen side faller løkkene som er basert på et sett av forhold under sløyfefamilien.

I denne artikkelen skal vi undersøke de forskjellige metodene som er tilgjengelige i R for å sløyfe. Vi vil videre se på forskjellige eksempler på looping ved å bruke funksjoner som er tilgjengelige i R-biblioteket. Når du jobber i R-språk For sløyfer er det bare loopforhold du vil trenge, sjelden kan det være behov for andre loopingforhold som for eksempel. La oss se hvordan For loop brukes til å itereere over numeriske verdier.

# for printing number from 9 to 99 usinf for loop
> for(i in 9:99)(
+ print(i)
+ )
(1) 9
(1) 10
(1) 11
(1) 12
(1) 13
(1) 14
(1) 15
(1) 16
(1) 17
(1) 18
(1) 19
(1) 20
(1) 21

I eksemplet over blir variabelen "i" tatt av sløyfen og iterert til betingelsen er oppfylt. Å skrive ut variabelen “i” inne i løkken gir oss verdier fra 9 til 99. La oss se et annet eksempel ved å bruke tegn.

# for printing and looping items in example vector
> example <- c("cat", "dog", "bill", "base")
> for(i in 1:4)
+ (
+
+ print(example(i))
+ )
(1) "cat"
(1) "dog"
(1) "bill"
(1) "base"
# In case we don't want the entire loop to be executed
# loop can be stopped with the help of break condition
# In the below example the fourth element will not be printed.
> example <- c("cat", "dog", "bill", "base")
> for(i in 1:3)
+ (
+
+ print(example(i))
+ )
(1) "cat"
(1) "dog"
(1) "bill"

I eksemplet over skriver vi ut ønskede elementer fra eksemplet. I det første eksemplet blir fire elementer kalt ut i sekvensen, og dermed er alle elementene skrevet ut når utskriftsoppgaven er blitt utført. I det andre eksemplet har sekvensen blitt kalt til det tredje elementet, derav er de tre første elementene skrevet ut.

På den annen side eksisterer det en tilstand som kalles repetisjonssløyfe, som har lignende funksjonalitet som sløyfen. Imidlertid brukes gjentatt betingelse for å iterere over kode kontinuerlig uten en tilstandskontroll.

Brukeren må definere en tilstand inne i løkken, og en "break" -erklæring må brukes for å gå ut av løkken. Unnlatelse av å bruke "break" -uttalelsen vil føre til en uendelig sløyfe.

# illustrating repeat statement to print numbers from 5 to 15
> n <- 5
> repeat
+ (
+ print(n)
+ n = n+1
+ if (n == 16)(
+ break
+ )
+ )
(1) 5
(1) 6
(1) 7
(1) 8
(1) 9
(1) 10
(1) 11
(1) 12
(1) 13
(1) 14
(1) 15

I eksemplet over har vi spesifisert tilstanden n == 16 slik at kompilatoren stopper sløyfen når n == 6 er nådd.

For sløyfeeksempler

For å introdusere For looper i R kan vi ta et eksempel på å trekke ut elementer eller elementer fra vektoren.

> states <- c('Oregon', 'Florida', 'Texas', 'Lowa', 'Nebraska', 'utah')
>
>
> for (str in states) (
+ print(paste("States in USA: ", str))
+ )
(1) "States in USA: Oregon"
(1) "States in USA: Florida"
(1) "States in USA: Texas"
(1) "States in USA: Lowa"
(1) "States in USA: Nebraska"
(1) "States in USA: utah"
# to illustrate the print operation outside the loop
> print("----prints outside the loop---")
(1) "----prints outside the loop---"

Trinn 1

Vector navngitte stater er definert som består av forskjellige tilstander

> states <- c('Oregon', 'Florida', 'Texas', 'Lowa', 'Nebraska', 'Utah')

Steg 2

I neste trinn brukes for loop til å iterere over tilstandsvektoren og vise individuelle navn på tilstandene.

> for (str in states) (
+ print(paste("States in USA: ", str))
+ )

Ettersom utskriftserklæringen er inkludert i loopen, får vi de ønskede resultatene og alle navnene på statene skrives ut. I det neste trinnet brukes en annen uttalelse utenfor loopen som praktisk talt kjøres når forløkken slutter.

La oss nå se logikken bak hver iterasjon under utførelsen av koden.

  1. Under den første iterasjonen, State = Oregon, er det elementer igjen i vektoren. Derfor utskrives uttalelsen av kompilatoren inne i løkken.
  2. I løpet av den andre iterasjonen State = Florida er det fire elementer til som gjenstår i vektoren. Derfor utskrives uttalelsen av kompilatoren inne i løkken.
  3. I løpet av den tredje iterasjonen, State = Texas, er det tre elementer igjen i vektoren. Derfor utskrives uttalelsen av kompilatoren inne i løkken.
  4. Under den fjerde iterasjonen, State = Lowa, er det to elementer som gjenstår i vektoren. Derfor utskrives uttalelsen av kompilatoren inne i løkken.
  5. I løpet av den femte iterasjonen, State = Nebraska, er det et annet element igjen i vektoren. Derfor utskrives uttalelsen av kompilatoren inne i løkken.
  6. I løpet av den sjette iterasjonen, State = Utah, kan det være elementer som er igjen i vektoren. Derfor utskrives uttalelsen av kompilatoren inne i løkken.
  7. I løpet av den syvende iterasjonen, siden det ikke er flere elementer å tildele for tilstandsvariabel, vil kompilatoren forlate sløyfen.

I det neste eksemplet, la oss se loopfunksjonaliteten når det gjelder heltal.

> num <- c(1:5)
>
> for (i in num) (
+ print(i)
+ )
(1) 1
(1) 2
(1) 3
(1) 4
(1) 5

Trinn 1

Vektor med navnet num er definert som består av heltal fra 1 til 5

> num <- c(1:5)

Steg 2

I neste trinn brukes for loop til å iterere over num vektor og vise de enkelte heltall.

> for (i in num) (
+ print(i)
+ )

Ettersom utskriftsuttalelsen er inkludert i løkken, får vi de ønskede resultatene og alle heltalene fra vektoren num skrives ut.

La oss nå se logikken bak hver iterasjon under utførelsen av koden.

  1. Under den første iterasjonen, “1”, er det elementer igjen i vektoren. Derfor utskrives uttalelsen av kompilatoren inne i løkken.
  2. I løpet av den andre iterasjonen, “2”, er det tre elementer igjen i vektoren. Derfor utskrives uttalelsen av kompilatoren inne i løkken.
  3. I løpet av den tredje iterasjonen, “3”, er det ytterligere to elementer igjen i vektoren. Derfor utskrives uttalelsen av kompilatoren inne i løkken.
  4. I løpet av den fjerde iterasjonen, “4”, er det fortsatt ett element igjen i vektoren. Derfor utskrives uttalelsen av kompilatoren inne i løkken.
  5. I løpet av den femte iterasjonen ”5”, kan det være elementer som er igjen i vektoren. Derfor utskrives uttalelsen av kompilatoren inne i løkken.
  6. I løpet av den sjette iterasjonen, siden det ikke er flere elementer å tildele for variabelen num vil kompilatoren forlate sløyfen.

Konklusjon - For Loop i R

I denne artikkelen har vi sett hvordan for loop-tilstand kan utføres ved bruk av R, R-studio har blitt brukt til å utføre operasjonene ovenfor, og resultatene er blitt vist. Vi har videre sett et eksempel på å trekke ut elementer eller elementer fra vektoren og evaluering for hvert trinn har blitt undersøkt i artikkelen.

Anbefalte artikler

Dette er en guide til For Loop i R. Her diskuterer vi hvordan for loop fungerer i R med passende eksempler og syntaks. Du kan også se på følgende artikler for å lære mer -

  1. For Loop in Python
  2. C # For Loop
  3. Looper i Java-programmering
  4. Looper i R
  5. For Loop i C