Practical 4

In this practical we will work with conditionals (branching) and loops.

Slides

The slides of the introduction can be found here: Intro

Execution flow

Recall from the lecture that there are at least three types of execution flows. Our statements can be simple and structured sequentially, when one instruction is executed right after the previous one, but some more complex flows involve conditional branching (when the portion of the code to be executed depends on the value of some condition), or loops when a portion of the code is executed multiple times until a certain condition becomes False.

These portions of code are generally called blocks and Python, unlike most of the programming languages, uses indentation (and some keywords like else, ‘:’, ‘next’, etc.) to define blocks.

Conditionals

We can use conditionals any time a decision needs to be made depending on the value of some condition. A block of code will be executed if the condition is evaluated to the boolean True and another one if the condition is evaluated to False.

The basic if - else statement

The basic syntax of conditionals is an if statement like:

if condition :

    #This is the True branch
    #do something

else:

    #This is the False branch (or else branch)
    #do something else

where condition is a boolean expression that tells the interpreter which of the two blocks should be executed. If and only if the condition is True the first branch is executed, otherwise execution goes to the second branch (i.e. the else branch). Note that the condition is followed by a “:” character and that the two branches are indented. This is the way Python uses to identify the block of instructions that belong to the same branch. The else keyword is followed by “:” and is not indented (i.e. it is at the same level of the if statement. There is no keyword at the end of the “else branch”, but indentation tells when the block of code is finished.

Example: Let’s get an integer from the user and test if it is even or odd, printing the result to the screen.

print("Dear user give me an integer:")
num = int(input())
res = ""
if num % 2 == 0:
    #The number is even
    res = "even"
else:
    #The number is odd
    res = "odd"

print("Number ", num, " is ", res)

Dear user give me an integer:
121
Number  121  is  odd

Note that the execution is sequential until the if keyword, then it branches until the indentation goes back to the same level of the if (i.e. the two branches rejoin at the print statement in the final line). Remember that the else branch is optional.

The if - elif - else statement

If statements can be chained in such a way that there are more than two possible branches to be followed. Chaining them with the if - elif - else statement will make execution follow only one of the possible paths.

The syntax is the following:

if condition :

    #This is branch 1
    #do something

elif condition1 :

    #This is branch 2
    #do something

elif condition2 :

    #This is branch 3
    #do something

else:

    #else branch. Executed if all other conditions are false
    #do something else

Note that branch 1 is executed if condition is True, branch 2 if and only if condition is False and condition1 is True, branch 3 if condition is False, condition 1 is False and condition2 is True. If all conditions are False the else branch is executed.

Example: The tax rate of a salary depends on the income. If the income is < 10000 euros, no tax is due, if the income is between 10000 euros and 20000 the tax rate is 25%, if between 20000 and 45000 it is 35% otherwise it is 40%. What is the tax due by a person earning 35000 euros per year?

income = 35000
rate = 0.0

if income < 10000:
    rate = 0
elif income < 20000:
    rate = 0.2
elif income < 45000:
    rate = 0.35
else:
    rate = 0.4

tax = income*rate

print("The tax due is ", tax, " euros (i.e ", rate*100, "%)")

The tax due is  12250.0  euros (i.e  35.0 %)

Note the difference in the two following cases:

#Example 1

val = 10

if val > 5:
    print("Value >5")
elif val > 5:
    print("I said value is >5!")
else:
    print("Value is <= 5")

#Example 2

val = 10

if(val > 5):
    print("\n\nValue is >5")

if(val > 5):
    print("I said Value is >5!!!")

Value >5


Value is >5
I said Value is >5!!!

Loops

Looping is the ability of repeating a specific block of code several times (i.e. until a specific condition is True or there are no more elements to process).

For loop

The for loop is used to loop over a collection of objects (e.g. a string, list, tuple, …). The basic syntax of the for loop is the following:

for elem in collection :
    #OK, do something with elem
    # instruction 1
    # instruction 2

the variable elem will get the value of each one of the elements present in collection one after the other. The end of the block of code to be executed for each element in the collection is again defined by indentation.

Depending on the type of the collection elem will get different values. Recall from the lecture that:

Let’s see this in action:

S = "Hi there from python"
Slist = S.split(" ")
Stuple = ("Hi","there","from","python")
print("String:", S)
print("List:", Slist)
print("Tuple:", Stuple)

#for loop on string
print("On strings:")
for c in S:
    print(c)

print("\nOn lists:")
#for loop on list
for item in Slist:
    print(item)

print("\nOn tuples:")
#for loop on list
for item in Stuple:
    print(item)

String: Hi there from python
List: ['Hi', 'there', 'from', 'python']
Tuple: ('Hi', 'there', 'from', 'python')
On strings:
H
i

t
h
e
r
e

f
r
o
m

p
y
t
h
o
n

On lists:
Hi
there
from
python

On tuples:
Hi
there
from
python

Looping over a range

It is possible to loop over a range of values with the pythom built-in function range. The range function accepts either two or three parameters (all of them are integers). Similarly to the slicing operator, it needs the starting point, end point and an optional step. Three distinct syntaxes are available:

range(E)        # ranges from 0 to E-1
range(S,E)      # ranges from S to E-1
range(S,E,step) # ranges from S to E-1 with +step jumps

Remember that S is included while E is excluded. Let’s see some examples.

Example: Given a list of integers, return a list with all the even numbers.

myList = [1, 7, 9, 121, 77, 82]
onlyEven = []

for i in range(0, len(myList)):  #this is equivalent to range(len(myList)):
    if( myList[i] % 2 == 0 ):
        onlyEven.append(myList[i])

print("original list:", myList)
print("only even numbers:", onlyEven)

original list: [1, 7, 9, 121, 77, 82]
only even numbers: [82]

Example: Store in a list the multiples of 19 between 1 and 100.

multiples = []

for i in range(19,101,19):
    multiples.append(i)

print("multiples of 19: ", multiples)

#alternative way:
multiples = []
for i in range(1, (100//19) + 1):
    multiples.append(i*19)
print("multiples of 19:", multiples)

multiples of 19:  [19, 38, 57, 76, 95]
multiples of 19: [19, 38, 57, 76, 95]

Note: range works differently in Python 2.x and 3.x

In Python 3 the range function returns an iterator rather storing the entire list.

#Check out the difference:
print(range(0,10))

print(list(range(0,10)))

range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Example: Let’s consider the two DNA strings s1 = “ATACATATAGGGCCAATTATTATAAGTCAC” and s2 = “CGCCACTTAAGCGCCCTGTATTAAAGTCGC” that have the same length. Let’s create a third string \(out\) such that \(out[i]\) is \("|"\) if \(s1[i]==s2[i]\), \("\ "\) otherwise.

s1 = "ATACATATAGGGCCAATTATTATAAGTCAC"
s2 = "CGCCACTTAAGCGCCCTGTATTAAAGTCGC"

outSTR = ""
for i in range(len(s1)):
    if(s1[i] == s2[i]):
        outSTR = outSTR + "|"
    else:
        outSTR = outSTR + " "

print(s1)
print(outSTR)
print(s2)

ATACATATAGGGCCAATTATTATAAGTCAC
   ||  || |  |  |   |  ||||| |
CGCCACTTAAGCGCCCTGTATTAAAGTCGC

Nested for loops

In some occasions it is useful to nest one (or more) for loops into another one. The basic syntax is:

for i in collection:
    for j in another_collection:
        #do some stuff with i and j

Example:

Given the matrix \(\begin{bmatrix}1 & 2 & 3\\4 & 5 & 6\\7 & 8 & 9\end{bmatrix}\) stored as a list of lists (i.e. matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]].

Print it out as: \(\begin{matrix}1 & 2 & 3\\4 & 5 & 6\\7 & 8 & 9\end{matrix}\)

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

for i in range(len(matrix)):
    line = ""
    for j in range(len(matrix[i])):
        line = line + str(matrix[i][j]) + " " #note int --> str conversion!
    print(line)

1 2 3
4 5 6
7 8 9

While loops

The for loop is great when we have to iterate over a finite sequence of elements. But when one needs to loop until a specific condition holds true, another construct must be used: the while statement. The loop will end when the condition becomes false.

The basic syntax is the following:

while condition:

    #do something
    #update the value of condition

An example follows:

i = 0
while (i < 5):
    print("i now is:", i)
    i = i + 1 #THIS IS VERY IMPORTANT!

i now is: 0
i now is: 1
i now is: 2
i now is: 3
i now is: 4

Note that if condition is false at the beginning the block of code is never executed.

Note: The loop will continue until condition holds true and the only code executed is the block defined through the indentation. This block of code must update the value of condition otherwise the interpreter will get stuck in the loop and will never exit.

We can combine for loops and while loops one into the code block of the other:

for i in range(1,10):                       # or without string output
    j = 1                                   # for i in range(1,10):
    output = ""                             #     j = 1
    while(j<= i):                           #     while(j<=i):
        output = str(j) + " " + output      #         print(j, end = " ")
        j = j + 1                           #         j = j + 1
    print(output)                           #     print("")

1
2 1
3 2 1
4 3 2 1
5 4 3 2 1
6 5 4 3 2 1
7 6 5 4 3 2 1
8 7 6 5 4 3 2 1
9 8 7 6 5 4 3 2 1

Exercises

1. Given the integer 134479170, print if it is divisible for the numbers from 2 to 16. Hint: use for and if.

Show/Hide Solution

val = 134479170
flag = False

for divisor in range(2,17):
    if val % divisor == 0:
        print(val, " can be divided by ", divisor)
        print("\t", divisor, "*", val//divisor, "=", val )
        flag = True

if flag == False:
    print("Sorry, could not find divisors")

134479170  can be divided by  2
         2 * 67239585 = 134479170
134479170  can be divided by  3
         3 * 44826390 = 134479170
134479170  can be divided by  5
         5 * 26895834 = 134479170
134479170  can be divided by  6
         6 * 22413195 = 134479170
134479170  can be divided by  7
         7 * 19211310 = 134479170
134479170  can be divided by  9
         9 * 14942130 = 134479170
134479170  can be divided by  10
         10 * 13447917 = 134479170
134479170  can be divided by  14
         14 * 9605655 = 134479170
134479170  can be divided by  15
         15 * 8965278 = 134479170

2. Given the DNA string “GATTACATATATCAGTACAGATATATACGCGCGGGCTTACTATTAAAAACCCC”, write a Python script that reverse-complements it. To reverse-complement a string of DNA, one needs to replace and A with T, T with A, C with G and G with C, while any other character is complemented in N. Finally, the sequence has to be reversed (e.g. the first base becomes the last). For example, ATCG becomes CGAT.

Show/Hide Solution

DNA = "GATTACATATATCAGTACAGATATATACGCGCGGGCTTACTATTAAAAACCCC"

revComp = ""
for base in DNA:
    if base == "T":
        revComp = "A"+ revComp
    elif base == "A":
        revComp = "T"+ revComp
    elif base == "C":
        revComp = "G"+ revComp
    elif base == "G":
        revComp = "C" + revComp
    else:
        revComp = "N" + revComp

print("5'-", DNA, "-3'")
print("3'-", revComp, "-5'")

5'- GATTACATATATCAGTACAGATATATACGCGCGGGCTTACTATTAAAAACCCC -3'
3'- GGGGTTTTTAATAGTAAGCCCGCGCGTATATATCTGTACTGATATATGTAATC -5'

""" Another solution"""

DNA = "GATTACATATATCAGTACAGATATATACGCGCGGGCTTACTATTAAAAACCCC"


dna_list = list(DNA)
print(dna_list)
compl = []
for el in dna_list:
    if el == 'A':
        compl.append('T')
    elif el == 'T':
        compl.append('A')
    elif el == 'C':
        compl.append('G')
    elif el == 'G':
        compl.append('C')
    else:
        compl.append('N')
print(compl)
compl.reverse()
print(compl)
print("".join(compl))

['G', 'A', 'T', 'T', 'A', 'C', 'A', 'T', 'A', 'T', 'A', 'T', 'C', 'A', 'G', 'T', 'A', 'C', 'A', 'G', 'A', 'T', 'A', 'T', 'A', 'T', 'A', 'C', 'G', 'C', 'G', 'C', 'G', 'G', 'G', 'C', 'T', 'T', 'A', 'C', 'T', 'A', 'T', 'T', 'A', 'A', 'A', 'A', 'A', 'C', 'C', 'C', 'C']
['C', 'T', 'A', 'A', 'T', 'G', 'T', 'A', 'T', 'A', 'T', 'A', 'G', 'T', 'C', 'A', 'T', 'G', 'T', 'C', 'T', 'A', 'T', 'A', 'T', 'A', 'T', 'G', 'C', 'G', 'C', 'G', 'C', 'C', 'C', 'G', 'A', 'A', 'T', 'G', 'A', 'T', 'A', 'A', 'T', 'T', 'T', 'T', 'T', 'G', 'G', 'G', 'G']
['G', 'G', 'G', 'G', 'T', 'T', 'T', 'T', 'T', 'A', 'A', 'T', 'A', 'G', 'T', 'A', 'A', 'G', 'C', 'C', 'C', 'G', 'C', 'G', 'C', 'G', 'T', 'A', 'T', 'A', 'T', 'A', 'T', 'C', 'T', 'G', 'T', 'A', 'C', 'T', 'G', 'A', 'T', 'A', 'T', 'A', 'T', 'G', 'T', 'A', 'A', 'T', 'C']
GGGGTTTTTAATAGTAAGCCCGCGCGTATATATCTGTACTGATATATGTAATC

3. Write a python script that creates the following pattern:

+
++
+++
++++
+++++
++++++
+++++++ <-- 7
++++++
+++++
++++
+++
++
+

Show/Hide Solution

outStr = ""
for i in range(0,7):
    outStr = ""
    for j in range(0,i+1):
        outStr = outStr + "+"
    if(i == 6):
        outStr = outStr + " <-- 7"

    print(outStr)

for i in range(1,7):
    outStr = ""
    for j in range(0, 7-i):
        outStr = outStr + "+"
    print(outStr)

+
++
+++
++++
+++++
++++++
+++++++ <-- 7
++++++
+++++
++++
+++
++
+

4. Count how many of the first 100 integers are divisible by 2, 3, 5, 7 but not by 10 and print these counts. Be aware that a number can be divisible by more than one of these numbers (e.g. 6) and therefore it must be counted as divisible by all of them (e.g. 6 must be counted as divisible by 2 and 3).

Show/Hide Solution

cnts = [0,0,0,0] #cnts[0] counts for 2, cnts[1] counts for 3...
vals = [2,3,5,7]
for i in range(1,101):
    if ( i % 2 == 0 and i % 10 != 0 ):
        cnts[0] = cnts[0] + 1

    if ( i % 3 == 0 and i % 10 != 0):
        cnts[1] = cnts[1] + 1

    if ( i % 5 == 0 and i % 10 != 0):
        cnts[2] = cnts[2] + 1

    if ( i % 7 == 0 and i % 10 != 0):
        cnts[3] = cnts[3] + 1

for i in range(0, len(cnts)):
    print(cnts[i], " numbers are divisible by ", vals[i], "(but not 10) in the first 100")

40  numbers are divisible by  2 (but not 10) in the first 100
30  numbers are divisible by  3 (but not 10) in the first 100
10  numbers are divisible by  5 (but not 10) in the first 100
13  numbers are divisible by  7 (but not 10) in the first 100

5. Given the following fastq entry:

@HWI-ST1296:75:C3F7CACXX:1:1101:19142:14904
CCAACAACTTTGACGCTAAGGATAGCTCCATGGCAGCATATCTGGCACAA
+
FHIIJIJJGIJJJJJ1HHHFFFFFEE:;CIDDDDDDDDDDDDEDDD-./0

Store the sequence and the quality in two strings. Create a list with all the quality phred scores (given a quality character “X” the phred score is: ord(“X”) -33. Finally print all the bases that have quality lower than 25, reporting the base, its position, quality character and phred score. Output example: base: C index: 14 qual:1 phred: 16).

Show/Hide Solution

entry = """@HWI-ST1296:75:C3F7CACXX:1:1101:19142:14904
CCAACAACTTTGACGCTAAGGATAGCTCCATGGCAGCATATCTGGCACAA
+
FHIIJIJJGIJJJJJ1HHHFFFFFEE:;CIDDDDDDDDDDDDEDDD-./0"""

lines = entry.split("\n")
seq = lines[1]
qual = lines[3]

phredScores = []
for i in range(len(qual)):
    phredScores.append(ord(qual[i]) - 33)


for i in range(len(seq)):
    if(phredScores[i] <25):
        print("base:",seq[i],"index:",i,"qual:",qual[i],"phredScore:",phredScores[i])

base: C index: 15 qual: 1 phredScore: 16
base: A index: 46 qual: - phredScore: 12
base: C index: 47 qual: . phredScore: 13
base: A index: 48 qual: / phredScore: 14
base: A index: 49 qual: 0 phredScore: 15

6. Given the following sequence:

AUGCUGUCUCCCUCACUGUAUGUAAAUUGCAUCUAGAAUAGCA
UCUGGAGCACUAAUUGACACAUAGUGGGUAUCAAUUAUUA
UUCCAGGUACUAGAGAUACCUGGACCAUUAACGGAUAAAU
AGAAGAUUCAUUUGUUGAGUGACUGAGGAUGGCAGUUCCU
GCUACCUUCAAGGAUCUGGAUGAUGGGGAGAAACAGAGAA
CAUAGUGUGAGAAUACUGUGGUAAGGAAAGUACAGAGGAC
UGGUAGAGUGUCUAACCUAGAUUUGGAGAAGGACCUAGAA
GUCUAUCCCAGGGAAAUAAAAAUCUAAGCUAAGGUUUGAG
GAAUCAGUAGGAAUUGGCAAAGGAAGGACAUGUUCCAGAU
GAUAGGAACAGGUUAUGCAAAGAUCCUGAAAUGGUCAGAG
CUUGGUGCUUUUUGAGAACCAAAAGUAGAUUGUUAUGGAC
CAGUGCUACUCCCUGCCUCUUGCCAAGGGACCCCGCCAAG
CACUGCAUCCCUUCCCUCUGACUCCACCUUUCCACUUGCC
CAGUAUUGUUGGUGU

Considering the genetic code and the first forward open reading frame (i.e. the string as it is remembering to remove newlines).

1. How many start codons are present in the whole sequence (i.e. AUG)?
2. How many stop codons (i.e. UAA,UAG, UGA)
3. Create another string in which any codon with except the start and stop codons are substituted with “—” and print the resulting string.

Show/Hide Solution

seq ="""AUGCUGUCUCCCUCACUGUAUGUAAAUUGCAUCUAGAAUAGCA
UCUGGAGCACUAAUUGACACAUAGUGGGUAUCAAUUAUUA
UUCCAGGUACUAGAGAUACCUGGACCAUUAACGGAUAAAU
AGAAGAUUCAUUUGUUGAGUGACUGAGGAUGGCAGUUCCU
GCUACCUUCAAGGAUCUGGAUGAUGGGGAGAAACAGAGAA
CAUAGUGUGAGAAUACUGUGGUAAGGAAAGUACAGAGGAC
UGGUAGAGUGUCUAACCUAGAUUUGGAGAAGGACCUAGAA
GUCUAUCCCAGGGAAAUAAAAAUCUAAGCUAAGGUUUGAG
GAAUCAGUAGGAAUUGGCAAAGGAAGGACAUGUUCCAGAU
GAUAGGAACAGGUUAUGCAAAGAUCCUGAAAUGGUCAGAG
CUUGGUGCUUUUUGAGAACCAAAAGUAGAUUGUUAUGGAC
CAGUGCUACUCCCUGCCUCUUGCCAAGGGACCCCGCCAAG
CACUGCAUCCCUUCCCUCUGACUCCACCUUUCCACUUGCC
CAGUAUUGUUGGUG"""

seq = seq.replace("\n","")


countStart = 0
countEnd = 0

newSeq = ""
i = 0
while i < len(seq):
    codon = seq[i:i+3]
    if(codon == "AUG"):
            countStart = countStart + 1

    elif (codon == "UAA" or codon == "UAG" or codon == "UGA"):
        countEnd = countEnd + 1
    else:
        codon = "---"

    newSeq = newSeq + codon
    i = i + 3


print("\nNumber of start codons:", countStart)
print("Number of end codons:", countEnd)
print("\n")
print(seq)
print("\n")
print(newSeq)

Number of start codons: 2
Number of end codons: 12


AUGCUGUCUCCCUCACUGUAUGUAAAUUGCAUCUAGAAUAGCAUCUGGAGCACUAAUUGACACAUAGUGGGUAUCAAUUAUUAUUCCAGGUACUAGAGAUACCUGGACCAUUAACGGAUAAAUAGAAGAUUCAUUUGUUGAGUGACUGAGGAUGGCAGUUCCUGCUACCUUCAAGGAUCUGGAUGAUGGGGAGAAACAGAGAACAUAGUGUGAGAAUACUGUGGUAAGGAAAGUACAGAGGACUGGUAGAGUGUCUAACCUAGAUUUGGAGAAGGACCUAGAAGUCUAUCCCAGGGAAAUAAAAAUCUAAGCUAAGGUUUGAGGAAUCAGUAGGAAUUGGCAAAGGAAGGACAUGUUCCAGAUGAUAGGAACAGGUUAUGCAAAGAUCCUGAAAUGGUCAGAGCUUGGUGCUUUUUGAGAACCAAAAGUAGAUUGUUAUGGACCAGUGCUACUCCCUGCCUCUUGCCAAGGGACCCCGCCAAGCACUGCAUCCCUUCCCUCUGACUCCACCUUUCCACUUGCCCAGUAUUGUUGGUG


AUG------------------------------UAG---------------------UGA---------------------------------UAG---------------UAA------------------------UGA------------------------------------------UGA------------------------UGA---------------------------------UAG------UAA------------------------------------------------------UAA---------------UAG------------------------------------------------------------AUG---------------------------------------------------------------------------------------------------------UGA---------------------------------

7. Playing time! Write a python scripts that:
   1. Picks a random number from 1 to 10, with: import random myInt = random.randint(1,10)
   2. Asks the user to guess a number and checks if the user has guessed the right one
   3. If the guess is right the program will stop with a congratulation message
   4. If the guess is wrong the program will continue asking a number, reporting the numbers already guessed (hint: store them in a list and print it).
   5. Modify the program to notify the user if he/she inputs the same number more than once.

Show/Hide Solution

import random
myInt = random.randint(1,10)
guessedNumbers = []

found = False
while (found == False):
    userInt = int(input("Guess a number from 1 to 10: "))
    if(userInt == myInt):
        print("Congratulations. The number I guessed was ", myInt)
        found = True
    else:
        if(userInt in guessedNumbers):
            print("You already guessed ", userInt)
        else:
            guessedNumbers.append(userInt)
        guessedNumbers.sort()
        print("Nope, try again. So far you guessed: ", guessedNumbers)

Guess a number from 1 to 10: 7
Nope, try again. So far you guessed:  [7]
Guess a number from 1 to 10: 5
Nope, try again. So far you guessed:  [5, 7]
Guess a number from 1 to 10: 2
Nope, try again. So far you guessed:  [2, 5, 7]
Guess a number from 1 to 10: 3
Congratulations. The number I guessed was  3