PyProg/functional_programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functional Programming in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funtional programming concepts\n",
    "**Imperative languages**: tell the computer what srpes to take to solve a problem\n",
    "\n",
    "**Declaritive languages**: tell the computer what result they want\n",
    "\n",
    "**Functional languages** are declarive languages with the following characteristics:\n",
    "- **Pure functions**: do not have side effects, that is, they do not change the state of the program. Given the same input, a pure function will always produce the same output.\n",
    "- **Immutability** - data cannot be changed after it is created.\n",
    "- **Higher Order Functions**: functions can accept other functions as an argument\n",
    "\n",
    "참고:\n",
    "> **first class function**: function을 value처럼 취급한다. Function을 variable에 assign 할수 있고, 다른 function에게 argument로 passing할 수도 있다. 이때, first class function을 passing 받는 '다른 function'을 high order function이라 한다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pure functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# not pure function\n",
    "def remove_last_item(mylist):\n",
    "    \"\"\"Removes the last item from a list.\"\"\"\n",
    "    mylist.pop(-1)  # This modifies mylist\n",
    "    \n",
    "# pure function has no side effects\n",
    "def butlast(mylist):\n",
    "    \"\"\"Like butlast in Lisp; returns the list without the last element.\"\"\"\n",
    "    return mylist[:-1]  # This returns a copy of mylist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The practival advatages of using functional programming\n",
    "- modularity: Since the function does not depend on any\n",
    "external variable or state, call it from a different piece of code is\n",
    "straightforward.\n",
    "- brevity. Functional programming is often less verbose than other paradigms.\n",
    "- concurrency - Purely functional functions are thread-safe and can run\n",
    "concurrently. \n",
    "- testability. Testing a functional program is incredibly easy. all you need\n",
    "is a set of inputs and an expected set of outputs.\n",
    "\n",
    "Note that concepts such as **list comprehension in Python are already functionals** in their approach, as they are designed to avoid side effects. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hight order functions\n",
    "한 줄을 여러차례 print하는 function을 생각해 보자"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Hello\n",
      "Hello\n",
      "Hello\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "def write_repeat(message, n):  \n",
    "    for i in range(n):\n",
    "        print(message)\n",
    "\n",
    "write_repeat('Hello', 5)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "log message를 남기려면, function을 새로 작성해야 하나?\n",
    "\n",
    "High order function 하나로 충분!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ERROR:root:Hello\n",
      "ERROR:root:Hello\n",
      "ERROR:root:Hello\n",
      "ERROR:root:Hello\n",
      "ERROR:root:Hello\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Hello\n",
      "Hello\n",
      "Hello\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "def hof_write_repeat(message, n, action):  \n",
    "    for i in range(n):\n",
    "        action(message)\n",
    "\n",
    "hof_write_repeat('Hello', 5, print)\n",
    "\n",
    "# Import the logging library\n",
    "import logging  \n",
    "# Log the output as an error instead\n",
    "hof_write_repeat('Hello', 5, logging.error)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List에 있는 number들을 각각 2, 3, 10을 더하는 function을 다음과 같이 3가지 function을 정의해야 하지만,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add2(numbers):  \n",
    "    new_numbers = []\n",
    "    for n in numbers:\n",
    "        new_numbers.append(n + 2)\n",
    "    return new_numbers\n",
    "\n",
    "def add5(numbers):\n",
    "    pass\n",
    "    \n",
    "def add10(numbers):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "하나의 high order function으로 쓸 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[28, 93]\n",
      "[33, 98]\n"
     ]
    }
   ],
   "source": [
    "def hof_add(increment):  \n",
    "    def add_increment(numbers):\n",
    "        new_numbers = []\n",
    "        for n in numbers:\n",
    "            new_numbers.append(n + increment)\n",
    "        return new_numbers\n",
    "    return add_increment\n",
    "\n",
    "add5 = hof_add(5)  \n",
    "print(add5([23, 88]))   # [28, 93]  \n",
    "add10 = hof_add(10)  \n",
    "print(add10([23, 88]))  # [33, 98]  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rewrite above function using **lambda expresssion** and **list comprehension**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[28, 93]\n",
      "[33, 98]\n"
     ]
    }
   ],
   "source": [
    "def hof_add(increment):\n",
    "    return lambda numbers: [n + increment for n in numbers]\n",
    "\n",
    "add5 = hof_add(5)  \n",
    "print(add5([23, 88]))   # [28, 93]  \n",
    "add10 = hof_add(10)  \n",
    "print(add10([23, 88]))  # [33, 98]  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-in High Order Functions\n",
    "### Map\n",
    "To apply a function to every element in an iterable object.\n",
    "```Python\n",
    "map(function, iterable, ...)\n",
    "    returns an iterator\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x182c803d518>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "map(lambda x, y: x+y, [1, 2, 3, 4], [10, 20, 30, 40])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 22, 33, 44]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x, y: x+y, [1, 2, 3, 4], [10, 20, 30, 40]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 22]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x, y: x+y, [1, 2, 3, 4], [10, 20]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hi Shivani', 'Hi Jason', 'Hi Yusef', 'Hi Sakura']\n"
     ]
    }
   ],
   "source": [
    "names = ['Shivani', 'Jason', 'Yusef', 'Sakura']  \n",
    "print(list(map(lambda x: 'Hi ' + x, names)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using list comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['High Shivani', 'High Jason', 'High Yusef', 'High Sakura']\n"
     ]
    }
   ],
   "source": [
    "print(['High ' + x for x in names])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using generator expression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<generator object <genexpr> at 0x00000182C7FFD3B8>\n",
      "['High Shivani', 'High Jason', 'High Yusef', 'High Sakura']\n"
     ]
    }
   ],
   "source": [
    "greeted_names = ('High ' + x for x in names)\n",
    "print(greeted_names)\n",
    "print(list(greeted_names))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filter\n",
    "The filter function tests every element in an iterable object with a function that returns either `True` or `False`, only keeping those which evaluates to `True`.\n",
    "```Python\n",
    "filter(function, iterable)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<filter object at 0x00000182C803DF60>\n",
      "['I think']\n"
     ]
    }
   ],
   "source": [
    "print(filter(lambda x: x.startswith(\"I \"), [\"I think\", \"I'm good\"]))\n",
    "print(list(filter(lambda x: x.startswith(\"I \"), [\"I think\", \"I'm good\"])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reduce\n",
    "```Python\n",
    "from functools import reduce\n",
    "reduce(function, iterable[, initial])\n",
    "```\n",
    "> Python 2에서는 built-in function이다.\n",
    "\n",
    "(((1 + 2) + 3) + 4) => 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "print(reduce(lambda a, b: a+b, [1, 2, 3, 4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `any` and `all`\n",
    "```Python\n",
    "any(iterable)\n",
    "all(iterable)\n",
    "```\n",
    "    both return a Boolean, depending on the values by iterables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False, True, True, False]\n",
      "At least one item is greater than 0\n"
     ]
    }
   ],
   "source": [
    "mylist = [0, 1, 3, -1]\n",
    "print(list(map(lambda x: x > 0, mylist)))\n",
    "if all(map(lambda x: x > 0, mylist)):\n",
    "    print(\"All items are greater than 0\")\n",
    "if any(map(lambda x: x > 0, mylist)):\n",
    "    print(\"At least one item is greater than 0\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combining lists with `zip`\n",
    "```Python\n",
    "zip(iter1, [, iter2 [...]])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    " keys = [\"foobar\", \"barzz\", \"ba!\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x182c804d748>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "map(len, keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<zip at 0x182c802d388>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zip(keys, map(len, keys))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ba!': 3, 'barzz': 5, 'foobar': 6}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict(zip(keys, map(len, keys)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3) (4, 5, 6)\n",
      "[(1, 4), (2, 5), (3, 6)]\n",
      "(1, 4) (2, 5) (3, 6)\n",
      "[(1, 2, 3), (4, 5, 6)]\n"
     ]
    }
   ],
   "source": [
    "matrix = [(1, 2, 3),\n",
    "          (4, 5, 6)]\n",
    "print(*matrix)  # unpacking\n",
    "print(list(zip(*matrix)))\n",
    "print(*zip(*matrix))\n",
    "print(list(zip(*zip(*matrix)))) # transpose"
   ]
  }
 ],
 "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}