# Don't worry about what this code does, but make sure to run it if you're following along.
from IPython.display import IFrame
def show_nested_eval():
    src = 'https://docs.google.com/presentation/d/e/2PACX-1vQpW0NzwT3LjZsIIDAgtSMRM1cl41Gp_Lf8k9GT-gm5sGAIynw4rsgiEFbIybClD6QtxarKaVKLbR9U/embed?start=false&loop=false&delayms=60000&rm=minimal" frameborder="0" width="960" height="569" allowfullscreen="true" mozallowfullscreen="true" webkitallowfullscreen="true"'
    width = 960
    height = 569
    return IFrame(src, width, height)

Lecture 2 – Expressions and Data Types

DSC 10, Winter 2024

Announcements

• Everything you need for this class is at dsc10.com. This class does not use Canvas.
• Lab 0 is out and is now due on Saturday, January 13 at 11:59PM.
  • It's worthwhile to watch the 🎥 video towards the end on how to navigate DataHub and Jupyter Notebooks.
• The office hours schedule is now posted, and office hours start today. Please visit!
• Post on Ed with any questions.
• Please fill out the Welcome Survey as soon as possible; here you can request to change discussions if needed.
  • We'll get back to you this weekend to let you know whether your request to switch was approved.

Agenda

• What is code? What are Jupyter Notebooks?
• Expressions.
• Variables.
• Calling functions.
• Data types.

There will be lots of programming – follow along in the notebook by clicking the "Expressions and Data Types" link on the course website.

What is code? What are Jupyter Notebooks? 💻

What is code?

• Instructions for computers are written in programming languages, and are referred to as code.
• “Computer programs” are nothing more than recipes: we write programs that tell the computer exactly what to do, and it does exactly that – nothing more, and nothing less.

Why Python?

• It's popular!

• It has a variety of use cases. Some examples:
  • Web development.
  • Data science and machine learning.
  • Scripting and automation.

• It's (relatively) easy to dive right in! 🏊

Jupyter Notebooks 📓

• Often, but not in this class, code is written in a text editor and then run in a command-line interface (or both steps are done in an IDE).

• Jupyter Notebooks allow us to write and run code within a single document. They also allow us to embed text and code. We will be using Jupyter Notebooks throughout the quarter.

• DataHub is a server that allows you to run Jupyter Notebooks from your web browser without having to install any software locally.

Aside: Lecture slides

• The lecture slides you're viewing right now are also in the form of a Jupyter Notebook – we're just using an extension (called RISE) to make them look like slides.
• When you click a lecture DataHub link on the course website, you'll see the lecture notebook in regular notebook form.
• To view it in slides form, click the bar chart button in the toolbar.

This button!

Expressions

Python as a calculator

• An expression is a combination of values, operators, and functions that evaluates to some value.

• For now, let's think of Python like a calculator – it takes expressions and evaluates them.

• We will enter our expressions in code cells. To run a code cell, either:
  • Hit shift + enter (or shift + return) on your keyboard (strongly preferred), or
  • Press the "▶ Run" button in the toolbar.

23

23

-15 + 2.718

-12.282

4 ** 3

64

(2 + 3 + 4) / 3

3.0

# Only one value is displayed. Why?
9 + 10
13 / 4
21

21

Arithmetic operations

Operation	Operator	Example	Value
Addition	+	2 + 3	5
Subtraction	-	2 - 3	-1
Multiplication	*	2 * 3	6
Division	/	7 / 3	2.66667
Remainder	%	7 % 3	1
Exponentiation	**	2 ** 0.5	1.41421

Python uses the typical order of operations – PEMDAS (BEDMAS? 🛏️)

5 * 2 ** 3

40

(5 * 2) ** 3

1000

Activity

In the cell below, replace the ellipses with an expression that's equivalent to

$$(19 + 6 \cdot 3) - 15 \cdot \left(\sqrt{100} \cdot \frac{1}{30}\right) \cdot \frac{3}{5} + \frac{4^2}{2^3} + \left( 6 - \frac{2}{3} \right) \cdot 12 $$

Try to use parentheses only when necessary.

Variables

Motivation

Below, we compute the number of seconds in a year.

60 * 60 * 24 * 365

31536000

If we want to use the above value later in our notebook to find, say, the number of seconds in 12 years, we'd have to copy-and-paste the expression. This is inconvenient, and prone to introducing errors.

60 * 60 * 24 * 365 * 12

378432000

It would be great if we could store the initial value and refer to it later on!

Variables and assignment statements

• A variable is a place to store a value so that it can be referred to later in our code. To define a variable, we use an assignment statement.

$$ \overbrace{\texttt{zebra}}^{\text{name}} = \overbrace{\texttt{23 - 14}}^{\text{any expression}} $$

• An assignment statement changes the meaning of the name to the left of the = symbol.

• The expression on the right-hand side of the = symbol is evaluated before being assigned to the name on the left-hand side.
  • e.g. zebra is bound to 9 (value) not 23 - 14 (expression).

Think of variable names as nametags!

# Note: This is an assignment statement, not an expression.
# Assignment statements don't output anything!
a = 1

a = 2

b = 2

Example

Note that before we use it in an assignment statement, triton has no meaning.

triton

10

After using it in an assignment statement, we can ask Python for its value.

triton = 15 - 5

triton

10

Any time we use triton in an expression, 10 is substituted for it.

triton * -4

-40

Note that the above expression did not change the value of triton, because we did not re-assign triton!

triton

10

Naming variables

• Give your variables helpful names so that you know what they refer to.
• Variable names can contain uppercase and lowercase characters, the digits 0-9, and underscores.
  • They cannot start with a number.
  • They are case sensitive!

The following assignment statements are valid, but use poor variable names 😕.

six = 15

i_45love_chocolate_9999 = 60 * 60 * 24 * 365

The following assignment statements are valid, and use good variable names ✅.

seconds_per_hour = 60 * 60
hours_per_year = 24 * 365
seconds_per_year = seconds_per_hour * hours_per_year

The following "assignment statements" are invalid ❌.

7_days = 24 * 7

  Cell In[92], line 1
    7_days = 24 * 7
     ^
SyntaxError: invalid decimal literal

3 = 2 + 1

  Cell In[93], line 1
    3 = 2 + 1
    ^
SyntaxError: cannot assign to literal

Assignment statements are not mathematical equations!

• Unlike in math, where $x = 3$ means the same thing as $3 = x$, assignment statements are not "symmetric".
• An assignment statement assigns (or "binds") the name on the left of = to the value to the right of =, nothing more.

x = 3

3 = x

  Cell In[95], line 1
    3 = x
    ^
SyntaxError: cannot assign to literal

A variable's value is set at the time of assignment

uc = 2
sd = 3 + uc

Assignment statements are not promises – the value of a variable can change!

uc = 7

Note that even after changing uc, we did not change sd, so it is still the same as before.

sd

5

Concept Check ✅ – Answer at cc.dsc10.com

Assume you have run the following three lines of code:

side_length = 5
area = side_length ** 2
side_length = side_length + 2

What are the values of side_length and area after execution?

A. side_length = 5, area = 25

B. side_length = 5, area = 49

C. side_length = 7, area = 25

D. side_length = 7, area = 49

E. None of the above

Aside: hit tab to autocomplete a set name

Calling functions 📞

Algebraic functions

• In math, functions take in some input and return some output.

$$f(x, y) = \frac{x}{y} + 2x^2 + y^5$$

• We can determine the output of a function even if we pass in complicated-looking inputs.

$$f\left(\frac{5-3}{17 \cdot 2}, (4-3)^{-5}\right)$$

Python functions

• Functions in Python work the same way functions in math do.
• The inputs to functions are called arguments.
• Python comes with a number of built-in functions that we are free to use.
• Calling a function, or using a function, means asking the function to "run its recipe" on the given input.

abs(-23)

23

Some functions can take a variable number of arguments

max(4, -8)

4

max(2, -3, -6, 10, -4)

10

max(9)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[102], line 1
----> 1 max(9)

TypeError: 'int' object is not iterable

# Only two arguments!
max(9 + 10, 9 - 10)

19

Put ? after a function's name to see its documentation 📄

Or use the help function, e.g. help(round).

round(1.45678)

1

round?

round(1.45678, 3)

1.457

Nested evaluation

We can nest many function calls to evaluate sophisticated expressions.

min(abs(max(-1, -2, -3, min(4, -2))), max(5, 100))

1

...how did that work?

show_nested_eval()

Import statements

• Python doesn't have everything we need built in.
• In order to gain additional functionality, we import modules through import statements.
• Modules are collections of Python functions and values.
• Call these functions using the syntax module.function(), called "dot notation".

Example: import math

Some of the many functions built into the math module are sqrt, pow, and log.

import math

math.sqrt(16)

4.0

math.pow(2, 5)

32.0

# What base is log?
math.log?

# Tab completion for browsing.
math.

  Cell In[113], line 2
    math.
         ^
SyntaxError: invalid syntax

math also has constants built in!

math.pi

3.141592653589793

Concept Check ✅ – Answer at cc.dsc10.com

Assume you have run the following statements:

x = 3
y = -2

Which of these examples results in an error?

A. abs(x, y)

B. math.pow(x, abs(y))

C. round(x, max(abs(y ** 2)))

D. math.pow(x, math.pow(y, x))

E. More than one of the above

Data types

What's the difference? 🧐

4 / 2

2.0

5 - 3

2

To us, 2.0 and 2 are the same number, $2$. But to Python, these appear to be different!

Data types

• Every value in Python has a type.
  • Use the type function to check a value's type.
• It's important to understand how different types work with different operations, as the results may not always be what we expect.

Two numeric data types: int and float

• int: An integer of any size.
• float: A number with a decimal point.

int

• If you add (+), subtract (-), multiply (*), or exponentiate (**) ints, the result will be another int.
• ints have arbitrary precision in Python, meaning that your calculations will always be exact.

7 - 15

-8

type(7 - 15)

int

2 ** 300

2037035976334486086268445688409378161051468393665936250636140449354381299763336706183397376

2 ** 3000

1230231922161117176931558813276752514640713895736833715766118029160058800614672948775360067838593459582429649254051804908512884180898236823585082482065348331234959350355845017413023320111360666922624728239756880416434478315693675013413090757208690376793296658810662941824493488451726505303712916005346747908623702673480919353936813105736620402352744776903840477883651100322409301983488363802930540482487909763484098253940728685132044408863734754271212592471778643949486688511721051561970432780747454823776808464180697103083861812184348565522740195796682622205511845512080552010310050255801589349645928001133745474220715013683413907542779063759833876101354235184245096670042160720629411581502371248008430447184842098610320580417992206662247328722122088513643683907670360209162653670641130936997002170500675501374723998766005827579300723253474890612250135171889174899079911291512399773872178519018229989376

float

• A float is specified using a decimal point.
• A float might be printed using scientific notation.

3.2 + 2.5

5.7

type(3.2 + 2.5)

float

# The result is in scientific notation: e+90 means "times 10^90".
2.0 ** 300

2.037035976334486e+90

The pitfalls of float

• floats have limited precision; after arithmetic, the final few decimal places can be wrong in unexpected ways.
• floats have limited size, though the limit is huge.

1 + 0.2

1.2

1 + 0.1 + 0.1

1.2000000000000002

2.0 ** 3000

---------------------------------------------------------------------------
OverflowError                             Traceback (most recent call last)
Cell In[126], line 1
----> 1 2.0 ** 3000

OverflowError: (34, 'Result too large')

Converting between int and float

• If you mix ints and floats in an expression, the result will always be a float.
  • Note that when you divide two ints, you get a float back.
• A value can be explicity coerced (i.e. converted) using the int and float functions.

2.0 + 3

5.0

12 / 2

6.0

# Want an integer back.
int(12 / 2)

6

# int chops off the decimal point!
int(-2.9)

-2

Aside: Jupyter memory model

Our notebook still remembers all of the variables we defined earlier in the lecture.

triton

10

• However, if you come back to your notebook after a few hours, it will usually "forget" all of the variables it once knew about.
• When this happens, you will need to run the cells in your notebook again.
• See Navigating DataHub and Jupyter Notebooks for more.

Summary, next time

Summary

• Expressions evaluate to values. Python will display the value of the last expression in a cell by default.
• Python knows about all of the standard mathematical operators and follows PEMDAS.
• Assignment statements allow us to bind values to variables.
• We can call functions in Python similar to how we call functions in math.
  • Python knows some functions by default, and import statements allow us to bring additional functionality from modules.
• All values in Python have a data type.
  • ints and floats are numbers.
  • ints are integers, while floats contain decimal points.

Next time

• We'll learn about strings, a data type in Python designed to store text.
• We'll also learn how to store sequences, or many pieces of information, in a single variable.

Note: We will introduce some code in labs and homeworks as well. Not everything will be in lecture. You will learn by doing!