HW01 Connections - Expressions, values, types, operators, order of evaluation, variables, sequencing

c8 touched on values, expressions, call expressions

Let's get clear on values, operators, precedence, and types


In [ ]:
5+3

In [ ]:
5-3

In [ ]:
5*3

In [ ]:
-47

In [ ]:
# This is a comment.  It doesn't 'do anything', but ...
#  inform you and the reader of your code.  

# integers are like the integers you know, floats are like reals
5/3

In [ ]:
# if you want to stick to ints, be explicit about it
5//3

In [ ]:
# modulo or remainder
5%3

In [ ]:
# what do we mean 'rounds down'
2//3

In [ ]:
# we mean DOWN, towards negative infinity, not towards zero
-2//3

In [ ]:
-5//3

In [ ]:
# floats - they don't look like integers, and they aren't
3.141592

In [ ]:
# they behave like you would expect when you mix them
2*3.141592

In [ ]:
3.141592*3.141592

In [ ]:
# floats can have the same value as ints, but they are still floats
3.141592/3.141592

In [ ]:
# exponentiation
2**3

In [ ]:
# roots
2**(1/2)

What you should know:

  • two types: integers and floats
  • arithemetic operators: (+,-,*,/,//,%)

Expressions

follow 'operator precedence' The operations are performed one at at time in a specific order. Parentheses are used to specify order, just like in math class.


In [ ]:
# equal precedence, left to right
2 + 3 - 4 + 5

In [ ]:
# order matters.  Parentheses are your friend.
2 + 3 - (4 + 5)

In [ ]:
# make it explicit
(((2 + 3) - 4) + 5)

In [ ]:
2 + 3 * 4

In [ ]:
# * binds more tightly than + or -
2 + (3 * 4)

In [ ]:
(2 + 3) * 4

In [ ]:
# what about / ?
2 + 3/4 * 5

In [ ]:
2 + 3*4 / 5

In [ ]:
# left to right for same precedence
2 + ((3*4)/5)

In [ ]:
# can you always tell?
2 + 3 * (4/5)

In [ ]:
2 + (3*(4/5))

In [ ]:
2 + (3*4)/5

Call expressions

All of these operators are also functions. They have names. And those names reside in a namespace. Let's bring some of these operators into our namespace

You can learn more at https://docs.python.org/3/library/operator.html


In [ ]:
from operator import add, sub, mul, truediv

In [ ]:
add(2,3)

Variables

Introduced in c8 as "names for values". Assignment binds a value to a variable.


In [ ]:
pie = 3.1415

In [ ]:
# use variables just like values
pie*2

In [ ]:
# here's a better one
from math import pi
pi

In [ ]:
pi-pie

Order of evalation: one step at a time, in sequence


In [ ]:
# What is the order of evaluation?  Use variables to do this one step
# at a time
2 + 3/4 * 5

In [ ]:
x1 = 3/4
x2 = x1 * 5
x3 = 2 + x2
x3

In [ ]:
# but, all the variables remain.  
# Not just the value returned by the last expression
x1

In [ ]:
# what is the order of evaluation of
x1*x3+x1*x2

In [ ]:
# give each step a name

In [ ]:
# and variables and call all go together as you'd expect
y1 = add(x1,x2)
y1

In [ ]:
# so humpty dumpty can put it all back together again
# 2 + 3/4 * 5
add(2,mul(truediv(3,4),5))

Comparison operators: V x V => Bool


In [ ]:
2 >= 3

In [ ]:
2 < 3

So far everything you've seen looks the same as the arithmetic you did in elementary school. But back then you used the equals sign in two different ways without even knowing it. We need to be a little more careful.

When we mean the operator that tests for equality, we use ==.


In [ ]:
# Are these two the same?
2 == 3

In [ ]:
# Are they 'not equal'?
2 != 3

In [ ]:
3.141592 == 3.141592

In [ ]:
# Nice to be able to do this too
1 == 1.0

In [ ]:
# what's the order here?
1 / 2 == 3

In [ ]:
# nonsensical expressions do funny things
1 / (2 == 3)

In [ ]:
# makes more sense here
1/0

In [ ]:
# what is the difference between asignment and equality?
x = 2 == 3

In [ ]:
x

Bit more about numbers


In [ ]:
# this look right?
1/11

In [ ]:
# floats are really similar to reals
11*(1/11)

In [ ]:
1/11 == 0.09090909090909091

In [ ]:
11*0.09090909090909091

In [ ]:
0.0909090909090909090909

In [ ]:
# but not quite
(2**(1/2))**2

In [ ]:
# Be a little careful with floats
(2**(1/2))**2 == 2

Values all have types. Just ask them.


In [ ]:
type(2)

In [ ]:
type(2.0)

In [ ]:
2 == 2.0

In [ ]:
type(2 == 2.0)

In [ ]:
type("cool")

Are all values numbers??? No. You can represent anything in the computer. How about strings.

So what operators are defined on strings?


In [ ]:
# Concatenation
"cal"+"rocks"

In [ ]:
# Replication
"cal"*3

In [ ]:
# let's try something weird
"cal"*pie

In [ ]:
# string equality,
"cal" == "cal"

In [ ]:
"cal" == "rocks"

In [ ]:
# regardless of the kind of quotes
"cal" == 'cal'

In [ ]:
# lexicographic order
'cal' < 'rocks'

In [ ]:
# case matters
'Cal' == 'cal'

In [ ]:
# Uppercase before lower case
'Cal' < 'cal'

In [ ]:
# go on, it won't break anything
"cal"*"rocks"

In [ ]:
# These are really different, but we can still ask if they are the same - they aren't
0 == "hello world"

In [ ]:
# Not like C (what's 'C'? another programming language)
0 == ""

In [ ]:
False == ""

In [ ]:
# Not everything is comparable
0 < "cal"

Logical operations make sense on boolean values. And you can build expressions


In [ ]:
1 < 2 and 2 < 3

In [ ]:
1 < 2 or 2 > 3

In [ ]:
1 != 2 or "cal" == "rocks"

In [ ]:
not "cal" == "rocks"

In [ ]:
not "cal" != "rocks"

Strings are a very special type of sequence. There are others. We call these data structures. For example, tuples, lists, arrays.


In [ ]:
# tuples - created by separating values by commas (often in parens)
1,2

In [ ]:
type((1,2))

In [ ]:
# You can even assign tuples
a,b = 1,2

In [ ]:
a

In [ ]:
# lists - are in brackets
[1,2,3]

In [ ]:
type([1,2,3])

Every datatype has a set of operators defined on it - not just values. Try out some operators on sequences.


In [ ]:
# operators: concatenation
(1,2)+(3,4)

In [ ]:
[1,2,3]+[4,5]

In [ ]:
# replication
(1,2)*3

In [ ]:
# does this make any sense?
(1,2)*(3,4)

In [ ]:
# what about this?
[1,2]+(3,4)

In [ ]:
# conversion
list((1,2))

Variables are defined in a namespace


In [ ]:
from math import pi

In [ ]:


In [ ]:
# assignment defines the variable
pi = 3.141592

In [ ]:
# Sequence of statements 
# They happen one after the other
# Each can use the variables assigned before
r = 3
c = 2*pi*r
# and an expression
c

In [ ]:
# assignment
L = [1,2,3]

In [ ]:
# use it like any other variable
L

In [ ]:
T = (1,2,3)
T

In [ ]:
# comparisons - element by element
L == L

In [ ]:
L < [1,2,4]

In [ ]:
L == T

In [ ]:
L == [1,2,3]

In [ ]:
L > [1,2]

In [ ]:
L > [2]