# CS190/295 Programming in Python for Life Sciences: Lecture 6 - PowerPoint PPT Presentation

1 / 33

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.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

CS190/295 Programming in Python for Life Sciences: Lecture 6

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

## 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.

• 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

### 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 programmer-defined 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.

### 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

### 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

### 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’]