#### Previous topic

CS 2120: Class #3

#### Next topic

CS 2120: Class #5

# CS 2120: Class #4¶

## Conditionals¶

• We’re pretty good at telling the interpreter exactly what to do now.
• But there is no room for choice. It’s just: do these steps in this order
• That doesn’t give us much flexibility (or computational power)

Activity

Using only the Python features/statements we’ve seen so far, can you write a program that will divide a number in half only if that number is a multiple of 2?

• We need to work towards conditional execution

## Logic First¶

Activity

Write out the truth tables for the logical operations AND, OR and NOT. Don’t know what a ‘logical operator’ or ‘truth table’ is? No problem. Ask Wikipedia. (Or your neighbour).

• To make parts of the program conditionally executed, we need a formal way to describe conditions.

• We need: logic.

• Let’s try some comparison::
```>>> 19 == 87
False
>>> 5==5
True
```
• Note that == is comparison while = is assignment. They are not the same! Python will punish you if you forget this!

Activity

Figure out what the other comparison operators in Python are. Hint: 3 doesn’t equal 5, it is ____ than 5.

• These operators can be applied to any two expressions (could be simply a value or variable, but can be more complex).::
```>>> a=15
>>> b=37
>>> (a+b)*9 > (b-a)*3 + 2
True
```
• What is the type of the result of applying a comparison operator?

## Conditional execution¶

• Now we can test if a comparison statement is True or False.

• We need a way to use that to control our program.

• if some condition is True, do something:

```if grade < 50:
print 'Shoulda gone to class more often.'
```
• If the condition following the keyword if is True, the code after the : gets executed.

• If the condition is False, the code gets skipped over.

• As usual, the block that gets executed/skipped is denoted with indentation

• The block can be as long as you want; no maximum size (though the minimum size is 1)

• (just like in a function definition)

Activity

Using only the Python features/statements we’ve seen so far, can you write a program that will divide a number in half only if that number is a multiple of 2?

## Compound conditions¶

• We can use the logical operators and, or and not to combine conditions.

• The combinations can be arbitrarily complex:

```if (grade < 90 and personality_type == 'A' and desired_career == 'med school') or (grade < 100 and personality_type == 'AAA'):
print 'Time to ask for extra credit!'
```

## Alternative execution¶

• This pattern is very common:

```if x > 10:
do_something()

if not(x > 10):
do_something_else()
```
• Programmers are lazy and don’t want to type the condition (here x > 10) twice (this also introduces the chance for more bugs)

• So if statements have a special else statement that can go with them:

```if x > 10:
do_something()
else:
do_something_else()
```
• Does exactly the same thing as the preceding code... but...

• Involves less typing and is easier to read and understand.

Activity

Write a Python function called hail that takes an integer as its argument. If the integer is even, return the value of the integer divided by 2. If it’s odd, return the value of the integer multiplied by 3 and with 1 added. That is: n goes to 2*n if even, 3*n+1 if odd. HINT: You may want to look up the Python modulus operator: %.

## Chains of alternatives¶

• Sometimes a binary if/else isn’t enough.

• What if I want several, mutually exclusive, alternatives?:

```if year < 1960:
print 'Jazz'
elif year < 1980:
print 'Rock'
elif year < 1990:
print 'Synthpop'
elif year < 2003:
print 'Alternative'
else:
print 'Music died when I got my first real job'
```
• elif is a contraction of else if

• NOTE: One one of the elifs gets executed, that’s it. The remaining ones are completely ignored.

• You can chain as many as you want

• Always end with a plain else to catch any conditions not covered in the chain.

Activity

Write a Python function that takes an integer from 0-100 representing a course grade and returns a string representing the letter grade: A,B,C,D or F. You can pick the cutoffs.

## Nested conditionals¶

• Computer scientists love “nesting” things: putting things inside other things.
• You can “nest” a conditional inside another conditional:

```if x > 0:
if y > 0:
else:
else:
if y > 0:
else
• Again, no limit to how deep you nest... but mind the readability of your code!

## Libraries¶

• Most of you are here because you are scientists who want to get stuff done
• The fastest way to get stuff done is by leveraging stuff that other people have done.
• Remember functions? Wouldn’t it be awesome if there were huge collections of functions that already existed... and did a lot of the stuff you want to do?
• One of reasons we’re using Python is because it has a huge variety of existing libraries/packages.
• No matter what you want to do, there’s probably a library that can help you.

## NumPy¶

• The most important library for us is Numerical Python (“NumPy” for short).

• We’re going to get quite a bit of mileage out of NumPy, and some of it’s affiliated packages, in this course.

• NumPy is not a core part of Python, but it is included in the EPD.

• For a scientist working with real data in Python, NumPy is absolutely essential

• Because it isn’t ‘built in’ to Python, we have to tell the interpreter that we want to use NumPy::
```>>> import numpy
```
• This guy talks a big game, but does NumPy pass the dogfood test?

## NumPy Types¶

• Recall that Python values have types.

• NumPy defines a whole bunch of new types.

• When you call NumPy functions, Python will, as always, try it’s best to guess at type conversions for you.

• but... you can be explicit about it, too::
```>>> x = numpy.float32(7.3)
>>> print x
7.3
>>> type(x)
<type 'numpy.float32'>
```
• and, hey, remember that weird ‘floating point’ thing that came up the other day? Check this out:
```>>> numpy.float32(3.33)
3.3299999
>>> numpy.float64(3.33)
3.3300000000000001
```
• When you are ready, grasshopper.
• You can convert regular Python types, and NumPy types, back and forth as you need.
• If you aren’t sure what type a variable has, remember that you can always check with type()

Activity

Write a Python function that takes two Python float s as inputs, converts them both into numpy.float32 type and then returns the product.