Class 5: If, while & lists

… loops…
… loops …
… loops …
… & …
… lists …

The plan!
Basics: data types (and operations & calculations)
Basics: conditionals & iteration
Basics: lists, tuples, dictionaries
Basics: writing functions
Reading & writing files: opening, parsing & formats
Working with numbers: numpy & scipy
Making plots: matplotlib & pylab
… if you guys want more after all of that …
Writing better code: functions, pep8, classes
Working with numbers: Numpy & Scipy (advanced)
Other modules: Pandas & Scikit-learn
Interactive notebooks: ipython & jupyter
Advanced topics: virtual environments & version control

for … in … range
# the basic “for - in - range” loop
for x in range(stop):
code to repeat goes here…
it can be as long as you want!
and include, ifs, other loops, etc..
again, indentation is
everything in python!
# three ways to create a range
… range(stop)
… range(start, stop)
… range(start, stop, step)
(stop - 1)

okay, some exercises with loops
Basic practice:
- Write a script that asks the user for two numbers and calculates:
- The sum of all numbers between the two.
- Write a script that asks the user for a single number and calculates:
- The sum of all even numbers between 0 and that number.
A little more complex:
- Write a script that asks the user for a single number and calculates whether or not
the number is prime.
- Write a script that asks the user for a single number and finds all prime numbers
less than that number.

the “while loop”
---- file contents ----
# adding numbers, until we reach 100
total = 0
while total <= 100:
n = int(raw_input(“Please write a number:”))
total = total + n
print “The total exceeded 100. It is:”, total

total = 0
while total <= 100:
total = total + n
user_input = “”
while user_input != “stop”:
user_input = raw_input(“Type ‘stop’ to stop:”)
# the basic “while ” loop
while boolean:
code goes here
again, indentation!

total = 0
while total <= 100:
total = total + n
user_input = “”
while user_input != “stop”:
user_input = raw_input(“Type ‘stop’ to stop:”)
# the basic “while ” loop
while boolean:
code goes here
again, indentation!
NEVER use while loops!
okay… not “never”, but a “for loop” is
almost always better!

Let’s write the following variants of the lion/chair/hungry program. They start as
above, but:
- If the ‘user’ does not write ‘yes’ or ‘no’ when answering ‘hungry?’, keeps on asking
them for some useful information.
okay, juuuust one exercise using “while”
# the beginning of the lion / hungry program from last week…
chairs = int(raw_input(“How many chairs do you have?:”))
lions = int(raw_input(“How many lions are there?:”))
hungry = raw_input(“Are the lions hungry? (yes/no)?:”)
… etc…

data types for multiple things...
lists
[ 1, 2, 3, 100, 99 , 50]
strings
“wait, we already know these!”
tuples
(10, 11, 12, 100, 90, 80)
dictionaries
… we’ll get to those later…

lists!
# define a list like any other variable
# using “[” and “]” and commas:
numbers = [1, 2, 3]
print type(numbers)
# lists can contain different data...
mylist = [1, 2.0, 50.0, True, “wow”, 70, “that’s cool!”]
# lists can even have lists as elements!
awesome = [‘A’, ‘B’, [5, 3, 1], “amazing”, [“stuff”, “with”, “lists”]]
# lists can also be defined using variables (of course)
pi = 3.14
a = 100
mega_list = [50, 40, a, pi, 1, mylist]

indexing and slicing
# lets define a list…
numbers = [1, 2, “a”, “b”, 99, 98]
# indexing: find the 2nd
element in the list:
print numbers[1]
# remember, we start counting at 0 :)
# slicing: find the first 3 elements:
print numbers[:3]
# yap, also “n-1”
# slicing: ignore the first three elements:
print numbers[3:]
print numbers[3:5]
# what about negative numbers?
print numbers[-2]
# reassignment
numbers[3] = “X”

what about strings?
# lets define a string
mystring = “What if a string is basically a list of characters?”
# indexing and slicing on strings:
print mystring[8:]
print mystring[20:36]
# but … this won’t work...
mystring[8] = “A”

what about strings?
# lets define a string
mystring = “What if a string is basically a list of characters?”
# indexing and slicing on strings:
print mystring[8:]
print mystring[20:36]
# but … this won’t work...
mystring[8] = “A”
list
a “mutable object” (i.e., we can change the list
after creating it)
string
an “immutable object” (and cannot be
changed after creation).

what about tuples?
# lets define a tuple:
# note the “(” and “)”
sometuple = (1, 2, “A”, “B”, 100.0)
print type(sometuple)
# indexing and slicing on tuples:
print sometuple[3]
print sometuple[:3]
# this also won’t work...
sometuple[2] = “X”
# muuuuch better
somelist = list(sometuple)

what about tuples?
sometuple = (1, 2, “A”, “B”, 100.0)
print sometuple[3]
print sometuple[:3]
# muuuuch better
tuple
is basically an “immutable” list. Its values
cannot be changed after creation.

what about tuples?
sometuple = (1, 2, “A”, “B”, 100.0)
print sometuple[3]
print sometuple[:3]
# muuuuch better
tuple
is basically an “immutable” list. Its values
cannot be changed after creation.
don't use tuples
They just confuse you. Unless you
have a really good reason to make to
define an immutable object...

what about pancakes?
---- pancakes.py ----
# lets define a list of pancakes:
pancakes = [“strawberry”, “chocolate”,
“pineapple”, “chocolate”, “sugar”, “cream”]
# finding an element: index()
print pancakes.index(“sugar”)
print pancakes.count(“chocolate”)
# removing an element: remove()
pancakes.remove(“sugar”)
# removing and storing the last element: ()
popped = pancakes.pop()
print pancakes
print popped
# removing and storing the an element by position: ()
popped = pancakes.pop(2)
print pancakes
print popped
Using an existing list with methods:
mylist.method()
Finding things:
.index(element) ← first only
.count(element)
Removing things:
.pop(<pos>) ← returns element
.remove(element) ← first only
Adding things:
.append(element)
.insert(<pos>, element)
.extend(newlist)
Not a method, but also useful: len(list)

what about pancakes?
---- pancakes.py (cont) ----
# adding an element to the end: append
pancakes.append(“cherry”)
# inserting an element to the beginning
pancakes.insert(“kiwi”)
# inserting an element anywhere
pancakes.insert(3, “more kiwi”)
print pancakes
# extending one list with another
newlist = [“cheese”, “bacon”]
pancakes.extend(newlist)
print pancakes
# getting the length
print len(pancakes)
Using an existing list with methods:
mylist.method()
Finding things:
.index(element) ← first only
.count(element)
Removing things:
.pop(<pos>) ← returns element
.remove(element)
Adding things:
.append(element)
.insert(<pos>, element)
.extend(newlist)
Not a method, but also useful: len(list)

copying lists
# making a copy of a list:
morecakes = pancakes
pancakes.append(“banana”)
print pancakes
print morecakes

copying lists
# making a copy of a list:
morecakes = pancakes
pancakes.append(“banana”)
print pancakes
print morecakes
# use list() or [:] to copy a list:
anothercakes = list(pancakes)
anothercakes.remove(“banana”)
print anothercakes
print pancakes
“=” does not copy a list!
list2 = list1 ← are the same list
… use:
list2 = list(list1)
list2 = list1[:]

exercises!
Here is a hamburger:
First, let's remove ingredients that don’t make sense. Then, add some ingredients, and
put them into the place you think they belong. Add (at least): Tomatoes, Salad, cheese.
hamburger = ["bread", "burger", "chocolate", "bread"] # left is the bottom, right is the top :)

lists, loops and conditionals
---- somefile.py ----
# lets take a close look at “range”:
a = range(10)
print type(a) # (note: different in python 3)
# using lists in loops:
a = [1, 2, “a”, “b”, “hello”, 3.0, 99]
for element in a:
print element, “is of type:”, type(element)
# using lists in tests and conditionals:
mylist = [1, 2, “a”, “b”, “hello”, 99]
print “is a in the list:”, a in mylist
for a in range(100):
if a in mylist:
print a, “is in the list!”
Using in with lists:
for var in list:
do stuff in loop
if var in list:
do “True” block
else:
do “False” block

- How many ingredients are there in total?
- Are there any in the “stack” which are not in “pancakes” or “hamburger”? (add
these to the correct list)
- By majority vote: is it a pancake or hamburger?
hamcake!
# you should be able to copy-paste this :)
stack = [
"chocolate", "strawberries", "salad", "chocolate", "salad", "cheese", "cream", "cheese", "tomatoes", "bacon", "bacon", "tomatoes", "burger", "onions", "cheese",
"banana", "pineapple", "tomatoes", "bacon", "cheese", "burger", "salad", "tomatoes", "onions", "chocolate", "pineapple", "tomatoes", "onions", "salad",
"strawberries",
"egg", "cheese", "tomatoes", "burger", "bacon", "cream", "sugar", "burger", "ketchup", "salad", "chocolate", "cream", "egg", "sugar", "salad", "pineapple", "bacon",
"cheese", "bacon",
]
pancake = [ "chocolate", "strawberries", "chocolate", "salad", "cream", "pineapple", "sugar",]
hamburger = [ "tomatoes", "bacon", "cheese", "burger", "salad", "onions", "egg", ]

Class 5: If, while & lists

Recommended

More Related Content

What's hot (20)

Viewers also liked (11)

Similar to Class 5: If, while & lists (20)

Recently uploaded (20)

Class 5: If, while & lists