In [1]:
# Run this cell to set up packages for lecture.
from lec02_imports import *

Lecture 2 – Variables and Data Types¶

DSC 10, Fall 2025¶

Solution to the activity from last class¶

In the cell below, write 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.

In [2]:
# Only the last pair of parentheses is necessary.
19 + 6 * 3 - 15 * 100 ** 0.5 * 1 / 30 * 3 / 5 + 4 ** 2 / 2 ** 3 + (6 - 2 / 3) * 12
Out[2]:
100.0

Common mistake¶

In [3]:
100 ** 1 / 2
Out[3]:
50.0

Agenda¶

  • Variables.
  • Calling functions.
  • Data types.

There will be lots of programming – follow along in the notebook by clicking the "💻 code" link on the course website.

Variables¶

Motivation¶

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

In [4]:
60 * 60 * 24 * 365
Out[4]:
31536000

Say we want to use this value to find the number of seconds in 12 years (excluding leap years). We could copy-and-paste the expression, but this is inconvenient, and prone to introducing errors.

In [5]:
60 * 60 * 24 * 365 * 12
Out[5]:
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!¶

In [6]:
# Note: This is an assignment statement, not an expression.
# Assignment statements don't output anything!
a = 1
In [7]:
a = 2
In [8]:
b = 2

Example¶

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

In [9]:
triton

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
/tmp/ipykernel_181/521444765.py in <module>
----> 1 triton

NameError: name 'triton' is not defined

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

In [10]:
triton = 15 - 5
In [11]:
triton
Out[11]:
10

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

In [12]:
triton * -4
Out[12]:
-40

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

In [13]:
triton
Out[13]:
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 😕.

In [14]:
six = 15
In [15]:
i_45love_chocolate_9999 = 60 * 60 * 24 * 365

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

In [16]:
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 ❌.

In [17]:
7_days = 24 * 7

  File "/tmp/ipykernel_181/3229775372.py", line 1
    7_days = 24 * 7
     ^
SyntaxError: invalid decimal literal
In [18]:
3 = 2 + 1

  File "/tmp/ipykernel_181/2449763097.py", 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 on the right of =, nothing more.
In [19]:
x = 3
In [20]:
3 = x

  File "/tmp/ipykernel_181/3780819163.py", line 1
    3 = x
    ^
SyntaxError: cannot assign to literal

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

In [21]:
uc = 2
sd = 3 + uc

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

In [22]:
uc = 7

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

In [23]:
sd
Out[23]:
5

Extra practice¶

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?

Answer this question without actually running any code. Then, to check your answer, copy-paste the three lines of code from above into a code cell and run the cell. Then display the values of the variables by typing each variable name into a code cell and running that cell to see the value of the variable.

In [ ]:
In [ ]:
In [ ]:

Aside: hit tab to autocomplete a set name¶

In [ ]:

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.
In [24]:
abs(-23)
Out[24]:
23

Some functions can take a variable number of arguments¶

In [25]:
max(4, -8)
Out[25]:
4
In [26]:
max(2, -3, -6, 10, -4)
Out[26]:
10
In [27]:
max(9)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/tmp/ipykernel_181/60825961.py in <module>
----> 1 max(9)

TypeError: 'int' object is not iterable
In [28]:
# Only two arguments!
max(9 + 10, 9 - 10)
Out[28]:
19

Nested evaluation¶

We can nest many function calls to evaluate sophisticated expressions.

In [29]:
min(abs(max(-1, -2, -3, min(4, -2))), max(5, 100))
Out[29]:
1

...how did that work?

In [30]:
show_nested_eval()
Out[30]:

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

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

In [31]:
round(1.45678)
Out[31]:
1
In [32]:
round?
In [33]:
round(1.45678, 3)
Out[33]:
1.457

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.

In [34]:
import math
In [35]:
math.sqrt(16)
Out[35]:
4.0
In [36]:
math.pow(2, 5)
Out[36]:
32.0
In [40]:
# What base is log?
math.log?
In [ ]:
# Tab completion for browsing.
math.

math also has constants built in!

In [41]:
math.pi
Out[41]:
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? For the ones that don't error, try to determine what they evaluate to!

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

In [ ]:

Data types¶

What's the difference? 🧐¶

In [42]:
4 / 2
Out[42]:
2.0
In [43]:
5 - 3
Out[43]:
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.
  • There are two data types used for numbers: 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.
In [44]:
7 - 15
Out[44]:
-8
In [45]:
type(7 - 15)
Out[45]:
int

float¶

  • A float is specified using a decimal point.
  • A float might be printed using scientific notation.
In [46]:
3.2 + 2.5
Out[46]:
5.7
In [47]:
type(3.2 + 2.5)
Out[47]:
float
In [48]:
# The result is in scientific notation: e+90 means "times 10^90".
2.0 ** 300
Out[48]:
2.037035976334486e+90

floats have limited precision¶

  • After arithmetic, the final few decimal places can be wrong in unexpected ways.
  • This is due to how numbers are represented on a computer. You don't need to worry about it in this class!
In [49]:
1 + 0.2
Out[49]:
1.2
In [50]:
1 + 0.1 + 0.1
Out[50]:
1.2000000000000002

floats have limited size¶

In [51]:
# ints have unlimited size, so this is exact
2 ** 3000
Out[51]:
1230231922161117176931558813276752514640713895736833715766118029160058800614672948775360067838593459582429649254051804908512884180898236823585082482065348331234959350355845017413023320111360666922624728239756880416434478315693675013413090757208690376793296658810662941824493488451726505303712916005346747908623702673480919353936813105736620402352744776903840477883651100322409301983488363802930540482487909763484098253940728685132044408863734754271212592471778643949486688511721051561970432780747454823776808464180697103083861812184348565522740195796682622205511845512080552010310050255801589349645928001133745474220715013683413907542779063759833876101354235184245096670042160720629411581502371248008430447184842098610320580417992206662247328722122088513643683907670360209162653670641130936997002170500675501374723998766005827579300723253474890612250135171889174899079911291512399773872178519018229989376
In [52]:
# floats have limited size
2.0 ** 3000

---------------------------------------------------------------------------
OverflowError                             Traceback (most recent call last)
/tmp/ipykernel_181/820317277.py in <module>
      1 # floats have limited size
----> 2 2.0 ** 3000

OverflowError: (34, 'Numerical result out of range')

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.
  • The function int converts its input into an int. Likewise, the function float converts its input into a float.
In [53]:
2.0 + 3
Out[53]:
5.0
In [54]:
12 / 2
Out[54]:
6.0
In [55]:
# Want an integer back.
int(12 / 2)
Out[55]:
6
In [56]:
# int chops off the decimal point!
int(-2.9)
Out[56]:
-2

Strings 🧶¶

  • A string is a snippet of text of any length.
  • In Python, strings are enclosed by either single quotes or double quotes (doesn't matter which!)
In [57]:
'woof'
Out[57]:
'woof'
In [58]:
type('woof')
Out[58]:
str
In [59]:
"woof 🐶🐶"
Out[59]:
'woof 🐶🐶'
In [60]:
# A string, not an int!
"1998"
Out[60]:
'1998'

String arithmetic¶

When using the + symbol between two strings, the operation is called "concatenation".

In [61]:
s1 = 'baby'
s2 = '🐼'
In [62]:
s1 + s2
Out[62]:
'baby🐼'
In [63]:
s1 + ' ' + s2
Out[63]:
'baby 🐼'
In [64]:
# Multiplication is repeated addition, same as s1 + s1 + s1.
s1 * 3
Out[64]:
'babybabybaby'

String methods¶

  • Associated with strings are special functions, called string methods.
  • Access string methods with a . after the string ("dot notation").
    • For instance, to use the upper method on string s, we write s.upper().
  • Examples include upper, title, and replace, but there are many more.
In [65]:
fave_string = 'My favorite class is DSC 10!'
In [66]:
fave_string.title()
Out[66]:
'My Favorite Class Is Dsc 10!'
In [67]:
fave_string.upper()
Out[67]:
'MY FAVORITE CLASS IS DSC 10!'
In [68]:
fave_string.replace('favorite', '😍' * 3)
Out[68]:
'My 😍😍😍 class is DSC 10!'
In [69]:
# You can use string methods directly on strings, even if not stored in a variable.
"hello".upper()
Out[69]:
'HELLO'
In [70]:
# len is not a method, since it doesn't use dot notation.
len(fave_string)
Out[70]:
28

Type conversion to and from strings¶

  • Any value can be converted to a string using the function str.
  • Some strings can be converted to int and float.
In [71]:
str(3)
Out[71]:
'3'
In [72]:
float('3')
Out[72]:
3.0
In [73]:
int('4')
Out[73]:
4
In [74]:
int('baby panda')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
/tmp/ipykernel_181/455936715.py in <module>
----> 1 int('baby panda')

ValueError: invalid literal for int() with base 10: 'baby panda'
In [75]:
int('4.3')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
/tmp/ipykernel_181/756068685.py in <module>
----> 1 int('4.3')

ValueError: invalid literal for int() with base 10: '4.3'

Concept Check ✅ – Answer at cc.dsc10.com¶

Assume you have run the following statements:

x = 3
y = '4'
z = '5.6'

Choose the expression that will be evaluated without an error.

A. x + y

B. x + int(y + z)

C. str(x) + int(y)

D. str(x) + z

E. All of them have errors

In [ ]:

Aside: Jupyter memory model¶

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

In [76]:
triton
Out[76]:
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¶

  • 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. Import statements allow us to bring in additional functions.
  • All values in Python have a data type.
    • ints and floats are numbers. Strings (str) are for text.
    • ints are integers, while floats contain decimal points.
    • Strings should be enclosed in single or double quotes.

Next time¶

We'll 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!

In [ ]: