Introduktion til For Loop
En tilstand for sløjfe udføres for at gøre det muligt for et sæt at gentage sig selv, indtil den krævede tilstand er nået. For loop er meget nyttige i tilfælde af, at et stort antal elementer eller heltal skal iteres. For loop kan bruges over dataramme, vektor eller ethvert objekt. I en situation, hvor man skal udføre en lignende funktion gentagne gange, for loop anvendes til at reducere indsatsen og tiden. Hvis det f.eks. Er påkrævet at udskrive 100 tilfældigt tal fra 1 til 1000, kan vi bruge for-loop-tilstanden til let at opnå dette uden at skulle bruge udskrivningsopgørelsen 100 gange. I dette emne skal vi lære om For Loop i R.
For Loop Syntax
Syntaks for loop i R svarer til python eller et hvilket som helst andet sprog. Nedenfor er syntaks for for loop i R.
Syntaks:
for (val in sequence) (
Statement
)
I ovenstående syntaks er vektoren repræsenteret ved sekvens, og val er værdien af vektoren under For Loop.
Lad os nu se den proces, der er foretaget af for loop-tilstand ved hjælp af flowdiagram. For hvert element i sekvensen gentager loopen sig, indtil den krævede betingelse er nået. Betingelsen kontrolleres, og når det sidste punkt er nået, findes der compiler.
Strukturen består af initialisering vist som "init", romb, der er beslutningskasse og rektangulær kasse, der er kroppen for en løkke. Mens der udføres et sæt kommandoer under for loop-tilstand, starter kompilatoren ikke løkken, før betingelsen er specificeret. Hvis der ikke er nogen betingelse tilgængelig, udføres den næste instruktion efter løkken. For hvert element i sekvensen matches betingelsen. Indtil betingelsen ikke matches, går løkken igen og igen. Når den sidste vare eller betingelsen er opfyldt, findes kompilatoren i løkken.
Hvordan fungerer loop i R?
Før vi lærer, hvordan For Loop fungerer i R, skal vi se, hvad en loop eller looping er. Sløjfe eller iteration, som dybest set er en instruktion til gentagelse, har sin oprindelse dateret længe tilbage. Kort sagt automatiserer det processen ved at gruppere visse krævede funktioner i en batch af dele. Det meste af det moderne programmeringssprog har en indbygget looping-funktion, der giver mulighed for at opbygge en funktion til automatisering. Sløjfefunktionerne kan opdeles i to dele, løkker, der kontrolleres og kan udføres, det ønskede antal gange falder ind under for sløjfefamilien. På den anden side falder de sløjfer, der er baseret på et sæt betingelser, under sløjfefamilien.
I denne artikel undersøger vi de forskellige metoder, der er tilgængelige i R med henblik på looping. Vi vil yderligere se på forskellige eksempler på looping ved hjælp af funktioner, der er tilgængelige i R-biblioteket. Når du arbejder på R-sprog. For loops er kun loopingbetingelser, du har brug for, sjældent kan der være behov for andre looping-forhold, f.eks. Lad os se, hvordan For loop bruges til at itereere over numeriske værdier.
# 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 ovenstående eksempel tages variablen "i" af løkken og itereres, indtil betingelsen er opfyldt. Udskrivning af variablen "i" inde i løkken giver os værdier fra 9 til 99. Lad os nu se et andet eksempel ved hjælp af 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 ovenstående eksempel udskriver vi ønskede elementer fra eksemplet. I det første eksempel kaldes fire elementer i sekvensen, hvorfor alle elementer er blevet udskrevet, når udskrivningssætningen er udført. I det andet eksempel er sekvensen kaldet indtil det tredje element, hvorfor de tre første elementer udskrives.
På den anden side findes der en tilstand, der kaldes gentagelsessløjfe, som har lignende funktionalitet som løkke. Imidlertid bruges gentagelsestilstand til at iterere over kode kontinuerligt uden en tilstandskontrol.
Brugeren skal definere en betingelse inde i løkken, og en "break" -angivelse skal bruges til at forlade loopen. Hvis du ikke bruger "break" -sætningen, vil det resultere i en uendelig loop.
# 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 ovenstående eksempel har vi specificeret betingelsen n == 16, så kompilatoren stopper loopen, når n == 6 er nået.
Til loopeksempler
At introducere For løkker i R lad os tage et eksempel på udtrækning af elementer eller genstande 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---"
Trin 1
Der er defineret vektor navngivne stater, der består af forskellige tilstande
> states <- c('Oregon', 'Florida', 'Texas', 'Lowa', 'Nebraska', 'Utah')
Trin 2
I det næste trin bruges for loop til at itereere over tilstandsvektoren og vise det individuelle navn på tilstande.
> for (str in states) (
+ print(paste("States in USA: ", str))
+ )
Da udskrivningsopgørelsen er inkluderet i loopen, får vi de ønskede resultater, og alle navnene på staterne udskrives. I det næste trin bruges en anden udskrivning uden for løkken, der praktisk talt udføres, når forløkken slutter.
Lad os nu se logikken bag hver iteration under udførelsen af koden.
- Under den første iteration State = Oregon er der elementer tilbage i vektoren. Derfor udskrives udskrivningen af kompilatoren inde i løkken.
- I løbet af den anden iteration, State = Florida, er der fire flere elementer tilbage i vektoren. Derfor udskrives udskrivningen af kompilatoren inde i løkken.
- Under den tredje iteration, State = Texas, er der endnu tre elementer tilbage i vektoren. Derfor udskrives udskrivningen af kompilatoren inde i løkken.
- Under den fjerde iteration, State = Lowa, er der endnu to elementer tilbage i vektoren. Derfor udskrives udskrivningen af kompilatoren inde i løkken.
- I løbet af den femte iteration, State = Nebraska, er der endnu et element tilbage i vektoren. Derfor udskrives udskrivningen af kompilatoren inde i løkken.
- Under den sjette iteration, State = Utah, kan der muligvis være elementer tilbage i vektoren. Derfor udskrives udskrivningen af kompilatoren inde i løkken.
- I løbet af den syvende iteration, da der ikke er flere elementer at tildele til tilstandsvariabel, vil kompilatoren forlade loopen.
I det næste eksempel, lad os se loop-funktionaliteten i tilfælde af heltal.
> num <- c(1:5)
>
> for (i in num) (
+ print(i)
+ )
(1) 1
(1) 2
(1) 3
(1) 4
(1) 5
Trin 1
Der er defineret en vektor, der hedder num, som består af heltal fra 1 til 5
> num <- c(1:5)
Trin 2
I det næste trin bruges for loop til at itereere over num vektor og vise de individuelle heltal.
> for (i in num) (
+ print(i)
+ )
Efterhånden som udskrivningsangivelsen er inkluderet i løkken, får vi de ønskede resultater, og alle heltalene fra vektoren numre udskrives.
Lad os nu se logikken bag hver iteration under udførelsen af koden.
- Under den første iteration, “1”, er der elementer tilbage i vektoren. Derfor udskrives udskrivningen af kompilatoren inde i løkken.
- Under den anden iteration, “2”, er der endnu tre elementer tilbage i vektoren. Derfor udskrives udskrivningen af kompilatoren inde i løkken.
- Under den tredje iteration, “3”, er der endnu to elementer tilbage i vektoren. Derfor udskrives udskrivningen af kompilatoren inde i løkken.
- Under den fjerde iteration, “4”, er der stadig et element tilbage i vektoren. Derfor udskrives udskrivningen af kompilatoren inde i løkken.
- Under den femte iteration ”5” kan der muligvis være elementer tilbage i vektoren. Derfor udskrives udskrivningen af kompilatoren inde i løkken.
- I løbet af den sjette iteration, da der ikke er flere elementer, der skal tildeles til den numeriske variabel, vil kompilatoren forlade loopen.
Konklusion - For Loop i R
I denne artikel har vi set, hvordan en loop-tilstand kan udføres ved hjælp af R, R-studio er blevet brugt til at udføre ovenstående operationer, og resultaterne er blevet vist. Vi har yderligere set et eksempel på udtrækning af elementer eller genstande fra vektoren, og evaluering for hvert trin er undersøgt i artiklen.
Anbefalede artikler
Dette er en vejledning til For Loop i R. Her diskuterer vi hvordan loop fungerer i R med de passende eksempler og syntaks. Du kan også se på de følgende artikler for at lære mere -
- For Loop i Python
- C # For sløjfe
- Loops i Java-programmering
- Sløjfer i R
- For Loop i C