<jupyter_start><jupyter_text>Hanzehogesch<NAME> - <NAME>; Matchingsdag  IntroductieWelkom bij het praktische gedeelte van de matchingsdag waarbij je middels oefeningen kunt ervaren wat enkele werkzaamheden zijn van een bio-informaticus. In dit geval betreft het de visualisatie en analyze van het *Hemagglutinine* eiwit van het Influenza A virus met als doel het identificeren van verschillen tussen varianten van dit eiwit. Tevens kan dit moment worden gebruikt om voor ons en voor jezelf te bekijken of je affiniteit hebt met de werkwijze waarmee je ook in het onderwijs in aanraking komt.De opdrachten maken gebruik van het 3D-visualisatie programma *PyMOL* en de programmeertaal *Python*, waarin ook PyMOL gemaakt is. De programmeeropdrachten worden steeds ingeleid met voorbeelden die de benodigde concepten uitleggen die daarna zelf toegepast dienen te worden. Bij onduidelijkheden is het mogelijk de aanwezige student(en) om hulp te vragen. De opdrachten zijn bedoeld om uit te voeren in de computerruimte waar je nu zit; uitvoeren op bijv. je eigen laptop is - doordat we bepaalde software gebruiken - nu *niet* mogelijk. Zie onderaan dit document voor links naar deze software zodat het later, bijv. thuis, ook uit te voeren is.In deze interactieve omgeving (een zogenaamde *iPython Notebook*) kan ook tekst bewerkt worden door te dubbelklikken op een blok text of een figuur. Wanneer je dit per ongeluk doet is de originele tekst weer te zien door op de toetscombinatie `Ctrl + Enter` te klikken.  1. Verkrijgen Biologische DataOm de opdrachten te kunnen uitvoeren hebben we allereerst de benodigde *data* nodig. Het gaat in dit geval om een enkel bestand dat het eiwit *Hemagglutinine* beschrijft, die te vinden is in de *Protein Data Bank* (PDB). Dit eiwit is in een ver verleden een keer het [*molecuul van de maand*](http://pdb101.rcsb.org/motm/76) geweest en is daarom uitvoerig beschreven.* Zoek op de bovenstaande pagina de * PDB entry* op voor de *actieve vorm* van het Hemagglutinine eiwit en klik op de bijbehorende link.    + Op deze nieuwe pagina staat veel informatie over het eiwit; o.a. om welke variant van Hemagglutinine het gaat (de **H1** variant) en het jaar waarin deze gevonden is (1918, het jaar waarop de *Spaanse griep* zorgde voor één van 's werelds grootste natuurrampen in de geschiedenis van de mensheid).* Download het bestand dat de volledige structuur van dit eiwit beschrijft:    + Klik op de `Download Files` knop rechtsbovenaan de pagina    + Klik vervolgens op de `PDB Format` link in het verschenen menu    + Het bestand wordt nu gedownload naar de `Downloads` mapJe ben nu klaar om dit molecuul in meer detail te gaan bekijken in PyMOL, ga hiervoor verder naar de volgende opdracht.  2. Visualisatie; *Hemagglutinine*De data waarmee gewerkt wordt in de bio-informatica bestaat in de basis vaak uit tekst. Zoals grote bestanden vol met DNA- or aminozuur-sequenties (eiwitten). Indien mogelijk is het altijd aan te raden om de data te *visualiseren* om het zo beter inzichtelijk te maken. Het zojuist gedownloade PDB bestand is hier een goed voorbeeld van. Allereerst gaan we kort kijken *wat* er in dit bestand staat om het daarna te visualiseren met PyMOL.* Doel:    + Inzicht verkrijgen in biologische *data*    + Kennismaking met PyMOL *interface*    + Verschillende visualisatie technieken toepassen (namelijk *atomistisch* en *cartoon*)     Inhoud PDB-bestandOpen de *bestandsbrowser* door in de onderste balk op de aangegeven knop te klikken: Ga vervolgens naar de `Downloads` map om het gedownloade PDB-bestand te vinden (als het goed is v/h `1ruz` eiwit). Dit bestand is in principe een standaard tekst-bestand en kan daardoor door meerdere programma's geopend worden. Klik met de rechtermuis op het bestand en selecteer *Open With Other Application* en type daarna *Geany* zodat je dit programma kunt selecteren. Zoals te zien is bovenaan het document staat veel van de informatie die te vinden is op de website ook hier in. Op regel `479` begint een onderdeel genaamd `SEQRES` waar de eiwit sequenties van alle losse onderdelen te vinden zijn. Om het molecuul in vol detail te kunnen weergeven is echter meer detail nodig. Hiervoor staat vanaf regel `775` tot bijna het einde van het bestand (meer dan 12.000 regels verder) per regel één atoom beschreven. Hieronder volgt een voorbeeld van 4 atomen op de posities 6047-6050:```ATOM   6047  N   PRO J 294      35.077 120.037  39.710  1.00 44.09           N ATOM   6048  CA  PRO J 294      34.451 118.833  40.257  1.00 42.65           C  ATOM   6049  C   PRO J 294      35.186 117.516  40.094  1.00 41.43           C  ATOM   6050  O   PRO J 294      34.975 116.596  40.879  1.00 41.99           O```De eerste drie decimalen (kolommen 7, 8 & 9) zijn de x-, y- en z-coordinaten die gebruikt worden om het molecuul mee te visualiseren. De laatste kolom is het atoom dat zich op deze positie in het eiwit bevind (in dit voorbeeld; stikstof (*N*), koolstof (*C*), koolstof en zuurstof (*O*)). Visualisatie met PyMOLWe gaan het bestand nu openen met PyMOL. Het programma PyMOL is te vinden in het *Applications* menu (linksboven), onder het submenu *Education* als *PyMOL Molecular Graphics System*. Wanneer je dit programma start verschijnen er twee aparte schermen; als eerste het zogenaamde *External GUI* met daarin de standaard menu-items als *File*, *Edit*, *Settings*, enz. Hiermee gaan we straks het PDB-bestand inladen. In een volgende oefening gaan we hier ook tekstuele commando's invoeren om het gedrag van PyMOL aan te passenHet tweede scherm wordt ook wel de *PyMOL Viewer* genoemd waarin uiteindelijk het eiwit verschijnt en de opties voor weergave van het eiwit zijn ondergebracht.**Oefening**: Open het bestand door in de *PyMOL External GUI* in het *File* menu op *Open* te klikken en vervolgens het PDB-bestand te openen uit de `Downloads` map.Na het openen verschijnt het eiwit in beeld en is er in de *External GUI* informatie over het geladen eiwit te lezen, o.a. over de naam van het eiwit en de zogenaamde *chains* (*ketens*). Hemagglutinine bestaat namelijk uit twee hoofd-componenten (*HA1* en *HA2*, in het figuur hiernaast weergegeven met blauw en oranje) en deze komen elk drie keer voor in het eiwit (HA1: de ketens H, J & L en HA2: I, K & M). De huidige weergave van het eiwit is wat onduidelijk; de ketens zijn nu niet afzonderlijk te identificeren en doordat elk van de ~12.000 atomen wordt weergegeven oogt het wat chaotisch. Een betere weergave voor grote eiwitten is i.p.v. *line* (huidige weergave) de *cartoon* weergave. Hierin worden de grote structuren in het eiwit zichtbaar; de zogeheten *helices* en *sheets*. In het *PyMOL Viewer* venster is nu in de rechter kolom de naam (PDB-identifier) van het eiwit zichtbaar met daarnaast 5 knoppen die gebruikt kunnen worden voor het aanpassen van de weergave, gelabeld met de letters **`A` `S` `H` `L`** en **`C`**. We gaan de weergave in vier stappen aanpassen:1. In het `H` (*Hide*) menu: klik op `everything` (alles is nu - tijdelijk - verstopt)2. In het `S` (*Show*) menu: ga via het `as` menu naar `cartoon`:     ![](https://raw.githubusercontent.com/mkempenaar/hanze_skc/master/syllabus/images/pymol_model_settings.png)3. In het `L` (*Label*) menu: zet de labels voor de `chains` aan, hiermee zijn de 6 verschillende chains te identificeren4. In het `C` (*Color*) menu: zorg voor een kleur *per chain*, via het `by chain` menu op `by chain` te klikken:     ![](https://raw.githubusercontent.com/mkempenaar/hanze_skc/master/syllabus/images/pymol_color_settings.png)Het uiteindelijke resultaat zou er als volgt uit moeten zien (de orientatie kan middels de muis worden aangepast):Laat het PyMOL programma open op de achtergrond met het Hemagglutinine eiwit geladen; we gaan hier straks mee verder.  3. Data Analyse; *Interaction Sites*In deze opdracht wordt gewerkt aan het lokaliseren van bepalende locaties van het Hemagglutinine eiwit. Ook grote eiwitten hebben vaak maar één of enkele locaties die daadwerkelijk interacties aangaan met andere moleculen. Zo is er van Hemagglutinine bekend op welke plekken het eiwit de interacties aangaat met de te infecteren cel tijdens de infectiecyclus. De locatie waar we in deze opdracht in geinteresseerd zijn bevind zich direct naast zo'n *interactie locatie* en het aminozuur op deze plek geeft de oorsprong aan van het eiwit. * Doel:     + Eerste kennismaking met programmeren    + Het verschil herkennen tussen *variabelen* van verschillende typen (namelijk *strings* en *integers*)    + Het bepalen van de oorsprong van het Hemagglutinine eiwit Programmeren; introductieOm uiteindelijk te kunnen zoeken in de aminozuur-sequentie van Hemagglutinine maken we gebruik van de kracht van een *programmeertaal*. In dit geval werken we met *Python*, een taal die als standaard wordt gezien binnen de bio-informatica. Het document die je nu voor je hebt is een *interactieve omgeving* waarin met Python gewerkt kan worden om onze data te analyseren. Allereerst moet echter de basis van het programmeren duidelijk worden en aan de hand van voorbeelden leer je hier de basisprincipelen van het programmeren met Python. Onderaan dit document staan nog enkele links die verwijzen naar online bronnen waarmee je deze basiskennis kunt uitbreiden. Tijdens de opleiding beginnen we weer bij het absolute begin, maar alle voorkennis die je hebt is uiteindelijk mooi meegenomen. Programmeren; *variabelen*Variabelen zijn een onmisbaar concept bij het programmeren en deze ken je mogelijk wel uit de wiskunde. De beschrijving op Wikipedia is voor nu afdoende:> "Soms heb je een bepaalde (berekende) waarde (value) doorheen de programmacode meer dan één keer nodig. In dat geval kun je – i.p.v. die waarde steeds opnieuw te berekenen – de waarde opslaan in een variabele en dan gewoon de naam van de variabele gebruiken. Bij een complexe berekening kan je d.m.v. variabelen deze berekening opsplitsen in tussenstappen, waarvan je elk tussenresultaat kan opslaan in een aparte variabele. Een variabele is dus een benoemde geheugenlocatie waar gegevens opgeslagen kunnen worden."De laatste zin geeft aan dat het om een *benoemde geheugenlocatie* gaat waar je *gegevens* in kunt opslaan. Het meest simpele voorbeeld is bijv. het opslaan van het getal `10` in de variabele *benoemd met* **`x`**, of het woord *`hallo`* in de variabele **`groet`**. Onderstaande code laat deze twee voorbeelden zien in Python waarbij het '*opslaan van*' wordt uitgebeeld met het '**`=`**' teken. De naam van de variabele (het gedeelte voor het `=` teken) mag je volledig zelf bedenken:<jupyter_code>x = 10
groet = "hallo"<jupyter_output><empty_output><jupyter_text>Type variabelenIn bovenstaand voorbeeld maken we gebruik van twee *type* variabelen, namelijk *integers* voor het opslaan van hele getallen (zoals het getal `10` hierboven) en *strings* (voor het opslaan van alle tekstuele data vormen, zoals het woord '`hallo`' hierboven). Afhankelijk van het type variabele kun je er andere *operaties* mee uitvoeren. Zo is het mogelijk om met *integers* te rekenen (optellen, aftrekken, delen, enz.) en met *strings* is het mogelijk om tekst (letters, woorden, zinnen of - in de bio-informatica - *sequenties*) te zoeken, op te delen (splitsen), combineren, enz. Het type van een variabele wordt alleen bepaald door wat eraan toegewezen wordt. Tijdens onderstaande oefening maken we gebruik van beide variabele typen. Werken met variabelenHier volgen enkele code-voorbeelden van veelgebruikte *operaties* met variabelen. Deze zijn niet direct noodzakelijk voor de opdrachten maar zijn meer bedoeld om te laten zien wat er veelal mee gedaan kan worden. De tekst die wordt voorafgegaan door een hekje (*``*) is zogenaamd *commentaar*, dit wordt genegeerd door Python en heeft als doel om code te verduidelijken.De `print` *functies* in onderstaande code zorgt er alleen voor dat het resultaat van bijv. een berekening zichtbaar wordt:* Klik met de muis in onderstaande code fragmenten* Voer de code uit door op de toetsen `Shift + Enter` te drukkenHet resultaat van de berekeningen komt nu direct onder de code te staan. Het is in deze interactieve omgeving mogelijk om bijv. getallen aan te passen en dan nogmaals middels `Shift + Enter` deze uit te voeren.<jupyter_code># Het 'definieren' van twee integer variabelen, x en y
x = 10
y = -2

# vermenigvuldigen
z = y * x
print(z)

# optellen
z = x + 2
print(z)

# delen
z = x / 2
print(z)<jupyter_output><empty_output><jupyter_text>Het volgende stuk code geeft enkele voorbeelden van *string* operaties en het gebruik van één van de vele *functies*. Ook het resultaat hiervan kan *geprint* worden door de code uit te voeren:<jupyter_code># Strings:
groet = "Hallo, "
naam = "Henk"

# combineren ('optellen')
print( groet + naam )

# herhalen ('vermenigvuldigen')
print( groet * 3 + naam)

# alles in hoofdletters
print( naam.upper() )<jupyter_output><empty_output><jupyter_text>De laatste regel in dit voorbeeld voert een *functie* uit op de inhoud in de `naam` variabele. In dit geval een functie die alle letters omzet naar hoofdletters. Dergelijke *String* functies schrijf je met een punt achter de variabele naam. We gaan verder geen gebruik maken van String functies tijdens deze oefeningen. Programmeren; *slicing*Getals variabelen bevatten altijd maar één getal (`x = 42`) en het is niet mogelijk om hier alleen de `4` of de `2` uit te halen (is ook vrij zinloos). Met string variabelen is het echter wel mogelijk om elke **letter** afzonderlijk te benaderen, bijv. de eerste of laatste letter, of de eerste drie letters enz. De technische term hiervoor is *slicen*, oftewel er een gedeelte 'uit snijden'. Door blokhaken ('`[`' en '`]`') *achter* de variabele naam te plaatsen met daartussen een getal kunnen er karakters uitgehaald worden. Belangrijk punt om te onthouden, het **eerste** element zit op positie **0**! Zo zal bijv. het getal 10 het 11$^e$ karakter uit de string geven, zo geeft bijvoorbeeld `seq[10]` het 11$^e$ karakter uit de string-variabele `seq`. Naast een enkel getal zijn er nog meer opties om tussen de blokhaken te zetten. De opties die we nodig hebben zijn:* een getals*reeks* met een start en een eind, gescheiden door een dubbele-punt '`:`', bijvoorbeeld:    + Van het eerste tot en met het 3$^e$ karakter: `seq[`**`0:3`**`]` (dit zijn echter posities 0, 1 & 2!)    + Van karakter 10 t/m 15: `seq[`**`9:15`**`]`* Van het begin t/m een bepaalde positie, of vanaf een bepaalde positie *tot het einde* door het weglaten van het *start* of *eind* getal:    + Van het begin t/m het 3$^e$ karakter: `seq[`**`:3`**`]`    + Vanaf karakter 10 (positie 9) t/m het einde: `seq[`**`9:`**`]`* En als laatste het gebruik van *negatieve posities* om vanaf het eind te beginnen:    + De laatste drie karakters door van positie `-3` tot en met het einde te selecteren: `seq[`**`-3:`**`]`Hieronder staat een stuk *interactieve code* die bovenstaande voorbeelden demonstreert. Om het resultaat van een *expressie* te zien is het nodig om deze te *printen*. Om deze reden staat er overal `print( )` omheen met tussen de haakjes een stukje tekst dat aangeeft wat er geprint wordt en daarna - gescheiden met een komma - een voorbeeld van *slicing* zoals hierboven besproken. Als onderstaande code wordt aangepast kan deze uitgevoerd worden met de toetscombinatie `Shift + Enter`.**Oefening:** Verander de laatste regel uit onderstaand code voorbeeld zodat het *tweede* codon geprint wordt ('`TCA`'). Pas het gedeelte '`seq[0]`' aan zodat, wanneer je op `Shift + Enter` drukt er het juiste codon geprint wordt.<jupyter_code># Voorbeeld sequentie opgeslagen als String in de variabele 'seq'
seq = "ATGTCAGACCTAGTGCCGGAATCGATCGATATCGAGTAG"

# De volgende vier 'statements' printen elk één of meerdere basen uit bovenstaande DNA sequentie
print('De eerste base:', seq[0] )

print('De laatste base:', seq[-1] )

print('De eerste drie basen (eerste "codon"):', seq[0:3] )

print('De laatste drie basen (laatste "codon"):', seq[-3:] )

print('Het tweede "codon" (TCA, basen 4 t/m 6):', seq[0])<jupyter_output><empty_output><jupyter_text>Zoals we hebben gezien bestaat het eiwit Hemagglutinine ten minste uit 6 onderdelen; de twee unieke componenten HA1 en HA2 die elk drie keer in het uiteindelijke eiwit zitten (de ketens). In elk van deze ketens zitten enkele aminozuren die ervoor zorgen dat het zijn schadelijke effect kan uitoefenen.In de volgende oefening gaan we kijken wat de *oorsprong* van dit Influenza virus is. Als er namelijk op positie **72** in de H, J en L ketens een **asparaginezuur** amiozuur (aangeduid met de letter **D**) zit, heeft het virus een oorspong in de vogel. Als er op deze positie echter het aminozuur **glutaminezuur** (aangeduid met de letter **E**) zit, is het virus oorspronkelijk afkomstig uit de mens.**Oefening:** Bepaal welk aminozuur er op positie **72** zit in de sequentie opgeslagen in de variabele `seq` en print deze. * Download het bijbehorende FASTA bestand, ook afkomstig uit de *Protein Data Bank*:    - Bezoek de link van het `1RUZ` eiwit uit opdracht 1 en  download daar de '*FASTA Sequence*'* Open dit bestand (zie de `Downloads` map, zoals bij Opdracht 2) in de Geany tekst-editor* Kopieer de sequentie van de juiste *chain* (naamgeving is `>1RUZ_:`*`chain`*)* Plak de sequentie in de variabele `seq` in het code voorbeeld hier onder, tussen de dubbele aanhalingstekens.* Zorg ervoor dat de sequentie zelf op één - hele lange - regel staat* Voeg de benodigde code als laatste regel toe in onderstaand voorbeeld en gebruik `Ctrl + Enter` om het resultaat te kunnen zien. Wat is de oorsprong van deze variant van het Influenza virus?<jupyter_code># De sequentie voor de ketens H, J en L.
seq = ""

# Geeft de lengte van de sequentie aan
print("Lengte van de aminozuur sequentie:", len(seq))

# Bepaling aminozuur op positie 72<jupyter_output><empty_output><jupyter_text>4. Visualisatie;  *Interaction Sites*In de vorige opdracht hebben we gezien dat er een interessant aminozuur vlakbij één van de interactie-locaties zit. De locatie kunnen we - voor alle drie HA1-ketens - visualiseren in PyMOL. * Doel:    + Koppeling tussen grafische interface en commandogestuurd taken uitvoeren, m.b.v. Python codeAllereerst volgt hier nog een complex maar compleet overzicht van interessante posities in het eiwit:In het *donkerblauw* aangegeven, in (a) en (b), is de positie waar we eerder naar gekeken hebben, hier beschreven als "A highly conserved residue ..." en bovenaan in het figuur weergegeven op positie **77** (in het gedownloade sequentie bestand echter op posititie **72**). Naast deze positie is het met wit aangegeven gedeelte (posities 133 t/m 138) de *receptor binding site*; de locatie waar het eiwit binding aangaat met de te infecteren cel.**Oefening**: We willen nu in PyMOL positie 72 gaan *highlighten* (aanduiden) in alle drie HA1 ketens. Er zijn meerdere manieren om dit uit te voeren en in deze oefening gaan we dit met Python uitvoeren. Het is namelijk mogelijk om in PyMOL stukken Python code te *importeren*. Om dit te kunnen doen gaan we onderstaande code (werking voor nu onbelangrijk) in een Python *script* plaatsen en dan inladen in PyMOL:* Kopieer de inhoud van het onderstaande code voorbeeld* Open de *Geany* tekst editor (te vinden onder het `Applications`, `Development` menu)* Plak de Python code in Geany* Sla het bestand op (`File`, `Save As`) op de `Desktop` map met als bestandsnaam: `highlight.py` (let op dat het deze exacte naam krijgt)<jupyter_code>from pymol import cmd

def highlight(selected):
    # Change visualization of selected residue to 'spheres'
    cmd.show('sticks', selected)
    # Change color of selected residue to 'yellow'
    cmd.color('yellow', selected)

# Make the 'highlight' command available in PyMOL
cmd.extend("highlight", highlight)<jupyter_output><empty_output><jupyter_text>Ga nu terug naar het PyMOL programma en plaats de cursor in het *invoer veld* naast de tekst '`PyMOL >`'. Allereerst gaan we het net geschreven Python programma inladen; type hiervoor het volgende commando: ```run ~/Desktop/highlight.py``` en klik op de `Enter` toets. Nu is de *functie* `highlight` beschikbaar die voor ons aminozuren duidelijk kan aangeven. Om de posities echter beter te kunnen zien is het ook mogelijk om de ketens waarin hij zit een andere kleur te geven. Gebruik hiervoor het volgende commando in PyMOL om de juiste ketens *wit* te kleuren:```color white, chain H + chain J + chain L```PyMOL heeft nu de voor ons interessante ketens wit gekleurd en nu kunnen we positie 72 in de chains H, J en L een andere kleur geven met de geimporteerde `highlight` functie. Gebruik hiervoor de volgende code:```highlight res 72```Nu zijn de drie residuen (aminozuren) als molecuul zichtbaar in het geel. Om te bevestigen dat het juiste aminozuur gekleurd is kun je op de **`S`** knop klikken helemaal rechts onderaan, dit laat de sequentie v/h eiwit zien met - als het goed is - positie 72 geel gekleurd. Komt de locatie ongeveer overeen met hetgeen in bovenstaande afbeelding te zien is?**Uitdaging:** (optioneel) gegeven het bovenstaande figuur, *highlight* ook de *Receptor Binding Site*. Hiervoor moet je mogelijk zoeken hoe je meerdere residuen kunt gebruiken in het commando. 5. Data Analyse; *Sequence Alignment*Nu we een goed beeld hebben van het eiwit van de **H1** variant uit 1918 kunnen we een vergelijking maken met een Hemagglutinine eiwit van een *andere* variant. De sequentie van Hemagglutinine uit verschillende varianten zijn voor grote delen volledig identiek (*geconserveerde* delen) en op een aantal andere locaties juist erg verschillend (niet *geconserveerd*) met als resultaat dat het een andere variant genoemd wordt en, hoewel de methode van infectie gelijk blijft, mogelijk niet herkend wordt door een immuunsysteem.* Doel:    + Data (sequenties opgeslagen in *strings*) vergelijken middels programmeer technieken Programmeren; *vergelijkingen*Het vergelijken van *objecten* (bijv. getallen of tekst) is een belangrijke, veelvoorkomende taak bij het programmeren. Een vergelijking geeft in dit geval als resultaat de waarde `True` (waar) of `False` (niet waar). Een dergelijke test werkt voor zowel integeres als strings. De code (of eigenlijk, *syntax*) om een vergelijking te schrijven is `a == b`, dus met een dubbel **`=`** teken. Het volgende voorbeeld laat enkele vergelijkingen zien die `True` of `False` als resultaat geven. Daarna kijken we naar hoe we deze informatie kunnen gebruiken om bijvoorbeeld een beslissing te nemen.<jupyter_code># Twee integer variabelen
x = 10
y = 20

# Vergelijking 1 (False)
print( x == y )

# Vergelijking 2 (True)
print( y == 20 )

# String variabele
getal = "10"

# Vergelijking 3 (False)
print( x == getal )

# Vergelijking 4, omzetten van string naar integer (True) 
print( x == int(getal) )<jupyter_output><empty_output><jupyter_text>Vergelijking 3 probeert een `string` met een `integer` te vergelijken wat niet werkt. Het is middels een klein trucje echter wel mogelijk, er bestaat namelijk een functie genaamd `int` waarmee een getal als `string` is om te zetten naar een `integer`. Stel we willen in plaats van alleen een `True` of `False` waarde een boodschap printen, dan dienen we de vergelijking *als een vraag* te stellen. Hiervoor kennen vrijwel alle programmeertalen een zogenaamd `if`-statement. Stel we willen de vrij nutteloze code schrijven dat het volgende doet:    als x gelijk is aan 2:        zeg: x is even!    anders:        zeg: x is geen 2...Dan kunnen we dit in Pyhon redelijk letterlijk vertalen:<jupyter_code>x = 2

if x == 2:
    print( 'x is even!' )
else:
    print( 'x is geen 2...' )<jupyter_output><empty_output><jupyter_text>Het concept van deze vrij leesbare code wordt veel gebruikt om, afhankelijk van gevonden waarden, beslissingen te nemen. Een demonstratie van het vergelijken van karakters uit `strings` volgt hieronder. Programmeren; *herhaling*Mogelijk is het al duidelijk geworden, maar het vergelijken van sequenties die - van nature - bestaan uit meerdere karakters (basen of aminozuren) kan niet met een enkel `if`-statement. Een sequentie vergelijken gaat per karakter en met de sequenties waar wij naar kijken dus al gauw honderden vergelijkingen in totaal. Aangezien de procedure van elke individuele vergelijking hetzelfde is kunnen we gebruik maken van *herhaling*. We willen bijvoorbeeld het volgende probleem programmeren:    Voor elk karakter k uit string seq:        als k gelijk is aan 'A':            zeg: Alanine gevonden!Op bovenstaande manier kunnen we een vergelijking maken met *elk* karakter uit een *string*. De uitwerking hiervan in Python is als volgt:<jupyter_code>seq = 'HQNAQGEGTAADYKSTQSAIDQIT'
for k in seq:
    if k == 'A':
        print( 'Alanine gevonden!' )<jupyter_output><empty_output><jupyter_text>Wanneer je bovenstaande code uitvoert zal je zien dat er 4x geprint wordt dat er een Alanine gevonden is. Dit is de meest basale vorm van *herhaling* als we gebruik maken van strings. Het wordt echter een iets grotere uitdaging wanneer we karakters uit twee strings willen halen om te vergelijken (oefening hier onder). Stel we willen twee strings van elk 10 karakters *per karakter* vergelijken, dan kunnen we hiervoor de eerder geleerde *slicing* techniek gebruiken. De vergelijking is dan bijv. `seq_1[0] == seq_2[0]`. Hiermee vergelijken we de eerste karakters uit `seq_1` en `seq_2` met elkaar.Het enige dat we nodig hebben hiervoor zijn de getallen 0 t/m het aantal elementen in beide strings (die dienen dus even lang te zijn!). Hiervoor gebruiken we een Python functie genaamd `range`. Onderstaand voorbeeld demonstreerd deze functie *en* gecombineerd met de functie `len` waarmee de lengte van een string opgevraagd kan worden:<jupyter_code># Print de getallen 0 t/m 4
for i in range(5):
    print( 'Getal:', i )
print("\n") # print lege regel

# Print de eerste 5 aminozuren uit de variabele seq
seq = 'HQNAQGEGT'
for i in range(5):
    print( 'AA op positie', i, ':', seq[i] )

# Print alle aminozuren uit de variabele seq
print( "\nHet aantal AAs in 'seq':", len(seq) )
for i in range( len(seq) ):
    print( 'AA op positie', i, ':', seq[i] )<jupyter_output><empty_output><jupyter_text>**Oefening**: Onderstaande code definieert een viertal `strings` met daarin de eerste 35 aminozuren afkomstig uit de *I*-keten van vier verschillende Hemagglutinine varianten. Deze uitdagende opdracht vraagt om zelf **twee** van deze sequenties te kiezen en door middel van *herhaling*, *vergelijkingen*, *optellen* en *printen* aan te geven hoeveel aminozuren de twee sequenties van elkaar verschillen. De totale *pseudocode* voor deze oefening is als volgt:    teller = 0    zeg: De lengte van de sequenties is: ...    Voor elk karakter k1 uit seq1 en elk karakter k2 uit seq2:        als k1 gelijk is aan k2:            teller = teller + 1        anders:             doe niets en ga door    zeg: Het totaal aantal matches is: tellerDe variabele teller (*count*er in het Engels) wordt gebruikt om bij te houden hoeveel karakters overeenkomen tussen beide sequenties. *Ergens* in het `if`-statement dien je deze variabele *op te hogen* met 1 (dus 1 bij zichzelf optellen) zoals in bovenstaande *pseudocode*. Om de oefening te kunnen doen moeten technieken uit alle voorgaande oefeningen en voorbeelden gecombineerd worden.<jupyter_code>chain_I_H1_1918 = 'GLFGAIAGFIEGGWTGMIDGWYGYHHQNEQGSGYA'
chain_I_H5_2010 = 'GLFGAIAGFIEGGWQGMVDGWYGYHHSNEQGSGYA'
chain_I_H7_1979 = 'GLFGAIAGFIENGWEGLVDGWYGFRHQNAQGEGTA'
chain_I_H3_2014 = 'GIFGAIAGFIENGWEGMKDGWYGFRHQNSEGIGQA'

# Vergelijk twee sequenties naar keuze en print het aantal afwijkende posities
# door het bijhouden van een 'counter'
count = 0<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.0657192324339922, 'fraction_numerical': 0.012047323618525466, 'mean_word_length': 4.733043837882548, 'pattern_counts': {'":': 0, '<': 47, '<?xml version=': 0, '>': 50, 'https://': 2, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 13, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '11', 'dir': 'jupyter-structured-clean-dedup', 'id': '202924', 'license': 'MIT', 'n_tokens_mistral': 9706, 'n_tokens_neox': 9442, 'n_words': 4055, 'path': 'syllabus/matchingsdag.ipynb', 'repo_name': 'mkempenaar/hanze_skc', 'size': '27743'}