[Lab-Lambda-Functions]-Maximilian Kempken

module-1/Lambda-Functions/your-code/.ipynb_checkpoints/main-checkpoint.ipynb

@@ -0,0 +1,380 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Before your start:\n",
+    "- Read the README.md file\n",
+    "- Comment as much as you can and use the resources in the README.md file\n",
+    "- Happy learning!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Challenge - Passing a Lambda Expression to a Function\n",
+    "\n",
+    "In the next excercise you will create a function that returns a lambda expression. Create a function called `modify_list`. The function takes two arguments, a list and a lambda expression. The function iterates through the list and applies the lambda expression to every element in the list."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[285.15, 296.15, 311.15, 218.14999999999998, 297.15]"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "temps = [12, 23, 38, -55, 24]\n",
+    "convert = lambda x: x + 273.15\n",
+    "\n",
+    "def modify_list(lst, lmbda):\n",
+    "    \"\"\"\n",
+    "    Input: list and lambda expression\n",
+    "    Output: the transformed list\n",
+    "    \"\"\"\n",
+    "    # your code here\n",
+    "    return [lmbda(x) for x in lst]\n",
+    "    \n",
+    "    \n",
+    "modify_list(temps, convert)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Now we will define a lambda expression that will transform the elements of the list. \n",
+    "\n",
+    "In the cell below, create a lambda expression that converts Celsius to Kelvin. Recall that 0°C + 273.15 = 273.15K"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[285.15, 296.15, 311.15, 218.14999999999998, 297.15]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# your code here\n",
+    "convert = lambda x: x + 273.15\n",
+    "converted = [convert(x) for x in temps]\n",
+    "print(converted)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, convert the list of temperatures below from Celsius to Kelvin."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[285.15, 296.15, 311.15, 218.14999999999998, 297.15]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "temps = [12, 23, 38, -55, 24]\n",
+    "\n",
+    "# your code here\n",
+    "modify_list(temps, convert)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### In this part, we will define a function that returns a lambda expression\n",
+    "\n",
+    "In the cell below, write a lambda expression that takes two numbers and returns 1 if one is divisible by the other and zero otherwise. Call the lambda expression `mod`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# your code here\n",
+    "mod = lambda x, y: 1 if (x % y == 0) else 0\n",
+    "mod(2, 3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Now create a function that returns mod. The function only takes one argument - the first number in the `mod` lambda function. \n",
+    "\n",
+    "Note: the lambda function above took two arguments, the lambda function in the return statement only takes one argument but also uses the argument passed to the function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def divisor(b):\n",
+    "    \"\"\"\n",
+    "    Input: a number\n",
+    "    Output: a function that returns 1 if the number is \n",
+    "    divisible by another number (to be passed later) and zero otherwise.\n",
+    "    \"\"\"\n",
+    "    return lambda c: 1 if (c % b == 0) else 0\n",
+    "    # your code here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, pass the number 5 to `divisor`. Now the function will check whether a number is divisble by 5. Assign this function to `divisible5`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# your code here\n",
+    "divisible5 = divisor(5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Test your function with the following test cases:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "divisible5(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "divisible5(22)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Bonus Challenge - Using Lambda Expressions in List Comprehensions\n",
+    "\n",
+    "In the following challenge, we will combine two lists using a lambda expression in a list comprehension. \n",
+    "\n",
+    "To do this, we will need to introduce the `zip` function. The `zip` function returns an iterator of tuples."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[(1,), (2,), (3,), (4,), (5,)]"
+      ]
+     },
+     "execution_count": 67,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Here is an example of passing one list to the zip function. \n",
+    "# Since the zip function returns an iterator, we need to evaluate the iterator by using a list comprehension.\n",
+    "\n",
+    "l = [1,2,3,4,5]\n",
+    "[x for x in zip(l)]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Using the `zip` function, let's iterate through two lists and add the elements by position."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "list1 = ['Green', 'cheese', 'English', 'tomato']\n",
+    "list2 = ['eggs', 'cheese', 'cucumber', 'tomato']\n",
+    "\n",
+    "# your code here\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Bonus Challenge - Using Lambda Expressions as Arguments\n",
+    "\n",
+    "#### In this challenge, we will zip together two lists and sort by the resulting tuple.\n",
+    "\n",
+    "In the cell below, take the two lists provided, zip them together and sort by the first letter of the second element of each tuple. Do this using a lambda function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "list1 = ['Engineering', 'Computer Science', 'Political Science', 'Mathematics']\n",
+    "list2 = ['Lab', 'Homework', 'Essay', 'Module']\n",
+    "\n",
+    "# your code here"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Bonus Challenge - Sort a Dictionary by Values\n",
+    "\n",
+    "Given the dictionary below, sort it by values rather than by keys. Use a lambda function to specify the values as a sorting key."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "d = {'Honda': 1997, 'Toyota': 1995, 'Audi': 2001, 'BMW': 2005}\n",
+    "\n",
+    "# your code here"
+   ]
+  }
+ ],
+ "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.8.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}