Introduction_to_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.5.0"
    },
    "toc": {
      "colors": {
        "hover_highlight": "#DAA520",
        "running_highlight": "#FF0000",
        "selected_highlight": "#FFD700"
      },
      "moveMenuLeft": true,
      "nav_menu": {
        "height": "161px",
        "width": "252px"
      },
      "navigate_menu": true,
      "number_sections": true,
      "sideBar": true,
      "threshold": 4,
      "toc_cell": false,
      "toc_section_display": "block",
      "toc_window_display": false
    },
    "colab": {
      "name": "Copia de Introduction_to_Python.ipynb",
      "provenance": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "iDUqewx59d3o",
        "colab_type": "text"
      },
      "source": [
        "# Plan of the lecture"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "f2wFm1VL9d3s",
        "colab_type": "text"
      },
      "source": [
        "The aim of this lecture is to familiarise yourself with Python sintax: \n",
        "\n",
        "1. ¿Why Python?  \n",
        "2. Introduction to Python. \n",
        "3. Introduction to Pandas.\n",
        "4. Introduction to Beautidul Soup + Pandas. \n",
        "5. Demo of Pandas + Beautiful Soup with practical cases. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "-Ow8zwO-9d3t",
        "colab_type": "text"
      },
      "source": [
        "# Python: basic concepts"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "1Fs8GJRk9d3u",
        "colab_type": "text"
      },
      "source": [
        "Python is a very flexible and very powerful **programming language** that allows us to communicate with the computer. Python has become very famous in the humanities lately because of its specific libraries to work with text and data. \n",
        "\n",
        "Interestingly, the name of Python doesn´t come from the snake but from the British comedy group 'Monty Python'. This reflects the idea of Python developers to keep the language fun to use. \n",
        "\n",
        "Python's phylosophy emphasizes code readability and features a simple and very expressive syntax. It is actually easy to master the basic aspects of Python's syntax: it is amazing how much you can do even with just the most basic concepts... The aim of this session is to introduce to you some of these basic operations, let you see some code in action and also give you some exercise where you can apply what you've seen."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ekz20mQN9d3w",
        "colab_type": "text"
      },
      "source": [
        "It is also amazing how many thing you can accomplish with some well written lines of Python! By the end of this class, you will be familiar with Pandas and Beautiful Soup. But of course, you can even just use Python do something as easy as..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "EknBD6Z79d3x",
        "colab_type": "code",
        "outputId": "e28a73fa-bd19-4636-882c-189fefdf7a72",
        "colab": {}
      },
      "source": [
        "2 + 3"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "FCRSoOGF9d34",
        "colab_type": "text"
      },
      "source": [
        "## Variables and data types"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "TPoD6xL29d36",
        "colab_type": "text"
      },
      "source": [
        "Here we go! we've written our first line of code... But I guess we want to do something a little more interesting, right? Well, for a start, we might want to use Python to execute some operation (say: sum two numbers like 2 and 3) and process the result to print it on the screen, process it, and reuse it as many time as we want..."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "nvkuzH0e9d37",
        "colab_type": "text"
      },
      "source": [
        "**Variables** is what we use to store values. Think of it as a shoebox to access your data; next time you need that content (i.e. the result of a previous operation, or for example some input you've read from a file) you simply call the shoebox name..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "FLuL9jYW9d38",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "result = 2 + 3"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ULtYieqJ9d4A",
        "colab_type": "code",
        "outputId": "c41ab510-cc2c-4f48-c4aa-58ea7a41945d",
        "colab": {}
      },
      "source": [
        "#now we print the result\n",
        "print(result)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "8SX8ysbo9d4F",
        "colab_type": "code",
        "outputId": "1337a221-a478-42a7-b6dc-79067f7f4ef1",
        "colab": {}
      },
      "source": [
        "# by the way, I'm a comment. I'm not executed\n",
        "# every line of code following the sign # is ignored:\n",
        "# print(\"I'm line n. 3: do you see me?\")\n",
        "# see? You don't see me...\n",
        "print(\"I'm line nr. 5 and you DO see me!\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "I'm line nr. 5 and you DO see me!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "X4naCPwk9d4L",
        "colab_type": "text"
      },
      "source": [
        "That's it! As easy as that (yes, in some programming languages you have to create or declare the variable first and then use it to fill the shoebox; in Python, you go ahead and simply use it!)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "UeZm071q9d4M",
        "colab_type": "text"
      },
      "source": [
        "Now, what do you think we will get when we execute the following code?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "VPJffR9u9d4O",
        "colab_type": "code",
        "outputId": "b547ca1d-a841-4ef1-fce7-e92fefbcb003",
        "colab": {}
      },
      "source": [
        "result + 5"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "18yceJD-9d4R",
        "colab_type": "text"
      },
      "source": [
        "What types of values can we put into a variable? What goes into the shoebox? We can start by the members of this list:\n",
        "\n",
        "* **Integers** (-1,0,1,2,3,4...)\n",
        "* **Strings** (\"Hello\", \"s\", \"Wolfgang Amadeus Mozart\", \"I am the α and the ω!\"...)\n",
        "* **floats** (3.14159; 2.71828...)\n",
        "* **Booleans** (True, False)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "kequihww9d4S",
        "colab_type": "text"
      },
      "source": [
        "If you're not sure what type of value you're dealing with, you can use the function `type()`. Yes, it works with variables too...!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "x6XG3lk69d4T",
        "colab_type": "code",
        "outputId": "2d0fadba-168f-4a47-dd6f-3acfdc7f085f",
        "colab": {}
      },
      "source": [
        "type(\"I am the α and the ω!\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Pi6LUVU69d4Y",
        "colab_type": "code",
        "outputId": "9e266adc-84c2-4220-9f41-ac0e67eb4e35",
        "colab": {}
      },
      "source": [
        "type(2.7182818284590452353602874713527)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "nrSNYXep9d4c",
        "colab_type": "code",
        "outputId": "31b5392a-7173-4115-b726-0bba1699615a",
        "colab": {}
      },
      "source": [
        "type(True)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "bool"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K9UWaKxf9d4j",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "result = \"hello\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "diAwKYgZ9d4m",
        "colab_type": "code",
        "outputId": "3e4c6264-26d3-4761-f319-3cd46aae3894",
        "colab": {}
      },
      "source": [
        "type(results)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "DnoWswkK9d4q",
        "colab_type": "text"
      },
      "source": [
        "You declare strings with single ('') or double (\"\") quote: it's totally indifferent! But now two questions:\n",
        "1. what happens if you forget the quotes?\n",
        "2. what happens if you put quotes around a number?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Lfo45ZPq9d4r",
        "colab_type": "code",
        "outputId": "72eab7df-61ca-4ba8-9456-ac3a2a3d4efd",
        "colab": {}
      },
      "source": [
        "hello = \"goodbye\"\n",
        "print(hello)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "goodbye\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nv15gF5l9d4v",
        "colab_type": "code",
        "outputId": "a5c8327d-3139-4899-a800-a3b97f05cd5a",
        "colab": {}
      },
      "source": [
        "print(\"hello\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "eMYo_hAW9d40",
        "colab_type": "code",
        "outputId": "fb694ac4-5cbe-4fe1-b32b-6ff9f7125c59",
        "colab": {}
      },
      "source": [
        "type(\"2\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "4F4H54gn9d44",
        "colab_type": "text"
      },
      "source": [
        "String, integer, float... Why is that so important? Well, try to sum two strings and see what happens..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "0xAzlqPv9d45",
        "colab_type": "code",
        "outputId": "fee8e8fd-bdf6-446b-d616-6e4212bf9d71",
        "colab": {}
      },
      "source": [
        "\"2\" + \"3\""
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'23'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "IUzxzPza9d48",
        "colab_type": "code",
        "outputId": "78fc1566-da15-494c-dab2-34f91a0eeffa",
        "colab": {}
      },
      "source": [
        "#probably you wanted this...\n",
        "int(\"2\") + int(\"3\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "hO5fhKpp9d5A",
        "colab_type": "text"
      },
      "source": [
        "But if we are working with strings, then the \"+\" sign is used to concatenate the strings:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "2ClMgolF9d5B",
        "colab_type": "code",
        "outputId": "ec2ddf3c-5945-4c9b-c23b-e7bdbed2ce58",
        "colab": {}
      },
      "source": [
        "a = \"interesting!\"\n",
        "print(\"not very \" + a)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "not very interesting!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "qGWTUhjI9d5F",
        "colab_type": "text"
      },
      "source": [
        "## Lists and dictionaries"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "I2ZZLwk49d5G",
        "colab_type": "text"
      },
      "source": [
        "Lists and dictionaries are two very useful types to store whole collections of data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "qzu4Cx-c9d5H",
        "colab_type": "code",
        "outputId": "ef3d1e39-392a-49fa-f53e-b5f136bd9ee6",
        "colab": {}
      },
      "source": [
        "beatles = [\"John\", \"Paul\", \"George\", \"Ringo\"]\n",
        "type(beatles)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Raur2d599d5L",
        "colab_type": "code",
        "outputId": "7b7de8cb-87f2-412b-ea06-6acdf5c42783",
        "colab": {}
      },
      "source": [
        "# dictionaries collections of key : value pairs\n",
        "beatles_dictionary = { \"john\" : \"John Lennon\" ,\n",
        "                      \"paul\" : \"Paul McCartney\",\n",
        "                      \"george\" : \"George Harrison\",\n",
        "                      \"ringo\" : \"Ringo Starr\"}\n",
        "type(beatles_dictionary)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "BuqiG9qt9d5O",
        "colab_type": "text"
      },
      "source": [
        "(there are also other types of collection, like [Tuples](https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences) and [Sets](https://docs.python.org/3/tutorial/datastructures.html#sets), but we won't talk about them now; read the links if you're interested!)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "KRsobw3i9d5P",
        "colab_type": "text"
      },
      "source": [
        "Items in list are accessible using their index. **Do remember** that indexing starts from 0!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "n5F_MxUe9d5Q",
        "colab_type": "code",
        "outputId": "4cb8da13-1c1c-4828-87ff-26b7f00e502d",
        "colab": {}
      },
      "source": [
        "print(beatles[0])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "John\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "p1K5urK_9d5T",
        "colab_type": "code",
        "outputId": "12c3b48d-eca6-4482-cedd-65d6c35a1d4c",
        "colab": {}
      },
      "source": [
        "#indexes can be negative!\n",
        "beatles[-1]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Ringo'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "qxfcAIxg9d5X",
        "colab_type": "text"
      },
      "source": [
        "Dictionaries are collections of *key : value* pairs. You access the value using the key as index"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ZU1kSICW9d5Y",
        "colab_type": "code",
        "outputId": "d27f94dd-e8fd-4569-f5e7-22c7cf6e0704",
        "colab": {}
      },
      "source": [
        "beatles_dictionary[\"john\"]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'John Lennon'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AAdS50WL9d5b",
        "colab_type": "code",
        "outputId": "f4924ed6-50ac-4a30-8d05-d1eeca215e05",
        "colab": {}
      },
      "source": [
        "beatles_dictionary[0]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "0",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-31-31e6fcd3d0e7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbeatles_dictionary\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m: 0"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "7ilDjtt_9d5e",
        "colab_type": "text"
      },
      "source": [
        "There are a bunch of methods that you can apply to list to work with them.\n",
        "\n",
        "You can append items at the end of a list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "BzLiNUTJ9d5k",
        "colab_type": "code",
        "outputId": "2819889e-0b8b-4b72-9d59-d368c99a97c9",
        "colab": {}
      },
      "source": [
        "beatles.append(\"Billy Preston\")\n",
        "beatles"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['John', 'Paul', 'George', 'Ringo', 'Billy Preston']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "MU3yeaH69d5q",
        "colab_type": "text"
      },
      "source": [
        "You can learn the index of an item"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "2Hmiq0nP9d5r",
        "colab_type": "code",
        "outputId": "98b37c25-7ddb-4888-f9d8-90aa2bccdba0",
        "colab": {}
      },
      "source": [
        "beatles.index(\"George\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "nj0sHO1u9d5u",
        "colab_type": "text"
      },
      "source": [
        "You can insert elements at a predefinite index:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "_2DUZJ-D9d5v",
        "colab_type": "code",
        "outputId": "a0fed091-8bf3-430d-eec6-17acf7f61c4f",
        "colab": {}
      },
      "source": [
        "beatles.insert(0, \"Pete Best\")\n",
        "print(beatles.index(\"George\"))\n",
        "beatles"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Pete Best', 'John', 'Paul', 'George', 'Ringo', 'Billy Preston']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ErZ24ngL9d5z",
        "colab_type": "text"
      },
      "source": [
        "But most importantly, you can **slice** lists, producing sub-lists by specifying the range of indexes you want:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "-3GPr6Bm9d50",
        "colab_type": "code",
        "outputId": "c623826d-9eea-4d23-c63d-fdbe41963e0b",
        "colab": {}
      },
      "source": [
        "beatles[1:5]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['John', 'Paul', 'George', 'Ringo']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "BxMRB_eM9d55",
        "colab_type": "text"
      },
      "source": [
        "Do you notice something strange? Yes, the limit index is **not** inclusive (i.e. item beatles[5] is not included)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "hc3aAv3h9d56",
        "colab_type": "code",
        "outputId": "2ed06885-ef09-4250-b1ea-49ad6ded8dde",
        "colab": {}
      },
      "source": [
        "beatles[5]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Billy Preston'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "icJIroLK9d5_",
        "colab_type": "text"
      },
      "source": [
        "What happens if you specify an index that is too high?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "dvhXiJjs9d6A",
        "colab_type": "code",
        "outputId": "c2b4ee9c-70c8-40b2-af27-19646379cef0",
        "colab": {}
      },
      "source": [
        "beatles[7]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndexError",
          "evalue": "list index out of range",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-37-b9b16afb11e9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbeatles\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m: list index out of range"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Hy-Pz93s9d6E",
        "colab_type": "text"
      },
      "source": [
        "How can you know how long a list is?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "1JLq7DMb9d6F",
        "colab_type": "code",
        "outputId": "a4a529c2-8b41-4167-fdfa-8fe2306336d8",
        "colab": {}
      },
      "source": [
        "len(beatles)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "uhL11sx39d6I",
        "colab_type": "text"
      },
      "source": [
        "Do remember that indexing starts at 0, so don't make the mistake of thinking that `len(yourlist)` will give you the last item of your list!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "0BFrqalK9d6J",
        "colab_type": "code",
        "outputId": "03113c19-8a3c-4d80-c63f-622b0e623ff2",
        "colab": {}
      },
      "source": [
        "beatles[len(beatles)]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndexError",
          "evalue": "list index out of range",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-39-00884e355894>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbeatles\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbeatles\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m: list index out of range"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ucxTILZU9d6M",
        "colab_type": "text"
      },
      "source": [
        "This will work!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "M_Oj2Dqp9d6N",
        "colab_type": "code",
        "outputId": "736b8024-e59b-4498-bb7b-965c476fdcc7",
        "colab": {}
      },
      "source": [
        "beatles[len(beatles) -1]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Billy Preston'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "X7g_qxt09d6R",
        "colab_type": "text"
      },
      "source": [
        "## If-statements"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "rgwrnu_Y9d6S",
        "colab_type": "text"
      },
      "source": [
        "Most of the times, what you want to do when you program is to check a value and execute some operation depending on whether the value matches some condition. That's where **if statements** help!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ce31mr9G9d6b",
        "colab_type": "text"
      },
      "source": [
        "In its easiest form, an If statement is syntactic construction that checks whether a condition is met; if it is some part of code is executed"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "7Byt8mnq9d6f",
        "colab_type": "code",
        "outputId": "282efe04-c3e4-4064-f566-00caf19cd9ff",
        "colab": {}
      },
      "source": [
        "bassist = \"Paul McCartney\"\n",
        "\n",
        "if bassist == \"Paul McCartney\":\n",
        "    print(\"Paul played bass with the Beatles!\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Paul played bass with the Beatles!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "hj5a_NtV9d6q",
        "colab_type": "text"
      },
      "source": [
        "Mind the **indentation** very much! This is the essential element in the syntax of the statement"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "VgGKqI2v9d6u",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "bassist = \"Bill Wyman\"\n",
        "\n",
        "if bassist == \"Paul McCartney\":\n",
        "    print(\"I'm part of the if statement...\")\n",
        "    print(\"Paul played bass in the Beatles!\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "NzQSGrEO9d61",
        "colab_type": "text"
      },
      "source": [
        "What happens if the condition is not met? Nothing! The indented code is not executed, because the condition is not met, so lines 4 and 5 are simply skipped.\n",
        "\n",
        "**But what happens if we de-indent line 5**? Can you guess why this is what happes?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "xHRvEI_z9d62",
        "colab_type": "text"
      },
      "source": [
        "Most of the time, we need to specify what happens if the conditions are not met"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "5IzzyjWT9d67",
        "colab_type": "code",
        "outputId": "1cd635f8-0d2a-4f5d-93ab-8527876811f7",
        "colab": {}
      },
      "source": [
        "bassist = \"\"\n",
        "\n",
        "if bassist == \"Paul McCartney\":\n",
        "    print(\"Paul played bass in the Beatles!\")\n",
        "else:\n",
        "    print(\"This guy did not play for the Beatles...\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "This guy did not play for the Beatles...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "kAZJH7pT9d7B",
        "colab_type": "text"
      },
      "source": [
        "This is the flow:\n",
        "* the condition in line 3 is checked\n",
        "* is it met?\n",
        "    * **yes**: then line 4 is executed\n",
        "    * **no**: then line 6 is executed"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "s6cJFnRG9d7C",
        "colab_type": "text"
      },
      "source": [
        "Or we can specify many different conditions..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "lrkXJs3E9d7D",
        "colab_type": "code",
        "outputId": "0e3a2ede-4862-41f3-95ee-8f5b42d78587",
        "colab": {}
      },
      "source": [
        "bassist = \"Bill\"\n",
        "\n",
        "if bassist == \"Paul McCartney\":\n",
        "    print(\"Paul played bass in the Beatles!\")\n",
        "elif bassist == \"Bill Wyman\":\n",
        "    print(\"Bill Wyman played for the Rolling Stones!\")\n",
        "else:\n",
        "    print(\"I don't know what band this guy played for...\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "I don't know what band this guy played for...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "T6t1sPRL9d7I",
        "colab_type": "text"
      },
      "source": [
        "##  For loops"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "XicBnlzp9d7J",
        "colab_type": "text"
      },
      "source": [
        "The greatest thing about lists is that thet are **iterable**, that is you can loop through them. What do we do if we want to apply some line of code to each element in a list? Try with a for loop!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "vIibQyKX9d7K",
        "colab_type": "text"
      },
      "source": [
        "A **for loop** can be paraphrased as: \"for each element named x in an iterable (e.g. a list): do some code (e.g. print the value of x)\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "s-_rhplR9d7K",
        "colab_type": "code",
        "outputId": "943add25-cbc8-416a-bcb7-aeeeeb635d3a",
        "colab": {}
      },
      "source": [
        "for b in beatles:\n",
        "    print(b + \" was one of the Beatles\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Pete Best was one of the Beatles\n",
            "John was one of the Beatles\n",
            "Paul was one of the Beatles\n",
            "George was one of the Beatles\n",
            "Ringo was one of the Beatles\n",
            "Billy Preston was one of the Beatles\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "3eF5OuSb9d7Q",
        "colab_type": "text"
      },
      "source": [
        "Let's break the code down to its parts:\n",
        "* **b**: an arbitrary name that we give to the variable holding every value in the loop (it could have been any name; b is just very convenient in this case!)\n",
        "* **beatles**: the list we're iterating through\n",
        "* **:** as in the if-statements: don't forget the colon!\n",
        "* **indent**: also, don't forget to indent this code! it's the only thing that is telling python that line 2 is part of the for loop!\n",
        "* **line 2**: the function that we want to execute for each item in the iterables"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "yzEpquRB9d7R",
        "colab_type": "text"
      },
      "source": [
        "Now, let's join if statements and for loop to do something nice..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "aCVu7SxG9d7S",
        "colab_type": "code",
        "outputId": "fc810072-1f6d-4d99-ee5a-f025a238e677",
        "colab": {}
      },
      "source": [
        "beatles = [\"John\", \"Paul\", \"George\", \"Ringo\"]\n",
        "for b in beatles:\n",
        "    if b == \"Paul\":\n",
        "        instrument = \"bass\"\n",
        "    elif b == \"John\":\n",
        "        instrument = \"rhythm guitar\"\n",
        "    elif b == \"George\":\n",
        "        instrument = \"lead guitar\"\n",
        "    elif b == \"Ringo\":\n",
        "        instrument = \"drum\"\n",
        "    print(b + \" played \" + instrument + \" with the Beatles\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "John played rhythm guitar with the Beatles\n",
            "Paul played bass with the Beatles\n",
            "George played lead guitar with the Beatles\n",
            "Ringo played drum with the Beatles\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Tc3wtpVG9d7W",
        "colab_type": "text"
      },
      "source": [
        "## Input and Output"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "S_wHgY_l9d7X",
        "colab_type": "text"
      },
      "source": [
        "One of the most frequent tasks that programmers do is reading data from files, and write some of the output of the programs to a file. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "CVGRsgw-9d7Y",
        "colab_type": "text"
      },
      "source": [
        "In Python (as in many language), we need first to open a file-handler with the appropriate mode in order to process it. Files can be opened in:\n",
        "* read mode (\"r\")\n",
        "* write mode (\"w\")\n",
        "* append mode\n",
        "\n",
        "Let's try to read the content of one of the txt files of our Sunoikisis directory"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "deletable": true,
        "editable": true,
        "id": "gCZ7NC099d7Z",
        "colab_type": "text"
      },
      "source": [
        "First, we open the file handler in **read mode**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "deletable": true,
        "editable": true,
        "id": "Zc9uMwdT9d7a",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#see? we assign the file-handler to a variable, or we wouldn't be able\n",
        "#to do anything with that!\n",
        "f =  open(\"NOTES.md\", \"r\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "XW7D_SYV9d7k",
        "colab_type": "text"
      },
      "source": [
        "note that **\"r\" is optional**: read is the default mode!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ZjInxINy9d7k",
        "colab_type": "text"
      },
      "source": [
        "Now there are a bunch of things we can do:\n",
        "* read the full content in one variable with this code:\n",
        "\n",
        "`content = f.read()`\n",
        "\n",
        "* read the lines in a list of lines:\n",
        "\n",
        "`lines = f.readlines()`\n",
        "\n",
        "* or, which is the easiest, simply read the content one line at the time with a for loop; the **f object is iterable**, so this is as easy as:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "jS5va7Ej9d7l",
        "colab_type": "code",
        "outputId": "8982f354-608c-4da9-ffd0-19a8fa212229",
        "colab": {}
      },
      "source": [
        "for l in f:\n",
        "    print(l)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Password = ~Sun0ikiS1s!2oi62oi7#\n",
            "\n",
            "\n",
            "\n",
            "\tpip install jupyter\n",
            "\n",
            "\tjupyter notebook --generate-config\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "iZoIvHQ99d7o",
        "colab_type": "text"
      },
      "source": [
        "Once you're done, don't forget to **close the handle**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "deletable": true,
        "editable": true,
        "id": "5ZYtUZ6O9d7o",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "f.close()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "zcM-YfZ29d7r",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#all together\n",
        "f = open(\"NOTES.md\")\n",
        "for l in f:\n",
        "    print(l)\n",
        "f.close()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "_eI1r0MK9d7u",
        "colab_type": "text"
      },
      "source": [
        "Now, there's a shortcut statement, which you'll often see and is very convenient, because it takes care of opening, closing and cleaning up the mess, in case there's some error:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "2rEPqWR-9d7v",
        "colab_type": "code",
        "outputId": "7166d234-5244-44da-8cd2-6c01e0cac92e",
        "colab": {}
      },
      "source": [
        "with open(\"NOTES.md\") as f:\n",
        "    #mind the indent!\n",
        "    for l in f:\n",
        "        #double indent, of course!\n",
        "        print(l)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Password = ~Sun0ikiS1s!2oi62oi7#\n",
            "\n",
            "\n",
            "\n",
            "\tpip install jupyter\n",
            "\n",
            "\tjupyter notebook --generate-config\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Bo3Ca4kh9d7z",
        "colab_type": "text"
      },
      "source": [
        "Now, how about **writing** to a file? Let's try to write a simple message on a file; first, we open the handler in write mode"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "deletable": true,
        "editable": true,
        "id": "JkpYA7eu9d7z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "out = open(\"test.txt\", \"w\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "wWO0CrKT9d71",
        "colab_type": "code",
        "outputId": "1abc2640-aca1-405e-c2e8-bd36c1e4e73e",
        "colab": {}
      },
      "source": [
        "#the file is now open; let's write something in it\n",
        "out.write(\"This is a test!\\nThis is a second line (separated with a new-line feed)\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "70"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ScB6JA4W9d74",
        "colab_type": "text"
      },
      "source": [
        "The file has been created! Let's check this out"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "EAg68T5w9d74",
        "colab_type": "code",
        "outputId": "aae0017c-c595-43fc-fee4-7d7428e9d3d7",
        "colab": {}
      },
      "source": [
        "#don't worry if you don't understand this code!\n",
        "#We're simply listing the content of the current directory...\n",
        "import os\n",
        "os.listdir()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Sunoikisis - Named Entity Extraction 1a-VV.ipynb',\n",
              " 'requirements.txt',\n",
              " 'Sunoikisis - Named Entity Extraction 1a.ipynb',\n",
              " 'outline.md',\n",
              " 'Sunoikisis - Named Entity Extraction 1a_MR.ipynb',\n",
              " 'Sunoikisis - Named Entity Extraction 1b.ipynb',\n",
              " '.git',\n",
              " 'Sunoikisis - Named Entity Extraction 1b_MR.ipynb',\n",
              " '.ipynb_checkpoints',\n",
              " 'LICENSE',\n",
              " 'test.txt',\n",
              " 'Sunoikisis - Named Entity Extraction 1b-VV.ipynb',\n",
              " '.gitignore',\n",
              " 'imgs',\n",
              " 'README.md',\n",
              " 'NOTES.md']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "jPElHfPI9d7_",
        "colab_type": "text"
      },
      "source": [
        "But before we can do anything (e.g. open it with your favorite text editor) you have to **close the file-handler**!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "e8m-QMMP9d8A",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "out.close()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "vqdCNMEo9d8F",
        "colab_type": "text"
      },
      "source": [
        "Let's look at its content"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "G84wvSQh9d8G",
        "colab_type": "code",
        "outputId": "c464a36c-c3f9-4823-8238-7a1ec72076d7",
        "colab": {}
      },
      "source": [
        "with open(\"test.txt\") as f:\n",
        "    print(f.read())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "This is a test!\n",
            "This is a second line (separated with a new-line feed)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "P2bWECCq9d8J",
        "colab_type": "text"
      },
      "source": [
        "Again, also for writing we can use a **with statement**, which is very handy.\n",
        "\n",
        "But let's have a look at what happens here, so we understand a bit better why **\"write mode\" must be used carefully!**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "deletable": true,
        "editable": true,
        "id": "W1tSPWQe9d8J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "with open(\"test.txt\", \"w\") as out:\n",
        "    out.write(\"Oooops! new content\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "_-_rwXhT9d8M",
        "colab_type": "text"
      },
      "source": [
        "Let's have a look at the content of \"test.txt\" now"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "SyIx1bLY9d8R",
        "colab_type": "code",
        "outputId": "00d53869-f155-41f5-edc1-b90c0d284dbd",
        "colab": {}
      },
      "source": [
        "with open(\"test.txt\") as f:\n",
        "    print(f.read())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Oooops! new content\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "vuzP8LvA9d8W",
        "colab_type": "text"
      },
      "source": [
        "See? After we opened the file in \"write mode\" for the second time, **all content of the file was erased** and replaced with the new content that we wrote!!!\n",
        "\n",
        "So keep in mind: when you open a file in \"w\" mode:\n",
        "\n",
        "* if it doesn't exist, a new file with that name is created\n",
        "* if it does exist, it is completely overwritten and all previous content is lost"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "AOcFCE0q9d8X",
        "colab_type": "text"
      },
      "source": [
        "If you want to write content to an existing file without losing its pervious content, you have to open the file with the \"a\" mode:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "deletable": true,
        "editable": true,
        "id": "FIJAyZcz9d8Y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "with open(\"test.txt\", \"a\") as out:\n",
        "    out.write('''\\nAnd this is some additional content.\n",
        "The new content is appended at the bottom of the existing file''')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "-xnivikr9d8b",
        "colab_type": "code",
        "outputId": "5561adef-5532-4569-ff4a-6d467ed15abd",
        "colab": {}
      },
      "source": [
        "with open(\"test.txt\") as f:\n",
        "    print(f.read())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Oooops! new content\n",
            "And this is some additional content.\n",
            "The new content is appended at the bottom of the existing file\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "BTWscQ749d8f",
        "colab_type": "text"
      },
      "source": [
        "## Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "t5e_ZAkj9d8g",
        "colab_type": "text"
      },
      "source": [
        "Above, we have opened a file several times to inspect its content. Each time, we had to type the same code over and over. This is the typical case where you would like to save some typing (and write code that is much easier to maintain!) by defining a **function**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "bnTWGMfQ9d8g",
        "colab_type": "text"
      },
      "source": [
        "A function is a block of reusable code that can be invoked to perform a definite task. Most often (but not necessarily), it accepts one or more arguments and return a certain value.\n",
        "\n",
        "We have already seen one of the built-in functions of Python: `print(\"some str\")`\n",
        "\n",
        "But it's actually very easy to define your own. Let's define the function to print out the file content, as we said before. Note that this function takes one argument (the file name) and prints out some text, but doesn't return back any value."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "deletable": true,
        "editable": true,
        "id": "3sQXYb9u9d8h",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def printFileContent(file_name):\n",
        "    #the function takes one argument: file_name\n",
        "    with open(file_name) as f:\n",
        "        print(f.read())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "s-LMVWE-9d8j",
        "colab_type": "text"
      },
      "source": [
        "As usual, mind the indent!\n",
        "\n",
        "`file_name` (line 1) is the placeholder that we use in the function for any argument that we want to pass to the function in our real-life reuse of the code.\n",
        "\n",
        "Now, if we want to use our function we simply call it with the file name that we want to print out"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "x3nePypA9d8l",
        "colab_type": "code",
        "outputId": "06cedd95-8825-4fc4-a924-51f23f65e734",
        "colab": {}
      },
      "source": [
        "printFileContent(\"README.md\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "# SunoikisisDC_NER\n",
            "The materials for the SunoikisisDC sessions on Named Entity Extraction (2016/2017) \n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "PVTOt6IQ9d8p",
        "colab_type": "text"
      },
      "source": [
        "Now, let's see an example of a function that returns some value to the users. Those functions typically take some argument, process them and yield back the result of this processing.\n",
        "\n",
        "Here's the easiest example possible: a function that takes two numbers as arguments, sum them and returns the result."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "deletable": true,
        "editable": true,
        "id": "On-D-LFF9d8q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def sumTwoNumbers(first_int, second_int):\n",
        "    s = first_int + second_int\n",
        "    return s"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "deletable": true,
        "editable": true,
        "id": "WNDXXj5A9d8t",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#could be even shorter:\n",
        "def sumTwoNumbers(first_int, second_int):\n",
        "    return first_int + second_int"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "fTZcudhc9d8x",
        "colab_type": "code",
        "outputId": "29adb581-b555-463a-b208-22503382a01f",
        "colab": {}
      },
      "source": [
        "sumTwoNumbers(5, 6)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "11"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "RWvJmfhM9d8z",
        "colab_type": "text"
      },
      "source": [
        "Most often, you want to assign the result returned to a variable, so that you can go on working with the results..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "rz3Z4hTi9d8z",
        "colab_type": "code",
        "outputId": "ddc576a2-2a73-4050-f8db-1d99d02ed0d9",
        "colab": {}
      },
      "source": [
        "s = sumTwoNumbers(5,6)\n",
        "s * 2"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "22"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 78
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "JlIXDXEX9d86",
        "colab_type": "text"
      },
      "source": [
        "## Error and exceptions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "hE0bokiX9d89",
        "colab_type": "text"
      },
      "source": [
        "Things can go wrong, especially when you're a beginner. But no panic! Errors and exceptions are actually a good thing! Python gives you detailed reports about what is wrong, so read them carefully and try to figure out what is not right.\n",
        "\n",
        "Once you're getting better, you'll actually learn that you can do something good with the exceptions: you'll learn how to handle them, and to anticipate some of the most common problems that dirty data can face you with..."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "5zrwirFt9d8_",
        "colab_type": "text"
      },
      "source": [
        "Now, what happens if you forget the **all-important syntactic constraint of the code indent**?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "RmGq-DE99d9A",
        "colab_type": "code",
        "outputId": "c106fceb-4ba7-45db-fc7b-1da2c9d7fd05",
        "colab": {}
      },
      "source": [
        "if 1 > 0:\n",
        "    print(\"Well, we know that 1 is bigger than 0!\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Well, we know that 1 is bigger than 0!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "IesniQyd9d9F",
        "colab_type": "text"
      },
      "source": [
        "Pretty clear, isn't it? What you get is an **error** a construct that is not grammatical in Python's syntax. Note that you're also told where (at what line, and at what point of the code) your error is occurring. That is not always perfect (there are cases where the problem is actually occuring before what Python thinks), but in this case it's pretty OK."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "M9sk5k1r9d9G",
        "colab_type": "text"
      },
      "source": [
        "What if you forget to define a variable (or you misspell the name of a variable)?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "XnhGZhr59d9G",
        "colab_type": "code",
        "outputId": "cc657135-3a97-401a-8a79-dce47a2b55c6",
        "colab": {}
      },
      "source": [
        "var = \"bla bla\"\n",
        "if var1:\n",
        "    print(\"If you see me, then I was defined...\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "name 'var1' is not defined",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-84-f4ea1c51d2f6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mvar\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"bla bla\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mvar1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"If you see me, then I was defined...\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'var1' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "I8ChVnyA9d9I",
        "colab_type": "text"
      },
      "source": [
        "You get an **exception**! The syntax of your code is right, but the execution met with a problem that caused the program to stop.\n",
        "\n",
        "Now, in your program, you can handle selected exception: this means that you can write your code in a way that the program would still be executed even if a certain exception is raised.\n",
        "\n",
        "Let's see what happens if we use our function to try to print the content of a file that doesn't exist:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "0Uqoe0jt9d9I",
        "colab_type": "code",
        "outputId": "3afe0fd1-41fd-4993-971d-9b93ead4fb69",
        "colab": {}
      },
      "source": [
        "printFileContent(\"file_that_is_not_there.txt\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "FileNotFoundError",
          "evalue": "[Errno 2] No such file or directory: 'file_that_is_not_there.txt'",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-85-501b445822cd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprintFileContent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"file_that_is_not_there.txt\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-71-09207a2f323d>\u001b[0m in \u001b[0;36mprintFileContent\u001b[0;34m(file_name)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mprintFileContent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;31m#the function takes one argument: file_name\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile_name\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'file_that_is_not_there.txt'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "t-8lWiQX9d9K",
        "colab_type": "text"
      },
      "source": [
        "We get a `FileNotFoundError`! Now, let's re-write the function so that this event (somebody uses the function with a wrong file name) is taken care of..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "qIhcJ80S9d9L",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def printFileContent(file_name):\n",
        "    #the function takes one argument: file_name\n",
        "    try:\n",
        "        with open(file_name) as f:\n",
        "            print(f.read())\n",
        "    except FileNotFoundError:\n",
        "        print(\"The file does not exist.\\nNevertheless, I do like you, and I will print something to you anyway...\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "jiJieS1c9d9M",
        "colab_type": "code",
        "outputId": "f96ec0c5-64f1-46fe-f694-796e9f626d37",
        "colab": {}
      },
      "source": [
        "printFileContent(\"file_that_doesnt_exist.txt\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The file does not exist.\n",
            "Nevertheless, I do like you, and I will print something to you anyway...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "deletable": true,
        "editable": true,
        "id": "34i3sL6z9d9O",
        "colab_type": "text"
      },
      "source": [
        "# Appendix: useful links"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "dYmBoM9i9d9P",
        "colab_type": "text"
      },
      "source": [
        "## Python: how to install"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "uD9Halqn9d9P",
        "colab_type": "text"
      },
      "source": [
        "If you're using Mac OSX or Linux, you already have (at least one version) of Python installed. Anyway, it's very easy to install Python or upgrade your version. See:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Y8T5D49l9d9Q",
        "colab_type": "text"
      },
      "source": [
        "https://wiki.python.org/moin/BeginnersGuide/Download"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "9hcosEgV9d9Q",
        "colab_type": "text"
      },
      "source": [
        "## Jupyter: how to install"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "1U06eOec9d9R",
        "colab_type": "text"
      },
      "source": [
        "http://jupyter.org/install.html"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "saaUWnde9d9R",
        "colab_type": "text"
      },
      "source": [
        "Python and Jupyter come also in a pre-packaged environment (which is designed especially for data science) called [Anaconda](https://www.continuum.io/downloads). You might be interested to look at that."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Gnj4KdXn9d9S",
        "colab_type": "text"
      },
      "source": [
        "## Python 2 or Python 3? "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "tpiErZoQ9d9T",
        "colab_type": "text"
      },
      "source": [
        "Python 3 is the latest version of Python (currently, 3.6.1). It's a major upgrade from Python 2, but the code has been somewhat dramatically changed in the passage from 2 to 3 and there is some problem of backward compatibility. Some version of Linux or Mac OSX still come with Python 2.7 (the final version of Python 2).\n",
        "\n",
        "Anyway, Python 3 is currently in active development: it's where the cutting-edge improvements and new stuff are being developed (especially for NLP and the NLTK library). In this code, we assume Python 3!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Zwx0XPyL9d9U",
        "colab_type": "text"
      },
      "source": [
        "https://wiki.python.org/moin/Python2orPython3"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "YaokJDOh9d9U",
        "colab_type": "text"
      },
      "source": [
        "## NLTK: Book"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "deletable": true,
        "editable": true,
        "id": "n0rS9wGp9d9V",
        "colab_type": "text"
      },
      "source": [
        "Would you like a book that is a great introduction to Python for absolute beginners, is a wonderfull resource to learn the basics of Natural Language processing and gives you a thorough introduction to the NLTK library to do NLP in Python? Oh, yeah, I was forgetting: that can be read for free on the internet? Yes, it's Christmass time!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "4SWZ42T59d9W",
        "colab_type": "text"
      },
      "source": [
        "http://www.nltk.org/book/"
      ]
    }
  ]
}