# Homework: Introduction to Python¶

**Due: Thursday, Sept. 21**

Your assignment should be handed in an ipython notebook checked into your github repository. To download this assignment, your best option is to clone the original github repository for the course website:

```
git clone https://github.com/rabernat/research_computing.git
```

You will find the assignment in `content/Assignments/`

directory, along with the two data files.

If you really don't want to clone the repo, you can download it directly. You will also need to download the two data files.

## Optional But Recommended Reading¶

Read the official Python Tutorial sections 1-5. This excellent, well written tutorial introduces all of the most important concepts of the core python language and its standard library. Even if you don't read it, you should know where to find it; if you get stuck, it should be your first place to turn for help.

## Constraints¶

- This assignment should be done in
*basic python*: don't`import`

any extra modules unless specifically instructed to do so. - You should work on this assignment
*alone*. - Try to do the problems yourself. Refer to the lecture notes and the Python Tutorial if you get stuck. Avoid random googling and stack-overflowing. A perfect solution is less important than the process of figuring it out yourself.

## 1. Dictionaries and Strings¶

In this section we will explore a dictionary whose keys and values are strings.

Cut and paste the following code to read a data file. (You are not expected to understand exactly what is happening here...it's just a quick way for us to get some data into python.)

```
import pickle
with open('class_names.pkl', 'rb') as file:
data = pickle.load(file)
```

This will load some pre-generated data into the variable `data`

.

### 1.1 Examine the data by allowing the notebook to print it¶

(Just enter `data`

on the last line of the cell and execute it.)

## 1.2 Comare to the output of `print(data)`

¶

Which one is prettier?

### 1.3 Determine what type of object is `data`

¶

### 1.4 Use python's built-in `help`

function to find out what operations are available on `data`

¶

(What is the meaning of the methods that start with __?)

By now it should be clear that `data`

is a dict (i.e. "dictionary") that maps UNIs to names for all students in the class.

For the remaining questions, the point is to *have python tell you the answer*. (Obviously you could just manually count / sort the data, but that defeats the purpose!)

### 1.5 How many entries are there in `data`

¶

### 1.6 Is your UNI in `data`

?¶

### 1.7 How many total times does the character "s" appear in the names?¶

Do this in a way that is not case sensitive,

### 1.7 Create a new dictionary that contains the same keys but only the first names as values¶

### 1.8 What is the longest first name?¶

### 1.9 Check that the first letter of each UNI matches the first letter of each first name¶

(Be careful about the case.)

## 2 Lists and Numbers¶

In this section, we will play with a list of numbers.

Keep in mind that doing lots of numerical calculations on lists of numbers (using just core python) is somewhat awkward and inefficient. Numpy makes this sort of work much easier; in order to appreciate numpy, however, it is useful to first do things the "hard way".

Run this chunk of code to load some data.

```
with open('numbers.pkl', 'rb') as file:
numbers = pickle.load(file)
```

### 2.1 Confirm that `numbers`

is indeed a list¶

### 2.2 How many items are in `numbers`

?¶

### 2.3 What is the difference between the first and last values?¶

### 2.4 What are thre first five and last five items?¶

### 2.5 What is the type of the first item? Confirm that all items have the same type.¶

### 2.6 What are the minimum and maximum values in `numbers`

?¶

### 2.7 What is the mean value?¶

### 2.8 What is the standard deviation?¶

### 2.9 What is the largest (most positive) and smallest (most negative) *change* from one value to the next¶

### Bonus: can you guess the source of these numbers?¶

### 3.1 Create a list of the first three planets in the solar system¶

### 3.2 Append the fourth planet to the end of the list¶

(Print the list so you can verify its contents after every modification)

### 3.3 Venus has exploded. Remove it from the list¶

### 3.4 Convert the last item of your list to upper case¶

### 3.5 Create a tuple of the first three planets in the solar system¶

### 3.6 Try to append or remove items from the tuple¶

Go ahead, try it! I dare you!

### 3.7 Create a new tuple by concatenating a second tuple to your original tuple¶

(No loops needed). It should work. Check your original tuple. Did it change?

## 4 Standard Library: `datetime`

¶

Basic python comes with a powerful "standard library" of modules which help you do useful things like interact with the operating system, perform complex pattern matching on strings using regular expressions, and open network connections. This standard library is too big for us to learn every module: the point here is just to be aware that it exists.

In this exercise we will also explore a simple but powerful module from python's standard library: the `datetime`

module.

### 4.1 Import the datetime module¶

### 4.2 Read the built-in help on `datetime.date`

and `datetime.timedelta`

¶

These are the two functions we will be using from the `datetime`

module.

### 4.3 Create a `datetime.date`

object for your birthday¶

### 4.4 What day of the week was your birthday on?¶

### 4.5 Find out how many days have elapsed since your birthday?¶

As an example, we will consider the harmonic series, defined as

$$ \sum^N_{n=1}\frac{1}{n} $$

This series diverges logarithmically.

### 5.1 Write a function to compute the value of the harmonic series up to `N`

terms¶

The function shold have one argument: `N`

. It should `return`

the series sum.

### 5.2 What is the value of the harmonic series after 1000 and 1000000 iterations¶

The alternating harmonic series:

$$ \sum^N_{n=1}\frac{(-1)^{n+1}}{n} $$

*does* converge.

### 5.3 Write a function to compute the value of the alternating harmonic series up to `N`

terms¶

### 5.2 What is the value of the alternating harmonic series after 1000 and 1000000 iterations¶

### 5.3 Numerical convergence test¶

Now for something more complicated: we will write a function that tests whether another function converges. As its first argument, this function should accept *another function*. It should also have *optional keyword arguments* that specify

- the numerical tolerance (how close is close enough to consider a series converged?)
- the number of iterations (we can't iterate an infinite number of times, we just have to pick a "large number")

This function should print a statement telling what it found. If the test function converges, print the value it converges to.

*(Hint: the alernating harmonic series oscillates strongly around the asymptotic value. So checking neighboring points may not be the best way to test for convergence. Can you think of a more robust method?)*

### 5.3 Use your convergence test function see that the harmonic series diverges and the alternating harmonic series converges?¶

Explore the sensitivity to the two optional parameters. What are the tradeoffs between tolerance and number of iterations?