03. Functional Programing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funtional Programing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sections\n",
    "- [Basics](#Basics)\n",
    "- [Methods](#Methods)\n",
    "- [Docstrings](#Docstrings)\n",
    "- [Args and Kwargs](#Args-and-Kwargs)\n",
    "- [Scope](#Scope)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are used to organize code in blocks, that can be later reused.\n",
    "\n",
    "We can create our own functions. A funtion can have parameters and/or arguments\n",
    "\n",
    "The structure of a basic funtion is:\n",
    "\n",
    "```python\n",
    "def name(parameter1, parameter2, ...):\n",
    "    \"\"\"\n",
    "    Function description ...\n",
    "    \"\"\"\n",
    "    execute\n",
    "    execute\n",
    "    return value\n",
    "    \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Basic example\n",
    "def my_func():\n",
    "    \"\"\"\n",
    "    Prints hello world (this is the __docstring__)\n",
    "    \"\"\"\n",
    "    print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function my_func in module __main__:\n",
      "\n",
      "my_func()\n",
      "    Prints hello world (this is the __docstring__)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(my_func)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    Prints hello world (this is the __docstring__)\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(my_func.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The return keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "# Or we could write (as a good pratice, use the return keyword to return the results of your funtion)\n",
    "def hello():\n",
    "    return \"Hello World\"\n",
    "\n",
    "print(hello())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello John.\n"
     ]
    }
   ],
   "source": [
    "# Using parameters\n",
    "def hello(name):\n",
    "    return f\"Hello {name}.\"\n",
    "\n",
    "print(hello(\"John\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello David.\n",
      "Hello someone.\n"
     ]
    }
   ],
   "source": [
    "# Using default arguments\n",
    "def hello(name=\"someone\"):\n",
    "    return f\"Hello {name}.\"\n",
    "\n",
    "print(hello(\"David\"))\n",
    "print(hello())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Methods are funtions inside a funtion. They add funtionality to a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HOLA'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example of a built-in method for a string object.\n",
    "\"hola\".upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Docstrings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Docstrings helps us to add a description to our funtion. In order to add a description we could use triple quotes:\n",
    "``` python\n",
    "def name(num1, num2):\n",
    "    \"\"\"\n",
    "    info: This is a doctring, this funtion is for bla, bla, bla\n",
    "    \"\"\"\n",
    "    return num11 + num2\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# Example\n",
    "def sum(num1=0, num2=0):\n",
    "    \"\"\"\n",
    "    Info: This basic function returns the sum of two numbers.\n",
    "          If no numbers are given, it returns 0.\n",
    "    \"\"\"\n",
    "    return num1 + num2\n",
    "print(sum(1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function sum in module __main__:\n",
      "\n",
      "sum(num1=0, num2=0)\n",
      "    Info: This basic function returns the sum of two numbers.\n",
      "          If no numbers are given, it returns 0.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# We can use the help funtion to see the description (docstring) of the function\n",
    "help(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    Info: This basic function returns the sum of two numbers.\n",
      "          If no numbers are given, it returns 0.\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "# Anotherway is to use the dunder attribute __doc__\n",
    "print(sum.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I Python there are five types of Function arguments\n",
    "- Positional\n",
    "- Default\n",
    "- Keyword (allows to ignore the position)\n",
    "- *args\n",
    "- **kwargs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Args and kwargs\n",
    "\n",
    "These \\*args and \\*\\*kwargs help us when we do not know the amount of arguments.\n",
    "The precendence when using multiple arguments is:\n",
    "- (normal parameters, \\*args, default parameters, \\*\\*kwargs) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# Example using *args\n",
    "\n",
    "def multi_sum(*args):\n",
    "    print(args)                     # this one is just to see how data is manipulated, with *args is a tuple\n",
    "    return sum(args)\n",
    "\n",
    "print(multi_sum(1,2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 2, 'c': 3}\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "def multi_func(**kwargs):\n",
    "    print(kwargs)                     # this one is just to see how data is manipulated, with **kwargs is a dictionary\n",
    "    return sum(kwargs.values())\n",
    "\n",
    "# Use keywords arguments\n",
    "print(multi_func(a=1,b=2,c=3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scope is related to the variables your program has access. There are several scopes in Python.\n",
    "\n",
    "- Global scope: a variable created in the main code\n",
    "- Local scope: a variable created inside a funtion, is only know in that function\n",
    "\n",
    "Ther are some rules to consider about scope:\n",
    "\n",
    "- Start with local scope\n",
    "- Parent local scope\n",
    "- Global scope\n",
    "- Built in python functions\n",
    "\n",
    "Arguments in a function only have local scope.\n",
    "We can use the `global` keywork if we want to manipulate a global varable inside a funtion.\n",
    "We can use also use the keywork `nonlocal` when you want a funtion not to create a local variable inside a funtion, and to refer to a parent local variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "5\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "a = 1                      # This variable has global scope\n",
    "\n",
    "def moreconfusion():\n",
    "    return a               # It will use the global variable\n",
    "\n",
    "def confusion():\n",
    "    a = 5                  # This variable has local scope\n",
    "    return a\n",
    "\n",
    "def parent():\n",
    "    a = 10                 \n",
    "    def crazyconfusion():\n",
    "        return a           # it will use the parent local scope\n",
    "    return crazyconfusion()\n",
    "\n",
    "print(a)\n",
    "print(moreconfusion())\n",
    "print(confusion())\n",
    "print(parent())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "\n",
    "def count():\n",
    "    global total    # not recommended to use this keyword\n",
    "    total += 1\n",
    "    return total\n",
    "count()\n",
    "count()\n",
    "print(count())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner: nonlocal\n",
      "outer: nonlocal\n"
     ]
    }
   ],
   "source": [
    "def outer():\n",
    "    x = \"local\"\n",
    "    def inner():\n",
    "        nonlocal x\n",
    "        x = \"nonlocal\"\n",
    "        print(\"inner:\", x)\n",
    "    inner()\n",
    "    print(\"outer:\", x)\n",
    "outer()"
   ]
  }
 ],
 "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
}