13785
Comment:
|
16884
|
Deletions are marked like this. | Additions are marked like this. |
Line 2: | Line 2: |
The metabolic modelling software we will be using, {{{ScrumPy}}}, is written in {{{Python}}}. {{{Python}}} is a high-level, object-oriented, interpreted programming language, it has a large standard library, and supports multiple programming paradigms. It is also syntactically clear and easy to learn. This is a very brief introduction to some of the basic features of the language, for a more complete introduction to the topic, see Lutz & Ascher, "Learning Python" O'Reilly Media inc. (Edition 2 or greater). A good source of {{{Python}}} documentation can be found [[http://docs.python.org/ | here]]. |
The metabolic modelling software we will be using, {{{ScrumPy}}}, is written in {{{Python}}}. {{{Python}}} is a high-level, object-oriented, interpreted programming language, it has a large standard library, and supports multiple programming paradigms. It is also syntactically clear and easy to learn. This is a very brief introduction to some of the basic features of the language, for a more complete introduction to the topic, see Lutz & Ascher, "Learning Python" O'Reilly Media inc. (Edition 2 or greater). A good source of {{{Python}}} documentation can be found [[http://docs.python.org/|here]]. |
Line 7: | Line 5: |
We will be using Python from the !ScrumPy environment. To start a new !ScrumPy session open a terminal and type "{{{ScrumPy}}}": |
We will be using Python from the !ScrumPy environment. To start a new !ScrumPy session open a terminal and type "{{{ScrumPy}}}": |
Line 14: | Line 10: |
Line 17: | Line 12: |
Line 19: | Line 13: |
Any data we may wish to store or manipulate is associated with a specific ''type''. The ways in which the data may be manipulated depends on the type. For example whole numbers are associated with the "{{{int}}}" type and can simply be added together: {{{ 2 + 1 = 3 }}} Likewise, sequences of characters are associated with the "{{{string}}}" type, and they too, can be added together: |
}}} Likewise, sequences of characters are associated with the {{{string}}} type, and they too, can be added together: |
Line 31: | Line 20: |
Line 34: | Line 22: |
Line 37: | Line 26: |
A given data type can be as simple as a single digit, or as complex as a suite of genome databases. Python comes with a number of relativley simple (but still extrememely useful) data-types, and !ScrumPy extends this by providing additional data-types particularly useful for metabolic modelling and related activities. |
A given data type 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 (but still extremely useful) data-types, and !ScrumPy extends this by providing additional data-types particularly useful for metabolic modelling and related activities. |
Line 42: | Line 30: |
Line 44: | Line 31: |
Line 48: | Line 34: |
Line 58: | Line 45: |
>>> str(n_int) '135' }}} |
}}} |
Line 63: | Line 47: |
The numerical types we will be dealing with are integers, {{{int}}}, and floating-point numbers, {{{float}}}. Integers are written as a sequence of digits. Floats are written as digits with a decimal point in the sequence, and an optional exponent ({{{e}}} or {{{E}}}). |
The numerical types we will be dealing with are integers, {{{int}}}, and floating-point numbers, {{{float}}}. Integers are written as a sequence of digits. Floats are written as digits with a decimal point in the sequence, and an optional exponent ({{{e}}} or {{{E}}}). |
Line 74: | Line 58: |
Line 76: | Line 59: |
{{{#!python | {{{#!python |
Line 82: | Line 67: |
Line 84: | Line 68: |
{{{#!python | {{{#!python |
Line 91: | Line 77: |
Line 94: | Line 79: |
Line 97: | Line 80: |
Line 111: | Line 93: |
>>> }}} == Lists (and tuples) == >>> val=True >>> if val: print 'val is true' 'val is true' >>> val=False >>> if val: print 'val is true' |
|
Line 118: | Line 113: |
Line 124: | Line 120: |
Items can be appended to a list by using the ''append()'' method. | Items can be appended to a list by using the {{{append()}}} method. |
Line 131: | Line 127: |
Line 133: | Line 128: |
Line 137: | Line 133: |
}}} Items can be removed from a list using the ''remove()'' method. {{{#!python >>> empty_list.remove('string 1') >>> empty_list [] }}} As with strings, indexing can be used to copy a subset of a list, keep in mind that the indices of items in lists (like characters in strings) are numbered from 0. Membership of an item in a list can be evaluated as described for strings. |
|
Line 159: | Line 145: |
}}} | }}} Items can be removed from a list using the {{{remove()}}} method. {{{#!python >>> empty_list.remove('string 1') >>> empty_list [] }}} As with strings, indexing can be used to copy a subset of a list, keep in mind that the indices of items in lists (like characters in strings) are numbered from 0. Membership of an item in a list can be evaluated as described for strings. |
Line 170: | Line 167: |
The index of a known item can be retrieved using the ''index()'' method. | The index of a known item can be retrieved using the {{{index()}}} method. |
Line 178: | Line 175: |
Line 191: | Line 190: |
Subsets of lists (and strings) can be accessed using ''slicing'': {{{#!python >>> empty_list[1:3] 'string 2', 'string 3'] }}} The index of a known item can be retrieved using the {{{index()}}} method. {{{#!python >>> empty_list.index('string_1') 0 }}} Lists can contain any objects, including other lists. These lists are referred to as ''nested'': {{{#!python >>> empty_list = ['string 1','string 2','string 3'] >>> nested = [1,2,3] >>> empty_list.append(nested) >>> empty_list ['string 1', 'string 2', 'string 3', [1, 2, 3]] >>> empty_list[3] [1, 2, 3] >>> empty_list[3][0] 1 }}} |
|
Line 216: | Line 238: |
Line 230: | Line 251: |
{{{Python}}} can be used in interactive mode (as we have seen above), as well as in batch mode. A pice of {{{Python}}} code can be saved in a text file with the file extension {{{.py}}} (in {{{ScrumPy}}} the most convenient option is the build-in IDLE text editor, accessed from the tool-bar under {{{File> New window}}}). The module can be run in the {{{ScrumPy}}} shell by ''importing'' the file. Assuming we have saved a file names ''some_py.py'' in the current directory, this is how it works: {{{ user@machine:~$ ls *.py #in terminal, list all .py files some_py.py user@machine:~$ more some_py.py #Python 'Hello world!' program print 'Hello world!' |
user@machine:~$ more some_py_func.py #print user-specified string def print_string(string): print string |
Line 244: | Line 260: |
}}} {{{#!python >>> reload(some_py_func) #if an imported module is modified the changes are updated by reloading the module >>> some_py_func.print_string('Hello world!') |
|
Line 247: | Line 270: |
It is usually more convenient to structure the stored code into functions that can be executed from the imported module. Functions are defined using the key-word ''def''. | It is usually more convenient to structure the stored code into functions that can be executed from the imported module. Functions are defined using the key-word ''def''. In many applications functions return objects to the user. |
Line 252: | Line 279: |
#Python 'Hello world!' program, accessed by function def print_hello(): print 'Hello world!' |
#return list of characters in user-specified string def print_string(string): return list(string) |
Line 266: | Line 293: |
Line 268: | Line 294: |
Line 274: | Line 301: |
}}} {{{#!python >>> reload(some_py_func) #if an imported module is modified the changes are updated by reloading the module >>> some_py_func.print_string('Hello world!') Hello world! }}} In many applications functions return objects to the user. {{{ user@machine:~$ more some_py_func.py #return list of characters in user-specified string def print_string(string): return list(string) }}} |
|
Line 298: | Line 309: |
Line 314: | Line 323: |
str_list.append(item) | self.str_list.append(item) |
Line 317: | Line 326: |
str_dict[key]=val | self.str_dict[key]=val }}} {{{#!python >>> reload(some_py_func) #if an imported module is modified the changes are updated by reloading the module >>> some_py_func.print_string('Hello world!') Hello world! }}} In many applications functions return objects to the user. {{{ user@machine:~$ more some_py_func.py #return list of characters in user-specified string def print_string(string): return list(string) }}} {{{#!python >>> reload(some_py_func) >>> hello_list = some_py_func.print_string('Hello world!') >>> hello_list ['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!'] }}} == Objects == As mentioned, {{{Python}}} supports multiple programming paradigms, one of those being object-orientation. Object-orientation allows collection of data into ''objects'', or class ''instances''. The data collected in objectes is referred to as ''fields'' or ''attributes'', objects also store functions that usually performs actions on the attributes. Object-specific functions are called ''methods''. Here is a small example of class definition, initialisation, and usage of a class that stores a list and a dictionary. {{{ user@machine:~$ more StringDL.py class StringDnLs: def __init__(self): self.str_list=[] self.str_dict={} def add2List(self,item): self.str_list.append(item) def add2Dict(self,key,val): self.str_dict[key]=val |
Line 325: | Line 372: |
>>> strdn.addList('a string') # add a string to str_list using method addList(item) >>> strdn.str_list ['a string'] }}} == Loops, conditionals, assignment, evaluation, and others == |
>>> strdn.add2List('a string') # add a string to str_list using method addList(item) >>> strdn.str_list ['a string'] }}} == Built-in functions, loops, conditionals, assignment, and evaluation == |
Line 333: | Line 378: |
Line 339: | Line 385: |
Line 343: | Line 390: |
You can read more about the built-in functions [[http://docs.python.org/2/library/functions.html|here]]. | |
Line 351: | Line 399: |
a b c >>> for i in range(len(a_list)): #iterating over indices print a_list[i] a b c }}} Note that {{{range(integer_1,integer_2)}}} is a built-in function that returns a list of integers ranging from the lower integer, {{{integer_1}}}, to (but excluding) the higher {{{integer_2}}}. If the first argument is left blank, {{{Python}}} assumes {{{integer_1}}} is 0. For example: {{{#!python |
|
Line 370: | Line 403: |
}}} The step size is 1 by default, but can be specified as the third argument: {{{#!python >>> range(0,10,2) [0, 2, 4, 6, 8] }}} Note that the step size must be an integer. If floating point steps are needed, the {{{arange()}}} function from the {{{numpy}}} package can be used. It is very similar to the {{{range()}}} function but accepts floating point arguments and returns {{{array}}} objects, which can be converted to lists using the method {{{tolist()}}} {{{#!python >>> from numpy import arange >>> arange(10) array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> arange(0,5,0.5).tolist() [0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5] |
|
Line 383: | Line 432: |
}}} | >>> for i in range(len(a_list)): #iterating over indices print a_list[i] a b c }}} Note that {{{range(integer_1,integer_2)}}} is a built-in function that returns a list of integers ranging from the one integer, {{{integer_1}}}, to (but excluding) the other, {{{integer_2}}}. If the first argument is left blank, {{{Python}}} assumes {{{integer_1}}} is 0. For example: {{{#!python >>> range(0,10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }}} The step size is 1 by default, but can be specified as the third argument: {{{#!python >>> range(0,10,2) [0, 2, 4, 6, 8] }}} Note that the step size must be an integer. If floating point steps are needed, the {{{arange()}}} function from the {{{numpy}}} package can be used. It is very similar to the {{{range()}}} function but accepts floating point arguments and returns {{{array}}} objects, which can be converted to lists using the method {{{tolist()}}} {{{#!python >>> from numpy import arange >>> arange(10) array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> arange(0,5,0.5).tolist() [0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5] }}} {{{while}}} loops iterate until a condition is fulfilled. {{{#!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 }}} |
Line 403: | Line 501: |
Line 407: | Line 506: |
if type(item)==type(str()): | if type(item)==type(str()): |
Line 409: | Line 509: |
elif type(item)==type(int()): | elif type(item)==type(int()): |
Line 418: | Line 518: |
}}} You may have noticed it already, but it is necessary to point out the distinction between assignment and evaluation: |
|
Line 421: | Line 525: |
Introduction to Python for Metabolic Modellers
The metabolic modelling software we will be using, ScrumPy, is written in Python. Python is a high-level, object-oriented, interpreted programming language, it has a large standard library, and supports multiple programming paradigms. It is also syntactically clear and easy to learn. This is a very brief introduction to some of the basic features of the language, for a more complete introduction to the topic, see Lutz & Ascher, "Learning Python" O'Reilly Media inc. (Edition 2 or greater). A good source of Python documentation can be found here.
Getting started
We will be using Python from the ScrumPy environment. To start a new ScrumPy session open a terminal and type "ScrumPy":
user@machine:~$ ScrumPy &
which will launch the ScrumPy window.
Data types
}}}
Likewise, sequences of characters are associated with the string type, and they too, can be added together:
"Apple" + "Pie" = "ApplePie"
However a string and an integer, cannot be meaningfully added together, so:
"Apple" + 2 = !! ERROR !!
A given data type 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 (but still extremely useful) data-types, and ScrumPy extends this by providing additional data-types particularly useful for metabolic modelling and related activities.
We will start here by examining some of the common built-in types.
Strings
Strings are collections of characters. Characters in a string can be accessed by indexing, and membership of a subset of characters in a string can be evaluated.
Numerical types
The numerical types we will be dealing with are integers, int, and floating-point numbers, float. Integers are written as a sequence of digits. Floats are written as digits with a decimal point in the sequence, and an optional exponent (e or E).
The type of a given data object can be checked using the built-in function type().
Floats and integers can be interconverted using the constructors int() or float().
The common mathematical operators (+,-,/,*) work as expected, note that x**y means xy.
Boolean
Booleans are a subtype of integers. A boolean type is either True or False, and can be very useful when writing conditional statements, i.e. if something is True, do something. Also, the integer 0 is False.
Lists (and tuples)
>>> val=True >>> if val:
- print 'val is true'
'val is true'
>>> val=False >>> if val:
- print 'val is true'
>>> }}}
Lists (and tuples)
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.
1 >>> empty_list=[]
Items can be appended to a list by using the append() method.
A list can also be created and populated in one go.
Items can be removed from a list using the remove() method.
As with strings, indexing can be used to copy a subset of a list, keep in mind that the indices of items in lists (like characters in strings) are numbered from 0. Membership of an item in a list can be evaluated as described for strings.
Subsets of lists (and strings) can be accessed using slicing:
The index of a known item can be retrieved using the index() method.
Lists can contain any objects, including other lists. These lists are referred to as nested:
Subsets of lists (and strings) can be accessed using slicing:
The index of a known item can be retrieved using the index() method.
Lists can contain any objects, including other lists. These lists are referred to as nested:
Dictionaries
In other programming languages dictionaries are sometimes called "associative arrays". Unlike lists, dictionaries store collections of items that are ordered by keys, not indices. There is no specific order of the items in a dictionary. The keys of a dictionary must be unique (for a given dictionary) and be hashable, for now this means that any object that is not a list can be used as a key. Here are some examples of dictionaries in action:
1 >>> dict_1 = {'alfa':1,'beta':2} #create a dictionary
2 >>> keys = ['alfa','beta']
3 >>> vals = [1,2]
4 >>> dict_1 = dict(zip(keys,vals)) #create a dictionary from two lists
5 >>> dict_1
6 {'alfa':1,'beta':2}
7 >>> dict_1['alfa'] #access value '1' by key 'alfa'
8 1
9 >>> dict_1.has_key('beta') #check that dict_1 has key 'beta'
10 True
11 >>> dict_1.keys() #print keys of dict_1
12 ['alfa','beta']
13 >>> dict_1.values() #print values
14 [1,2]
15 >>> dict_1['gamma'] = 1 #add new key:value pair
16 >>> dict_1['alfa'] = 'a' #overwrite key:value pair
As with lists, dictionaries can contain nested dictionaries:
1 >>> dict_1 = {'alfa':1,'beta':2} #define first dictionary
2 >>> dict_2 = {'gamma':1} #define second dictionary
3 >>> dict_1['nested'] = dict_2 #add dict_2 as value to key 'nested' in dict_1
4 >>> dict_1
5 {'beta': 2, 'alfa': 1, 'nested': {'gamma': 1}}
6 >>> dict_1['nested']['gamma'] #access key 'gamma' in nested dictionary
7 1
Modules and functions
user@machine:~$ more some_py_func.py
#print user-specified string def print_string(string):
- print string
}}}
1 >>> import some_py #import some_py.py (note absence of extension!)
It is usually more convenient to structure the stored code into functions that can be executed from the imported module. Functions are defined using the key-word def.
In many applications functions return objects to the user.
user@machine:~$ more some_py_func.py #return list of characters in user-specified string def print_string(string): return list(string)
Functions often require arguments that the user is supposed to provide.
user@machine:~$ more some_py_func.py #print user-specified string def print_string(string): print string {{{#!python >>> reload(some_py_func) >>> hello_list = some_py_func.print_string('Hello world!') >>> hello_list ['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!']
Objects
As mentioned, Python supports multiple programming paradigms, one of those being object-orientation. Object-orientation allows collection of data into objects, or class instances. The data collected in objectes is referred to as fields or attributes, objects also store functions that usually performs actions on the attributes. Object-specific functions are called methods. Here is a small example of class definition, initialisation, and usage of a class that stores a list and a dictionary.
user@machine:~$ more StringDL.py class StringDnLs: def __init__(self): self.str_list=[] self.str_dict={} def add2List(self,item): self.str_list.append(item) def add2Dict(self,key,val): self.str_dict[key]=val
In many applications functions return objects to the user.
user@machine:~$ more some_py_func.py #return list of characters in user-specified string def print_string(string): return list(string)
Objects
As mentioned, Python supports multiple programming paradigms, one of those being object-orientation. Object-orientation allows collection of data into objects, or class instances. The data collected in objectes is referred to as fields or attributes, objects also store functions that usually performs actions on the attributes. Object-specific functions are called methods. Here is a small example of class definition, initialisation, and usage of a class that stores a list and a dictionary.
user@machine:~$ more StringDL.py class StringDnLs: def __init__(self): self.str_list=[] self.str_dict={} def add2List(self,item): self.str_list.append(item) def add2Dict(self,key,val): self.str_dict[key]=val
1 >>> import StringDL #import module
2 >>> strdn = StringDL.StringDnLs() #create instance of class StringDnLs
3 >>> strdn.str_list #print StringDnLs field str_list
4 [] # which is empty
5 >>> strdn.add2List('a string') # add a string to str_list using method addList(item)
6 >>> strdn.str_list
7 ['a string']
Built-in functions, loops, conditionals, assignment, and evaluation
Some of the conventions for Python syntax we have already seen. Useful built-in functions include len(), which returns the length of an object,
and dir(), which returns a list of methods and attributes of an object.
You can read more about the built-in functions here.
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.
The step size is 1 by default, but can be specified as the third argument:
Note that the step size must be an integer. If floating point steps are needed, the arange() function from the numpy package can be used. It is very similar to the range() function but accepts floating point arguments and returns array objects, which can be converted to lists using the method tolist()
while loops iterate until a condition is fulfilled.
1 >>> a_list = ['a','b','c']
2 >>> i = 0 #assign value 0 to variable i
3 >>> while i<len(a_list): #as long as i is less than 3
4 print a_list[i] #print item at index i in a_list
5 i += 1 #increment i by 1
6
7 a
8 b
9 c
10
11
12
13 >>> for i in range(len(a_list)): #iterating over indices
14 print a_list[i]
15
16 a
17 b
18 c
Note that range(integer_1,integer_2) is a built-in function that returns a list of integers ranging from the one integer, integer_1, to (but excluding) the other, integer_2. If the first argument is left blank, Python assumes integer_1 is 0. For example:
The step size is 1 by default, but can be specified as the third argument:
Note that the step size must be an integer. If floating point steps are needed, the arange() function from the numpy package can be used. It is very similar to the range() function but accepts floating point arguments and returns array objects, which can be converted to lists using the method tolist()
while loops iterate until a condition is fulfilled.
This implies that if the condition i<len(a_list) is never fulfilled the loop continues indefinitely, which it will.
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.
If several options are possible the elif statement can be used.
You may have noticed it already, but it is necessary to point out the distinction between assignment and evaluation:
}}}
You may have noticed it already, but it is necessary to point out the distinction between assignment and evaluation: