2.1-functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# All About Functions\n",
    "theres more than meets the eye"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Definition Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# basic ol function definition\n",
    "def func():\n",
    "    return 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# functions can have arguments\n",
    "def func1(x, y):\n",
    "    return (x, y)\n",
    "\n",
    "# use positional arguments\n",
    "func1(5,6)\n",
    "\n",
    "# use keyword arguments (kwarg)\n",
    "func1(x=4, y=7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# functions can specify argument format\n",
    "\n",
    "# arguments as a list\n",
    "def func2(*arg):\n",
    "    return (arg[1], arg[2])\n",
    "\n",
    "print(func2(1,2,3))\n",
    "\n",
    "\n",
    "# arguments as a keywords (dictionary)\n",
    "def func3(**kwargs):\n",
    "    return kwargs\n",
    "\n",
    "print(func3(x=2, y=5))\n",
    "\n",
    "\n",
    "# arguments as a mix of positional and keywords\n",
    "def func4(arg1, arg2, **kwargs):\n",
    "    try:\n",
    "        return (arg1, arg2, kwargs['name'])\n",
    "    except:\n",
    "        return (arg1, arg2)\n",
    "\n",
    "print(func4(1,2, name=5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lambda Functions\n",
    "inline functions (throwaway) that help with functional programming patterns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# most basic lambda functions\n",
    "fn = lambda: 5     # without arguments\n",
    "print(fn())\n",
    "\n",
    "fn = lambda x: x     # with arguments\n",
    "print(fn(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# inline lambda function\n",
    "(lambda x: x+7)(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generators\n",
    "`yield` results as they are called for rather then calculating everything and returning the entire result set. generators are more memory efficient then functions (generally) and thereby also ussually faster regular functions... (generally)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(n):\n",
    "    a,b = 0,1\n",
    "    for i in range(n):\n",
    "        answer = a+b\n",
    "        yield answer\n",
    "        b,a = a,answer\n",
    "\n",
    "for i in fib(12): print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Closures\n",
    "a way to precompute values in the scope of a function. more performant than globals, and hides static values.\n",
    "\n",
    "> NOTE: python 3.8 global vars are loaded 40% faster then <=3.7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "def distance_fn(x, y):\n",
    "    \"\"\" d(P, Q) = √ (x2 − x1)2 + (y2 − y1)2 \"\"\"\n",
    "    p1_x = 8\n",
    "    p1_y = 4\n",
    "    \n",
    "    def inner_fn():\n",
    "        return sqrt((p1_x - x)**2 + (p1_y - y)**2)\n",
    "    \n",
    "    return inner_fn\n",
    "\n",
    "closure = distance_fn(2,2)\n",
    "closure()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decorators\n",
    "similar to closures. meant to use closures to act as wrapper funtion that can be called with a special syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "def timer(fn):\n",
    "    def wrapper():\n",
    "        t1 = time.time()\n",
    "        fn()\n",
    "        t2 = time.time()\n",
    "        return t2 - t1\n",
    "    return wrapper\n",
    "\n",
    "timer(lambda: 1+2+3+4+5/6)()"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}