all right so welcome to the first
lecture of 6100 L that's our new number
um my name is Anna Bell that's two
separate names first name Hanah last
name Belle super confusing but I've been
a lecture here in the ECS department for
probably almost 10 years now and I've
been doing the intro course for a while
I'm really happy to be teaching this
full semester version of
6100a so um today what we're going to do
is go over a little bit of course
administrative information and then
we'll Dive Right into just some thoughts
about computers high level how they work
and then we'll start going into some
python Basics so we're going to get
coding right away so I hi highly
encourage you since you're in this class
to download the lecture slides
beforehand to take notes and uh run code
when I do um some of the lectures are
interactive so and and we'll have breaks
so there'll be a a place where you uh
can take a break to actually do some
coding and that's important uh I call
them utri breaks that's important to
make sure that you're actually
practicing what we are learning right at
this time um the main idea for lectures
is yes I will do some teaching but there
will also be opportunities for questions
and for uh you guys to try some
programming right on the spot even if
you don't finish writing a program that
we start talking about I will finish it
and we can all kind of talk about it
together and I'll kind of show you some
uh pitfalls and things like that um
there will be lots of opportunities to
practice in this class through at
various degrees of granularity um and
then there's also lots of opportunities
um that I have in the handouts to do
extra practice at home and through a
bunch of different resources as well um
the reason why I stress participation
and practice is because part of the
reason you're here is you want to learn
how to program right you you don't know
how to program yet and programming is
actually a skill right it's like math or
reading it's something that you have to
practice you can't just watch me type in
a bunch of lines of code and then when
it comes time for to do the quiz you'll
automatically know how to do it you need
to do it often more and more so that it
becomes sort of second nature right so
the three big things you'll get out of
this class are knowledge of Concepts
obviously we're going to learn some
computer science ideas programming skill
and problem solving um problem solving
skills lectures and exams basically uh
help you with your knowledge of or test
your knowledge of Concepts and help you
get knowledge of Concepts finger
exercises get uh uh give you the
programming skills and the problem sets
help you with problem solving basically
if you're given an English version you
know of a problem in English how do you
go from that to thinking about what
computer science Concepts can I apply
and then after that how do I take those
computer science Concepts and actually
do the
programming so what are some topics
we'll be covering we will be at the core
of it learning computational thinking so
in the future when you encounter a
problem you can uh your first thought be
how do I kind of mathematically solve
this or how do I brot force right
manually solve this problem how can I
apply computation to help me solve this
problem and throughout these lectures
you're going to see some examples of us
applying computation to a problem you
might have already seen and maybe solved
uh mathematically um which is pretty
cool um obviously to get to that we're
going to learn the Python programming
language once we get the basics we're
going to see how we can start to uh
structure our code to look a little bit
better so we don't just have a bunch of
code dumped on a on um in a file we're
going to start to organize our code and
see how we can um make it neat readable
and modular and then towards the uh uh
uh not in this lecture but in a couple
lectures and as a theme throughout this
uh this class we're going to look at
some algorithms they're not super
complicated but they're kind of the base
algorithms for a bunch of algorithms you
might see um in the future if you decide
to take more CS classes
um lastly towards the end of the class
we're going to see algorithmic
complexity which basically means we're
going to start asking or trying to
answer the question um how do we know
the programs we write are efficient
right we can write programs but how do
we know that they're fast and how do we
know that they don't you know take up
all the memory in the computer so things
like that um comparing different
algorithms that do the same thing um
against each
other so if there's no
questions again as I said a bunch of
this information is already in the
handout plus more we can
begin okay so let's start by talking
about
knowledge um declarative knowledge is a
statement of fact and a lot of us
probably in math and in the past have
worked with declarative knowledge but
this is not how computer science this is
not how this class Works um in computer
science what we do is we we work with
imperative knowledge which is basically
a recipe how to do something and when
we're programming all we're doing is
writing a recipe for the computer to do
something that's
it so here's a numerical example um the
first statement is a declarative uh
statement right uh the square root of a
number X is y such that y * Y is equal
to X there are many possible values for
X and Y that this statement can be true
right but if we gave that statement to a
computer it wouldn't know what to do
with it what we need to do is tell the
computer how to find the square root of
a number and then tell us what the
square root of that number is and so the
computer then needs a
recipe um so the recipe a really simple
one for finding the square root of a
number is steps 1 two 3 so what we do is
let's say we want to find the square
root of
16 it we obviously know it's four but
the computer doesn't and so we give it
an initial guess let's say the guess is
three how do we go from there so the
steps we follow step one if um 3 * 3 9
is close enough to 16 we can stop it's
not really close enough for me so let's
keep going step two otherwise so we're
going to make a new guess by averaging G
which is our original guess three and X
over G which is 16 over 3 right 16 was
the square root we wanted to find so our
next guess is
4.17 okay using the new new guess repeat
the process until we are close enough so
we go back to step one that's the first
part of the process we find guess
squared 4.17 squar is
17.36% and 16 divid 4.17 right that
gives us our new guess
4.35
okay next step right using the new guess
we repeat the process so 4.35 squar is
0277 is that close enough to
X yeah I could be happy with this I
could stop there because we're within
sort of plusus one so I'm I'm okay with
that but if we wanted to be within plus
or minus one time 10 the negative like
six or seven or something like that then
we would continue the
process so really what we had there is
an algorithm right it's a sequence of
steps step one step two step three
there's some sort of flow of control
right we had uh a place where we said if
this is you know if if the guest is
close enough then you know we can stop
otherwise we do something else we had
another uh flow of control where we said
repeat this thing right so we're kind of
not going linearly but we're changing
the flow and then lastly is a way to
stop right we don't want the algorithm
to go on forever we would like to stop
at some point and the stopping point I
was kind of vague about it but it could
be you know when we were within plus or
minus one of the actual uh
answer and so right
recipes are basically algorithms right
my grandmother was basically teaching
algorithms when she would teach me to
like to to to bake a cake right she
didn't call it that but she was really
um and so even um recipes have that same
structure there's a sequence of steps
there's a flow of control like if you
don't have egg use egg substitute or
repeat this um you know repeat sticking
a toothpick to see if it comes out clean
every minute or something like that and
then there's a mean a way to stop right
when the toothpick comes out clean you
take it out of the oven and you eat
it and so computers are machines that
execute these algorithms they're
actually dumb right computers are not
very smart they don't make decisions on
their own they just follow these
sequences of steps that we told to do
computers are good at storing lots and
lots of data right we can't really do
that but computers can store um
gigabytes of storage terabytes even and
computers can do operations really
really quickly which is something we
can't do right they're good at those two
things but they're not very smart they
can't make decisions unless they're told
to make the
decisions
um so really the computer only does what
you tell it to
do and that's one of the big ideas that
I want you to come away uh from this
from this lecture with computer only
does what you tell it to do right the
sequences of steps that you tell it to
do that's the only thing it
follows so a little brief history just
to kind of make you appreciate uh
programming Python programming language
before we actually get started with it
is um so before the 1940s we had these
things called fixed program computers
okay like a pocket calculator is an
example of that every button was an
operation you could you know in the
little screen you could use parentheses
to put a bunch of different operations
together but there was no way to sort of
store all these operations together to
um to you know later put in different
inputs for that same sequence of
operations you had to input it every
single input those sequences of
operations every single
time um after the 1940s stored programs
computer uh computers came into play and
they were able to store instructions to
do things as
data okay and there was a special
program called an interpreter that
executed these instructions it knew how
to follow simple sequences of steps when
the program told it to go to a different
location it did so it was it was
basically executing these
instructions and um the instructions
that it it did were um arithmetic and
logical so addition subtraction things
like that simple tests like checking for
equality between two values and moving
data so taking this value and putting it
at a different memory
location so I just wanted to give you a
really brief overview and this is not
super accurate but it gives you a sense
of how exactly things happen um lowlevel
um in uh in the computer so the computer
basically has memory where things are
stored it has an arithmetic logic unit
that does operations it knows how to add
things subtract things multiply things
compare things and then it has the
control unit where this program counter
is um is set and this is where you put a
program in so see how this works um this
is a program and up here is our memory
so we have a bunch of memory locations 3
4 5 6 3 4 5 7 and at each of these
memory locations we have some values
stored pre you know
pre-filled so when we first run this
program what ends up happening is the um
The Interpreter sees the first
instruction add the values at 3456 and
3457 together so it goes to these memory
locations here grabs the three and the
four and sends them to the arithmetic
logic unit the ALU knows how to do the
addition so it adds 3 + 4 seven and
sends the result back here now we never
told it to store that result anywhere
but the next instruction says store the
value you just got back from the ALU at
this memory location 34 58 so the next
step basically takes that 34 uh that
seven and stores it at memory location
3458 super tedious all we did was add 3
4 we do that again uh we add 7 the
values at 7889 and 7890 so it goes in
the memory it grabs the five and the two
sends it to the
ALU the ALU calculates it as seven
brings it back and then we store that in
location 7891 okay and then after that
all we've done is two additions um and
then the next instruction says compare
the values at memory locations 3458 and
78 91 so we're going to compare the
seven with the
seven the ALU again does this comparison
and says all right well seven and seven
are equivalent so this is you know true
or whatever it wants to give give back
to the um to The Interpreter and then
the last instruction here we have is
print the result of that comparison so
we print true because they were equal
right again super high level but it kind
of gives you an appreciation for um
programming languages these days right
this is very tedious to write if we had
to write programs in in this manner um
Alan Turing a long time ago showed that
you can compute anything with actually a
very an even more basic set of
Primitives not addition subtraction but
instead with a tape you would actually
have six Primitives move the tape left
move the tape right read the value at
the tape put a value on the tape um
erase the value from the tape and no
operation and so since he showed this
what the result of it actually was um is
down
here anything computable in one language
is computable in any other programming
language so if we had some you know some
program written in Java that basically
boils down to right something super long
but something that is made up of these
six
Primitives that means that if we've
boiled down this program to these six
Primitives we can build back up the same
program in a completely different
language and that's really powerful
that's a really cool
statement now we're not going to be
working with those Primitives um we're
going to be using the python Primitives
which uh are more convenient and they
allow us to do a lot more things in much
less time I'm going to do a little
comparison as we talked talk about The
Primitives of python with
English so in English some of the
Primitives might be um words or even we
can do letters or characters but you
know we can we can say it's words um you
know with characters we can build up
words with words we can build up
sentences with sentences we can build up
stories with stories we can build up
books and things like that in
programming um in programming languages
The Primitives are
numbers um sequences of
characters uh operat like addition
multiplication division
um uh checking for equality checking
that something is greater than things
like that so once we have these
Primitives in a language we can start to
build up the syntax of the language so
in English having something like noun
and noun noun doesn't make any sense
right cat dog boy doesn't make much
sense it's not syntactically valid but
noun verb noun is tactically valid right
similarly in programming languages we
can have two objects kind of side by
side so here this is a sequence of
characters H and I and this is the
number five right beside that sequence
of
characters but that doesn't make any
sense right what does it mean to have
this sequence of characters and that
number right beside it it has no meaning
in Python instead what we have to do is
we have to add an operator in between
these two objects so here we add a
little star operator in between the
sequence of characters High and the
number five and in Python the meaning to
this is I want to repeat the sequence of
characters High hi five times so this
would basically give me high high high
high
high so once we have um sentences in
English right and and and uh Expressions
that are syntactically valid we can now
talk about the static semantics of the
language so in English saying something
like I are hungry is is syntactic Ally
correct but it's not synta uh static
it's not sorry it's not it doesn't have
uh good static semantics right there's
no meaning uh there's no meaning to that
because the r is for you know you or
plural similarly in programming
languages and this will differ depending
on what programming language you use um
here you know in the previous slide we
saw that you can use the star operator
between the uh the the sequence of
characters and the number and that meant
repeat that um that sequence many times
but if we use a plus operator in between
the sequence of characters and a number
that doesn't have uh any meaning in
Python so it has a static semantic error
even though it's syntactically valid
right we have operator uh sorry uh
object operator
object so so far we've been able to find
really nice parallels with English right
uh the English language and the
programming language but this is kind of
where things break down when we talk
about the semantics of a language so in
English you can have many different
meanings right the chicken is ready to
eat means let's eat this chicken um or
the chicken is ready to eat means the
chicken wants to eat something right
programming languages there is no
multiple meanings to a program that you
write because the pro because the
computer the machine the language
follows the set of instructions to a te
there's 's no ambiguity about what it
needs to do right it just follows the
instructions and does what it needs to
do to the end till it reaches um you
know the it terminates the program and
so programs only have one meaning but
the problem is it might not be the
meaning that you intended it to
have and that's when things start to go
wrong we can have syntactic errors in
our program spelling errors and
indentation errors things like that and
those are easy to catch static semantic
eror are 90% probably easy to catch but
the problem comes in with the semantics
right the meaning that you intended this
program to have might not be what it's
actually doing and that's where most of
my errors happen and that's where I get
super frustrated when I program and
that's probably where you guys will get
super frustrated too because you write a
program that you think is doing one
thing but instead either it crashes
right away or runs forever and doesn't
really stop or it terminates but it
gives you an incorrect answer it's not
what you expecting and we're we'll talk
about this um in a in in a few uh a few
lectures so when we write programs we're
basically writing sequences of
definitions and commands and we're going
to write these either in a file editor
or in a shell the first today at least
we're writing in the shell directly and
half of Tomorrow will write in the Shell
um because we're not really writing any
uh we're not really uh really writing
many lines of code um we're just going
to be I'm just going to be showing you
some really quick um uh quick things
that we can do with the Python
programming language so hopefully you
all have installed the programming
environment um this is the code editor
so tomorrow we'll start working in here
but for today we're really just going to
work on in the shell and even in the
future um you can still type commands in
the Shell I find the shell very useful
if there's just something really quick
that I want to check that I don't want
to write a you know write a program for
and then run it's just like a simple
command that I want to check to make
sure it's doing what I think it's doing
before I insert it in my code editor um
so here we
[Music]
have this right so mine is uh I guess
I'm using the White theme just because I
find it easier for you guys to see um
this is the file editor um and this is
just a bunch of Expressions uh yeah a
bunch of code that we're going to type
in today and we're going to type it in
the Shell today so the thing on the
right hand
side okay so what exactly do we do when
we write a program at the base of it we
are going to create objects inside our
programs and we're going to manipulate
them that's it that's what programming
is mostly about um as it's at its core
now when we create objects it's
important this is kind of something
we're going to come back to again and
again in a kind of more High Lev setting
but right now what I want you to
understand is that when we create an
object an object has a type okay and the
type that an object has tells python the
things you're allowed to do with that
object so here are two examples the
number 30 it's a number
um the type we we'll talk about it in a
bit the type is an integer it's a whole
number but basically what are the things
we can do with this integer with this
number we can add it to another number
we can subtract it to another number we
can take it to another power we can take
some other number to this power of 30
right a bunch of sort of mathematical
operations as you would expect so that's
pretty straightforward what about this
one here this quotation um capital a
lower case a lowercase n lowercase a
quotation so this is something we'll
talk about next lecture it's called a
string and it's a sequence of
characters the quotations tell python
it's a sequence of characters and the
characters part of it are capital a
lowercase n lower case
a the kinds of things I can do with this
string are not the same kinds of things
I'm allowed to do with a number right if
I tried to take um Anna and divide it by
the sequence of characters Bob
uh python would complain very much right
because you can't divide a string by
another string a sequence of characters
doesn't make sense to divide it by
another sequence of characters similarly
I can't take Anna to some power right I
can't multiply uh or I can't multiply by
itself things like that but the kinds of
things that I am allowed to do on a
sequence of characters is different than
the kinds of things I'm allowed to do on
a number so the things I can do with a
sequence of characters is I can say well
what's the character at the first
position what's the middle character how
long is the sequence of characters right
how many characters do I have and so now
you can see that the the type of the
object is actually really important
python uses it to to know the kinds of
operations you're allowed to do with it
and so there's actually um scalar
objects and these are Python's
Primitives um numbers and truth values
and there are non-scalar objects we're
not talking about these yet we'll talk
about these in a few lectures but um
these have some sort of structure so for
example a list of numbers has a
structure because there's a number at
the uh beginning of the list there's a
number at the end of the list things
like that but a number itself doesn't
have a structure it's just the
number so what are the types of the
scalar objects what are the types of The
Primitives in Python integers so number
five Z negative 100 a
million float is another type it
represents all the real numbers so three
you know 3.27 2.0 is a float because it
has a decimal number even though to us
that just means two but to python if you
put in 2.0 it says that's a type float
negative 3.14159 things like that bull
is a Boolean it represents truth values
and there's only two possible values
that a Boolean type has um true and
false and it has to be capital T true
and capital T oh sorry capital F
false and the last one is this uh nun
type uh uh type it's literally called
nun type and it has only one special
value none we're not going to talk about
it for a bit but we will sometime in the
future so to figure out the type of an
object when you create that object you
um you use the type command so we can
say something like type parentheses and
this is a command and inside the
parentheses you say what do you want to
find the type of so if we do type of
seven it tells me it's an INT
um and if you want to do the same
command again I hit the up arrow and it
automatically puts in what I wrote
previously and then if I want to do type
of
0.0 it's a float because there's a
decimal point
right um so this is basically what I
said so we type this in the Shell um and
uh the shell tells us what uh the output
is so just to
reiterate int float bu and nontype are
types of
objects and there can be many different
objects you can create of that type
right so if you think about it ins and
floats we basically have an infinite
number of objects we can create of those
types right because we can have zero 1
two three 100 200 300 a million right
there's and all the negatives there's
almost you know infinite number of
values uh objects that we can create of
type intern float but bu there's only
two the truth values true or false and
the non type there's only one this none
right so that's the type and these are
the possible values possible objects we
can
create you try it so you can just yell
out the answers uh there's nothing to
type unless you want to check yourself
so what is the type of
1,234 int type of
8.99 float type of 9.0 type of true bu
and type of false bu perfect if you ever
wonder what the type of something is you
type it in here just you guys are doing
well type is Bull type of lowercase T
true is an error just wanted to point
that out just to reiterate the fact that
capitalization matters in Python this is
our first error by the way guys very
exciting um the error is a name error
and this is the um messages associated
with
it um you also know that uh it's
something special in Python when you
have colorcoded stuff so you see capital
T true capital F false are uh this dark
blue here right whereas anything that's
not um spe special in Python is just
black right so type is a special Command
right this is a float so you see that
they're
colorcoded okay so once um we create
objects one thing we can do with these
objects is to cast them to a different
type now this is a little bit um maybe
confusing because we're not actually
changing the object once we've created
it so once we create the integer three
it's there in
memory if we cast that integer to a
float version of it we're creating a new
object in memory we're not changing the
three the three already exists we're
just getting the float version of it and
storing it as a new object in memory so
when we do float three this is a command
that gets for me the float version of
the integer three okay so that will give
me 3.0 so for
example um right this is what I had
float
three right the output is
3.0 if I do int of
5.2 it truncates it and it gives me the
integer portion of this float if I do
int of
5.9 it still truncates it and gives me
the integer version of this float it
doesn't round right I'm just asking for
the integer version of this of this of
this float some operations like round is
an operation we can do um has an
implicit cast in it so if I round 5.9
it's actually going to round it to 6.0
and then cast it to an integer so notice
it doesn't give me as an output put 6.0
it then rounds it to just
six okay um so that's basically what I
said um in the example so let's have you
try this um what are the types of the
following I don't need the values but
the types so if I get type of float of
123 what is the type of
that float yeah exactly yep I'm yep what
it what if I round 7.9 what's the type
of the result int yep what if I create a
float of the round of
7.2 yes good uh float would be 7.0 and
the int of
7.2 int yes exactly I want the type not
the value and the int of
7.9 is an INT exactly awesome
good Okay so we've created a bunch of
objects right we we know that we can
create a bunch of objects in our
programs what do we do with them well we
can combine them into
Expressions so let's say we have 3 + 2
I've got object operator object cool
syntactically valid in Python and has no
static semantic error so if I do that in
Python it's going
to be okay 3 + 2
5 and the type of 3 + 2 is an
integer right so basically what I've
done here I've put an expression within
this type um command and that's okay
right that's in fact encouraged in
Python you don't just want to calculate
and then stick in um that would be very
very tedious so you can insert
expressions in many many different
places right so here we have 3 + 2 5
divid 3 again we've got you know 5
divided 3 has this decimal value and the
result has a float has of type is of
type
float so the important thing to remember
when we're doing Expressions is python
reads the expression but it does not
store the expression in memory okay what
it does is it reads the expression
evaluates it to one single value and
then it stores the result value in
memory so it never stores the expression
it evaluates the expression and then
stores the value okay and so this is the
Syntax for an expression object operator
object as we just um just saw and that's
really and the idea I said before right
where python stores uh values of
Expressions not the Expressions them
themselves is really really
important right so this is my first big
idea slide um I decided to insert these
because I think they kind of stress the
importance of several Concepts so I hope
this is one um so you know we're taking
Express Expressions they can be as
complex as you'd like we can use
parentheses you know a bunch of it can
doesn't just have to be operator uh
object operator object it can be more
complex than that but basically however
complex that expression is we evaluate
it and we replace it with one value and
the
expression can be something like this it
doesn't just have to be something that's
mathematical right this was a
mathematical expression but this is also
an expression and it evaluates so this
entire thing
evaluates to this uh word you know this
word which represents the type
integer so here's some more examples um
3 plus 2 again um we got uh we've got
these uh examples with the parentheses 4
plus 2 * 6 - 1 obviously gives us the
number 35 and then we can insert
Expressions wherever we'd like so here
I'm inserting that specific expression
in the type command and this is also an
expression like I just said and its
result is
int okay and similarly we can also
insert that expression here and then we
can wrap that around cast and it gives
us a flow
yes when you're inserting
Expressions the
operator when you're inserting sorry
when you're inserting what well since
you said their expressions and you said
that you need like uh object operator
object expression typ
in this Cas oh I see um how are they def
yeah that's a good that's a good
question um
so in this particular case the type and
the float are not uh there is no
operator I guess in this particular case
it's more like a command that gives us
an output but there is still some there
is there is still an output that that it
gives us so we can then take the result
of this and save it somewhere else sorry
yeah I guess the the example I gave on
the previous slide was just an example
of an expression where we could do
object operator object
yeah um okay yeah so when we have these
uh I guess it works for mathematical
Expressions uh mathematical Expressions
work left to right just like in math
parentheses can override uh certain uh
uh
precedence um if we have commands that
have computations then we have this
command with the parentheses and we
evaluate what's inside the parenthesis
first so we work our way in to out in
that particular
case um so here's some examples let's
have you try these so we can type these
in our console uh what are the values of
the following Expressions so 13 - 4 / 12
* 12 so we can try
that um I don't know off the top of my
head so we'll have to type it in 0625
okay so the value of that expression is
a float right 0625 what's the value of
the expression type four time
3 int yep what about the type of the uh
expression 4.0 *
3 yes exactly that's very good so the
type of 4 * 3 is int but 4.0 * 3 is a
float good and then what about int of a
half or of one over
two yeah exactly it's
zero yep because it's 0.5 and we
truncate to
zero the reason I had this here is
because it leads nicely into this slide
you don't have to memorize these rules
you can always check it out in the
console but there are some rules for the
resulting types when we do operations so
um when we uh do operations with numbers
addition subtraction and
multiplication um always yield an
integer if both of the operators are
integers if one is a float or both are
floats then it gives me a float division
is different no matter what uh types you
divide you'll always get a
float okay
now what about this slash slash and this
percent these are actually useful
operations they kind of go hand inand
with division so when I do five divided
three it's this 1.
667 slash slash is basically a floor or
you know getting the integer portion of
the division so five sl3 gives me one
right it
truncates the um the the the fraction
the percent gives me the
remainder so 5% 3 gives me the remainder
when I divide 5 by three so it's going
to give me give it to me in a whole
number right so that's going to be two
because there's two left over when I
divide five by
three so these are pretty useful
operations um the the slash slash and
the percent when when we do sort of
mathematical programs the last thing is
the star star is how we denote um Power
exponentiation kind of different than uh
than you might be used to in math so 2
to the^ of 3 8 right 2 to the^ 3.0 8.0
and the rules for um integer uh integer
division percent and exponentiation are
just like addition subtraction
multiplication if one is a float then
the result will be a float as
well
okay um
yeah okay and we talked about the type
of
output uh so I think I briefly mentioned
this uh the operator precedence is
exponentiation and then multiplication
division percent remainder uh at the
next level and then addition subtraction
at the bottom but you can always
override these using
parenthesis okay question so far before
we move on yes so why division why does
it always result like like 9 by and
that's
why yeah so the question is why does it
always uh result in a float if it didn't
I think it would uh the operation itself
would have to do extra work to figure
out whether it's a whole number or not
so I think it's just easier that it
gives us always a float um I guess uh
previous versions of python the slash
was actually I think integer division
which is super counterintuitive because
you would use that in your program and
then you would basically integer divide
and things would go wrong but again I
just a design Choice uh on behalf of the
programmers yeah other questions so
far okay so we have a lot of objects
right objects have different types again
floats integers
booleans what can we do with them right
so far they're kind of just sitting in
there and we can get properties about
them but what we'd like to do is write
programs basically trying to automate
some things about these objects
manipulate them to help us uh achieve
you know a more complicated and
interesting
program so what we can
do to uh to get to that to that end is
to start assigning names to some of
these
objects okay if I create an object for
uh for PI right in my program to 20
decimal places somehow and I have that
number in my program that float in my
program if I want to use that number in
many different places in my program I'd
have to copy and paste it a whole bunch
of times right so
far which is very tedious lots of Errors
will happen right I don't want to do
that so instead what I can do is I can
give a name to this ridiculously long
value of pi called PI right and then I
can just use this name anywhere I want
to grab that ridiculously long value for
pi in my program it's a lot easier to
read right it's a lot easier for me to
write this program and you know it it it
leads to a really nice um uh and neat
program so what we can do is we can
start saying that you know the float 001
will be uh referenced by the name small
or uh you know the the 100.4 will be
referenced by the name
temp so what we want to do is create
these things called variables and a
variable is different in computer
science uh uh from a mathematical
variable or variables that you've known
so far in math so math variables come
back to the idea of declarative
knowledge right a declarative statement
you can have something like a plus b is
equal to B minus one in math right or X
is equal to or x x x is equal to Y and
that's perfectly okay right in math we
basically say that variable X represents
all the square roots of y That's not
going to fly in computer science
computer science we don't have right we
don't do declarative knowledge we do
imperative knowledge and so what we're
working with in computer science is a
bunch of assignment
statements so what we can do in computer
science is we're going to basically bind
a value to a variable so we're going to
say this variable name is bound to this
value every time I want to grab this
value I'm going to invoke this variable
name so here are some examples examples
I've got a is equal to B +
1 the thing on the right hand side will
evaluate to some value as long as I have
something that b uh you know B has a
value for I've got here m is equal to 10
right so m is a variable its value is 10
I've got f is equal to M * 9.98 so again
I have an expression on the right hand
side and that's okay I'm going to use
the value of 10 so F's value will be 99
9.8 yeah can you put it so that like
like
for is it like this one value of M or
can you have it like it's going to be
whatever M sign recently or like yeah
the question is can you have m whatever
it recently is so in this particular
case I just have these two lines and M
will be whatever 10 is but we'll see in
a couple lectures that we can write like
a loop where you change M and then every
time you change M you read immediately
calculate F and then it'll calculate F
based on the new value of M but if we
just have these two lines that's that's
all there is um it just uses 10 was
there another
question
okay so in computer science variable you
have only one variable to the left of
this equal sign called the assignment
operator and you have a value to the
right hand side of the equal sign the
assignment operator okay so one variable
basically maps to or binds to one
value so the equal sign is an assignment
statement it's not equality it's not a
solve for x type of situation it's just
an assignment it binds this name to this
value so the way that we figure out uh
the name uh with the value is well if we
have this assignment statement here we
first look at the right hand side so we
always start with the right hand side
and we evaluate it remember we have an
expression on the right we have to
evaluate it to one value so this will be
3.14 whatever it is 1.1 59 and then we
take that value and bind it to the name
Pi so anytime I type in Pi Pi in my
program from now on python will
automatically grab
3.14159 from memory right so it's bound
to that value
now okay there are some rules did I have
them on the previous one yes there are
uh some rules to um variable
names um but we'll talk about that in a
bit for now I want you to tell me if any
of the following are allowed if I do X
is equal to 6 is that allowed in
Python yes it is good because I have one
variable name B to one value six what
about 6 equals x it's just backward okay
good 6al X is bad syntax error how about
x * y = 3 + 4
four nope exactly because the thing on
the left has an operator in it and
operators are special right so it can't
have you can't have a variable with that
star as a name how about XY equal 3 + 4
allowed yes exactly I was hoping to get
you guys with that but I didn't XY = 3 +
4 is okay there was no error and then I
can invoke the name of the uh variable I
just created simply by typing it in so
if I type in XY it gives me seven right
and then I can do operations with it XY
+ 1 is eight right yeah before you were
putting the Str with
a so those are strings right sequences
of characters here these are variables
so these are names that I uh I'm giving
to uh as a variable yeah that's a great
question so this is going to be a string
and you notice it it changed color right
it has some meaning in Python um but but
XY is a variable that I I create
yeah
okay so why do we want to give uh names
to variables because as I showed you
with a pi example it's a lot easier to
uh write code write readable code if you
have variable names within uh within
your programs so when you uh grab uh
when you write programs it's important
to choose variable names wisely you
don't want to use just single letters
you don't want to name it something that
doesn't have something to do with the
program you're writing um because you're
going to want to reread um these
programs sometime in the future or
others might want to read your programs
sometime in the future so here's an
example of a nice program it's just
basically four assignment statements
that do some
calculations the first line of the
program is not really a line it's called
a comment um you can have as many of
these as you like they start with a hat
hash it's a line that starts with a hash
and it's uh basically uh text that you
write that helps you or others figure
out what the code is supposed to do and
usually we comment sort of large chunks
of code at a time not line by line um
then we have these four equal uh four
assignment statements so here I'm
defining variable named Pi bound to the
value here so not the division but
3.14159 variable named radius bound to
this float 2.2 and then I have a
variable named area which is bound to
the result of this expression okay so
when python sees my pi and my radius it
grabs them from memory replaces them
with the values evaluates the expression
grabs that one value that that we
evaluated to 15 point something whatever
this is and binds the 15 something to
the name
area same with circumference
code style is something that we're
actually going to look at in your
problem sets so I just wanted to quickly
talk about that here is a program that
has really bad style actually that
shouldn't be me it should be you know
terrible or something like that but it's
in case you haven't noticed it's the
same program as on the previous slide
but if I gave you this program straight
off the bat you probably wouldn't know
what it's doing it's reusing 355 over 1
13 twice here it's using Just A and C as
variable names it's description is do
calculations so pretty bad this is a
little bit better I've recognized that
355 over 113 is being used twice so I'm
saving it as a variable but my uh
variables are still single characters
and my comments are pretty bad I'm
basically saying what the code is doing
please don't do that
um we can see that a equals P * R * R
right I see that I'm multiplying p with
r 2qu i don't need to read that in
English right what I would like to see
is a comment like this here I'm
commenting you know a chunk of code and
someone who doesn't want to read this
chunk of code just reads the comment and
I already know that I'm calculating the
area in circumference using an
approximation for pi that's a pretty
nice uh comment there and good
descriptive names and all
that so we can actually once we create
an object a variable sorry once we
create an object and bind it to a
variable we can change the
bindings so we can take that variable
name and bind it to a completely
different value this might not be sort
of useful right now but it will be
useful when we uh introduce control flow
in our programs so to rebind a variable
what that means is we're going to take
the name we're going to lose the binding
to the previous value and we're going to
rebind it to a new value so I'm going to
show you how this looks like in memory
um I'm going to use this sort of cloud
picture to represent uh what happens
behind the scenes whenever we write
programs and it's uh like a little
animation to help you understand line by
line what's going on so here we have pi
equal
3.14 so the green 3 14 is my value in
memory cloud is memory that's my value
in memory and it's bound to this name Pi
so this is my variable
name the next line radius equals 2.2
same thing I've got 2.2 as my value in
memory my object and radius is the name
for that
object area equals Pi * radius squ so
what happens uh behind the scenes is it
calculates this value right it doesn't
store the expression it stores the value
resulting from the calculation and then
it saves it uh or binds it to the name
area okay everything okay so far we've
seen this code before cool so now what
happens when we do this radius equals
radius plus one in
math that would say 0 equals 1 but we're
not in math here right we're in computer
science and this is perfectly valid
we're following the rule right when we
have an assignment that says look at the
right hand side first and evaluate it
and then bind it to the left hand side
so if we look at the right hand side
first right we see radius well what's
the value
2.2 we see add one to it
3.2 save that in memory and then we see
the assignment now save it with the name
radius okay so we can only have one
variable
assigned to one value at a time right
this is not math this is computer
science so you can only have radius
point to one thing at a
time with this line of code radius
equals radius + one we've lost the
binding to 2.2 this object in memory and
we've rebound it to the value
3.2 okay and that's perfectly fine 2.2
is now just sitting in memory we can't
get back to it unless we say maybe
radius equals 2.2 it just sits in memory
and then you might be collected later on
by or reclaimed by garbage collection or
something like that but for now we can't
get back to it now what's the value for
area at the end of these
lines well according to this it's 15.1
1976 so it's using the old 2.2 value for
radius and that's okay because the
program never told uh never had a line
that said recal calculate area after we
change the
radius right it's just following dumb
line by line right it doesn't know that
hey if I change the radius the user
might want the area changed right it
doesn't make those connections it's just
following instructions and that's okay
if we wanted to change the area we would
have to copy this line and paste it
after we've changed the radius and then
the area would change as
well okay does that make sense that's
kind of an important part of this
lecture Okay
cool so big idea here is our lines are
evaluated one after the other we're not
skipping we're not repeating things
that's something we're going to learn
about later um but for now line by
line so here's a little UT Tri it um
these three lines are executed in order
what are the values for U meters and
feet variables at each line so how about
at the first line what's the value for
meters after after we execute the first
line 100 what about
feet so feet at at the end of the first
line there is no value for feet yet how
about after the second line 3 28.8 right
how about the value for
meters 100 still and what about after
the third line I'm changing meters to
200 exactly yeah meters is 200 but feet
is still 328 point
08 and this is something I want to show
you guys today and we're going to use
this python tutor a lot more in the
future python tutor is a nice website
that allows you to step in your code
step through your code step by step so
at
each line that you execute you get to
see the values of all the variables in
the code a very useful debugging tool I
hope you'll try it out today and uh on
Monday maybe for the finger exercises if
you're if you're having trouble and you
know you can use it for quizzes uh to
help you debug but we can I can just
show you it's pretty simple uh here
because it's just a step by step so we
step through so the red says the line
I'm going to execute green is the line I
just executed so I just executed meters
100 so here I have my meters variable
with the value 100 step through next so
I just executed feed equals this so I
now have a variable named feat with an a
value 3
28.8 meters still 100 and then meters
200 feet remained
okay so obviously this is a pretty
simple program to run the python tutor
on but you can imagine using it um in uh
um in more complex
settings how about one more and this is
my last example I want you to try to
write a program that swaps the values of
X and Y so originally and I'll draw this
the memory diagram real quick so we have
this is our memory we have X is bound to
one y is bound to two and what I want to
do without saying xal 2 yal 1 what I
want to do is swap the values I want X
to be associated with two and Y to be
associated with one but only using
commands like this right and so the code
here is buggy that means it's wrong it
has an error in it
because well let's step through let's
step through a little bit at a time yals
x what do I do when uh Y equals X
here yeah exactly Y is going to move
from
two to
one now what happens when I do x equals
y yes X stays the same my first line yal
X lost The Binding to two right and now
it's all messed up because I can't get
it back so instead so if you didn't
understand this you can click python
tutor and just kind of Step through step
by step on your own but how can we fix
this create a third variable yeah that's
a great idea yeah we can create a third
variable so X is one y is one uh Y is
two so we can create a third variable
what do you want to make the variable
equal
to X or Y y yeah either one um I made it
y so let's do y um so here I've got a
temporary variable called temp and I
made it equal to
two and now what can I
do which one can I reassign now x equals
y or Y equals
X exactly y equals if I do xals y I lose
my binding to one and I'm I it messed up
again so yals X is okay to do so I'm
going to lose the binding from y from
Two and bind it up to one and now what
do I
do yeah now I can safely reassign X
to Temp right so I can say x is equal to
Temp because temp points to two and I
want to make X point to two as
well so in terms of code so that's sort
of the diagram but um you know we can
write the code so don't uh let's see um
we don't write it in here but you know
on on your own or uh you can write it in
here if You' like or we can do it
together so X is equal oops x = 1 Y = 2
right um and then we can have we had
temp we wanted to assign it to whatever
y was right so we say temp is equal to
Y and if you want to check the values of
the variables you can just invoke the
names right so X is 1 Y is 2 and
temp should be whatever Y is 2 okay good
so far so now I'm at the step here I
think right I've just created this and
then the last thing I need to do is lose
the binding from
X to whatever temp is right so I want to
do this operation here which means I
want to assign X to be equal to
Temp right so now X is 2 Y is
one what did I
do yeah let's so this happens sometimes
we can just start all over
right so y equals temp or sorry sorry
temp equals
y y equals
x y is One X is one and then x equals
temp Y is 1 X is 2 okay so it's okay if
things go wrong um they will go wrong we
can just start all over in this
particular case by redefining our
variables and just trying it out all
over again so that's kind of what the
shell is for that's what I use it for
that's what we're going to use it for in
the future um just to do quick things
like this um you know and also things
like checking the types and uh and other
commands we've done
uh
earlier okay so any questions before we
do the summary was this all right pace
or was it too fast or it's okay okay
cool thumbs up is good so let's do a
quick summary um we saw that we can
create uh programs by manipulating
objects we created objects in Python and
we saw that objects have a particular
type the type that the object has tells
python the things that you can do with
that object object right um we can
combine objects in expressions and these
Expressions evaluate or boil down to one
particular value objects or values can
be stored in variables and these
variables allow us to access these
values with nicer names later on in our
program and to and then we're able to
write neater more uh legible uh programs
as well right so the equal sign I showed
you a couple of differences between
uh math and computer science the equal
sign was one notable difference right
the equal sign in in math is declarative
and the equal sign in computer science
is an assignment you're basically saying
this is associated with this right and
we're not doing any sort of equality in
computer
science
um and yes computers do what you tell
them to do that's kind of the big the
big thing here right line by line it
executes starting from the top goes line
by line so far we haven't seen any
places where we uh where the computer
makes a decision but next lecture we
will see how we can insert decision
points in our programs um for for the
computer to you know either execute one
set of code or another set of code all
right so that's the end of today's
lecture thank you all for joining I will
see you on
Monday