Updates on functions

.ipynb_checkpoints/Functions-checkpoint.ipynb

@@ -78,12 +78,29 @@
     "# 13"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Naming a function\n",
+    "\n",
+    "Like variables, python functions should also be in `lower_snake_case`\n",
+    "\n",
+    "One of the more universal, yet simple rules is: Function names should be verbs if the function changes the state of the program, and nouns if they're used to return a certain value.\n",
+    "\n",
+    "1. *Self-explanatory names*: a function `get_name()` will tell the developer what it returns as well as set_address(), is_male(), etc.\n",
+    "2. *Short*: a function name must be as short as possible so that it's simple to type as well as easy to remember. A function `get_number_of_pages_in_the_book()` is not good, something like `get_book_page_count()` is better.\n",
+    "3. Use of prefixes: use prefixes in the functions such as `get_name()`, `set_name()`, etc.\n",
+    "\n",
+    "The most important thing to note is to follow a constant naming convention throughout the function"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Lambda function (Inline or Anonymous function):\n",
-    "One liner of a function\n",
+    "One liner of a function. It is created for use at one point or one statememt and is not intended to be named and stored.\n",
     "\n",
     "Syntax:  \n",
     "```python\n",
@@ -93,7 +110,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -107,21 +124,33 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "True\n"
+      "From is_even(x): True\n",
+      "From lambda: True\n"
      ]
     }
    ],
    "source": [
     "# Example 1\n",
-    "# def c(x):\n",
-    "#     return x % 2 == 0 #One line function to check if even\n",
+    "\n",
+    "def is_even(x):\n",
+    "    return x % 2 == 0 # One line function to check if even\n",
+    "\n",
     "a = int(input())\n",
-    "c = lambda x: x % 2 == 0 # Equivalent lambda function\n",
-    "print(c(a))\n",
+    "print(\"From is_even(x):\", is_even(a))\n",
+    "print(\"From lambda:\", (lambda x: x % 2 == 0)(a)) # Equivalent lambda function\n",
     "\n",
     "# Input: 10"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `lambda` function is generally created for use with iterables where the function is applied to several values but at only once (that part of the code).\n",
+    "\n",
+    "The usual places include maps, filter and keys for sorting for any iterable. Visit [Lists](DS_Lists.ipynb) or [Tuples](DS_Tuples.ipynb) to know more on them"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -177,6 +206,7 @@
    "source": [
     "Breaking down of problem:\n",
     "\n",
+    "```python\n",
     "n = 6  \n",
     "n <= 1 False  \n",
     "6 * factorial(5)  \n",
@@ -203,14 +233,69 @@
     "\n",
     "Building up:\n",
     "\n",
-    "1 <br>\n",
+    "1\n",
     "2 * 1  \n",
     "3 * 2 * 1  \n",
     "4 * 3 * 2 * 1  \n",
     "5 * 4 * 3 * 2 * 1  \n",
     "6 * 5 * 4 * 3 * 2 * 1  \n",
     "\n",
-    "720"
+    "720\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can find the steps in recursion below  \n",
+    "The '|' line indicates the same level of recursive call"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "6\n",
+      "|\t5\n",
+      "|\t|\t4\n",
+      "|\t|\t|\t3\n",
+      "|\t|\t|\t|\t2\n",
+      "|\t|\t|\t|\t|\t1\n",
+      "|\t|\t|\t|\t2\n",
+      "|\t|\t|\t6\n",
+      "|\t|\t24\n",
+      "|\t120\n",
+      "720\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "720"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# The indent paramter defines the offset of output. This program is to understand recursion only.\n",
+    "def fact(n, indent=''):\n",
+    "    print(indent, n, sep='')\n",
+    "    if 0 <= n <= 1: return 1\n",
+    "    else:\n",
+    "        fac = n * fact(n-1, indent + \"|\\t\")\n",
+    "        print(indent, fac, sep='')\n",
+    "        return fac\n",
+    "\n",
+    "fact(6)"
    ]
   },
   {
@@ -459,7 +544,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
@@ -488,7 +573,7 @@
    "source": [
     "#Example\n",
     "# Example \n",
-    "def add(a, *b): # Function Definition -  * incicates variable length arguments\n",
+    "def add(a, *b): # Function Definition -  * indicates variable length arguments\n",
     "    print(b)\n",
     "    return a + sum(b) # returns the sum; sum is a built in function that returns sum of elements in an iterable\n",
     "x = int(input())\n",
@@ -1230,7 +1315,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.4"
+   "version": "3.9.6"
   }
  },
  "nbformat": 4,

Functions.ipynb

@@ -78,12 +78,29 @@
     "# 13"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Naming a function\n",
+    "\n",
+    "Like variables, python functions should also be in `lower_snake_case`\n",
+    "\n",
+    "One of the more universal, yet simple rules is: Function names should be verbs if the function changes the state of the program, and nouns if they're used to return a certain value.\n",
+    "\n",
+    "1. *Self-explanatory names*: a function `get_name()` will tell the developer what it returns as well as set_address(), is_male(), etc.\n",
+    "2. *Short*: a function name must be as short as possible so that it's simple to type as well as easy to remember. A function `get_number_of_pages_in_the_book()` is not good, something like `get_book_page_count()` is better.\n",
+    "3. Use of prefixes: use prefixes in the functions such as `get_name()`, `set_name()`, etc.\n",
+    "\n",
+    "The most important thing to note is to follow a constant naming convention throughout the function"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Lambda function (Inline or Anonymous function):\n",
-    "One liner of a function\n",
+    "One liner of a function. It is created for use at one point or one statememt and is not intended to be named and stored.\n",
     "\n",
     "Syntax:  \n",
     "```python\n",
@@ -93,7 +110,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -107,21 +124,33 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "True\n"
+      "From is_even(x): True\n",
+      "From lambda: True\n"
      ]
     }
    ],
    "source": [
     "# Example 1\n",
-    "# def c(x):\n",
-    "#     return x % 2 == 0 #One line function to check if even\n",
+    "\n",
+    "def is_even(x):\n",
+    "    return x % 2 == 0 # One line function to check if even\n",
+    "\n",
     "a = int(input())\n",
-    "c = lambda x: x % 2 == 0 # Equivalent lambda function\n",
-    "print(c(a))\n",
+    "print(\"From is_even(x):\", is_even(a))\n",
+    "print(\"From lambda:\", (lambda x: x % 2 == 0)(a)) # Equivalent lambda function\n",
     "\n",
     "# Input: 10"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `lambda` function is generally created for use with iterables where the function is applied to several values but at only once (that part of the code).\n",
+    "\n",
+    "The usual places include maps, filter and keys for sorting for any iterable. Visit [Lists](DS_Lists.ipynb) or [Tuples](DS_Tuples.ipynb) to know more on them"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -177,6 +206,7 @@
    "source": [
     "Breaking down of problem:\n",
     "\n",
+    "```python\n",
     "n = 6  \n",
     "n <= 1 False  \n",
     "6 * factorial(5)  \n",
@@ -203,14 +233,69 @@
     "\n",
     "Building up:\n",
     "\n",
-    "1 <br>\n",
+    "1\n",
     "2 * 1  \n",
     "3 * 2 * 1  \n",
     "4 * 3 * 2 * 1  \n",
     "5 * 4 * 3 * 2 * 1  \n",
     "6 * 5 * 4 * 3 * 2 * 1  \n",
     "\n",
-    "720"
+    "720\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can find the steps in recursion below  \n",
+    "The '|' line indicates the same level of recursive call"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "6\n",
+      "|\t5\n",
+      "|\t|\t4\n",
+      "|\t|\t|\t3\n",
+      "|\t|\t|\t|\t2\n",
+      "|\t|\t|\t|\t|\t1\n",
+      "|\t|\t|\t|\t2\n",
+      "|\t|\t|\t6\n",
+      "|\t|\t24\n",
+      "|\t120\n",
+      "720\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "720"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# The indent paramter defines the offset of output. This program is to understand recursion only.\n",
+    "def fact(n, indent=''):\n",
+    "    print(indent, n, sep='')\n",
+    "    if 0 <= n <= 1: return 1\n",
+    "    else:\n",
+    "        fac = n * fact(n-1, indent + \"|\\t\")\n",
+    "        print(indent, fac, sep='')\n",
+    "        return fac\n",
+    "\n",
+    "fact(6)"
    ]
   },
   {
@@ -459,7 +544,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
@@ -488,7 +573,7 @@
    "source": [
     "#Example\n",
     "# Example \n",
-    "def add(a, *b): # Function Definition -  * incicates variable length arguments\n",
+    "def add(a, *b): # Function Definition -  * indicates variable length arguments\n",
     "    print(b)\n",
     "    return a + sum(b) # returns the sum; sum is a built in function that returns sum of elements in an iterable\n",
     "x = int(input())\n",
@@ -1230,7 +1315,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.4"
+   "version": "3.9.6"
   }
  },
  "nbformat": 4,