Lecture 01: Python primer

Course: Deep Learning for Solving and Estimating Dynamic Models in Economics and Finance
Script reference: Front matter and Appendix~E — tuples, lists, dictionaries
Notebook role: primer (pre-course self-study; skip if you write Python every day)
Author: Simon Scheidegger

Python Basics 3: Basics of Tuples and Lists¶

There are two ways you can have lists in Python. You can either use tuple’s or ... list’s. The difference between the two is that tuple are immutable (you cannot change them once you make them) but you can add or remove items for list’s.

Tuples¶

Tuples are immutable collections of objectes of any type. Right now, you only know of int’s, float’s, bool’s and NoneType. So, that’s all I will use to make tuples. But you can put anything in a tuple. Here is a tuple with two integers:

Here is a tuple with two floats:

Here is a tuple with two integers and a float:

All, these are tuples:

You can ask a tuple how many elements it has using the function len:

Indexing of tuples¶

You can access any element of a tuple using indexing. Note that indices start at 0 and go up to the len() of the tuple:

If you try to try to use an index larger than the length of the tuple, here is what happens:

You get an IndexError. This is a very common bug. You need to learn how to read it.

You can also use negative indices:

Negative indices give you the elements starting from the last one. In particular z[-1] gives you the last element of the tuple. What would you get with z[-2]:

So, z[-3] gives you the third element of the tuple counting from the last. Because z has just three elements, z[-3] is the same as z[0]. What would happen if you tried z[-4]?

You get an IndexError again.

Okay. What if you wanted to get the first and second elements of z and not the last one. You can do this using index ranges:

How about the second and the third:

Let’s make a bigger tuple so that we can do some more indexing:

This has 10 elements:

To get the first five you can do:

Now, if the first index in your range happens to be zero, then you can skip it. So, instead of w[0:5], you can just write:

Let’s get the last 3:

Note that this gives you w[7], w[8], w[9]. Just like before, if the last index in your range happens to be the length of the tuple, you can skip it. So, instead of w[7:10] you can write:

So when you ask for w[i:j] you get all elements between w[i] and w[j-1]. Let’s see what you will get when you do this:

This just gave you a tuple with just the fifth element. At this point, look at how a tuple with a single element is defined. It is (5,) instead of (5). The comma is essential. This is because without the comma (5) is just five ...

How can I have a tuple with zero elements? Can you guess? Well, it is just ():

Here is another way to get a tuple with zero elements:

Alright, now some more advanced indexing. You do not have to remember all these. I am just putting them here for your reference.

First, you can have ranges with negative numbers. This is how to get everything from the fourth element counting from the end to the second element counting from the end:

And if you want to go all the way to the last element you can write:

Or you can completely skip the last element:

Meditate a little bit with this example with negative indices:

This means that w[-i:-j] gives everything between w[len(w)-i] and w[len(w)-j] for i and j positive numbers in this example.

What happens if you try to give a range that doesn’t make sense. Like, take me all the way from the 5th element to the 2nd element:

You get an empty tuple. Nice. What happens if you mix positive and negative indices:

It works just fine if the ranges make sense. Of course, avoid this because it is quite confusing.

Indexing is getting quite long, but let me give you one more example before we move on. Here is how you can take skip elements in between:

So, w[i:j:k] will give you every k-th element from i (inclusive) to j (exclusive). For $k=1$, of course, you get everything:

Let’s say now that we want to take every other element as we did above. We can do this:

But because we start at zero, we can skip the first index:

And because we end at len(w) (which is 10), we can also skip the second index:

Similarly, if we wanted to take every third element we would do:

You can also make k negative. Let’s see what happens:

Wow, the elements are reveresed. How about this:

Reveresed and we skip every other element. Note that w[::-2] is equivalent to:

So, the range has to make sense. You say, I want to go from the 10th element to the first one backwards skipping every other one.

Concatentating tuples¶

You can concatenate tuples. Here is how:

Nice. Observe that x + y and y + x are different:

What if you add the () (0-element tuple) to a tuple:

You just get the tuple back.

You cannot change tuples¶

You cannot change a tuple once you create it. For example, you cannot do this:

Read the error message. It is quite clear: “TypeError: ‘tuple’ object does not support item assignment.” Always read the error messages.

So, you should not be using tuple’s for things that may change. You should only use tuple’s for things that do not change. As a matter of fact, you should always use tuples’s for things that do not change. In this way, if you try to change that object you will get this nice error above instead of a nasty bug.

If you want something that can be changed, then you need to use a list.

Questions¶

• In the code block provided below evaluate the angle between the two vectors:

  $$\vec{r}_1 = 4\hat{i} + 3.5\hat{j} + 2.5\hat{k},$$

  (1)

  and

  $$\vec{r}_2 = 1.5\hat{i} + 2.5\hat{j}.$$

  (2)

  Remember that the dot product of two vectors is:

  $$\theta = \cos^{-1}\left(\frac{\vec{r}_1\cdot \vec{r}_2}{|\vec{r}_1||\vec{r}_2|}\right).$$

  (3)

  Hint: Use tuples to represent r1 and r2. You will have to import math and use math.acos().

• Consider the tuple:

Do the following:

• Get the lentgh of q:

• Get all the elements of q from the second to the second to last

• Get every other element of q from the second to the second to last

• Reverse q

Lists¶

Lists are like tuples, containers of many things, but they can be changed. Here is a list:

Notice that you define it with [] instead of ().

Just like tuples, you can get the length of the list with len:

And you can index lists in exactly the same way you index tuples:

You can also combine two lists into a new list, like this:

And here is the empty list:

So, lists behave just like tuples but with one main difference: You can change lists. For example, you can change the second element of the list to 3.4:

You can also put a new item at the end of the list using list.append(). Here is how:

You can also remove the last item of the list using list.pop():

Notice that the item was returned by pop(). Here is the list after the pop operation:

The last item was removed. Now append() and pop() are methods of the class list. They can be accessed by doing a.append() or a.pop(). We will talk about classes and methods in another hands-on activity. You can access the methods of an object by typing the name of the object followed by a . and then pressing the “tab” button of your keyboard. Try it here:

Another way to get help about an object is to use help() on it. You can do:

This will give you essentially all the information about the object you need.

Now back to lists. We saw append() and pop(). There are more built in methods. insert() is a useful one:

Here is what it does:

remove() is also useful:

Here is what it does:

Let’s try to remove something that is not there:

As I said before: Read the error messages!!!

The list.extend() method allows you to append an entire list to a given list:

You can also sort a list like this:

Here is how you can count the occurence of a specific element in a list:

And here is how you can find the index of a list element:

There more things you can do with lists, but that’s it for now.

Questions¶

Consider the list:

• Find how many occurances of 23.0 there are in data:

• Find the mean of the data list, i.e., the sum of all elements divided by their number. Hint: Use the built-in python function sum(). Here is the help for sum:

The term iterable above refers to either tuples or lists (it is more general, but we will explain it another time).

• Find the minimum and the maximum of data. Hint: Use the function min() for the minimum.