Transcript Lecture6 - University of California, Irvine

CS190/295 Programming in Python for
Life Sciences: Lecture 6
Instructor: Xiaohui Xie
University of California, Irvine
Announcement
• Homework #4 will be out this week (will send out
emails). Due on Feb 16 (next Thur)
• Lab session next Tuesday.
Control Structures
Part I: Decision structures
Multi-way decisions: if-elif-else
•
Python will evaluate each condition in turn looking for the first one that is
true. If a true condition is found, the statements indented under that
condition are executed, and control passes to the next statement after the
entire if-elif-else.
•
If none of the conditions are true, the statements under the else are
performed.
•
The else clause is optional; if omitted, it is possible that no indented
statement block will be executed.
Control Structures
Part 2: Loop Structures
For Loops
•
It allows us to iterate through a sequence of values
•
The loop index variable var takes on each successive value in
the sequence, and the statements in the body of the loop are
executed once for each value.
Indefinite Loops: while-statement
•
An indefinite loop keeps iterating until certain conditions are met.
•
Here condition is a Boolean expression, just like in if statements. The body
is, as usual, a sequence of one or more statements.
•
The body of the loop executes repeatedly as long as the condition remains
true. When the condition is false, the loop terminates
Nested Loops
Again in the number averaging example, suppose instead of one-per-line we
allow any number of values on a line, separated by comma.
Post-Test Loop
Suppose you are writing an input algorithm that is supposed to get a
nonnegative number from the user. If the user types an incorrect input, the
program asks for another value. It continues to reprompt until the user enters
a valid value. This process is called input validation.
Here is a simple algorithm:
repeat
get a number from the user
until number is >= 0
Post-Test Loop
•
Python does not have a statement that directly implements a post-test loop.
However you can implemented with a while statement using the trick of
“seeding”:
•
Or use the break statement:
Data Collections
Most real-world programs deal with large
collections of data
A few examples:
•Words in a document.
•Students in a course.
•Data from an experiment.
•Customers of a business.
•Graphics objects drawn on the screen.
•Cards in a deck.
Example problem: simple statistics
Extend this program so that it computes not only the mean, but also the
median and standard deviation of the data
Basic summary statistics
Lists
•
Lists are ordered sequences of items, a collection of values denoted by the
enclosing square brackets
•
Lists can be created by listing items inside square brackets
Lists vs. Strings
•
In Python strings and lists are both sequences that can be indexed. In fact, all
of the built-in string operations that we discussed previously are sequence
operations and can also be applied to lists:
Lists vs. Strings: differences
•
The items in a list can be any data type, including instances of programmerdefined classes. Strings, obviously, are always sequences of characters.
•
Second, lists are mutable. That means that the contents of a list can be
modified. Strings cannot be changed “in place.”
Tuples
• A tuple is a sequence of immutable Python objects.
Just like lists. The only difference is that types
cannot be changed.
• Tuples are defined using parentheses while lists
use square brackets.
• Examples:
Tup1 = (1,2,3,4)
Tup2 = (‘UCI’, ‘UCLA,’UCSD’)
List operations
•
•
Python lists are dynamic. They can grow and shrink on demand. They are also
heterogeneous. You can mix arbitrary data types in a single list. In a nutshell,
Python lists are mutable sequences of arbitrary objects. This is very different
from arrays in other programming languages.
A list of identical items can be created using the repetition operator.
•
Typically, lists are built up one piece at a time using the append method.
List operations: remove elements
List operations
Using lists is easy if you keep these basic
principles in mind
•
A list is a sequence of items stored as a single object.
•
Items in a list can be accessed by indexing, and sublists can be accessed by
slicing.
•
Lists are mutable; individual items or entire slices can be replaced through
assignment statements.
•
Lists will grow and shrink as needed.
Statistics with Lists
# get a list of numbers and store in a list
Statistics with Lists: Mean
Statistics with Lists: Standard Deviation
Statistics with Lists: Median
Simple Statistics: put together
Non-sequential collections
•
Dictionary is a build-in data type for non-sequential collections in Python.
•
Python dictionaries are mappings: Keys -> values
•
A dictionary can be created by listing key-value pairs inside a curly braces.
•
We can access the value associated with a particular key using:
•
Dictionaries are mutable:
Dictionary Operations
•
You can also extend a dictionary by adding new entries
•
In fact, a common method for building dictionaries is to start with an empty
collection and add the key-value pairs one at a time
Dictionary Operations
Dictionary methods: examples
References and Objects
• Consider the following example:
x = [1,2,3,4]
y = x
y[1] = ‘hello’
>>> y
[1,’hello’,3,4]
>>> x
[1,’hello’,3,4]
Note that items in x are also changed after y
assignment.
Call by reference in functions
• Consider the following example:
>>> def my_func(x):
x.append(’hello’)
>>> x = [1,2,3,4]
>>> my_func(x)
>>> x
[1,2,3,4,’hello’]