= Practical 2:  Common Python Data Structures and Functions =
=== Introduction/Aims of this practical ===
The  aims of this practical are two-fold: firstly to introduce you to the  different ways in which data is represented in python, and, in the  second part how to use python to manipulate data covering most of the  material in the previous lecture.  This practical is not about modelling  ''per se'', but the material here is an essential pre-requisite for the modelling practicals that follow.

=== Instructions ===
Having started !ScrumPy,  read the tutorial material below, and then replicate the python examples in the !ScrumPy  command window (don't copy and paste!).

It  is important that you understand what each of these examples is doing,  it's not enough to simply reproduce the ouptut shown here on your own  laptop screens! You should therefore test this by modifying some of  these  examples - you should be able to correctly predict the effects of  these  modifications, and if not then explain why not.

'''Note: '''In  the examples below we will be using python interactively. In this case  ">>>" represents the python prompt which tells you that python  is ready for you to type something, not something that you should  type.To do the excersises type in the text following the prompt and fit  the return key.

== Part 1: How data is represented in Python ==
Data  can be as simple as a single digit, or as complex as a  suite of genome  databases. Python comes with a number of relatively  simple data-types,   but as we will see, these can be combined to build a python  representation of whatever it is that we are studying. The purpose of  !ScrumPy is to define such collections of simple data-types in a defined way (a ''data-structure'')  particularly useful for metabolic modelling, and routines that act upon  them. We will start  by examining some of the common built-in types.The  complete, official python documentation can be found [[https://docs.python.org/3/library/stdtypes.html|here]], although you might find some of it a bit technical, and it goes beyond what is needed for this course.

=== Viewing data ===
Simply typing a value at the prompt causes it to be printed on the screen:

{{{#!python
>>> "Hello"
'Hello'
}}}
if we assign a value to a variable, then typing the variable name will cause the value of the variable to be printed:

{{{#!python

>>> Greet = "Hello"
>>> Greet
'Hello'
}}}
Finally, if we use the built in "print"  function, this will also cause the value to be printed on the screen.  For some data the two methods may result in a different represesentation  of the same value:

{{{#!python
>>> print(Greet)
Hello
}}}
'''Question:''' What is the difference between the two ways in which Greet is represented?

=== Primitive Data Types ===
==== Boolean ====
Booleans  are used to  indicate whether or not something is considered true, and  can take one  of exactly two values, True or False, they can be generated  explicitly,  or as the result of a comparison:

{{{#!python
>>> val=True
>>> val
True
>>> 3>=4
False
>>> val = 3==4
>>> val
False
}}}
'''Question:''' Explain line 6 in the example above.

==== Numbers ====
Python  has three built in ways of defining numbers: integer,  floating point and complex numbers although are not relevant to this course.

'''Integers''' are whole,  or counting, numbers and can be either positive or negative, they are  represented as a sequence of digits which contains no other characters.  Floating-point, or real, numbers contain a fractional component   followng a decimal point. They can also be represented using the "e"  notation, common to many other languages which represents "times 10 to  the power of".

{{{#!python
>>> Count = 135
>>> Count
135
>>> Pi = 3.1415926
>>> Pi
3.1415926
>>> VeryBig = 1.1e16
>>> VeryBig
1.1e+16
>>> VerySmall = 1/VeryBig
>>> print(VerySmall)
9.090909090909091e-17
}}}
The common mathematical operators ({{{+,-,/,*}}}) work as expected, note that {{{x**y}}} means ''x''^y^.  Numbers can also be compared using the common == (is equal), != (is not  equal), < (is less than), <= (is less than or equal to), > (is  greater than) and >= (is greater than or equal to). Some of these  operators can also be used with other types of data.

'''Question:'''

Consider the expression:

{{{#!python
>>> 1+VerySmall >1
}}}
Explain (to yourself) the syntax of this. What'' type ''will the expression evaluate to? What ''value ''do you expect? Now try it out.

=== Strings ===
<<Anchor(String)>>Strings  are sequences of characters and used to represent arbitrary text.They are found surrounded by quotation marks ( ' ) or double quotation marks ( " ).

{{{#!python
>>> SomeString = 'Hello'
>>> print(SomeString)
Hello
}}}
The characters stored in the sequence are indexed by integers:

{{{#!python
>>> SomeString = 'Hello'
>>> SomeString[0]
'H'
>>> SomeString[1]
'e'
>>> SomeString[-1]
'o'
}}}
Common operations involving strings include the .upper(), .startswith(), and endswith() methods:

{{{#!python
>>> SomeString = 'Hello'
>>> SomeString.upper() # this function returns a string which is identical to SomeString except that all of the characters are capitalized
'HELLO'
>>> SomeString.startswith('H') # this function returns 'True' if the first character in SomeString is an 'H' and False otherwise
True
>>> SomeString.startswith('a') # this function returns 'True'  if the first character in SomeString is an 'a' and False otherwise
False
>>> SomeString.startswith('h') # this function returns 'True' if the first character in SomeString is an 'h' and False otherwise
False
>>> SomeString.endswith('o') # this function returns 'True' if the last character in SomeString is an 'o' and False otherwise
True
}}}
=== The type() function ===
<<Anchor(Types)>> The type of each object defines what operations can be performed on it. For example, the numeric data-types (like integers and floats) can undergo numerical operations, such as subtraction and multiplication, whilst strings cannot.

The type() function returns the type of an object:

{{{#!python
>>> SomeString = 'Hello'
>>> SomeInteger = 5
>>> SomeFloat = 5.2548
>>> type(SomeString)
<class 'str'>
>>> type(SomeInteger)
<class 'int'>
>>> type(SomeFloat)
<class 'float'>
}}}
The print() function can be used to print different objects within the same text. This can be done by separating each object with a comma.

{{{#!python
>>> ChildName = 'Sam'
>>> ChildAge = 5
>>> print(ChildName, 'is', ChildAge, 'years-old')
Sam  is  5 years-old
}}}
=== Lists (and tuples) ===
<<Anchor(List)>>Lists   and tuples are collections of items in which are stored in a specific   order and each item is associated with (indexed by) an integer. The  main  difference between the two is that tuples are ''immutable'' -  once a  tuple is created it cannot be changed, whereas lists can. For  these  exercises we will mainly use lists. An empty list can be created  by  assigning a pair of closed square brackets to a variable.

{{{#!python
>>> SomeList=[]
}}}
 . Items can be appended to a list by using the {{{append()}}} method.

{{{#!python
>>> SomeList.append('string 1')
>>> SomeList
['string 1']
}}}
 . A list can also be created and populated in one go.

{{{#!python
>>> SomeList=['string 1']
>>> SomeList
['string 1']
}}}
Or:

{{{#!python
>>> SomeList = ['string 1','string 2','string 3']
>>> SomeList[0]
'string 1'
>>> SomeList[1]
'string 2'
>>> SomeList[2]
'string 3'
>>> SomeList[-1]
'string 3'
}}}
 . '''Question:''' What is the item at !SomeList[-2] ? !SomeList[-4] ?
 .

 . Indexing can be used to create a copy of part of a  subset of a list, a process known as ''slicing''.

{{{#!python
>>>SomeList[1:3]
['string 2', 'string 3']
}}}
 . The index of a known item can be retrieved using the {{{index()}}} method.

{{{#!python
>>> SomeList.index('string 2')
1
}}}
 .
 . .
  . Items can be removed from a list using the {{{remove()}}} method.
 {{{#!python
>>> SomeList.remove('string 1')
>>> SomeList
['string 2', 'string 3']
}}}

==== Nested lists: ====
 . Lists can contain any objects, including other lists. These lists are referred to as ''nested'':

{{{#!python
>>> SomeList = ['string 1','string 2','string 3']
>>> nested = [1,2,3]
>>> SomeList.append(nested)
>>> SomeList
['string 1', 'string 2', 'string 3', [1, 2, 3]]
>>> SomeList[3]
[1, 2, 3]
>>> SomeList[3][0]
1
}}}
Note the syntax of line 8 above.

'''Question:''' Explain the syntax of line 8 - how many ways are there to specify the item with the value of 3 using this notation?

=== Tuples ===
Tuples  are very similar to lists, but with one important difference: ince a  tuple is defined its contents cannot be changed, they are ''immutable. ''Tuples are created in a in the same way as lists, excet the round brackets "()", rather than square brackets "[ ]" are used.

{{{#!python

>>> SomeTuple = ("Item 1", "Item 2", "Item 3")
}}}
'''Exercise:''' Repeat the previous list examples with the tuple. What works and what doesnt? Explain.

== Dictionaries ==
 . <<Anchor(Dictionary)>>.  Conceptually, dictionaries are quite similar to lists and tuples in  that they contain collections of items, however, what makes them  distinct is the fact that instead of using integers to refer to items  (almost) anything can be used to refer to what is contained, this alos  means that, incontrast to lists and tuples there is no implicit order of  the items stored in a dictionary. The hace that we can use (almos)t  anything to refer to an item gives great flexibilty; dictionaries and  "dictianary-like" classes are used extensively in !ScrumPy.  Dictionaries are created by specifying a sequence of key:value pairs inside a pair of braces "{}":

{{{#!python
>>> dict_1 = {'alfa':1,'beta':2}  #create a dictionary
>>>  print(dict_1)
{'beta': 2, 'alfa': 1}
>>> dict_1['alfa']                #access value '1' by key 'alfa'
1
>>> dict_1['gamma'] = 1          #add new key:value pair
>>> dict_1['alfa'] = 'a'         #overwrite key:value pair
}}}
 .
 .
 . As with lists, dictionaries can be nested.

{{{#!python
>>> dict_1 = {'alfa':1,'beta':2} #define first dictionary
>>> dict_2 = {'gamma':1}         #define second dictionary
>>> dict_1['nested'] = dict_2    #add dict_2 as value to key 'nested' in dict_1
>>> dict_1
{'beta': 2, 'alfa': 1, 'nested': {'gamma': 1}}
>>> dict_1['nested']['gamma']    #access key 'gamma' in nested dictionary
1
}}}
== Part 2: Loops and conditionals ==
=== Repetition ===
==== For loops ====
<<Anchor(Loop)>>The {{{for}}}  loop is used to iterate over  an iterable object, e.g. a list.  Depending on how the loop is formulated  the loop variable will either  be an item in the iterable object or an  index.

{{{#!python
>>> a_list = ['a','b','c']
>>> for item in a_list:       #iterating over the items
        print (item)
a
b
c
}}}
{{{#!python
>>> a_list = ['a','b','c']
>>> for i in range(len(a_list)):   #iterating over indices
        print (a_list[i])

a
b
c
}}}
 .
 . While loops
 .
 . {{{while}}} loops continue repeating  as long as some condition (the ''loop invariant'') evaluates as True.

{{{#!python
>>> a_list = ['a','b','c']
>>> i = 0                  #assign value 0 to variable i
>>> while i<len(a_list):   #as long as i is less than 3
        print (a_list[i])  #print item at index i in a_list
        i += 1             #increment i by 1

a
b
c
}}}
 . This implies that if the condition {{{i<len(a_list)}}} is never fulfilled the loop continues indefinitely, which it will. <<Anchor(Conditional)>>Loops can be combined with ''conditional'' statements, where a block of code is executed {{{if}}} a statement is true, {{{else}}} another block is executed. The {{{else}}} block is optional, but must be the last option and no statement may follow on the same line.

{{{#!python
>>> a_list = ['a',1,'c',2]
>>> for item in a_list:
        if type(item)==type(str()):  #check if item is of string type
            print (item+' is a string')
        else:                        #if not...
            print (str(item)+' is not a string')

'a is a string'
'1 is not a string'
'c is a string'
'2 is not a string'
}}}
 . If several options are possible the {{{elif}}} statement can be used.

{{{#!python
>>> for item in a_list:

        if type(item)==type(str()):
            print (item+' is a string')
        elif type(item)==type(int()):
            print (str(item)+' is an int')
        else:
            print (str(item)+' is unkown')

'a is a string'
'1 is an int'
'c is a string'
'2 is an int'
}}}
== Part 3: Some more examples ==
'''Loops and Dictionaries'''

Dictionaries can be iterated over in a similar way to how we can iterate through the items of a list.

{{{#!python
>>> dict_1 = {'alfa':1,'beta':2, 'gamma':3} #define a dictionary
>>> for key in dict_1:       #iterate over the keys
        print (key)

alfa
beta
gamma
}}}
{{{#!python
>>> dict_1 = {'alfa':1,'beta':2, 'gamma':3} #define a dictionary
>>> for key in dict_1:       #iterate over the keys
        print ('the key', key, 'has value', dict_1[key]) # this print statement executes if either key.endsswith('a') is True or if key.startswith('b') is True or both are True

the key alfa has value 1
the key beta has value 2
the key gamma has value 3
}}}
'''Filtering strings'''

Sometimes we might want to select strings that have certain attributes. Recall the .startswith() function:

{{{#!python
>>> string_1 = 'alfa'
>>> string_1.startswith('a') # this function returns 'True' if string_1 starts with an 'a' and False otherwise
True
>>> string_1.startswith('b')
False
>>> string_1.startswith('A')
False
}}}
This function, along with an if statement, can be used to specify which keys of a dictionary are printed.

{{{#!python
>>> dict_1 = {'alfa':1,'beta':2, 'gamma':3} #define a dictionary
>>> for key in dict_1:       #iterate over the keys
        if key.startswith('a'):
            print (key) # this print statement executes if key.startswith('a') is True

alfa
}}}
{{{#!python
>>> dict_1 = {'alfa':1,'beta':2, 'gamma':3} #define a dictionary
>>> for key in dict_1:       #iterate over the keys
        if key.startswith('a') or key.startswith('b'):
            print ('the key', key, 'has value', dict_1[key]) # this print statement executes if either key.endsswith('a') is True or if key.startswith('b') is True or both are True

the key alfa has value 1
the key beta has value 2
}}}