2a: Expressions#

Learning goals:#

Recognize Python expressions
Recognize different data type literals
Recognize what operators are used for the appropriate data types
Recognize TypeErrors and common fixes

What are Expressions?#

Expressions are a basic building block of programs. They are chunks of Python code that evaluate to (yield) some value.

Here are a simple few examples.

What is 1 added to 1?

1 + 1

What is 3 multiplied by 2?

3 * 2

Is 3 larger than 2?

3 > 2

True

Here’s one that includes multiple expressions

3 * 2 + 5

So far, you may recognize these as basically math. That’s good! There’s a good amount of overlap between the concept of expressions and what you remember from math.

Now let’s stretch that prototypical example a bit. Keeping in mind that expressions are chunks of Python code that evaluate to (yield) some value, these are also expressions:

Is 3 the same as 3?

3 == 3

True

And even this: Evaluate the literal value 1

And of course, our most classic “hello world” in Python:

print("Hello world!")

Hello world!

One heuristic you can use to tell if a chunk of code is an expression or not, is to test or imagine it being the last line in a cell; if it yields an output by itself, then it’s an expression.

Anatomy of an expression#

An expression is built from, at minimum a value.

Like 3, or (as we will later see), a variable that holds a value.

Often, it also includes an operator that does something with the value(s).

Like > or +.

So, in:

3 + 1

The values are 3 and 1

and the operator is + (addition).

Types of operations#

There is a full list of operators here (bookmark this!). But for this module, the main ones to focus on are

Arithmetic operators (for doing math): + - * / %
Concatenation operator (for joining str values) +
Comparison operators (yield boolean values, used for conditionals)
Logical operators: and or not (yield boolean values, used for conditionals)

Let’s look at some examples together.

Arithmetic operators#

1 - 3

-2

Concatenation#

"1" + "1"

'11'

Comparison operators#

These can work with most/any data types. But the result may not always be what you expect!

"A" != "a"

True

Logical operators#

These are for logical expressions. You’ll find them to be most useful when you work with conditionals

a = 5
a < 10 and a % 2 != 0

True

Compound expressions#

We can build expressions from values that are… the results of expressions.

We know we can do this with math.

# value on the right is the *result* of the expression 1 + 2
3 * (1 + 2)

And it’s also common with logical expressions, which are often built from comparison expressions

# is 3 greater than 2 and less than 10? 
# this will make more sense when we use variables :)
3 > 2 and 3 < 10

True

Values have types#

To work with expressions and perform operations on them, Python needs to know what type of data they are.

Here are some basic types of data that Python knows out of the box:

str - strings, expressed with single quotes 'a' or double quotes "a" (Python doesn’t differentiate)
int - integer numbers (i.e., no decimals), like 3. For doing math.
float - floating point numbers (i.e., with decimals), like 3.0. For doing more precise math.
boolean - True or False values. Important for creating logical structures in your programs (like conditionals).

There are (many!) more types of values (including more complex data structures, such as lists, dictionaries, and data frames), but these will be sufficient for at least Module 1.

When we give these values to Python by themselves (not in a value), we call them literals. Let’s look at some examples.

# this is an int
1

# this is a float
1.0

# this is a string
"1"

# this is also a string
"True"

# this is a boolean
True

Notice how the syntax highlighting helps us recognize the different literals. Generally, for systems that do syntax highlighting for Python:

int and float are green
strings are red (as long as they are in quotation marks!)
and booleans are bold and green.

This color coding can help you manage data types.

Let’s practice a little!