Tutorial 1: Introduction to Python

Tutorial 1: Introduction to Python#

Python is a programming language which allows us to give instructions to the computer. These instructions can be as simple as “add together these two numbers” or as complex as “give me the average CO2 concentration for 2020”. For the former we will be able to complete the task using only a single instruction but for the latter, we may have to write a larger program containing hundreds or thousands of instructions.

This course is going to start from the beginning, showing you to talk to the computer to perform simple tasks and as you become more confident and follow the later courses, you will find that you are able to write much more complex programmes. Within this course, we assume no prior knowledge of Python. Experience with programming concepts or another programming language will help, but is not required to understand the material.

Python is a well-established language, with the current version (version 3) released in 2008 and it is installed by default on nearly all modern Linux systems. Python is also available for OS X and Windows.

In this first tutorial we will deal with the basics of Python and Jupyter Notebooks.

Note: This tutorial is heavily based upon the work of others

Important: This tutorial is not part of your final grade. You simply have to pass it by answering the questions.

Important before we start#

Make sure that you save this file before you continue, else you will lose everything. To do so, go to Bestand/File and click on Een kopie opslaan in Drive/Save a Copy on Drive!

Now, rename the file into Week1_Tutorial1.ipynb. You can do so by clicking on the name in the top of this screen.

Learning Objectives#

Create, describe and differentiate standard Python datatypes such as int, float, string, list, dict, tuple, etc.
Perform arithmetic operations like +, -, *, ** on numeric values.
Perform basic string operations like .lower(), .split() to manipulate strings.
Compute boolean values using comparison operators operations (==, !=, >, etc.) and boolean operators (and, or, not).
Assign, index, slice and subset values to and from tuples, lists, strings and dictionaries.
Write a conditional statement with if, elif and else.
Identify code blocks by levels of indentation.
Explain the difference between mutable objects like a list and immutable objects like a tuple.

1. Introduction#

Within this course, we use Jupyter notebooks to execute all our python code. A Jupyter notebook is a document that can combine live programming code, text, images, and pretty displays of data all in the same place. This combination makes Jupyter notebooks clutch for exploring data as well as for learning and teaching.

A Jupyter notebook has a special .ipynb file extension and can only be opened if you have the application JupyterLab or Jupyter Notebook installed and running. One of the cool things about Jupyter Book, which powers this online textbook, is that you can open a Jupyter notebook on the internet without any prior installation or configuration — using services like Google Colaboratory (click on the rocket on the top of this page to open this page in Google Colaboratory).

Tip

Jupyter notebooks

Jupyter notebooks combine the ability to make nice documentation in combination with python code, which is perfect for our needs in these tutorials and practicums.

Jupyter notebooks work with cells, each cell can be used to type either Python language or Markdown (text editing language).

Shortcuts

Shift + Enter run the current cell, select below
Ctrl/Cmd + Enter run selected cells
Ctrl/Cmd + S save and checkpoint
Enter take you into edit mode
A insert cell above
B insert cell below
C copy selected cells
V paste cells below
Z undo cell deletion
M change the cell type to Markdown
Y change the cell type to Code
H show all shortcuts

2. Basic Python Data Types#

A value is a piece of data that a computer program works with such as a number or text. There are different types of values: 42 is an integer and "Hello!" is a string. A variable is a name that refers to a value. In mathematics and statistics, we usually use variable names like $x$ and $y$. In Python, we can use any word as a variable name as long as it starts with a letter or an underscore. However, it should not be a reserved word in Python such as for, while, class, lambda, etc. as these words encode special functionality in Python that we don’t want to overwrite!

It can be helpful to think of a variable as a box that holds some information (a single number, a vector, a string, etc). We use the assignment operator = to assign a value to a variable.

Tip: See the Python 3 documentation for a summary of the standard built-in Python datatypes.

Common built-in Python data types#

English name	Type name	Type Category	Description	Example
integer	`int`	Numeric Type	positive/negative whole numbers	`42`
floating point number	`float`	Numeric Type	real number in decimal form	`3.14159`
boolean	`bool`	Boolean Values	true or false	`True`
string	`str`	Sequence Type	text	`"I Can Has Cheezburger?"`
list	`list`	Sequence Type	a collection of objects - mutable & ordered	`['Ali', 'Xinyi', 'Miriam']`
tuple	`tuple`	Sequence Type	a collection of objects - immutable & ordered	`('Thursday', 6, 9, 2018)`
dictionary	`dict`	Mapping Type	mapping of key-value pairs	`{'name':'DSCI', 'code':511, 'credits':2}`
none	`NoneType`	Null Object	represents no value	`None`

Numeric data types#

There are three distinct numeric types: integers, floating point numbers, and complex numbers (not covered here). We can determine the type of an object in Python using type(). We can print the value of the object using print().

x = 42

type(x)

print(x)

In Jupyter/IPython (an interactive version of Python), the last line of a cell will automatically be printed to screen so we don’t actually need to explicitly call print().

x  # Anything after the pound/hash symbol is a comment and will not be run

pi = 3.14159
pi

type(pi)

Arithmetic Operators#

Below is a table of the syntax for common arithmetic operations in Python:

Operator	Description
`+`	addition
`-`	subtraction
`*`	multiplication
`/`	division
`**`	exponentiation
`//`	integer division / floor division
`%`	modulo

Let’s have a go at applying these operators to numeric types and observe the results.

1 + 2 + 3 + 4 + 5  # add

2 * 3.14159  # multiply

2 ** 10  # exponent

Division may produce a different dtype than expected, it will change int to float.

int_2 = 2
type(int_2)

int_2 / int_2  # divison

type(int_2 / int_2)

But the syntax // allows us to do “integer division” (aka “floor division”) and retain the int data type, it always rounds down.

101 / 2

101 // 2  # "floor division" - always rounds down

We refer to this as “integer division” or “floor division” because it’s like calling int on the result of a division, which rounds down to the nearest integer, or “floors” the result.

int(101 / 2)

The % “modulo” operator gives us the remainder after division.

100 % 2  # "100 mod 2", or the remainder when 100 is divided by 2

101 % 2  # "101 mod 2", or the remainder when 101 is divided by 2

100.5 % 2

None#

NoneType is its own type in Python. It only has one possible value, None - it represents an object with no value. We’ll see it again in a later chapter.

x = None

print(x)

type(x)

Strings#

Text is stored as a data type called a string. We can think of a string as a sequence of characters.

We write strings as characters enclosed with either:

single quotes, e.g., 'Hello'
double quotes, e.g., "Goodbye"

There’s no difference between the two methods, but there are cases where having both is useful (more on that below)! We also have triple double quotes, which are typically used for function documentation (more on that in a later chapter), e.g., """This function adds two numbers""".

my_name = "John Deere"

my_name

type(my_name)

course = 'Big Data for Sustainability Science'

course

type(course)

If the string contains a quotation or apostrophe, we can use a combination of single and double quotes to define the string.

sentence = "It's a rainy day."

sentence

type(sentence)

quote = 'Andrew McAfee: "The world is one big data problem."'

quote

Boolean#

The Boolean (bool) type has two values: True and False.

the_truth = True

the_truth

type(the_truth)

lies = False

lies

type(lies)

Comparison Operators#

We can compare objects using comparison operators, and we’ll get back a Boolean result:

Operator	Description
`x == y`	is `x` equal to `y`?
`x != y`	is `x` not equal to `y`?
`x > y`	is `x` greater than `y`?
`x >= y`	is `x` greater than or equal to `y`?
`x < y`	is `x` less than `y`?
`x <= y`	is `x` less than or equal to `y`?
`x is y`	is `x` the same object as `y`?

2 < 3

"Deep learning" == "Solve all the world's problems"

2 != "2"

2 is 2

2 == 2.0

Boolean Operators#

We also have so-called “boolean operators” which also evaluates to either True or False:

Operator	Description
`x and y`	are `x` and `y` both True?
`x or y`	is at least one of `x` and `y` True?
`not x`	is `x` False?

True and True

True and False

True or False

False or False

("Python 2" != "Python 3") and (2 <= 3)

True

not True

not not True

Casting#

Sometimes we need to explicitly cast a value from one type to another. We can do this using functions like str(), int(), and float(). Python tries to do the conversion, or throws an error if it can’t.

x = 5.0
type(x)

x = int(5.0)
x

type(x)

x = str(5.0)
x

type(x)

str(5.0) == 5.0

int(5.3)

float("hello")

3. Lists and Tuples#

Lists and tuples allow us to store multiple things (“elements”) in a single object. The elements are ordered (we’ll explore what that means a little later). We’ll start with lists. Lists are defined with square brackets [].

my_list = [1, 2, "THREE", 4, 0.5]

my_list

type(my_list)

Lists can hold any datatype - even other lists!

another_list = [1, "two", [3, 4, "five"], True, None, {"key": "value"}]
another_list

You can get the length of the list with the function len():

len(my_list)

Tuples look similar to lists but have a key difference (they are immutable - but more on that a bit later). They are defined with parentheses ().

today = (1, 2, "THREE", 4, 0.5)

today

type(today)

len(today)

Indexing and Slicing Sequences#

We can access values inside a list, tuple, or string using square bracket syntax. Python uses zero-based indexing, which means the first element of the list is in position 0, not position 1.

my_list

my_list[0]

my_list[2]

len(my_list)

my_list[5]

We can use negative indices to count backwards from the end of the list.

my_list

my_list[-1]

my_list[-2]

We can use the colon : to access a sub-sequence. This is called “slicing”.

my_list[1:3]

Note from the above that the start of the slice is inclusive and the end is exclusive. So my_list[1:3] fetches elements 1 and 2, but not 3.

Strings behave the same as lists and tuples when it comes to indexing and slicing. Remember, we think of them as a sequence of characters.

alphabet = "abcdefghijklmnopqrstuvwxyz"

alphabet[0]

alphabet[-1]

alphabet[-3]

alphabet[:5]

alphabet[12:20]

List Methods#

A list is an object and it has methods for interacting with its data. A method is like a function, it performs some operation with the data, but a method differs to a function in that it is defined on the object itself and accessed using a period .. For example, my_list.append(item) appends an item to the end of the list called my_list. You can see the documentation for more list methods.

primes = [2, 3, 5, 7, 11]
primes

len(primes)

primes.append(13)

primes

Sets#

Another built-in Python data type is the set, which stores an un-ordered list of unique items. Being unordered, sets do not record element position or order of insertion and so do not support indexing.

s = {2, 3, 5, 11}
s

{1, 2, 3} == {3, 2, 1}

[1, 2, 3] == [3, 2, 1]

s.add(2)  # does nothing
s

s[0]

Above: throws an error because elements are not ordered and can’t be indexing.

Mutable vs. Immutable Types#

Strings and tuples are immutable types which means they can’t be modified. Lists are mutable and we can assign new values for its various entries. This is the main difference between lists and tuples.

names_list = ["Indiana", "Fang", "Linsey"]
names_list

names_list[0] = "Cool guy"
names_list

names_tuple = ("Indiana", "Fang", "Linsey")
names_tuple

names_tuple[0] = "Not cool guy"

Same goes for strings. Once defined we cannot modifiy the characters of the string.

my_name = "Tom"

my_name[-1] = "q"

x = ([1, 2, 3], 5)

x[1] = 7

x[0][1] = 4

4. String Methods#

There are various useful string methods in Python.

all_caps = "HOW ARE YOU TODAY?"
all_caps

new_str = all_caps.lower()
new_str

Note that the method lower doesn’t change the original string but rather returns a new one.

all_caps

There are many string methods. Check out the documentation.

all_caps.split()

all_caps.count("O")

One can explicitly cast a string to a list:

caps_list = list(all_caps)
caps_list

"".join(caps_list)

"-".join(caps_list)

We can also chain multiple methods together (more on this when we get to NumPy and Pandas in later chapters):

"".join(caps_list).lower().split(" ")

String formatting#

Python has ways of creating strings by “filling in the blanks” and formatting them nicely. This is helpful for when you want to print statements that include variables or statements. There are a few ways of doing this but I use and recommend f-strings which were introduced in Python 3.6. All you need to do is put the letter “f” out the front of your string and then you can include variables with curly-bracket notation {}.

name = "Newborn Baby"
age = 4 / 12
day = 10
month = 6
year = 2020
template_new = f"Hello, my name is {name}. I am {age:.2f} years old. I was born {day}/{month:02}/{year}."
template_new

Note: In the code above, the notation after the colon in my curly braces is for formatting. For example, `:.2f` means, print this variable with 2 decimal places. See format code options here.

5. Dictionaries#

A dictionary is a mapping between key-values pairs and is defined with curly-brackets:

house = {
    "bedrooms": 3,
    "bathrooms": 2,
    "city": "Amsterdam",
    "price": 2499999,
    "date_sold": (1, 3, 2015),
}

condo = {
    "bedrooms": 2,
    "bathrooms": 1,
    "city": "Terneuzen",
    "price": 699999,
    "date_sold": (27, 8, 2011),
}

We can access a specific field of a dictionary with square brackets:

house["price"]

condo["city"]

We can also edit dictionaries (they are mutable):

condo["price"] = 5  # price already in the dict
condo

condo["flooring"] = "wood"

condo

We can also delete fields entirely (though I rarely use this):

del condo["city"]

condo

And we can easily add fields:

condo[5] = 443345

condo

Keys may be any immutable data type, even a tuple!

condo[(1, 2, 3)] = 777
condo

You’ll get an error if you try to access a non-existent key:

condo["not-here"]

6. Empties#

Sometimes you’ll want to create empty objects that will be filled later on.

lst = list()  # empty list
lst

lst = []  # empty list
lst

There’s no real difference between the two methods above, [] is apparently marginally faster…

tup = tuple()  # empty tuple
tup

tup = ()  # empty tuple
tup

dic = dict()  # empty dict
dic

dic = {}  # empty dict
dic

st = set()  # empty set
st

7. Conditionals#

Conditional statements allow us to write programs where only certain blocks of code are executed depending on the state of the program. Let’s look at some examples and take note of the keywords, syntax and indentation.

name = "Tom"

if name.lower() == "tom":
    print("That's my name too!")
elif name.lower() == "santa":
    print("That's a funny name.")
else:
    print(f"Hello {name}! That's a cool name!")
print("Nice to meet you!")

The main points to notice:

Use keywords if, elif and else
The colon : ends each conditional expression
Indentation (by 4 empty space) defines code blocks
In an if statement, the first block whose conditional statement returns True is executed and the program exits the if block
if statements don’t necessarily need elif or else
elif lets us check several conditions
else lets us evaluate a default block if all other conditions are False
the end of the entire if statement is where the indentation returns to the same level as the first if keyword

If statements can also be nested inside of one another:

name = "Super Tom"

if name.lower() == "tom":
    print("That's my name too!")
elif name.lower() == "santa":
    print("That's a funny name.")
else:
    print(f"Hello {name}! That's a cool name.")
    if name.lower().startswith("super"):
        print("Do you really have superpowers?")

print("Nice to meet you!")

Inline if/else#

We can write simple if statements “inline”, i.e., in a single line, for simplicity.

words = ["the", "list", "of", "words"]

x = "long list" if len(words) > 10 else "short list"
x

if len(words) > 10:
    x = "long list"
else:
    x = "short list"

Truth Value Testing#

Any object can be tested for “truth” in Python, for use in if and while (next chapter) statements.

True values: all objects return True unless they are a bool object with value False or have len() == 0
False values: None, False, 0, empty sequences and collections: '', (), [], {}, set()

Tip: Read more in the docs here.

x = 1

if x:
    print("I'm truthy!")
else:
    print("I'm falsey!")

x = False

if x:
    print("I'm truthy!")
else:
    print("I'm falsey!")

x = []

if x:
    print("I'm truthy!")
else:
    print("I'm falsey!")