Notebooks/Introduction_I.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction I"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Author**: [Gabriele Pompa](https://www.linkedin.com/in/gabrielepompa/): gabriele.pompa@unisi.com"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome to the _IT for Business and Finance_ class 2019/20. This class is going to teach you financial applications using the Python programming language."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Credit**: Several contents and examples of this notebook are taken from the book [_Python for Finance -- Mastering Data-Driven Finance_](http://shop.oreilly.com/product/0636920117728.do) (2nd edition) by Yves Hilpisch (O'Reilly). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Table of contents\n",
    "\n",
    "1. [What is Python?](#what_is_python)\\\n",
    "    1.1. [Modules_ and _Packages](#modules_and_packages)\n",
    "2. [Why Python is relevant for Finance?](#why_python_is_relevant_for_finance)\n",
    "3. [Why Python is relevant for you?](#why_python_is_relevant_for_you)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Resources**: \n",
    "\n",
    "- [_Python for Finance (2nd ed.)_](http://shop.oreilly.com/product/0636920117728.do): Sec. 1.The Python Programming Language, 1.Technology in Finance, 1.Python for Finance, 1.Data-Driven Finance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. What is Python? <a name=\"what_is_python\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Executive Summary from the [Python.org](https://www.python.org/doc/essays/blurb/) website:\n",
    "\n",
    "    Python is an interpreted, object-oriented, high-level programming language with dynamic semantics. Its high-level built in data structures, combined with dynamic typing and dynamic binding, make it very attractive for Rapid Application Development, as well as for use as a scripting or glue language to connect existing components together. Python's simple, easy to learn syntax emphasizes readability and therefore reduces the cost of program maintenance. Python supports modules and packages, which encourages program modularity and code reuse. The Python interpreter and the extensive standard library are available in source or binary form without charge for all major platforms, and can be freely distributed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So many weird words, right? Let's try to clarify a bit:\n",
    "\n",
    "- [_Interpreted_](https://en.wikipedia.org/wiki/Interpreted_language): an interpreted language is a type of programming language for which most of its implementations execute instructions directly and freely, without previously compiling a program into machine-language instructions.\n",
    "\n",
    "\n",
    "- [_Object-oriented_](https://en.wikipedia.org/wiki/Object-oriented_programming): object-oriented programming (OOP) is a programming paradigm based on the concept of \"objects\", which can contain data, in the form of fields (often known as attributes or properties), and code, in the form of procedures (often known as methods).\n",
    "\n",
    "\n",
    "- [ _High-level_ programming language](https://en.wikipedia.org/wiki/High-level_programming_language): a high-level programming language is a programming language with strong abstraction from the details of the computer. In contrast to low-level programming languages, it may use natural language elements, be easier to use, or may automate (or even hide entirely) significant areas of computing systems (e.g. memory management), making the process of developing a program simpler and more understandable than when using a lower-level language. The amount of abstraction provided defines how \"high-level\" a programming language is.\n",
    "\n",
    "\n",
    "- [_Dynamic semantics_](https://en.wikipedia.org/wiki/Programming_language#Dynamic_semantics): the _semantics_ of a (programming) language refers to the meaning of the languages, as opposed to their form. For compiled languages, _static semantics_ essentially include those semantic rules (that is, restrictions on the structure of valid texts) that can be checked at compile time. For example checking that every identifier is declared before it is used or checking that identifiers are used in the appropriate context (e.g. not adding an integer to a function name). _Dynamic semantics,_ or _execution semantics,_ defines how and when the various constructs of a language should produce a program behavior. For example, it may define the strategy by which expressions are evaluated to values or the manner in which control structures conditionally execute statements.\n",
    "\n",
    "\n",
    "- [_Dynamic type (checking)_](https://en.wikipedia.org/wiki/Type_system#Dynamic_type_checking_and_runtime_type_information):  a _type system_ is a logical system comprising a set of rules that assigns a property called a 'type' to the various constructs of a computer program, such as variables, expressions, functions or modules. _Type checking_ is the process of verifying and enforcing the constraints of types. It may occur at compile-time (_static type check_ of program's text) or at run-time (_dynamic-type check_ of the type safety of the program). \n",
    "\n",
    "\n",
    "- [_Dynamic binding_](https://en.wikipedia.org/wiki/Late_binding): _dynamic binding_ (also known as _late binding_) is a mechanism by which a computer program waits until runtime to bind the name of a method being called to an actual subroutine (that is, to its machine address)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, so Python is _dynamic_...\n",
    "\n",
    "<img src=\"../images/Python_royal_35.png\" width=\"705\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, before you start to hate it... Python is not meant to be as pedantic as it seemed above, it's way more [_Zen_](https://www.python.org/dev/peps/pep-0020/)..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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": [
    "## 1.1. Modules and Packages <a name=\"modules_and_packages\"></a>\n",
    "In Python, a [_module_](https://docs.python.org/3/tutorial/modules.html#) is a Python file (that is, a file ending with `.py`, like `dummy.py`) containing Python statements and definitions. A Python [_package_](https://docs.python.org/3/tutorial/modules.html#packages), is a collection of modules in directories that give a package hierarchy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions defined in modules can be accessed prepending the module name to te name of the function, using the _dot_ operator `.`as follow: `ModuleName.functionName()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example**: let's import the $\\pi$ constant from the `math` module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "now we can access the $\\pi$ constant using the `.` access operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Brief excursus:_ notice that in Jupyter Notebooks, as this is, there is no need to explicitly type `print` to print on screen an expression. This is because a Jupyter Notebook is a _Read-Eval-Print loop_ [(REPL)](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop) programming environment. That is, it takes single user inputs (i.e., single expressions), evaluates (executes) them, and returns the result to the user (thanks to [Matteo Ipri](https://www.linkedin.com/in/matteo-ipri-33325438/?originalSubdomain=en) for pointing this out to me).\n",
    "\n",
    "Of course you get the same result printing it explicitly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "print(math.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [Python Standard Library](https://docs.python.org/3/library/index.html) (STL) comes with basic mathematical functionalities. More specialized functions/calculations need to be _imported_ explicitly from dedicated Python modules. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example**: Suppose that we want to compute $\\log(1)$. The logarithm $log()$ is an example of mathematical function not implemented in the Python STL. Invoking directly the `log()` function causes a `NameError` \n",
    "\n",
    "```python\n",
    "NameError: name 'log' is not defined\n",
    "```\n",
    "\n",
    "because the Python Interpreter is not able to resolve the `log` identifier within the namespace of the STL. In other words, there is no such `log()` function defined in the STL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# log(1) # un-comment this to induce NameError: name 'log' is not defined"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The typical module that we use to access mathematical functions in Python is the [Numpy](https://numpy.org/) module. We import it giving it the _alias_ (that is, a different - shorter - name to refer to it in our code) `np`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Therefore, function `log`, defined in the Numpy module, can be used in our code calling it prepending the `np` to its name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which returns 0, as expected... Do you feel the need to refresh basic mathematical functions? This is a good time to do it and [Wikipedia](https://en.wikipedia.org/wiki/List_of_mathematical_functions) is a comprehensive source of information."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Why Python is relevant for Finance? <a name=\"why_python_is_relevant_for_finance\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python can deliver across three dimensions that are crucial for finance professionals:\n",
    "\n",
    "- _Efficiency:_ getting results faster, thus saving costs and time:    \n",
    "- _Productivity:_ getting more job done with the same resources (people, assets,...);\n",
    "- _Quality:_ advantages over competing technologies "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All these three aspects are addressed by Python because:\n",
    "\n",
    "- Python has a full stack of scientific packages (e.g. Numpy, Pandas, Scipy,...) which allow users (Analysts, Quants, Strats, Traders,...) to focus on their domain and not/less on technical aspects of the implementation. \n",
    "\n",
    "- Python covers the end-to-end process from prototyping to production, reducing the need (and the inherent inefficiencies) of separation between the two (e.g. prototype written by the Front-Office, production code developed by IT department)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example**: In the Equity department of the IB division of Deutsche Bank in London, where I used to work, our team of [Strats](https://corporatefinanceinstitute.com/resources/careers/jobs/strats/) used to manage a proprietary library fully-written in Python, only rarely delegating to the IT department for lower level implementations. This allowed us to react very efficiently to the requests coming from the Traders. We were able to provide them analysis and analytics with a delivery period of hours/days, instead of weeks (if not more)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Why Python is relevant for you? <a name=\"why_python_is_relevant_for_you\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From [efinancialcareers.com](https://news.efinancialcareers.com/lu-en/3001136/python-for-banking-jobs):\n",
    "\n",
    "    If you can’t code and you work in finance you risk being pushed out by those who can. Not today. Not tomorrow, but soon.\n",
    "    \n",
    "    It’s a trend that’s visible in decisions by banks like Citi, JPMorgan and Goldman Sachs to encourage their junior traders and investment managers to learn how to code in Python. But it’s also a trend that’s visible in banks’ job ads – which increasingly list coding as a prerequisite - even in jobs far removed from the ‘engineering’ coal face.\n",
    "    \n",
    "    The message is clear: if you can’t code, more and more banking jobs will be closed to you soon. There is still time to make amends.\n",
    "    \n",
    "Yes, agree, in finance we tend to be very _friendly_ when it comes to recommendations."
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}