03 - Python Essentials.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Essentials"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://lectures.quantecon.org/py/python_essentials.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Looping without Indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The capital of Japan is Tokyo\n",
      "The capital of Korea is Seoul\n",
      "The capital of China is Beijing\n"
     ]
    }
   ],
   "source": [
    "countries = ('Japan', 'Korea', 'China')\n",
    "cities = ('Tokyo', 'Seoul', 'Beijing')\n",
    "for country, city in zip(countries, cities):\n",
    "    print(f'The capital of {country} is {city}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Tom': 'E', 'John': 'F'}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = ['Tom', 'John']\n",
    "marks = ['E', 'F']\n",
    "dict(zip(names, marks))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "letter_list[0] = 'a'\n",
      "letter_list[1] = 'b'\n",
      "letter_list[2] = 'c'\n"
     ]
    }
   ],
   "source": [
    "letter_list = ['a', 'b', 'c']\n",
    "for index, letter in enumerate(letter_list):\n",
    "    print(f\"letter_list[{index}] = '{letter}'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparisons and Logical Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparisons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 < 2 < 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'yes'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 'yes' if 42 else 'no'\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'no'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 'yes' if [] else 'no'\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 4)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(0, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(0, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Docstrings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    \"\"\"\n",
    "    This function squares its argument\n",
    "    \"\"\"\n",
    "    return x ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mDocstring:\u001b[0m This function squares its argument\n",
       "\u001b[0;31mFile:\u001b[0m      ~/Estudos/Data Science/Quantitative Economics with Python/<ipython-input-14-994e3a167404>\n",
       "\u001b[0;31mType:\u001b[0m      function\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mSource:\u001b[0m   \n",
       "\u001b[0;32mdef\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0;34m\"\"\"\u001b[0m\n",
       "\u001b[0;34m    This function squares its argument\u001b[0m\n",
       "\u001b[0;34m    \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0;32mreturn\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m**\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mFile:\u001b[0m      ~/Estudos/Data Science/Quantitative Economics with Python/<ipython-input-14-994e3a167404>\n",
       "\u001b[0;31mType:\u001b[0m      function\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### One-Line Functions: lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return x ** 3\n",
    "#vs\n",
    "f = lambda x: x ** 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4.0, 4.440892098500626e-14)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy.integrate import quad\n",
    "quad(lambda x: x** 3, 0, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keyword Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x, a=1, b=1):\n",
    "    return a + b * x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(2,a=4,b=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Coding Style and PEP8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Part 1:** Given two numeric lists or tuples x_vals and y_vals of equal length, compute their inner product using zip().\n",
    "\n",
    "**Part 2:** In one line, count the number of even numbers in 0,…,99.\n",
    "\n",
    "Hint: x % 2 returns 0 if x is even, 1 otherwise.\n",
    "\n",
    "**Part 3:** Given pairs = ((2, 5), (4, 2), (9, 8), (12, 10)), count the number of pairs (a, b) such that both a and b are even.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 0, 1, 8, 2, 5, 2, 9, 6, 8]\n",
      "[7, 0, 5, 9, 7, 3, 3, 2, 4, 8]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "232"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Part 1\n",
    "import numpy as np\n",
    "x_vals = list(np.random.randint(0, 10, size=10))\n",
    "y_vals = list(np.random.randint(0, 10, size=10))\n",
    "print(x_vals)\n",
    "print(y_vals)\n",
    "sum(x * y for x, y in zip(x_vals,y_vals))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Part 2\n",
    "sum(i % 2 == 0 for i in range(100))  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Part 3\n",
    "pairs = ((2, 5), (4, 2), (9, 8), (12, 10))\n",
    "sum([x % 2 == 0 and y % 2 == 0 for  x, y in pairs])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "onsider the polynomial\n",
    "\n",
    "p(x)=a0+a1x+a2x2+⋯anxn=∑i=0naixi(1)\n",
    "Write a function p such that p(x, coeff) that computes the value in (1) given a point x and a list of coefficients coeff.\n",
    "\n",
    "Try to use enumerate() in your loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "53"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def p(x, coeff):\n",
    "    \"\"\"\n",
    "    Computes the polinomial \n",
    "    p(x)=a0 + a_1*x +a_2*x^2 + ⋯ a_n*x^n = ∑( i= to 0n) a_i*x^i,\n",
    "    given a point x and a list of coefficients coeff.\n",
    "    \"\"\"\n",
    "    return sum(a * (x ** n) for n, a in enumerate(coeff))\n",
    "p(2, [3, 5, 2, 4])     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "53"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = lambda x, coeff: sum(a * (x ** n) for n, a in enumerate(coeff))\n",
    "p(2, [3, 5, 2, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function that takes a string as an argument and returns the number of capital letters in the string.\n",
    "\n",
    "Hint: **'foo'.upper()** returns **'FOO'**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ncapital = lambda word: sum(i==i.upper() and i.isalpha() for i in word)\n",
    "ncapital('Hello Word')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function that takes two sequences seq_a and seq_b as arguments and returns True if every element in seq_a is also an element of seq_b, else False.\n",
    "\n",
    "* By “sequence” we mean a list, a tuple or a string.\n",
    "* Do the exercise without using sets and set methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compare(seq_a, seq_b):\n",
    "    \"\"\"Takes two sequences seq_a and seq_b as arguments \n",
    "    and returns True if every element in seq_a is also \n",
    "    an element of seq_b, else False\"\"\"\n",
    "    for a in seq_a:\n",
    "        if a not in seq_b:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "seq_a = [1, 2, 4, 51]\n",
    "seq_b = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]\n",
    "compare(seq_a, seq_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we cover the numerical libraries, we will see they include many alternatives for interpolation and function approximation.\n",
    "\n",
    "Nevertheless, let’s write our own function approximation routine as an exercise.\n",
    "\n",
    "In particular, without using any imports, write a function linapprox that takes as arguments\n",
    "\n",
    "* A function f mapping some interval [a,b] into R.\n",
    "* Two scalars a and b providing the limits of this interval.\n",
    "* An integer n determining the number of grid points.\n",
    "* A number x satisfying a <= x <= b.\n",
    "\n",
    "and returns the piecewise linear interpolation of f at x, based on n evenly spaced grid points a = point[0] < point[1] < ... < point[n-1] = b.\n",
    "\n",
    "Aim for clarity, not efficiency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linapprox(f, a, b, n, x):\n",
    "    \"\"\"\n",
    "    Evaluates the piecewise linear interpolant of f at x on the interval\n",
    "    [a, b], with n evenly spaced grid points.\n",
    "\n",
    "    Parameters\n",
    "    ==========\n",
    "        f : function\n",
    "            The function to approximate\n",
    "\n",
    "        x, a, b : scalars (floats or integers)\n",
    "            Evaluation point and endpoints, with a <= x <= b\n",
    "\n",
    "        n : integer\n",
    "            Number of grid points\n",
    "\n",
    "    Returns\n",
    "    =======\n",
    "        A float. The interpolant evaluated at x\n",
    "\n",
    "    \"\"\"\n",
    "    length_of_interval = b - a\n",
    "    num_subintervals = n - 1\n",
    "    step = length_of_interval / num_subintervals\n",
    "\n",
    "    # === find first grid point larger than x === #\n",
    "    point = a\n",
    "    while point <= x:\n",
    "        point += step\n",
    "\n",
    "    # === x must lie between the gridpoints (point - step) and point === #\n",
    "    u, v = point - step, point\n",
    "\n",
    "    return f(u) + (x - u) * (f(v) - f(u)) / (v - u)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}