Comp 112

Lecture 1
Expressions, Variables and Programs

2018.01.30

Expressions and Values

Expressions represent data.
- 2 + 3
Evaluating an expression yields a value.
- 2 + 3 ⟼ 5
The value represents the same data, but in a canonical form.
- 2 + 3 = 5
Python knows how to evaluate expressions.
Typing an expression into the Python interactive interpreter causes it to evaluate the expression and display the value.

A Simple Expression Language

Integer Values (0, 1, 2, -3, etc.)

Integer Arithmetic:

addition (_+_), subtraction (_-_), multiplication (_*_)
quotient (_//_), remainder (_%_)
exponential (_**_)

Boolean Values (True, False)

Boolean Logic:

negation (not_), conjunction (_and_), disjunction (_or_)

Numeric Comparisons:

is less than (_<_), is greater than (_>_)
is equal to (_==_), is not equal to (_!=_)
is less than or equal to (_<=_), is greater than or equal to (_>=_)

Evaluating Compound Expressions

The expression:

16 % 7 < 3 and 2 == 3 ** 2 // 4

parses as:

((16 % 7) < 3) and (2 == ((3 ** 2) // 4))

and evaluates to:

True

Types

Types classify expressions.

To ask Python the type of an expression, use:

type (<expression>)

e.g.

type (2 + 3)

The type of an expression is always the same as the type of its value.

type of integers: int
type of booleans: bool

Floats

What happens if we try to do division (_/_)?

11 / 3

Floating point numbers are variable-precision decimal approximations.
They have type float.
Python uses the decimal point to indicate that a number is a float rather than an int.

Compare:
```
type (3)
type (3.0)
```

Overloading

The arithmetic and comparison operators are overloaded to act on floats as well:

2.5 + 3.5

2.5 < 3.5

Overloading is when different (but conceptually related) operations are given the same notation.

This is just for our convenience, under the hood they are completely different operations.

The types are used to tell them apart.

As expressions get more complicated it becomes increasingly important to keep track of their types.

Strings

Strings are sequences of characters (i.e. text).
To enter a string, surround it with (single or double) quotes:
```
'hi'
"how's it going?"
```
Strings have type str.
Python overloads _+_ as string concatenation:
```
'py' + 'thon'
```
and _*_ as string repetition:
```
'python!' * 3
```

Statements

A statement is an instruction to perform some actions.
When Python executes a statement, it performs the corresponding actions.
Observable changes caused by actions are called effects.

(e.g. taking user input from the keyboard, printing text to the screen, drawing a picture, saving data to a file, etc.)
The central role of statements is what makes Python an imperative programming language.
In Python, there is a statement that does nothing:
```
pass
```
It may seem useless, but sometimes we must provide a statement even though we don’t want anything to happen.

Variables

Variables (“references”, “assignables”) are names that refer to values.

Rules for variable names:

may contain only letters, digits and underscores (“_”),
cannot begin with a digit,
are case sensitive,
can’t be any of Python’s keywords (see reading).

Variable Assignment

An assignment statement causes a variable to refer to the value of an expression:

<variable>  =  <expression>

life_the_universe_and_everything  =  42

The value of the variable becomes that of the expression assigned to it.

Warning: assignment is not mathematical equality! Read “=” as “gets”, and note the difference to “==” (“is equal to”).

Variable Assignment Process

When an assignment statement is executed:

First, the expression on the right is evaluated to a value.
Next, that value is assigned to the variable on the left.

x  =  1 + 1

x  =  x * x

Variable Tables

A variable table (a.k.a “environment” or “~~state diagram~~”) keeps track of the value assigned to each variable:

variable value

w ⟼ 'hello'

x ⟼ 42

y ⟼ 3.14

z ⟼ True

⋮ ⋮
Assigning a value to a new variable causes it to be added to the table.
Reassigning a different value to an existing variable causes its table entry to be overwritten.
It is an error to refer to a variable that has not yet been assigned a value.

variable		value
`w`	⟼	`'hello'`
`x`	⟼	`42`
`y`	⟼	`3.14`
`z`	⟼	`True`
⋮		⋮

As Python runs a program, it repeatedly consults and updates its variable table to keep track of the program’s state.

Programs

A Python program is a sequence of statements.
We can save a program to a plain text script file to edit or run later.
We will use Python’s built-in program editor, called IDLE, for writing Python programs.
Python script files should have the suffix “.py”.
Running a program causes its statements to be executed in order (modulo features that we’ll meet later).
You can run Python scripts using:
- the IDLE environment,
- the “python” (or “python3”) command from a terminal.

Unlike the interactive interpreter, running a program from a file does not cause the value of every expression to be displayed.

x  =  2
y  =  3
x + y

So how can we get a Python program to show us what it’s computing?

Print Statements

A print statement causes a textual representation of a value to be written to the screen:
```
print (x + y)
```

Print statements can be used in programs to show the value of an expression.

print ('The answer to life, the universe and everything is:')
answer  =  2 * 20 + 2
print (answer)

Otherwise, the value will be computed, but not displayed anywhere.

Note: the term “print statement” is a slight lie: print is not actually a statement in modern Python, the terminology is a historical holdover.

Comments

A comment is text in a program intended for humans not computers.
Comments are ignored when the program is run.
In Python, comments start with a “#” character and go to the end of the line:
```
print ('Programming is fun!')  #  yes it is!
```
An alternate style of comment starts with a triple-quote (""") and extends to the closing triple-quote:
```
"""
I'm sorry my homework is late,
but my dog ate my python.
"""
```

Comments in Submissions

Every script file you turn in should begin with a comment containing:

your name
your Wesleyan email address
the course number and your lab section
the assignment name or number
the date

"""
Jane Hacker
jhacker@wesleyan.edu
COMP 112, section 2
Homework 1
2018.01.30
"""

To Do This Week:

Do the reading:
- chapter 2: expressions, statements, variables, comments (7 pages)
- sections 5.1–5.3: arithmetic and logical operators (2 pages)
- sections 7.1–7.2: variable reassignment (2 pages)
Come to lab on Thursday.
Complete homework 1.
Get help from the instructor or CA if you had trouble installing Python on your computer.

Comp 112 Lecture 1 Expressions, Variables and Programs