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 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:
if we assign a value to a variable, then typing the variable name will cause the value of the variable to be printed:
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:
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:
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".
The common mathematical operators (+,-,/,*) work as expected, note that x**y means xy. 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:
Explain (to yourself) the syntax of this. What type will the expression evaluate to? What value do you expect? Now try it out.
Strings
- Strings are sequences of characters and used to represent arbitrary text.They are found surrounded by quotation marks ( ' ) or double quotation marks ( " ).
The characters stored in the sequence are indexed by integers:
Common operations involving strings include the .upper(), .startswith(), and endswith() methods:
The type() function
- 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:
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.
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.
Items can be appended to a list by using the append() method.
- A list can also be created and populated in one go.
Or:
Indexing can be used to create a copy of part of a subset of a list, a process known as slicing.
The index of a known item can be retrieved using the index() method.
- .
Items can be removed from a list using the remove() method.
Nested lists:
Lists can contain any objects, including other lists. These lists are referred to as nested:
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.
Exercise: Repeat the previous list examples with the tuple. What works and what doesnt? Explain.
Dictionaries
. 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 "{}":
- As with lists, dictionaries can be nested.
Part 2: Loops and conditionals
Repetition
For loops
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.
- While loops
while loops continue repeating as long as some condition (the loop invariant) evaluates as True.
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.
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.
Filtering strings
Sometimes we might want to select strings that have certain attributes. Recall the .startswith() function:
This function, along with an if statement, can be used to specify which keys of a dictionary are printed.
None: Meetings/Nottingham2022/Prac2 (last edited 2024-09-10 14:18:21 by trunil)