R voor SEO Deel 7: Loops

Welkom terug bij mijn R for SEO-serie. We zijn nu in de laatste rechte lijn, met deel zeven. Vandaag gaan we kijken naar verschillende manieren waarop we functies of opdrachten kunnen uitvoeren over een reeks elementen met behulp van de verschillende soorten lussen die in R bestaan.

Als je tot nu toe hebt meegevolgd, of als je zelf wat hebt geëxperimenteerd, ben je waarschijnlijk loops en applys tegengekomen. Ik weet dat het in het begin van mijn R-reis heel erg op potluck leek welke apply ik moest gebruiken, of dat een loop makkelijker was, dus hopelijk zal het stuk van vandaag dat een beetje voor je verduidelijken.

Ik weet dat de meeste programmeercursussen deze elementen al eerder behandelen, maar voor mij drong het pas echt tot me door toen ik meer te weten kwam over de andere onderwerpen die we in deze serie hebben behandeld. Daarom heb ik het hier geplaatst.

Als u dit artikel nuttig vindt, deel het dan op uw sociale netwerken en meld u aan voor mijn gratis e-mailupdates. Zo wordt u op de hoogte gehouden wanneer ik mijn volgende artikel publiceer.

Wat is een lus?

Een lus in R is min of meer wat de naam al doet vermoeden: een opdracht die een bepaalde code blijft uitvoeren totdat een bepaalde voorwaarde deze stopt.

Vandaag gaan we twee hoofdtypen bekijken: de for-lus en de while-lus.

Voordat we ingaan op de werking, kijken we eerst wat de twee verschillende lussen doen en waarvoor ze gebruikt worden.

• De for-lus: De for-lus is de meest gebruikte in R en werkt geweldig als u een gedefinieerde vector of dataset hebt waarover u uw opdrachten wilt uitvoeren, of als u weet hoe vaak u deze wilt uitvoeren
• De while-lus: De while-lus blijft draaien zolang aan een bepaalde voorwaarde is voldaan, of het nu een bepaalde waarde, luslengte of zelfs tijdsbestek is. Ze zijn erg handig

De For-lus in R

Als je bekend bent met andere programmeertalen zoals Python, dan is de eenvoudige for-lus vast iets voor jou. In R zijn ze echter niet minder krachtig.

Laten we hieronder een heel eenvoudige for-lus samenstellen, waarbij we onze Google Search Console-gegevens van de laatste paar stukken doorlopen (de tutorial staat in deel 2). We gaan deze lus gebruiken om het aantal zoekwoorden te tellen dat 20 of meer vertoningen heeft.

Eerst willen we een object met de naam kwCount maken en we gaan de waarde ervan op nul zetten, zoals hier:

kwCount 



Now to create our loop:



for (val in gsc$Impressions){
  if(val >= 20)  kwCount = kwCount+1
}
Oké, laten we het eens opsplitsen.
De For-lus in R uitgelegd
Er zijn veel mogelijkheden met lussen, en dit is slechts een heel eenvoudig voorbeeld. Ze volgen allemaal hetzelfde algemene proces.

voor (val in gsc$Impressions){: We beginnen onze lus met “for” en zeggen dat voor elke waarde in gsc$Impressions, de opdracht binnen onze accolades moet worden uitgevoerd. Er zijn een aantal verschillende manieren waarop lussen kunnen worden gebruikt, en ik zal er onderweg nog een paar laten zien, maar de anatomie is altijd vergelijkbaar
als(waarde >= 20) kwCount = kwCount+1}: Zoals we zagen in onze R if statements tutorial, bevatten onze accolades onze commando’s. In dit simpele voorbeeld gebruiken we een kleine if statement, die zegt dat als de waarde groter is dan of gelijk is aan 20, deze moet worden toegevoegd aan onze kwCount vector als een numerieke waarde van plus 1

Zoals u kunt zien, is dit een heel eenvoudige for-lus met behulp van R. Net als in ons stuk over R-functies, hoeven we niet strikt behoefte een lus hiervoor, maar het is een eenvoudige manier om je de anatomie te laten zien.
Als u nu kwCount in uw console typt, ziet u het totale aantal Google Search Console-query’s dat groter is dan of gelijk is aan 20 vertoningen. In mijn geval krijgt u het volgende:

Andere For Loop-methoden
In ons vorige voorbeeld gebruikten we een eenvoudige val in methode voor onze for-lus, maar er zijn er nog veel meer.
Persoonlijk gebruik ik loops veel vaker op lijsten of vectoren, dus ik gebruik onderweg ook wat alternatieven. Laten we er eens een paar bekijken:
For-lussen gebruiken in een lijst
Laten we een for-lus gebruiken om een ​​subset van onze Google Search Console te maken die alleen rijen bevat met 20 of meer vertoningen. Nogmaals, een lus is hier overdreven, maar het is een goed voorbeeld.
Eerst willen we ons dataframe maken om onze data te hosten. Laten we dat kw20 noemen.
kw20 



Now our for loop is as follows:



for (i in seq_along(gsc)) {
  if (gsc$Impressions(i) >= 20) {
    kw20 



Fairly self-explanatory, isn’t it? But, as always, let’s break it down:





voor (i in seq_along(gsc)){: Zoals eerder roepen we onze for-lus aan, maar er is hier een belangrijk verschil. We gebruiken “i in seq_along(gsc)”, wat betekent “voor deze waarde (i) in de sequentie langs onze lijst van ons gsc-object, willen we doen wat er in onze accolades staat”
als (gsc$Impressions(i) >= 20){: We gebruiken een if-instructie om te zien of de waarde in onze lijst waar we naar (i) lussen groter is dan of gelijk is aan 20, om onze volgende actie in de accolades uit te voeren
kw20 Laten we het met onze actie naar huis brengen. Onze lus zal een rij (i) nemen die overeenkomt met de voorwaarden die we in de vorige opdracht hebben ingesteld en met behulp van rbind zal het deel uitmaken van ons kw20-frame

Als we onze dataset alleen maar op basis van deze voorwaarden wilden subsetten, zouden we uiteraard gewoon subset gebruiken zoals we in deel 1 zagen. Het zou dan erg inefficiënt zijn om deze lus met rbind te gebruiken. Ik hoop echter dat het een goed voorbeeld geeft van hoe je de for-lus in een lijst kunt gebruiken.
Om het in actie te zien, kun je mijn bericht Bulk Resizing Images in R bekijken, waarin loops veelvuldig voorkomen.
For-lussen gebruiken op een dataframe
Laten we, vergelijkbaar met de bovenstaande lijst, een lus maken die een dataframe subset als het aantal impressies gelijk is aan of kleiner is dan 20.
Het is niet heel anders, maar voor deze oefening ga ik seq_len gebruiken in plaats van seq_along. Ze zijn niet echt heel anders, maar het is een meer algemeen gebruikte iteratie voor dataframes.
kwL20 



As you can see, it’s exactly the same as on our list, aside from that I’ve changed our output dataframe to kwL20 (keywords less than 20) and used seq_len(nrow for our frame. This works more or less the same as seq_along, but is a little more explicit. I’ve also set the impressions volume to be less than or equal to 20 for this exercise.



So there we have it. An introduction to the for loop in R. While these are simple examples, I hope it’s given you an idea of how they can work and be used in your SEO work. Next up, lets have a look at the while loop.



While Loops In R



Where we saw the for loop, which executes our code across every item in our dataset, the while loop is a little more steady. A while loop in R will keep executing its command all the time a condition is met, and will stop when that condition is no longer true.
While loops are great for automation. I’ve used them in the past to run real-time API data from Salesforce into my environment during a specific timeframe, for example. Again though, very simple to create and execute.



Let’s do a very simple while loop in R, looking at our Google Search Console dataset once again.



A While Loop To Find Keywords With More Than 20 Impressions



Again, this is a bit of a case of a sledgehammer to crack a nut, but hopefully this simple example will give you some ideas of where and how you can use a while loop in your day to day SEO work with R.



kw_df = 20) {
    kw_df 



Again, by this point in your R journey, this might look pretty simple. But let’s break it down anyway.



The While Loop Explained



Let’s dig into how this while loop works.





kw_df Dit zal u inmiddels bekend voorkomen, maar we maken een nieuw dataframe genaamd kw_df en stellen de querykolom in op een tekenreeks.
index We maken een numeriek object genaamd index om onze lus mee te vergelijken, beginnend met 1
while (index Nu naar onze lus. We beginnen met een while-opdracht in plaats van for, en geven R vervolgens de opdracht dat terwijl de waarde van ons indexobject is lager dan het aantal rijen in ons gsc-dataframe, om onze code uit te voeren
als (gsc$Impressions(index) >= 20) {: Daar is onze if-statement weer. In dit geval is onze voorwaarde dat onze Impressions-waarde op het rijnummer dat is gedefinieerd in onze index groter is dan of gelijk is aan 20, om onze code uit te voeren
kw_df Net als bij onze for-lus rbinden we onze query die overeenkomt met de relevante rij uit onze index als onze if-instructie waar is, en voegen deze toe aan kw_df
index Dit is het belangrijke onderdeel om onze lus draaiende te houden. Aan het einde van onze lus voegen we 1 toe aan de waarde in onze index, wat onze while-lus gaande houdt – zodra het getal in index groter is dan het aantal rijen in onze dataset, stopt de lus

Dat is een heel eenvoudige introductie tot while-loops. Je kunt er ontzettend veel mee doen, en ik ben soms een beetje schuldig aan het gebruiken ervan terwijl ik een elegantere oplossing zou moeten gebruiken omdat ik haast heb. Probeer ze zelf – while-loops in R hebben veel toepassingen voor SEO-werk.
Break & Next-voorwaarden in R-lussen
De break- en next-voorwaarden in lussen zijn opdrachten die de lus direct stoppen zodra aan de voorwaarde is voldaan, of die op basis van de uitvoer gewoon doorgaan naar de volgende iteratie.
Ik gebruik ze over het algemeen niet zo vaak, als ik eerlijk ben, behalve als een ruwe vorm van foutafhandeling als ik haast heb, maar ze zijn het waard om te weten. Laten we eens kijken naar de break-conditie binnen een repeat-loop.
Pauzevoorwaarden
Break-condities zijn min of meer precies wat ze lijken: een conditie waaronder een lus wordt verbroken of gestopt.
Ik gebruik break-condities niet echt veel, vooral omdat ik zelden repeat-loops gebruik, tenzij ze binnen een specifieke functie vallen en de loop voor iets nodig is. Repeat-loops zijn echter de beste manier om de break-conditie in actie te demonstreren.
Hier is een hele simpele herhaallus met een break-voorwaarde die een object genaamd repVal met een waarde van één neemt, die waarde herhaaldelijk afdrukt en dan elke keer 1 aan het object toevoegt. En dan, zodra we 10 herhalingen van die lus hebben bereikt, komt de break-voorwaarde en stopt het.
Laten we de code eens bekijken en daarna zullen we deze verder uitsplitsen.
repVal  10){
    break
  }
}

Als dit goed werkt, krijgt u de volgende uitvoer in uw console:

Simpel toch? Laten we eens kijken hoe het werkt.
De herhaallus en onderbrekingsvoorwaarde uitgelegd
Hier is die zin nog eens: laten we hem eens opsplitsen.

repVal We maken ons repVal-object en wijzen er een waarde van 1 aan toe
herhalen{: Dit is het type lus dat we gebruiken, vergelijkbaar met de for- en while-lussen
afdrukken(repWaarde): Onze lus zal de waarde van repVal continu afdrukken, zolang onze lus loopt
repVal Nu zeggen we dat we elke keer dat de lus wordt uitgevoerd 1 aan ons repVal-object moeten toevoegen
als(repWaarde > 10){: Daar is onze if-statement weer. Lekker simpel hier, we kijken alleen of de waarde van repVal groter is dan tien
pauze}}: En tot slot onze break-conditie. In essentie, zodra onze if-statement waar wordt (repVal is groter dan tien), triggert het onze break-conditie en stopt de lus.

En zo kan een break-voorwaarde worden gebruikt in een repeat-loop. Het kan ook worden gebruikt in elk ander type loop, en het kan een handige manier zijn om een ​​loop te stoppen als aan een bepaalde voorwaarde is voldaan.
Laten we nu eens kijken naar de volgende voorwaarden.
Volgende voorwaarden in R-lussen
De volgende voorwaarde is er een die ik iets vaker gebruik. Het springt in feite naar de volgende iteratie van onze opdracht als aan een bepaalde voorwaarde niet wordt voldaan. Ik gebruik het bijvoorbeeld soms om lege uitvoer van API’s over te slaan. Als er geen gegevens worden geretourneerd voor een bepaald trefwoord of een bepaalde pagina, wil ik geen fout, ik wil gewoon dat het naar de volgende springt.
Laten we een ander eenvoudig voorbeeld gebruiken, dit keer met een for-lus.
for (val in 1:10){

  if (val == 5){

    next
  }
  print(val)
}

Nogmaals, het is eenvoudig en als je de stappen tot hier gevolgd hebt, zou je moeten kunnen achterhalen wat hier gebeurt, maar laten we het toch even doornemen.
De volgende voorwaarde uitgelegd
Zullen we eens kijken hoe dit voorbeeld werkt?

voor (waarde in 1:10){: In dit voorbeeld gaan we een for-lus gebruiken om onze opdrachten door de waarden van één tot en met tien te laten lopen
als (waarde == 5){: Je ziet nu waarom if statements zo fundamenteel zijn voor programmeren, toch? In dit geval controleert onze if statement of we een lus hebben gemaakt naar een punt waar onze val exact gelijk is aan vijf
volgende{: Als onze if-instructie waar blijkt te zijn en onze val precies gelijk is aan vijf, gaan we naar het volgende getal in onze val-reeks
print(waarde): En ten slotte, zolang we onze volgende voorwaarde niet hebben geactiveerd, zien we een lijst met de getallen in onze waarde.

Als dit allemaal correct verloopt, zouden we het volgende in onze R-console moeten zien:

Zoals u kunt zien, zijn lussen in R vrij eenvoudig en bieden ze u een heel goede manier om een ​​opdracht over een dataset te itereren, maar er is enige controverse over wanneer, of zelfs als Je zou ze nooit in R moeten gebruiken.
De Loop vs. Apply-debat
Het verhaal gaat dat het gebruik van loops in R dirty code is. Dat ze langzaam zijn, dat je meer code gebruikt dan je nodig zou moeten hebben, dat het gebruik van de apply-familie gewoon beter.
Persoonlijk ben ik iemand die R leerde door een heleboel verschillende talen te leren en die tegenwoordig vooral Python en Julia gebruikt. Ik heb altijd al lussen gebruikt en ze waren een soort van go-to (zoals je zult zien in mijn andere R-berichten), maar ik ben ook de verschillende beschikbare toepassingsmethoden gaan waarderen.
In mijn ervaring en door onderzoek lijkt het erop dat het een soort misvatting is dat loops in R langzaam zijn. Dat gezegd hebbende, schrijf je vaak meer code dan je zou doen met een van de apply-methoden. Omgekeerd heb ik altijd gemerkt dat loops erg betrouwbaar zijn, terwijl ik soms een paar extra stappen moet nemen om een ​​apply werkend te krijgen.
Toch zijn de toepassingsmethoden geweldig en zul je ze veel gebruiken tijdens je R-reis. Ze vormen dan ook het onderwerp van mijn volgende bericht.
Afronden
Ik beloof dat ik heb geprobeerd om dit stuk iets korter te maken dan andere stukken, maar dit is wat je moet weten over het gebruik van loops in R, inclusief de for-loop, while-loop, repeat-loop en de break-, jump- en next-condities. Probeer ze zelf en ik hoop dat je ze nuttig vindt.
In het volgende stuk zal ik de verschillende toepassingsmethoden bespreken die je kunt gebruiken.
Tot de volgende keer!
Onze code van vandaag
# For Loop

kwCount = 20)  kwCount = kwCount+1
}

## On A List

kw20 = 20) {
    kw20 = 20) {
    kw_df  10){
    break
  }
}

## For Loop With Jump Condition

for (val in 1:10){

  if (val == 5){

    next
  }
  print(val)
}
Dit bericht is geschreven door Ben Johnston op Ben Johnston
Verwant