From 7dae4294a51c0b0cee7302b774482954ced55a94 Mon Sep 17 00:00:00 2001 From: elenaarenal <156951192+elenaarenal@users.noreply.github.com> Date: Thu, 27 Jun 2024 18:06:41 +0200 Subject: [PATCH] Add files via upload --- lab_lamda_fuctions.ipynb | 401 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 401 insertions(+) create mode 100644 lab_lamda_fuctions.ipynb diff --git a/lab_lamda_fuctions.ipynb b/lab_lamda_fuctions.ipynb new file mode 100644 index 0000000..f2f27a6 --- /dev/null +++ b/lab_lamda_fuctions.ipynb @@ -0,0 +1,401 @@ +{ + "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": "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": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here\n", + "lambda x : x + 273.15\n", + "l= lambda x: x+ 273.15\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, convert the list of temperatures below from Celsius to Kelvin." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[285.15, 296.15, 311.15, 218.14999999999998, 297.15]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "temps = [12, 23, 38, -55, 24]\n", + "lst=[]\n", + "for t in temps:\n", + " l(t)\n", + " lst.append(l(t)) \n", + "lst\n", + "# your code here\n", + "\n", + "lst=[l(t) for t in temps]\n", + "lst" + ] + }, + { + "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": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "\n", + "mod= lambda x,y: 1 if x%y==0 or y%x==0 else 0\n", + "mod(9,3)\n", + "\n" + ] + }, + { + "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": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + ".(x)>" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def divisor(b):\n", + " \n", + " return lambda x: 1 if x % b == 0 else 0\n", + " # your code here\n", + "div=divisor(3)\n", + "div" + ] + }, + { + "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": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# your code her\n", + "def divisible5(x):\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 mod (x, y=5)\n", + " # your code here" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Test your function with the following test cases:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "divisible5(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "divisible5(8)" + ] + }, + { + "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": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(1,), (2,), (3,), (4,), (5,)]" + ] + }, + "execution_count": 10, + "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" + ] + }, + { + "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": 23, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'list' object is not callable", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[23], line 8\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mzip\u001b[39m(list1, list2))\n\u001b[0;32m 6\u001b[0m zipea\u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mlambda\u001b[39;00m lst1, lst2: [(lst1(i), lst2(i)) \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(lst1))]\n\u001b[1;32m----> 8\u001b[0m zipea(list1,list2)\n", + "Cell \u001b[1;32mIn[23], line 6\u001b[0m, in \u001b[0;36m\u001b[1;34m(lst1, lst2)\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[38;5;28mzip\u001b[39m(list1, list2)\n\u001b[0;32m 4\u001b[0m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mzip\u001b[39m(list1, list2))\n\u001b[1;32m----> 6\u001b[0m zipea\u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mlambda\u001b[39;00m lst1, lst2: [(lst1(i), lst2(i)) \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(lst1))]\n\u001b[0;32m 8\u001b[0m zipea(list1,list2)\n", + "Cell \u001b[1;32mIn[23], line 6\u001b[0m, in \u001b[0;36m\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[38;5;28mzip\u001b[39m(list1, list2)\n\u001b[0;32m 4\u001b[0m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mzip\u001b[39m(list1, list2))\n\u001b[1;32m----> 6\u001b[0m zipea\u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mlambda\u001b[39;00m lst1, lst2: [(lst1(i), lst2(i)) \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(lst1))]\n\u001b[0;32m 8\u001b[0m zipea(list1,list2)\n", + "\u001b[1;31mTypeError\u001b[0m: 'list' object is not callable" + ] + } + ], + "source": [ + "list1 = ['Engineering', 'Computer Science', 'Political Science', 'Mathematics']\n", + "list2 = ['Lab', 'Homework', 'Essay', 'Module']\n", + "zip(list1, list2)\n", + "list(zip(list1, list2))\n", + "\n", + "zipea= lambda lst1, lst2: [(lst1(i), lst2(i)) for i in range(len(lst1))]\n", + "\n", + "zipea(list1,list2)\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": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('Audi', 2001), ('BMW', 2005), ('Honda', 1997), ('Toyota', 1995)]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d = {'Honda': 1997, 'Toyota': 1995, 'Audi': 2001, 'BMW': 2005}\n", + "\n", + "# your code here\n", + "sorted(d.items()) #ordenado por keys" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on built-in function sorted in module builtins:\n", + "\n", + "sorted(iterable, /, *, key=None, reverse=False)\n", + " Return a new list containing all items from the iterable in ascending order.\n", + " \n", + " A custom key function can be supplied to customize the sort order, and the\n", + " reverse flag can be set to request the result in descending order.\n", + "\n" + ] + } + ], + "source": [ + "help(sorted)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sorted(d.items(), key = lambda )" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}