Lecture 2. Conditional statements.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Lec2_DataSci.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "GJHWHDB-z7NY",
        "CXBEHao7FK-1"
      ],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rkpURhJKubxa"
      },
      "source": [
        "**Lecture 2: Conditional statements**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I26qFjc8u0Rp"
      },
      "source": [
        "## **IF**\n",
        "\n",
        "- Syntax of the conditional statement:\n",
        "```\n",
        "if expression:\n",
        "    <block of code>\n",
        "```\n",
        "- the conditional statements with two options: T or F:\n",
        "```\n",
        "if expression1:\n",
        "    <block of code 1>\n",
        "else:\n",
        "    <block of code 2>\n",
        "```\n",
        "- If we have more than two options (aka T or F):\n",
        "```\n",
        "if expression_1:\n",
        "    <block of code 2>\n",
        "elif expression_2:\n",
        "    <block of code 2>  \n",
        "[...] #Only the block of code corresponding to the first T expression is executed\n",
        "elif expression_N:\n",
        "    <block of code N>\n",
        "else:\n",
        "    <block of code N+1> #The final else might be missing\n",
        "```\n",
        "\n",
        "*If* can also be written on a single line e.g.:\n",
        "\n",
        "```\n",
        "x if x > 0 else -x\n",
        "x - y if x > y else y - x\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I1w6CoKq5nZE",
        "outputId": "408f871c-0e67-41b3-d56a-fe21bfcffe0f"
      },
      "source": [
        "#E.g.\n",
        "#if - the key word\n",
        "#x > 0 - the condition\n",
        "\n",
        "x = int(input('Write an int number:'))\n",
        "if x > 0:\n",
        "  print('positive')\n",
        "else:\n",
        "  print('null or negative')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Write an int number:-5\n",
            "null or negative\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tLdOfAFh_KE6"
      },
      "source": [
        "y = 5\n",
        "x = y if y > 0 else - y #in one line"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ItzMEONsxXaQ"
      },
      "source": [
        "## **Loops**\n",
        "\n",
        "There're two types of loops **while** and **for**:\n",
        "```\n",
        "while expression:\n",
        "    <block of code>\n",
        "    \n",
        "for variable in iterable:\n",
        "    <block of code>\n",
        "```\n",
        "- break: stop the execution of the loop\n",
        "- continue: move straight to the next execution of the loop\n",
        "- else: the following block of code is executed only if the loop terminates without a break"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9c_AkHQf_v6U",
        "outputId": "b9507420-fca7-43a4-b2d0-eccd1ce453f0"
      },
      "source": [
        "#WHILE Loop\n",
        "x = int(input('Write a positive number:'))\n",
        "while x <= 0:\n",
        "  x = int(input('Write a positive number:')\n",
        "  #if x == 5:\n",
        "    #break # exit from the cycle\n",
        "    ##continue\n",
        "  ##print('...')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Write a positive number:5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "44cAwbesASnl",
        "outputId": "3a66cbdc-5447-4307-85ef-43dd3ca4b42f"
      },
      "source": [
        "#FOR Loop\n",
        "l = [0,1,2,3,4,5]\n",
        "for x in l:\n",
        "  print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QxJmghPUubTj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d13d171b-47a5-47d3-9a01-38666ae85af3"
      },
      "source": [
        "#Examples from slides\n",
        "while True:\n",
        "  x = input('Provide a positive number:')\n",
        "  x = int(x)\n",
        "  if x > 0:\n",
        "    print('x =', x)\n",
        "    break"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Provide a positive number:5\n",
            "x = 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lfRAl-Ajy2gg"
      },
      "source": [
        "import math\n",
        "l = [1.2, 3.2, -0.1]\n",
        "for x in l:\n",
        "  if x < 0:\n",
        "    continue\n",
        "  print('log(x) = ', math.log(x))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fy_wKSwIzRRp"
      },
      "source": [
        "i = 0\n",
        "while i < 10:\n",
        "  x = input('Provide a positive number:')\n",
        "  x = int(x)\n",
        "  if x > 0:\n",
        "    print('x =', x)\n",
        "    break\n",
        "  i += 1\n",
        "else:\n",
        "  print('I surrender !') #this block is executed only if cycle ends without a break"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ai4xrH45Bvaa",
        "outputId": "c8b5b598-328b-40c4-e713-f8239183fdd2"
      },
      "source": [
        "i = 0 \n",
        "while i < 3: #the loop for max 3 times\n",
        "  x = int(input('Write a positive number:'))\n",
        "  if x > 0:\n",
        "      break # if the number is positive I break\n",
        "      i += 1\n",
        "  else:\n",
        "    print('stop') #if you provide a negative value for more than three times the loop stops"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Write a positive number:5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GJHWHDB-z7NY"
      },
      "source": [
        "## **List comprehensions**\n",
        "\n",
        "- a particular way of Python to do cycles\n",
        "\n",
        "**[** expression **for** value **in** iterator **if** expression **]**\n",
        "\n",
        "- The if part might be missing\n",
        "- More than one for cycle (each one eventually includign an if) can also be used\n",
        "\n",
        "```\n",
        "l = [n**2 for n in range(10)] #Result: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
        "[x for x in l if (x % 3) == 0] #Result: [0,9,36,81] \n",
        "```\n",
        "\n",
        "NB: range(stop): generates a sequence of\n",
        "numbers from $0$ to stop (not included)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C1yQRoW0CcRp",
        "outputId": "83df3f0a-569a-4f1b-b139-99deffdc7de6"
      },
      "source": [
        "#Range function\n",
        "for i in range(10):\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L45KEEK_Cu8E",
        "outputId": "0787d3fc-22b5-4917-d692-f425840f6733"
      },
      "source": [
        "l = [n**2 for n in range(10)] #[] - the list comrehension \n",
        "print(l)\n",
        "\n",
        "#and it's the same as FOR cycle:\n",
        "l1 = []\n",
        "for i in range(10):\n",
        "  l1.append(i**2)\n",
        "print(l1)\n",
        "\n",
        "#the full syntax\n",
        "l2 = [n**2 for n in range(10) if (n % 2) == 0] #it stores the squares only of even numbers\n",
        "print(l2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
            "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
            "[0, 4, 16, 36, 64]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ib6v9AZ_1E3m",
        "outputId": "58155784-f865-4bdc-c6ce-0bff20e65ffa"
      },
      "source": [
        "#If {} are used instead of [], a set is created\n",
        "\n",
        "[n%2 for n in range(10)] #Result: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]\n",
        "{n%2 for n in range(10)} #Result: [0, 1]\n",
        "\n",
        "#When using {}, a dict is created if the expression includes:\n",
        "{n:(n%2 == 0) for n in range(10)} #Result: {0:True, 1: False, 2:True, 3:False,...}"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{0: True,\n",
              " 1: False,\n",
              " 2: True,\n",
              " 3: False,\n",
              " 4: True,\n",
              " 5: False,\n",
              " 6: True,\n",
              " 7: False,\n",
              " 8: True,\n",
              " 9: False}"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rw7vWRSIEhbq",
        "outputId": "baaa764b-9526-4822-fdb0-d9e40ca4b373"
      },
      "source": [
        "S = {n%2 for n in range(10)} #set\n",
        "print(S)\n",
        "\n",
        "L = [n%2 for n in range(10)] #list\n",
        "print(L)\n",
        "\n",
        "D = {n:n%2==1 for n in range(10)} #dict\n",
        "print(D)\n",
        "\n",
        "t = (1,2)#tuplet\n",
        "print(t) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{0, 1}\n",
            "[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]\n",
            "{0: False, 1: True, 2: False, 3: True, 4: False, 5: True, 6: False, 7: True, 8: False, 9: True}\n",
            "(1, 2)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CXBEHao7FK-1"
      },
      "source": [
        "# **Problems**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NmWk4eqnF_o5"
      },
      "source": [
        "## **Problem 6**\n",
        "\n",
        "Read $N$ integer numbers separated by spaces from the keyboard and compute:\n",
        "\n",
        "- the sum of all numbers;\n",
        "- the minimum;\n",
        "- the maximum;\n",
        "- the count of positives, negatives, and null.\n",
        "\n",
        "Numbers are written in the same line, separated by a white space."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "65iUV7quGOM4",
        "outputId": "d883ea16-93a4-4bd1-c1e8-703e7393e235"
      },
      "source": [
        "s = input('Write n numbers separated by space:')\n",
        "l = [int(x) for x in s.split()]\n",
        "print('list: ',l)\n",
        "print('sum: ',sum(l))\n",
        "print('max: ',max(l))\n",
        "print('min: ',min(l))\n",
        "print('n. positives: ',len([x for x in l if x > 0]))\n",
        "print('n. nulls: ',len([x for x in l if x == 0]))\n",
        "print('n. negatives: ',len([x for x in l if x < 0]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Write n numbers separated by space:5\n",
            "list:  [5]\n",
            "sum:  5\n",
            "max:  5\n",
            "min:  5\n",
            "n. positives:  1\n",
            "n. nulls:  0\n",
            "n. negatives:  0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fV25NGGwGRnL"
      },
      "source": [
        "## **Problem 7**\n",
        "Read two sentences from the keyboard. Find if they are written with exactly the same letters (count doesn't matter).\n",
        "\n",
        "*Example*: `\"Apple\", \"pale\" -> True (Because they are written with the letters \"a\", \"e\", \"l\" and \"p\")`\n",
        "\n",
        "*Example*: `\"airplane\", \"air\" -> False (Because the word \"air\" does not contain the letters \"e\", \"l\", \"n\" and \"p\")`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D0QbMIO5GiGx",
        "outputId": "09b30500-4bfe-431d-d13a-fc7dcb4251af"
      },
      "source": [
        "s1 = input('Write a word:')\n",
        "s2 = input('Write another word:')\n",
        "print('Same letter?', set(s1) == set(s2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Write a word:ten\n",
            "Write another word:net\n",
            "Same letter? True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Rfb9ApCGi-Z"
      },
      "source": [
        "## **Problem 8**\n",
        "\n",
        "Create a list that contains all the words longer then a given $n$ in a given text.\n",
        "\n",
        "Notice: Remove punctutation first."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BKuLPX2EGprp"
      },
      "source": [
        "text = \"\"\"Il 2020 sarà un anno di importanti elezioni amministrative in Italia. Si voterà per rinnovare presidenti e consigli regionali in otto regioni e per scegliere i sindaci e i consigli comunali di oltre mille comuni, tra cui Venezia, Mantova, Agrigento e Arezzo. L’elezione più vicina in ordine di tempo sarà anche quella considerata più importante per la situazione politica nazionale: il voto per scegliere il presidente dell’Emilia-Romagna, la “regione rossa” per eccellenza, dove si voterà il prossimo 26 gennaio. Una sconfitta del Partito Democratico in questa regione, ipotizzano in molti, potrebbe portare addirittura alla fine del secondo governo Conte.\"\"\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TeeVv3aEH1dS",
        "outputId": "843d16eb-3a15-42c7-bffa-45dd17e4181f"
      },
      "source": [
        "lw = [w for w in text.split()]\n",
        "lc = [w.strip('.,;:!?') for w in lw]\n",
        "print(lc[:10])\n",
        "\n",
        "#OR\n",
        "#n = 10\n",
        "#text_cleaned = [word.strip('.,;:!?') for word in text.split()]\n",
        "#print('Number of words longer than {0:d} is {1:d}'.format(n, sum([len(word) > n for word in text_cleaned])))\n",
        "\n",
        "n = 10 #to see words that are longer than 10 charcters\n",
        "lw2 = [w for w in text.split()]\n",
        "lc2 = [w.strip('.,;:!?') for w in lw2]\n",
        "ll2 = [w for w in lc2 if len(w) > n]\n",
        "print(ll2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Il', '2020', 'sarà', 'un', 'anno', 'di', 'importanti', 'elezioni', 'amministrative', 'in']\n",
            "['amministrative', 'considerata', 'dell’Emilia-Romagna', 'Democratico', 'addirittura']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dhi0FP1TK1rB"
      },
      "source": [
        "## **Problem 9**\n",
        "Merge two given dictionaries. Assume they have integer values. When dictionaries contain values for the same key, hold the average.\n",
        "\n",
        "Example:\n",
        "```\n",
        "d1 = {'a': 1, \n",
        "      'b': 2}\n",
        "\n",
        "d2 = {'a': 3,\n",
        "      'c': 3}\n",
        "\n",
        "d_result = {'a': 2,\n",
        "            'b': 2,\n",
        "            'c': 3}\n",
        "```\n",
        "Notice: we write the average between 1 and 3 for the 'a' key."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fiXzqbCRLFUJ"
      },
      "source": [
        "#We create dictionaries\n",
        "d1 = {'a': 1, \n",
        "      'b': 2}\n",
        "\n",
        "d2 = {'a': 3,\n",
        "      'c': 3}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Px2JbfQbLPGY",
        "outputId": "0e3e3285-983b-43b4-87fa-cd60fd0fd723"
      },
      "source": [
        "#Then, we have to cycle over the dictionaries and see if the key is incl. in one dict or in another\n",
        "for k, v in d2.items():\n",
        "  if k in d1: #to see if it's included in d1\n",
        "      d1[k] = 0.5*(d1[k] +v)\n",
        "  else:\n",
        "       d1[k] = v\n",
        "print(d1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'a': 2.0, 'b': 2, 'c': 3}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OKMntn7t3FVn"
      },
      "source": [
        "# **Function Definition**\n",
        "\n",
        "```\n",
        "def FunctionName(...):\n",
        "    \"\"\" doc string \"\"\"\n",
        "    <block of code>\n",
        "```\n",
        "- return is used to stop execution and return a value\n",
        "- If the function ends without a return, None is returned\n",
        "- When the doc_string is defined, it is returned by help(FunctionName)\n",
        "- Functions are first class objects\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vOYv4ncR3af4"
      },
      "source": [
        "#Examples from slides\n",
        "def add_one(x):\n",
        "  '''just adding 1'''\n",
        "  y = x + 1\n",
        "  return y \n",
        "\n",
        "def make_even(x):\n",
        "  '''return the even number >= x'''\n",
        "  if x % 2 == 0:\n",
        "    return x\n",
        "  else:\n",
        "    return x + 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bj-SFakRMNFi",
        "outputId": "595af319-bb6c-4511-e39b-ae6555e29366"
      },
      "source": [
        "#other exmaples from class\n",
        "def function(x,y): \n",
        "  #some description of my function\n",
        "  \"\"\" \n",
        "  x: float\n",
        "  y: float\n",
        "  Return: x + y, x- y\n",
        "  \"\"\"\n",
        "  z1 = x + y\n",
        "  z2 = x - y\n",
        "  return z1, z2 #to return both values in tuplet\n",
        "s,d = function(3,2)\n",
        "print(s,d)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WQx5UAtTMWqi",
        "outputId": "920dbd39-99cb-4e77-ab5b-501be650c8e6"
      },
      "source": [
        "help(function) #gives back the documentation string i.e. the manual that I set up before"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Help on function function in module __main__:\n",
            "\n",
            "function(x, y)\n",
            "    x: float\n",
            "    y: float\n",
            "    Return: x + y, x- y\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gkfs1dKbRJQo"
      },
      "source": [
        "## **Positional and keyword arguments**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CvHxf4Iu4Qkn",
        "outputId": "ac3e721c-493d-4c71-8e97-cd0efdeccc6f"
      },
      "source": [
        "#x and y are positional parameters i.e no default values\n",
        "#n=1 is a keyword argument \n",
        "def function(x,y, n=1): \n",
        "  z1 = x**n + y**n\n",
        "  return z1 \n",
        "s = function(3,2, n=2)\n",
        "print(s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "13\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ptxmBf4VOGlh",
        "outputId": "4a57d61c-76d9-4d74-95c0-e45ee29a0ccc"
      },
      "source": [
        "#multiple keyword arguments\n",
        "def function(x,y, n=1, m=1): \n",
        "  z1 = x**n + y**m\n",
        "  return z1 \n",
        "s = function(3,2, n=2, m=3)\n",
        "print(s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "17\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pfKA_bb84FfU"
      },
      "source": [
        "**\\* operator** - expand a sequence in its components:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E8E4KB7fSrmE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ce9bdbdd-1cc4-4f4f-b822-5ab5367d576d"
      },
      "source": [
        "#* Operator - *args\n",
        "l = [3,6,1,0]\n",
        "print(l)\n",
        "print(*l) # the same as print(3,6,1,0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[3, 6, 1, 0]\n",
            "3 6 1 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eWqp5iil4hh6"
      },
      "source": [
        "***args** - to provide an arbitrary number of positional arg to the function\n",
        "```\n",
        "def function(*args):\n",
        "    print('Number of arguments: ',len(args))\n",
        "    print('Arguments: ',args)\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ns4EqjNHO4gZ",
        "outputId": "26fd946b-a4f2-4083-b8b1-71e050466539"
      },
      "source": [
        "#* Operator - *args\n",
        "#to provide an arbitrary number of positional arg to the function\n",
        "def function(x, *args): #*args can be expended as many elements as you want\n",
        "  z = x\n",
        "  for arg in args:\n",
        "    z += arg\n",
        "  return z\n",
        "s = function(3,4) # 3+4 \n",
        "print(s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T185KzdzQnFJ",
        "outputId": "e3808e02-ba8d-4617-c296-64ba8a77f4f2"
      },
      "source": [
        "def function(x, *args, n =1):  \n",
        "  z = x**n\n",
        "  for arg in args:\n",
        "    z += arg**n\n",
        "  return z\n",
        "s = function(3,4,5,6,7,8, n=2)\n",
        "print(s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "199\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vcfGnF3m5CVS"
      },
      "source": [
        "**\\**** - expand a dictionary in its key = value components\n",
        "\n",
        "```\n",
        "def function(**kwargs):\n",
        "    print('Number of keyword arguments: ',len(kwargs))\n",
        "    print('Arguments: ‘,kwargs)\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OBqWMvw8R3K6",
        "outputId": "2e513c68-9912-449b-ba1f-f35f673acb73"
      },
      "source": [
        "#** Operator - **kwargs\n",
        "def function(x, *args, n =1, **kwargs):\n",
        "  print(x) #3\n",
        "  print(args) #(4, 5)\n",
        "  print(n) #2\n",
        "  print(kwargs) #{'n1': 3, 'n2': 5}\n",
        "  #z =  x**n\n",
        "  #for arg in args:\n",
        "  #  z+=arg**n\n",
        "  #return z\n",
        "s = function(3,4,5, n =2, n1=3, n2=5)\n",
        "#print(s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "(4, 5)\n",
            "2\n",
            "{'n1': 3, 'n2': 5}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iXDTTum2TKG0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "af3fdfc8-994d-4740-d9ed-93cfd6f17c24"
      },
      "source": [
        "#to define an arbitrary number of keyword arguments\n",
        "def function(x, *args, n =1, **kwargs):\n",
        "  z =  x**n\n",
        "  for arg in args:\n",
        "    z+=arg**n\n",
        "  return z\n",
        "s = function(3,2,4,5,6,7,8)\n",
        "print(s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "35\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f-7nqmRb5Vc-"
      },
      "source": [
        "## **Functions are objects**\n",
        "\n",
        "- So they can be assigned to variables\n",
        "```\n",
        "sum_all = sum\n",
        "sum_all([1,2,3]) # it’s the same as sum([1,2,3])\n",
        "```\n",
        "- ... or they can be passed to other functions\n",
        "\n",
        "```\n",
        "def print_int_other_base(x, convert):\n",
        "    print(convert(x))\n",
        "\n",
        "print_int_other_base(21, bin) à 0b10101\n",
        "print_int_other_base(21, oct) à 0o25\n",
        "print_int_other_base(21, hex) à 0x15\n",
        "```\n",
        "\n",
        "- ... or they can be returned by other functions\n",
        "\n",
        "```\n",
        "def convert2kelvin(input_scale):\n",
        "    if input_scale == 'fahrenheit':\n",
        "      def convert(temperature):\n",
        "        return (temperature - 32) * 5/9 + 273.15\n",
        "      return convert\n",
        "    else:\n",
        "      def convert(temperature):\n",
        "        return 273.15 + temperature\n",
        "      return convert\n",
        "\n",
        "kelvin = convert2kelvin('celsius')\n",
        "kelvin(0) à 273.15\n",
        "kelvin = convert2kelvin('fahrenheit')\n",
        "kelvin(32) à 273.15\n",
        "```\n",
        "- ... or it’s possible to define list of functions, dictionaries\n",
        "that have functions as values or keys, etc...\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SHAzb5GJTDph"
      },
      "source": [
        "#Functions in Python are objects\n",
        "def function(x,y):\n",
        "  return x + y"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YRrHW-zOTIai"
      },
      "source": [
        "s = function"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yD9w3bFBTOLB"
      },
      "source": [
        "def f1(x,y):\n",
        "  return x < y"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f3u_IFrG68hU"
      },
      "source": [
        "**Method:** `sort of list (iterable, key = None)`\n",
        "\n",
        "- Method that sort a list in place\n",
        "- If key is defined, the elements are ordered using the\n",
        "result of this function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WtAH6nTvTJ7p",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cee29520-cbfd-4044-8eef-cc222235ff1b"
      },
      "source": [
        "l = [1,3,-2,2,0,1,-9,-6]\n",
        "l.sort()\n",
        "print(l)\n",
        "\n",
        "def n(x):\n",
        "  return abs(x)\n",
        "\n",
        "l.sort(key = n) #sort a list in place\n",
        "print(l) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[-9, -6, -2, 0, 1, 1, 2, 3]\n",
            "[0, 1, 1, -2, 2, 3, -6, -9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G_Hieg3A1XgK",
        "outputId": "df313898-44f4-408d-e64a-d35d689856b2"
      },
      "source": [
        "#list that is made of list\n",
        "l2 = [[1,2], [-2,4], [3,1], [9,2]]\n",
        "print(l2)\n",
        "\n",
        "def k1(x):\n",
        "  return x[0] #to sort by the first element vs. [1] by the second element\n",
        "\n",
        "l2.sort(key = k1)\n",
        "print(l2) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1, 2], [-2, 4], [3, 1], [9, 2]]\n",
            "[[-2, 4], [1, 2], [3, 1], [9, 2]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R-iGBETU7w7P"
      },
      "source": [
        "**Anonymous lambda functions**\n",
        "\n",
        "- lambda variable(s): expression \n",
        "- It’s a method to define simple functions without name"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NzkzsbRk2pSz",
        "outputId": "2766b575-c502-4eab-ad55-012c7168c1b9"
      },
      "source": [
        "#Anonymous lambda functions\n",
        "l2.sort(key = lambda x: x[0])\n",
        "print(l2)\n",
        "l2.sort(key = lambda x: x[1])\n",
        "print(l2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[-2, 4], [1, 2], [3, 1], [9, 2]]\n",
            "[[3, 1], [1, 2], [9, 2], [-2, 4]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QaZz71gS3HxC",
        "outputId": "d19be921-4465-4c28-be16-9da19b6e0a96"
      },
      "source": [
        "#SYNTAX: lambda x,y: x + y\n",
        "s = lambda x,y: x + y\n",
        "print(s(1,2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kYy-OvcD3pAC"
      },
      "source": [
        "# **Problems** (ex2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v6ZhPkdk8PNi"
      },
      "source": [
        "## **Problem 1**\n",
        "\n",
        "Write a python function to find the median of a list. Read the list from stdin.\n",
        "\n",
        "Remember: the median for a data set may be thought of as the \"middle\" value. If there is an odd number of numbers, the middle one is picked. For example, consider the list of numbers\n",
        "\n",
        "1, 3, 3, **6**, 7, 8, 9\n",
        "\n",
        "contains seven numbers. The median is $6$.\n",
        "\n",
        "If there is an even number of observations, then there is no single middle value; the median is then usually defined to be the mean of the two middle values. For example, in the data set\n",
        "\n",
        "1, 2, 3, **4, 5**, 6, 8, 9\n",
        "\n",
        "the median is the mean of the middle two numbers: this is $(4+5)/2 = 4.5$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HJ0m0-Bqep8g"
      },
      "source": [
        "#FROM SOLUTION\n",
        "def median(l):\n",
        "    # If the list is empty, the function returns None\n",
        "    if len(l) == 0:\n",
        "        return None\n",
        "    # Create a sorted copy of the list\n",
        "    sorted_l = l.copy()\n",
        "    sorted_l.sort()\n",
        "    # If the list contains an odd number of values, the function returns the \"middle\" value\n",
        "    # Else, the function returns the average of the two \"middle\" values\n",
        "    if len(sorted_l) % 2 == 1:\n",
        "        return sorted_l[len(sorted_l) // 2]\n",
        "    else:\n",
        "        return sum(sorted_l[len(sorted_l) // 2 - 1 : len(sorted_l) // 2 + 1]) / 2."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QmFl88a6BIFo",
        "outputId": "b15ecad3-5369-4094-fb04-43e82f370d58"
      },
      "source": [
        "#FROM SOLUTION\n",
        "l = [1, 3, 2]\n",
        "print(\"The median of\", l , \"is\", median(l))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The median of [1, 3, 2] is 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SeYgrI-QBKqZ",
        "outputId": "77a58bae-df80-4440-f39d-bd056575fa50"
      },
      "source": [
        "#FROM SOLUTION\n",
        "l = [1, 2, 3, 4]\n",
        "print(\"The median of\", l , \"is\", median(l))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The median of [1, 2, 3, 4] is 2.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iPGonIDX_kaK",
        "outputId": "d597662e-1404-43be-c76a-d3656f2ea0e9"
      },
      "source": [
        "#FROM CLASS\n",
        "def median(l):\n",
        "  \"\"\"\n",
        "  Return the median of the elements in the list\n",
        "  \"\"\"\n",
        "  l = list(l)\n",
        "  l.sort() #sorting the actual list\n",
        "  if len(l) % 2 == 1:\n",
        "    return l[len(l)//2]\n",
        "  else:\n",
        "    return 0.5* ( l[len(l)//2-1]+l[len(l)//2])\n",
        "\n",
        "l = [4,5,6,1,2,3]\n",
        "m = median(l)\n",
        "print('Median = {}'.format(m))\n",
        "print(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Median = 3.5\n",
            "[4, 5, 6, 1, 2, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 129
        },
        "id": "UN4VTqizA0sC",
        "outputId": "d6704895-4654-4538-ca10-1325d9eec0a1"
      },
      "source": [
        "#FROM CLASS\n",
        "def median(*args): #now args is the list of these elements\n",
        "  l = list(args)\n",
        "  l.sort() #sorting the actual list\n",
        "  if len(l) % 2 == 1:\n",
        "    return l[len(l)//2]\n",
        "  else:\n",
        "    return 0.5* ( l[len(l)//2-1]+l[len(l)//2]\n",
        "                 \n",
        "#Here instead we don't provide a list BUT we provide an arbitrarty number of elements\n",
        "#and we expect that it gives the medium for it\n",
        "m = median(4,5,6,1,2,3) #WHY DOESN\"T WORK???\n",
        "print('Median = {}'.format(m))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-103-bc81336592e4>\"\u001b[0;36m, line \u001b[0;32m12\u001b[0m\n\u001b[0;31m    m = median(4,5,6,1,2,3) #WHY DOESN\"T WORK???\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AOARu3zg8o63"
      },
      "source": [
        "## **Problem 2**\n",
        "\n",
        "Write a python function to check if a sentence is a palindrome.\n",
        "\n",
        "Remember: A palindrome is a word, phrase, number or any other sequence of units which has the property of reading the same forwards as it does backwards. Example: the word \"rotator\".\n",
        "\n",
        "Notice: remove white spaces and punctuation first."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HCAHT28qGq-Q",
        "outputId": "31db04f7-faac-4eb8-e5eb-b8a934b05100"
      },
      "source": [
        "#FROM SOLUTION\n",
        "def is_palindrome(sentence):\n",
        "    # Remove white spaces and punctuation, convert to lower case\n",
        "    s = {\" \", \".\", \",\", \":\", \"!\", \"?\", \";\", \"'\", '\"', \"’\"}\n",
        "    for i in s:\n",
        "        sentence = sentence.replace(i, \"\")\n",
        "    sentence = sentence.lower()\n",
        "    # Create the backward sentence\n",
        "    sentence = list(sentence)\n",
        "    backward = sentence[::-1]\n",
        "    return sentence == backward\n",
        "\n",
        "is_palindrome(\"Not palindrome!\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VEpSWWMiGyBg",
        "outputId": "d1d577ea-8ece-4e4f-fac4-71dc8f08f806"
      },
      "source": [
        "is_palindrome(\"Murder for a jar of red rum.\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NAWAjVXkgBkv",
        "outputId": "4b842324-55bc-45d7-fed0-5b45642eade9"
      },
      "source": [
        "#FROM CLASS\n",
        "def is_pal(s):\n",
        "  '''\n",
        "  Return T if s is palindrome after removing . , : ; ! ?\n",
        "  '''\n",
        "  s = s.lower()\n",
        "  for c in '. , : ; !?':\n",
        "    s = s.replace(c, '')\n",
        "  return s == s[::-1]\n",
        "\n",
        "s = 'not palindrome'\n",
        "print(is_pal(s)) # False\n",
        "s = '?Radar!'\n",
        "print(is_pal(s)) # True"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_tXT11O4-CMj"
      },
      "source": [
        "**Extended:**\n",
        "\n",
        "Create a function that receives an arbitrary number of sentences as input and check if they are palindromes. It returns a list with a boolean value for each sentence"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LhWWdlGHHRRj",
        "outputId": "744cbfcf-f760-471e-8439-bb11de49ae6c"
      },
      "source": [
        "#FROM SOLUTION\n",
        "def are_palindromes(*args):\n",
        "    pal = []\n",
        "    for sentence in args:\n",
        "        pal.append(is_palindrome(sentence))\n",
        "    return pal\n",
        "\n",
        "are_palindromes(\"Hello\", \"Rotator\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[False, True]"
            ]
          },
          "metadata": {},
          "execution_count": 73
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oTpMOvzVHh4Y",
        "outputId": "3d14aec2-bf4b-48cf-d910-81d5129ac20e"
      },
      "source": [
        "#FROM CLASS\n",
        "def are_pal(*args):\n",
        "  return [is_pal(s) for s in args]\n",
        "\n",
        "are_pal('not palindrome', '?Radar!')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[False, True]"
            ]
          },
          "metadata": {},
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SkuMN0jg81kR"
      },
      "source": [
        "## **Problem 3**\n",
        "\n",
        "Merge two lists with the \\* operator. Merge two dictionaries using the \\** operator."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "duQ1cC6S-UJz",
        "outputId": "48f87627-65d1-4d5d-9dee-ca2d823a9b2c"
      },
      "source": [
        "#FROM SOLUTION\n",
        "l1 = [10, 'Armando', 1e10]\n",
        "l2 = list(\"Word\")\n",
        "l = [*l1, *l2]\n",
        "print('Merged list: ',l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Merged list:  [10, 'Armando', 10000000000.0, 'W', 'o', 'r', 'd']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ssw4AcQSIeVF",
        "outputId": "e98b743d-15ae-4017-8d39-d13367a703a5"
      },
      "source": [
        "d1 = {'alessandro': 10.0, \n",
        "      'biagio': 7.0}\n",
        "d2 = {'carlo': 6.0,\n",
        "      'danilo': 5.0}\n",
        "d = {**d1, **d2}\n",
        "print('Merged dictionary: ',d)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Merged dictionary:  {'alessandro': 10.0, 'biagio': 7.0, 'carlo': 6.0, 'danilo': 5.0}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ebaipwe3IfUJ",
        "outputId": "1e1b0f08-3d64-4475-c0eb-6046fd165d24"
      },
      "source": [
        "#FROM CLASS\n",
        "l1 = [1,2,3]\n",
        "l2 = [4,5,6]\n",
        "l3 = [*l1, *l2]\n",
        "#OR l3 = l1 + l2\n",
        "print(l3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 4, 5, 6]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dCC30ok4Iz2n",
        "outputId": "48a0c8c4-690b-4b1c-98ef-7a4a162393a7"
      },
      "source": [
        "d1 = {'dog': 'cane'}\n",
        "d2 = {'cat': 'gatto'}\n",
        "d3 = {**d1, **d2} #the same as with lists but two *\n",
        "print(d3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'dog': 'cane', 'cat': 'gatto'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fq3cVf8k-O__"
      },
      "source": [
        "## **Problem 4**\n",
        "\n",
        "Write a python function that filters even or odd numbers in a list.\n",
        "\n",
        "Note: Use a keyword argument to specify wether even or odd numbers are desired (\"even\" by default). If a different value is specified for the key number, an empty list is returned."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gPc_19wh-Otd",
        "outputId": "6ea5260d-ecd8-4076-8b10-657f417ec4be"
      },
      "source": [
        "#FROM SOLUTION\n",
        "def list_filtering(l, pass_filter='even'): \n",
        "    \"\"\"This function filters even or odd numbers in a list.\n",
        "\n",
        "    Parameters:\n",
        "    l (list): list of numbers\n",
        "    pass_filter (string): 'even' to even numbers pass filter, 'odd' for odd numbers pass filter.\n",
        "\n",
        "    Returns:\n",
        "    list: filtered list\n",
        "    \"\"\"\n",
        "    if pass_filter == \"even\":\n",
        "        return [i for i in l if i % 2 == 0]\n",
        "    elif pass_filter == \"odd\":\n",
        "        return [i for i in l if i % 2 == 1]\n",
        "    else:\n",
        "        return []\n",
        "\n",
        "list_filtering([1, 2, 3, 4, 5])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[2, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3f_XdVloJykF",
        "outputId": "09590f89-3c8d-490e-ffbf-96f403fdc63c"
      },
      "source": [
        "list_filtering([1, 2, 3, 4, 5], pass_filter='odd')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 3, 5]"
            ]
          },
          "metadata": {},
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sHlfag0XJ4av",
        "outputId": "c328865a-57b6-4b55-86c2-62e81d173cc8"
      },
      "source": [
        "list_filtering([1, 2, 3, 4, 5], pass_filter='primes')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[]"
            ]
          },
          "metadata": {},
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k7enS8r8J5Ne",
        "outputId": "17c63fbd-4660-48bd-9229-5f85e2b405c4"
      },
      "source": [
        "#FROM CLASS\n",
        "def filter(l, what = 'even'):\n",
        "  '''\n",
        "  Return only even/odd values depending on the parameter what\n",
        "  '''\n",
        "  if what == 'even':\n",
        "    return [x for x in l if x % 2 == 0]\n",
        "  elif what == 'odd':\n",
        "    return [x for x in l if x % 2 == 1]\n",
        "  else:\n",
        "    return []\n",
        "\n",
        "l = [0,1,2,3,4,5,6,7,8,9]\n",
        "print(filter(l, what = 'odd'))\n",
        "print(filter(l, what = 'prime'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 3, 5, 7, 9]\n",
            "[]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fPKgIMpw-deo"
      },
      "source": [
        "## **Problem 5**\n",
        "\n",
        "Create a function that:\n",
        "\n",
        "- receives an arbitrary number of numeric values (`*args`)\n",
        "- receives an arbitrary number of keyword arguments (`**kwargs`).\n",
        "-- This `**kwargs` are function themselves;\n",
        "-- This functions perform operation over lists;\n",
        "-- keyword represents the name of the function;\n",
        "Compute and prints the result of each of the functions passed as `**kwargs`.\n",
        "\n",
        "Notice: The function returns `None`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nEA6Vaid-nER",
        "outputId": "c6afb6df-8042-4d7e-f404-0ecd2565c726"
      },
      "source": [
        "#FROM SOLITION\n",
        "def function(*values, **operations):\n",
        "    for op_name, op_func in operations.items():\n",
        "        print(\"The\", op_name, \"is\", op_func(list(values)))\n",
        "\n",
        "function(2, 3, 4, Median=median, Sum=sum)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The Median is 3\n",
            "The Sum is 9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sk80tm5bLoM3",
        "outputId": "970812d9-e80b-4cfb-f414-ca4983788e7c"
      },
      "source": [
        "#FROM CLASS\n",
        "#function(1,2,3, maximum = max, minimum = min, median = median)\n",
        "#maximum = 3\n",
        "#minimum = 1\n",
        "#median = 2\n",
        "\n",
        "def function(*args, **kwargs):\n",
        "  print('args:', args)\n",
        "  #print('kwargs:', kwargs)\n",
        "  for op_name, function in kwargs.items():\n",
        "    print(op_name, '=', function(args))\n",
        "\n",
        "function(1,2,3, maximum = max, minimum = min, median = median)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "args: (1, 2, 3)\n",
            "maximum = 3\n",
            "minimum = 1\n",
            "median = 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HqIlWafMQFRI"
      },
      "source": [
        "# **File Objects**\n",
        "\n",
        "- **file_object = open(*Name_of_the_file, mode*)**\n",
        "- *Modes:*\n",
        "-- ` r`- Read from the beginning\n",
        "-- `w` - Write from the beginning \n",
        "-- `a` - Apped: Write from the end if the file does not exist, it is created\n",
        "-- ` r+` - Read/write from the beginning\n",
        "-- `w+` -  Read/write from the beginning\n",
        "-- `a+` -  Read/write from the end "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ulxS6hT_S3vG"
      },
      "source": [
        "When file is open:\n",
        "\n",
        "- `.read([N])` Read all the characters, or a maximum of $N$ characters if $N$ is defined\n",
        "- `.readline([N])` Read up to the new line character (included), or up to a maximum of $N$ characters, if $N$ is defined\n",
        "- `.readlines()` Read all the lines and return a list of strings\n",
        "- `.write(item)` write the sequence of characters write the sequence of bytes\n",
        "- .`writelines(list)` write the elements of the list (strings)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NL0rYGXdRGak"
      },
      "source": [
        "fin = open('tmp.txt', 'rt') #t stands for text / b for binary\n",
        "l = fin.read() #.read(3) to read 3 characters\n",
        "fin.close() #to close the file"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mo1y4kTtVcg3"
      },
      "source": [
        "fin = open('tmp.txt', 'rt')  \n",
        "c = fin.read(1)\n",
        "while c:\n",
        "  print(c)\n",
        "  c = fin.read(1)\n",
        "fin.close()  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KbBXRGv2U7R0"
      },
      "source": [
        "**with ... as** - the other way to do it\n",
        "\n",
        "```\n",
        "with open(’file.txt’, ‘rt’) as fin:\n",
        "    s = f_in.readline()\n",
        "    while s:\n",
        "      print(s)\n",
        "      s = f_in.readline()\n",
        "```\n",
        "\n"
      ]
    }
  ]
}