01 - Python Essential - instructor.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Essential"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To start this course, we will do a series of short exercises to refamiliarise ourselves with the Python language. We are going to redo in fast pace what we did in the introduction class.\n",
    "\n",
    "We are going start with the Jupyter Notebook, as we did in the previous class, to remind us of the python basics and to introduce some new concepts and python commands."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we mentioned in the previous class, the best way to learn how to program is to do something meaningful. \n",
    "\n",
    "Last time we learned some fundamental concepts in programming by doing some scientific data analysis using the python language. \n",
    "\n",
    "This time we will extend that analysis by transferring it into a proper python integrated developer environment (IDE) which can later be reused for further study."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The basics\n",
    "\n",
    "We learned the concept of *variable* and how to *assign* a value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dt = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can verify that the variable has the value *3* as expected:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('variable \"dt\" has the value:', dt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can assign to a variable any valid python object: an integer, a float, a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "a = 1.1\n",
    "car = 'aeiou'\n",
    "\n",
    "print('i =', i, 'is is integer', type(i))\n",
    "print('a =', a, 'is a float', type(a))\n",
    "print('car =', car, 'is a string', type(car))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but it is possible to assign a more complex object. Here we are assigning a list. One of python's built-in types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "odds = [1, 3, 4, 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to add elements to a list with the method *append* or by using the operator *+*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "odds.append(7)\n",
    "print(odds)\n",
    "\n",
    "odds = odds + [9]\n",
    "print(odds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**note**:\n",
    "\n",
    "You can only use the operator *+* with two lists. Python will return an error if not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "odds + 11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But you can concatenate two lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "odds + [12,13,14]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python also provides a reverse method for list objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Odds in normal order', odds)\n",
    "odds.reverse()\n",
    "print('Odds in reversed order', odds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and a *sort* method: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list = [4, 1, 5, 7]\n",
    "a_list.sort()\n",
    "print(a_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** note:**\n",
    "\n",
    "A list can be a composite object i.e. an object which contains differents type of object *but* in this case the sort method will not work:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list = [4, 1, 5, 7, 'a', 'z']\n",
    "print(a_list)\n",
    "\n",
    "a_list.sort()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The List is a very important object in python and it is very commonly used when you want to perform the same operation on list items using iteration. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Repeating Actions with loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the most important structures in software development is the loop. Computers are very good at repeating actions and applications are build around this capacity. \n",
    "\n",
    "Repeating actions in Python can be done with two differents structures:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For Loop\n",
    "\n",
    "```python\n",
    "\n",
    "for item in <group>:\n",
    "    <do something with item>\n",
    "    <do something>\n",
    "#end of the loop\n",
    "```\n",
    "\n",
    "For each thing (item) in this group, do these operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for number in [1, 8, 6]:\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is equivalent to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1)\n",
    "print(8)\n",
    "print(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list = [1, 8, 6]\n",
    "print(a_list[0])\n",
    "print(a_list[1])\n",
    "print(a_list[2])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style='background:#B1E0A8; padding:10px 10px 10px 10px;'>\n",
    "<H2> Challenges </H2>\n",
    "\n",
    " <ol>\n",
    " <li> \n",
    " Write two different for-loop to print each character in the word 'Mercury'.\n",
    " </li>\n",
    " <br>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Method 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Method 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style='background:#B1E0A8; padding:10px 10px 10px 10px;'>\n",
    "<H2> Challenges </H2>\n",
    "\n",
    " <ol>\n",
    " <li>\n",
    " Create a list which contains the odds numbers &lt; 20.\n",
    " </li>\n",
    " Hint: You can use the function 'range'.\n",
    " <br>\n",
    " <li> \n",
    " Can you use another object (which is not a built-in object in Python), similar to the list but essentially for numerical items?\n",
    " </li>\n",
    " Hint: Python capacity can be extended by importing libraries. Here you can use the library 'numpy'.\n",
    " <br>\n",
    "<li>\n",
    " Print on screen the 10 digits.\n",
    " </li>\n",
    " <br>\n",
    " \n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution challenge 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Note: \n",
    "\n",
    "In Python 3 the *range* function does not return a list but an iterator, to improve the efficiency in term of speed and memory. To create the list you have to force it by using the function *list*.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('range only:', range(1, 10, 2))\n",
    "\n",
    "l = list(range(1, 10, 2))\n",
    "print('range and list:', l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution Challenge 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution Challenge 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A new type of loop: *while*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The while loop is similar to  *for*  loop since it is made to repeat sections of code. It will not run for a predetermined number of times but until a certain condition is not fulfilled."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This new loop has the following syntax:\n",
    "```python\n",
    "\n",
    "while <condition>:\n",
    "    # instruction 1\n",
    "    # instruction 2\n",
    "    # ...\n",
    "    # instruction N\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word = 'Mercury'\n",
    "i = 0\n",
    "while i < len(word): \n",
    "    print(word[i])\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *break* keyword"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style='background:#B1E0A8; padding:10px 10px 10px 10px;'>\n",
    "<H2> Challenges </H2>\n",
    "\n",
    " <ol>\n",
    " <li> Can you explain what will happen with the following piece code?\n",
    " </li>\n",
    "<br>\n",
    "</div>\n",
    "\n",
    "```python\n",
    "while 1: # 1 is always true -> infinite loop\n",
    "    letter = input(\"Print 'Q' to exit  : \")\n",
    "    if letter == \"Q\":\n",
    "        print(\"End of the loop\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while 1: # 1 is always true -> infinite loop\n",
    "    letter = input(\"Print 'Q' to exit  : \")\n",
    "    if letter == \"Q\":\n",
    "        print(\"End of the loop\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To avoid the infinite loop, we can use the keyword *break* to force the software to exit the loop.\n",
    "\n",
    "\n",
    "```python\n",
    "while 1: # 1 is always true -> infinite loop\n",
    "    letter = input(\"Print 'Q' to exit  : \")\n",
    "    if letter == \"Q\":\n",
    "        print(\"End of the loop\")\n",
    "        break\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while 1: # 1 is always true -> infinite loop\n",
    "    letter = input(\"Print 'Q' to exit  : \")\n",
    "    if letter == \"Q\":\n",
    "        print(\"End of the loop\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making choice: Logic "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the Introduction to Python course we studied some data and noticed problem within them. We dealt with them by doing a test and we highlighted the one's with problems. To achieve that we used the *if* statement. The general form is:\n",
    "\n",
    "```python\n",
    "if <test1>:         # first test\n",
    "    <statements1>\n",
    "elif <test2>:       # optional elif test\n",
    "    <statements2>\n",
    "else:\n",
    "    <statements3>   # Optional else test\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style='background:#B1E0A8; padding:10px 10px 10px 10px;'>\n",
    "<H2> Challenges </H2>\n",
    "\n",
    " <ol>\n",
    "    <li> \n",
    "     Using the conditional structure: \n",
    "     'if ...:  else:'\n",
    "     For the numbers up to 10, print on screen whether the number is an odd or an even.\n",
    "    </li>\n",
    "Hint: Combine conditional and loop statements in this challenge.\n",
    "    <br>\n",
    "    <li>\n",
    "    Write a conditional block which will print on screen when a number is zero, a digit (1, ...9) or a number.\n",
    "    </li>\n",
    "    <br>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has an operator *%* which return the rest of the division between two numbers.\n",
    "\n",
    "Usage: \n",
    "\n",
    "```python\n",
    "a % b \n",
    "```\n",
    "\n",
    "If a is divisible by b the result will be equal to zero if not that will be the rest of the division.\n",
    "\n",
    "e.g: to determine if a number is an even you can write:\n",
    "\n",
    "```python\n",
    "a % 2 \n",
    "```\n",
    "\n",
    "If *a* is even the result will be zero. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution to Challenge 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution to Challenge 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function allow the developer to write a sequence of commands onec and to reuse it when it is needed. \n",
    "\n",
    "Breaking up software into small functions is considered as good practice and will help you to maintain it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function in python are starting with the keyword ```def``` follow by the name of the function, the parameters and by a block of commands.\n",
    "\n",
    "```python\n",
    "\n",
    "def func_name(arg1,arg2):\n",
    "    <commands1>\n",
    "    <commands2>\n",
    "    return <something>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greeting():\n",
    "    print('Hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**note:**\n",
    "\n",
    "Defining a function does not run it. You have to call it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can take arguments as input and do some operation on it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_date(year, month, day):\n",
    "    date = str(year) + '/' + str(month) + '/' + str(day)\n",
    "    print(date)\n",
    "    \n",
    "print_date(2018, 2, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions in python accept positioned and named arguments. You can mix both but the named argument calls always have to be **after** the positional ones.\n",
    "\n",
    "Here an example where the argument year is called using the position (first) but the other two, non optional arguments are called by name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_date(2012, day=20, month=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can **return** a result by using the keyword 'return'.\n",
    "\n",
    "*return* exits the function. The commands after that (if executed) will not be run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def average(values):\n",
    "    l = len(values)\n",
    "    if l != 0:\n",
    "        return sum(values)/l\n",
    "\n",
    "a_list = [1, 2, 3, 4]\n",
    "\n",
    "a = average(a_list)\n",
    "print('Average:', a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function can have optional argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myname(surname='Gledson', firstname='Ann'):\n",
    "    print(firstname, surname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myname()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myname('Capes', firstname='Gerard')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style='background:#B1E0A8; padding:10px 10px 10px 10px;'>\n",
    "<H2> Challenges </H2>\n",
    "<li>\n",
    "    Write a function which will calculate the polynomial: $f(x) = 3x^2 + 8x + 4$\n",
    "</li>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Documenting your function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has a very powerful system for documenting functions which automatically create a helper.\n",
    "\n",
    "Here we are using the numpy documention format: [numpydoc](https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    '''Function which return the value of the polynome: :math:`3x^2 + 8x + 4`\n",
    "\n",
    "    Input\n",
    "    -----\n",
    "    \n",
    "    x: float\n",
    "        a number that will be the input value of the polynomial\n",
    "    \n",
    "    Return\n",
    "    ------\n",
    "    float\n",
    "        return the value of the polynomial \n",
    "    '''\n",
    "    return 3*x*x + 8*x + 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Input/Output "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading numerical data from a file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<div style='background:#B1E0A8; padding:10px 10px 10px 10px;'>\n",
    "<H2> Challenges </H2>\n",
    "\n",
    "As in the Intro to Python course, we will open a data file using a function provided by the *numpy* library.\n",
    "\n",
    "   <li>Verify that you are in the expected working directory (should contain a 'data' folder) and if not change your working directory. (use the console part of spyder to run the command learned in jupyter)\n",
    "    </li>\n",
    "   <li>\n",
    "   Can you print on screen the files present in the current directory?\n",
    "   </li>\n",
    "   <li>Can you save in the variable *data01* the inflammation data from the file *inflammation-01.csv* (use 'numpy').\n",
    "   </li>\n",
    "   <br>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Jupyter/ipython:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ls data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cd data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reinitialisation to be able to run the pure python part."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cd .."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pure python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir('data')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.listdir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "fname = 'inflammation-01.csv'\n",
    "data01 = numpy.loadtxt(fname, delimiter=',')\n",
    "print('data in file ', fname, ':\\n', data01)\n",
    "print('data type:', type(data01))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The *numpy* function *loadtxt* is very convenient but does have limitations and will not work or will work not as expected for other files (even ascii files) and we will see an example later.\n",
    "\n",
    "Python provides a more generic function *open* to interact with file. In general, when you are dealing with files this is done in four steps: \n",
    "\n",
    "1. Open the file\n",
    "2. Read the content of the file\n",
    "3. Update/write in the file\n",
    "4. Close the file.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading a text file using python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fname = 'inflammation-01.csv'\n",
    "f = open(fname, 'r')\n",
    "data1 = f.readlines()\n",
    "f.close()\n",
    "print('Type of the data:', type(data1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('contents of the file:\\n', data1[0:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you just want to read the content of a file and put it in memory, it is better to use the following method, as makes sure that you do not forget to close the file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(fname,'r') as f:\n",
    "    data2 = f.readlines()\n",
    "print('Type of the data:', type(data2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('content of the file:\\n', data2[0:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can verify that the variables *data1* and *data2* are the same (we are reading the same file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data1 == data2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style='background:#B1E0A8; padding:10px 10px 10px 10px;'>\n",
    "<H2> Challenges </H2>\n",
    "<li>\n",
    "    Convert the variable <b>data1</b> from a list of strings to a numpy array.\n",
    "</li>\n",
    "    <p>\n",
    "        Hint: to remove the character '\\n' at the end of a string you can use the method 'strip()'. </p>\n",
    "<p>You can also use the method 'split(',')' which will split the string using the character ',' as the delimitor.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This second method is using a new tool called *list comprehension* which allows the developer to create a list without a for block and append.\n",
    "\n",
    "'python\n",
    "new_list = [ expression(i) for i in oldlist if filter(i)]\n",
    "'\n",
    "\n",
    "The filter *if (condition)*  is optional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now we can convert it as a numpy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = numpy.array(data)\n",
    "print('Data:\\n', data)\n",
    "print('Data type:', type(data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As You can see that the numpy function is saving us several lines of code and since the number of bugs in a software is strongly correlated with the number of lines this is a very good things to remember. \n",
    "If you can use the tools provided by other people."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving data in a file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We mention before that saving in file will be similar than to read. Here an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "line = 'A line we want to save in a file'\n",
    "line2 = 'Another line'\n",
    "\n",
    "f = open('ex1.txt', 'w')\n",
    "f.write(line)\n",
    "f.write('\\n')\n",
    "f.write(line2)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Attention:**\n",
    "\n",
    "You can only save strings to a file. To save something else you need to convert it before (or use a method provided by a library)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style='background:#B1E0A8; padding:10px 10px 10px 10px;'>\n",
    "<H2> Challenges </H2>\n",
    "<li>\n",
    "    Try to save a numpy array variable 'data' to a file.\n",
    "</li>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Data type:', type(data))\n",
    "f = open('numpyarray.txt', 'w')\n",
    "f.write(data)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy provides functions to achieve this. Here we want to save in a text file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numpy.savetxt('numpyarray.txt', data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Complex data file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%more agelist.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style='background:#B1E0A8; padding:10px 10px 10px 10px;'>\n",
    "<H2> Challenges </H2>\n",
    "<li>\n",
    "    Try to read the file <i>agelist.txt</i> into a variable using <i>loadtxt</i> function.\n",
    "</li>\n",
    "<li>Use another method to read the file.\n",
    "</li>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = numpy.loadtxt('agelist.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('agelist.txt', 'r') as f:\n",
    "    phonelist = f.readlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(phonelist)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}