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