notebooks/functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "\n",
    "In Python, a **function** is a reusable block of code that performs a specific task or a set of tasks. Functions are defined using the **def** keyword, and they allow you to **encapsulate** a piece of code, give it a name, and **reuse** it multiple times throughout your program. Functions help make your code more **modular**, **readable**, and **maintainable**.\n",
    "\n",
    "* [Components of a function](#components-of-a-function)\n",
    "* [Default Arguments in Functions](#default-arguments-in-functions)\n",
    "* [Keyword Argument List](#keyword-argument-list)\n",
    "* [Data Lifecycle](#data-lifecycle)\n",
    "* [How to Change Data Inside Functions](#how-to-change-data-inside-functions)\n",
    "* [Lambda Functions](#lambda-functions)\n",
    "* [map() function](#map-function)\n",
    "* [filter() function](#filter-function)\n",
    "* [Functions as arguments of functions](#functions-as-arguments-of-functions)\n",
    "* [Decorators](#decorators)\n",
    "* [How to pass arguments to decorator functions](#how-to-pass-arguments-to-decorator-functions)\n",
    "* [How to stack decorators](#how-to-stack-decorators)\n",
    "* [Built-in decorators](#built-in-decorators)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Components of a function\n",
    "\n",
    "Functions can be defined and used to perform a wide range of tasks in Python, from simple calculations to complex operations. They can also include conditional statements, loops, and can be used to group and organize your code for better readability and maintainability.\n",
    "\n",
    "Let's break down the components of a function:\n",
    "\n",
    "* **def**: This keyword is used to define a function.\n",
    "\n",
    "* **function_name**: You should choose a descriptive name for your function, following the naming conventions (e.g., use lowercase letters and underscores for function names). The name should be unique within your program.\n",
    "\n",
    "* **parameters**: These are optional. They allow you to pass values into the function, which it can then use in its code. Parameters are enclosed in parentheses and separated by commas. If a function doesn't need any parameters, you can leave the parentheses empty.\n",
    "\n",
    "* **function body**: This is an indented block of code that contains the instructions for what the function should do.\n",
    "\n",
    "* **return**: This keyword is used to specify the value that the function should return when it's called. Functions can return a single value, multiple values (as a tuple), or nothing (in which case, None is returned)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Alice!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Hello, Bob!'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Here's an example of a simple Python function:\n",
    "def greet(name):\n",
    "    return f\"Hello, {name}!\"\n",
    "\n",
    "# Calling the function\n",
    "result = greet(\"Alice\")\n",
    "print(result)\n",
    "\n",
    "\"\"\"\n",
    "When you call greet(\"Alice\"), the function is executed with the parameter \"Alice\", and it returns the string \"Hello, Alice!\".\n",
    "The result is then printed to the console.\n",
    "\"\"\"\n",
    "\n",
    "# You can also call functions without storing their return values, like this:\n",
    "greet(\"Bob\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Default Arguments in Functions\n",
    "\n",
    "In Python, you can define default arguments for functions. Default arguments are used to provide a default value for a parameter if the caller of the function does not provide a value for that parameter. This is particularly useful when you want to make a parameter optional, and if the caller doesn't provide a value, the default value is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Alice!\n",
      "Hi, Bob!\n"
     ]
    }
   ],
   "source": [
    "# Here's how you can define a function with default arguments:\n",
    "\"\"\"\n",
    "def function_name(param1, param2=default_value):\n",
    "    # Function body\n",
    "    # Code that uses param1 and param2\n",
    "\"\"\"\n",
    "# In this syntax:\n",
    "\"\"\"\n",
    "param1: is a required parameter that the caller must provide a value for.\n",
    "param2: is an optional parameter with a default value (default_value).\n",
    "\n",
    "If the caller provides a value for param2, it will override the default value.\n",
    "If the caller doesn't provide a value for param2, the default value will be used.\n",
    "\"\"\"\n",
    "# Here's an example:\n",
    "def greet(name, greeting=\"Hello\"):\n",
    "    return f\"{greeting}, {name}!\"\n",
    "\n",
    "# Calling the function with and without the second argument\n",
    "result1 = greet(\"Alice\")  # Uses the default greeting\n",
    "result2 = greet(\"Bob\", \"Hi\")  # Overrides the default greeting\n",
    "\n",
    "print(result1)  # Output: \"Hello, Alice!\"\n",
    "print(result2)  # Output: \"Hi, Bob!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Alice Smith, Age: 30, City: Unknown\n",
      "Name: Bob Johnson, Age: 25, City: Unknown\n",
      "Name: Charlie Brown, Age: 40, City: New York\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "You can also have multiple parameters with default values, and you can mix parameters with and without default values in the same function.\n",
    "However, parameters with default values should come after parameters without default values in the function definition.\n",
    "\"\"\"\n",
    "# Here's an example with multiple default arguments:\n",
    "def create_person(first_name, last_name, age=30, city=\"Unknown\"):\n",
    "    return f\"Name: {first_name} {last_name}, Age: {age}, City: {city}\"\n",
    "\n",
    "# Calling the function with and without all arguments\n",
    "result1 = create_person(\"Alice\", \"Smith\")\n",
    "result2 = create_person(\"Bob\", \"Johnson\", 25)\n",
    "result3 = create_person(\"Charlie\", \"Brown\", 40, \"New York\")\n",
    "\n",
    "print(result1)  # Output: \"Name: Alice Smith, Age: 30, City: Unknown\"\n",
    "print(result2)  # Output: \"Name: Bob Johnson, Age: 25, City: Unknown\"\n",
    "print(result3)  # Output: \"Name: Charlie Brown, Age: 40, City: New York\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Keyword Argument List\n",
    "\n",
    "In Python, you can use keyword arguments and unpacking to pass a variable number of keyword arguments to a function. Keyword arguments allow you to pass arguments to a function using the parameter name as a keyword, making the code more readable and flexible.\n",
    "\n",
    "You can use the double asterisk ** before a parameter name in the function definition to indicate that it should accept a variable number of keyword arguments. These keyword arguments are collected into a dictionary within the function, where the keys are the parameter names, and the values are the corresponding argument values.\n",
    "\n",
    "This allows you to have a flexible function that can accept a mix of regular and keyword arguments, making your code more versatile and adaptable to various use cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name: Alice\n",
      "age: 25\n",
      "city: New York\n",
      "Name: Bob\n",
      "age: 30\n",
      "city: Los Angeles\n",
      "message: I Love Python!\n"
     ]
    }
   ],
   "source": [
    "# Here's how to define a function that accepts a variable number of keyword arguments:\n",
    "\"\"\"\n",
    "def function_name(**kwargs):\n",
    "    # kwargs is a dictionary containing keyword arguments\n",
    "    # Code that uses the keyword arguments\n",
    "\"\"\"\n",
    "# You can call this function by providing any number of keyword arguments when you call it.\n",
    "def print_info(**kwargs):\n",
    "    for key, value in kwargs.items():\n",
    "        print(f\"{key}: {value}\")\n",
    "\n",
    "# Calling the function with keyword arguments\n",
    "print_info(name=\"Alice\", age=25, city=\"New York\")\n",
    "\n",
    "# You can also use a combination of regular parameters and keyword arguments in a function.\n",
    "# Just make sure that regular parameters come before keyword arguments in the function definition.\n",
    "def print_person_info(name, **kwargs):\n",
    "    print(f\"Name: {name}\")\n",
    "    for key, value in kwargs.items():\n",
    "        print(f\"{key}: {value}\")\n",
    "\n",
    "# Calling the function with a regular parameter and keyword arguments\n",
    "print_person_info(\"Bob\", age=30, city=\"Los Angeles\", message=\"I Love Python!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Lifecycle\n",
    "\n",
    "The data lifecycle in Python refers to the stages that data goes through during its lifetime in a Python program. Understanding the data lifecycle is important for managing memory efficiently and avoiding issues like memory leaks.\n",
    "\n",
    "It's important to note that Python automatically manages memory and garbage collection. However, you should be aware of these stages in the data lifecycle to write efficient code and prevent memory leaks. In some cases, you might explicitly release resources, like closing files or network connections, to ensure proper memory management. Additionally, understanding how data is created, used, and managed can help you optimize your code for performance and memory efficiency.\n",
    "\n",
    "Here are the typical stages of data in Python's data lifecycle:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42 Alice\n"
     ]
    }
   ],
   "source": [
    "# Data is created when you define a variable and assign it a value.\n",
    "\n",
    "x = 42  # Creation of an integer variable\n",
    "name = \"Alice\"  # Creation of a string variable\n",
    "\n",
    "print(x, name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The result is 10\n",
      "The square of 5 is 25\n"
     ]
    }
   ],
   "source": [
    "# Data is used in your program by performing operations on it, reading its value, or passing it to functions.\n",
    "\n",
    "# Creating a variable\n",
    "number = 5\n",
    "\n",
    "# Using the data by performing operations\n",
    "result = number * 2  # Multiplying the value of 'number' by 2\n",
    "\n",
    "# Reading the value\n",
    "print(f\"The result is {result}\")  # Printing the result\n",
    "\n",
    "# Defining a function that takes data as a parameter\n",
    "def square_and_print(value):\n",
    "    squared = value ** 2\n",
    "    print(f\"The square of {value} is {squared}\")\n",
    "\n",
    "# Passing the data to the function\n",
    "square_and_print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reference Counting\n",
    "\n",
    "In Python, reference counting is an important mechanism for managing memory. When an object's reference count drops to zero, it means there are no more references to that object, making it eligible for garbage collection.\n",
    "\n",
    "In this example:\n",
    "\n",
    "1. We create a list my_list and use sys.getrefcount() to check its reference count before creating any references.\n",
    "The reference count at this point will include the reference created by the getrefcount() function itself.\n",
    "\n",
    "2. We create a reference my_list_reference that points to the same list as my_list. This increases the reference count.\n",
    "\n",
    "3. We delete the reference my_list_reference, which reduces the reference count.\n",
    "\n",
    "4. We check the reference counts at different stages and print the results.\n",
    "\n",
    "When you run this code, you'll observe that the reference count increases when a reference is created and decreases when the reference is removed.\n",
    "The reference count is checked using sys.getrefcount() to demonstrate how Python keeps track of references to an object.\n",
    "In the end, when the original list is deleted, the reference count drops to zero, making it eligible for garbage collection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reference count before: 2\n",
      "Reference count after creating reference: 3\n",
      "Reference count after removing reference: 2\n"
     ]
    }
   ],
   "source": [
    "# Here's an example that demonstrates reference counting in Python:\n",
    "\n",
    "import sys\n",
    "\n",
    "# Creating a list and checking its reference count\n",
    "my_list = [1, 2, 3]\n",
    "ref_count_before = sys.getrefcount(my_list)\n",
    "\n",
    "# Creating a reference to the same list\n",
    "my_list_reference = my_list\n",
    "ref_count_after_reference = sys.getrefcount(my_list)\n",
    "\n",
    "# Removing the reference\n",
    "del my_list_reference\n",
    "ref_count_after_removal = sys.getrefcount(my_list)\n",
    "\n",
    "# Check reference counts\n",
    "print(\"Reference count before:\", ref_count_before)\n",
    "print(\"Reference count after creating reference:\", ref_count_after_reference)\n",
    "print(\"Reference count after removing reference:\", ref_count_after_removal)\n",
    "\n",
    "# Deleting the original list\n",
    "del my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# Some data types, like lists or dictionaries, can be modified after creation.\n",
    "# When you change the value of an existing variable, you're mutating the data.\n",
    "my_list = [1, 2, 3]\n",
    "my_list.append(4)  # Mutation of the list\n",
    "\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reassignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37\n"
     ]
    }
   ],
   "source": [
    "# Data can be reassigned to a new value, which may release the previous value from memory if there are no references left to it.\n",
    "x = 42  # Initial assignment\n",
    "x = 37  # Reassignment, old value 42 may be released if there are no references\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scope\n",
    "\n",
    "The concept of scope in Python refers to where a variable is defined and where it can be accessed or modified. Data within a function's scope exists only within the function's lifetime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a local variable\n",
      "I am a global variable\n"
     ]
    }
   ],
   "source": [
    "# Here's an example that demonstrates the scope of a variable in Python:\n",
    "\n",
    "# Global scope variable\n",
    "global_var = \"I am a global variable\"\n",
    "\n",
    "def demonstrate_scope():\n",
    "    # Local scope variable\n",
    "    local_var = \"I am a local variable\"\n",
    "    print(local_var)  # Accessing the local variable\n",
    "\n",
    "    # Accessing the global variable from within the function\n",
    "    print(global_var)\n",
    "\n",
    "# Call the function\n",
    "demonstrate_scope()\n",
    "\n",
    "# Trying to access the local variable from the global scope (will result in an error)\n",
    "# print(local_var)  # Uncommenting this line will raise a NameError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Garbage Collection\n",
    "\n",
    "In Python, garbage collection is responsible for reclaiming memory occupied by objects that are no longer referenced. When an object's reference count drops to zero, it becomes eligible for garbage collection, and Python's garbage collector deallocates the memory used by that object.\n",
    "\n",
    "Python's garbage collector is responsible for automatically deallocating memory when objects are no longer referenced, but you can also manually trigger garbage collection using gc.collect() when needed, though this is rarely necessary in typical Python programs.\n",
    "\n",
    "In this example:\n",
    "\n",
    "1. We define a class MyClass with a constructor and a destructor method (__del__). The destructor is called when an object is about to be garbage collected.\n",
    "\n",
    "2. We create two instances of MyClass, named obj1 and obj2.\n",
    "\n",
    "3. We check if the garbage collector is enabled using gc.isenabled() and print whether it's enabled or not.\n",
    "\n",
    "4. We remove references to obj1 and obj2 using the del` statement, which reduces the reference count of these objects.\n",
    "\n",
    "5. We manually run the garbage collector using gc.collect(). This triggers the garbage collector to deallocate objects with a reference count of zero.\n",
    "\n",
    "6. As a result, the destructor __del__ is called for obj1 and `obj2, and the message \"Deleting instance of...\" is printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Garbage collector enabled: True\n",
      "Deleting instance of Object 1\n",
      "Deleting instance of Object 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "194"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Here's an example that demonstrates Python's garbage collection:\n",
    "\n",
    "import gc\n",
    "\n",
    "# Create a simple class with a destructor (__del__) method\n",
    "class MyClass:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def __del__(self):\n",
    "        print(f\"Deleting instance of {self.name}\")\n",
    "\n",
    "# Create instances of MyClass\n",
    "obj1 = MyClass(\"Object 1\")\n",
    "obj2 = MyClass(\"Object 2\")\n",
    "\n",
    "# Check if the garbage collector is enabled\n",
    "gc_enabled = gc.isenabled()\n",
    "print(\"Garbage collector enabled:\", gc_enabled)\n",
    "\n",
    "# Remove references to obj1 and obj2\n",
    "del obj1\n",
    "del obj2\n",
    "\n",
    "# Manually run the garbage collector\n",
    "gc.collect() # The number of unreachable objects is returned.\n",
    "\n",
    "# At this point, the objects obj1 and obj2 have been deallocated"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Program Termination\n",
    "\n",
    "In Python, when a program terminates, all data is released, and memory is reclaimed by the operating system. This happens automatically as part of Python's cleanup process.\n",
    "\n",
    "Python's automatic memory management and garbage collection ensure that resources are efficiently managed, and memory is reclaimed when it is no longer needed, making it easier for developers to focus on writing code without worrying about manual memory management."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to Change Data Inside Functions\n",
    "\n",
    "In Python, you can change data inside functions by modifying variables. However, how you modify data depends on the type of variable you're working with. Variables in Python can be categorized into two main types: mutable and immutable. Mutable objects can be modified in place, while immutable objects cannot be changed; instead, they create new objects when you try to modify them.\n",
    "\n",
    "Here's how you can change data inside Python functions for both mutable and immutable objects:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutable Objects\n",
    "\n",
    "Mutable objects include lists, dictionaries, sets, and user-defined classes. You can modify them directly within a function because they can be changed in place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[99, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "def modify_list(my_list):\n",
    "    my_list.append(4)  # Modifying the list by adding an element\n",
    "    my_list.extend([5, 6])  # Extending the list\n",
    "    my_list[0] = 99  # Changing an element at a specific index\n",
    "\n",
    "original_list = [1, 2, 3]\n",
    "modify_list(original_list)\n",
    "print(original_list)  # The list has been modified: [99, 2, 3, 4, 5, 6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Immutable Objects\n",
    "\n",
    "Immutable objects include integers, strings, tuples, and frozen sets. These objects cannot be modified directly. When you try to change an immutable object, you create a new object.\n",
    "\n",
    "To modify an immutable object and have the changes persist outside the function, you need to return the modified object from the function and assign it to the original variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "def modify_string(my_string):\n",
    "    my_string += \" World\"  # Creating a new string\n",
    "\n",
    "original_string = \"Hello\"\n",
    "modify_string(original_string)\n",
    "print(original_string)  # The original string remains unchanged: \"Hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "def modify_string(my_string):\n",
    "    my_string += \" World\"  # Creating a new string\n",
    "    return my_string\n",
    "\n",
    "original_string = \"Hello\"\n",
    "original_string = modify_string(original_string)\n",
    "print(original_string)  # The string is modified: \"Hello World\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In summary, to change data inside Python functions:\n",
    "\n",
    "* For mutable objects, you can modify them directly within the function.\n",
    "\n",
    "* For immutable objects, you need to create a new object with the desired changes and return it from the function, then reassign it to the original variable outside the function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambda Functions\n",
    "\n",
    "In Python, a lambda function, also known as an anonymous function or a lambda expression, is a small, anonymous function that can have any number of arguments but can only have one expression. Lambda functions are often used when you need a simple function for a short period and don't want to define a formal function using the def keyword. They are commonly used for short, simple operations and as arguments for higher-order functions.\n",
    "\n",
    "Lambda functions are concise and useful for small, one-off tasks, but for more complex or reusable functionality, it's often better to use a regular named function defined with def."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "# The syntax of a lambda function is as follows:\n",
    "\"\"\"\n",
    "lambda arguments: expression\n",
    "\n",
    "Here are some key points about lambda functions:\n",
    "\n",
    "* lambda: is the keyword used to define a lambda function.\n",
    "* arguments: are the input parameters to the function.\n",
    "* expression: is a single expression that is evaluated and returned as the result of the lambda function.\n",
    "\"\"\"\n",
    "\n",
    "# Simple lambda function\n",
    "add = lambda x, y: x + y\n",
    "result = add(3, 5)\n",
    "\n",
    "print(result)  # Output: 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]\n"
     ]
    }
   ],
   "source": [
    "# Sorting a list of tuples by the second element\n",
    "pairs = [(1, 'one'), (4, 'four'), (3, 'three'), (2, 'two')]\n",
    "pairs.sort(key=lambda pair: pair[1])\n",
    "\n",
    "print(pairs)  # Output: [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Filtering a list\n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "even_numbers = list(filter(lambda x: x % 2 == 0, numbers))\n",
    "\n",
    "print(even_numbers)  # Output: [2, 4, 6, 8, 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "# Using lambda functions with map\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "squared_numbers = list(map(lambda x: x**2, numbers))\n",
    "\n",
    "print(squared_numbers)  # Output: [1, 4, 9, 16, 25]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## map() function\n",
    "\n",
    "In Python, the map() function is a built-in function used to apply a specified function to each item in an iterable (such as a list, tuple, or other iterable objects) and return an iterable (usually a map object, which is an iterator) containing the results. The purpose of map() is to transform the data in the original iterable by applying the specified function to each element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n",
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "# The basic syntax of the map() function is as follows:\n",
    "\"\"\"\n",
    "map(function, iterable)\n",
    "\n",
    "* function: A function that will be applied to each element of the iterable.\n",
    "* iterable: An iterable (e.g., a list, tuple, or other iterable) containing the data that you want to process.\n",
    "\n",
    "The map() function returns an iterator, so you often need to convert it to a list, tuple, or another iterable to see the results.\n",
    "\"\"\"\n",
    "# Here's an example of how the map() function is used:\n",
    "\n",
    "# Define a function to square a number\n",
    "def square(x):\n",
    "    return x ** 2\n",
    "\n",
    "# Create a list of numbers\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Use the map function to apply the 'square' function to each element in the 'numbers' list\n",
    "squared_numbers = map(square, numbers)\n",
    "\n",
    "# Convert the result to a list to see the squared numbers\n",
    "squared_numbers_list = list(squared_numbers)\n",
    "\n",
    "print(squared_numbers_list)\n",
    "# Output: [1, 4, 9, 16, 25]\n",
    "\n",
    "\n",
    "# You can also use map() with lambda functions for more concise code\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Using a lambda function to square each element\n",
    "squared_numbers = map(lambda x: x ** 2, numbers)\n",
    "\n",
    "squared_numbers_list = list(squared_numbers)\n",
    "print(squared_numbers_list)\n",
    "# Output: [1, 4, 9, 16, 25]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The map() function is useful for applying the same operation to all elements in an iterable, avoiding the need for explicit loops and making the code more concise and readable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## filter() function\n",
    "\n",
    "In Python, the filter() function is a built-in function that allows you to filter elements from an iterable (e.g., a list, tuple, or other iterable object) based on a specified function or condition. The filter() function returns an iterator that contains the elements for which the specified function or condition evaluates to True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n",
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# The basic syntax of the filter() function is as follows:\n",
    "\"\"\"\n",
    "filter(function, iterable)\n",
    "\n",
    "* function: A function or a lambda function that defines the condition for filtering elements.\n",
    "The function should return True for the elements you want to keep in the result.\n",
    "* iterable: An iterable containing the data that you want to filter.\n",
    "\n",
    "The filter() function returns an iterator, so you often need to convert it to a list, tuple, or another iterable to see the filtered results.\n",
    "\"\"\"\n",
    "# Here's an example of how the filter() function is used:\n",
    "\n",
    "# Define a function to check if a number is even\n",
    "def is_even(x):\n",
    "    return x % 2 == 0\n",
    "\n",
    "# Create a list of numbers\n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "# Use the filter function to filter even numbers from the 'numbers' list\n",
    "even_numbers = filter(is_even, numbers)\n",
    "\n",
    "# Convert the result to a list to see the filtered numbers\n",
    "even_numbers_list = list(even_numbers)\n",
    "\n",
    "print(even_numbers_list)\n",
    "# Output: [2, 4, 6, 8, 10]\n",
    "\n",
    "\n",
    "# You can also use filter() with lambda functions for more concise code\n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "# Using a lambda function to filter even numbers\n",
    "even_numbers = filter(lambda x: x % 2 == 0, numbers)\n",
    "\n",
    "even_numbers_list = list(even_numbers)\n",
    "print(even_numbers_list)\n",
    "# Output: [2, 4, 6, 8, 10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The filter() function is useful for selectively extracting elements from an iterable based on a specific condition or criterion, making your code more concise and readable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions as arguments of functions\n",
    "\n",
    "In Python, you can pass functions as arguments to other functions. This concept is known as higher-order functions, and it allows you to create more flexible and reusable code by treating functions as first-class citizens. You can pass functions as arguments to other functions and return functions from functions.\n",
    "\n",
    "Using functions as arguments of functions in Python allows you to create more flexible and powerful code, as it enables you to reuse functions and tailor their behavior based on specific requirements or conditions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Passing Functions as Arguments\n",
    "\n",
    "You can pass a function as an argument to another function. This is often used when you want to apply a specific operation or transformation to elements in an iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Define a function that applies another function to each element of a list\n",
    "def apply_function_to_list(func, lst):\n",
    "    result = []\n",
    "    for item in lst:\n",
    "        result.append(func(item))\n",
    "    return result\n",
    "\n",
    "# Define a function to double a number\n",
    "def double(x):\n",
    "    return x * 2\n",
    "\n",
    "# Define a list of numbers\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Pass the 'double' function as an argument to 'apply_function_to_list'\n",
    "doubled_numbers = apply_function_to_list(double, numbers)\n",
    "\n",
    "print(doubled_numbers)  # Output: [2, 4, 6, 8, 10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Returning Functions from Functions\n",
    "\n",
    "You can also return functions from functions. This is useful for creating functions that encapsulate behavior based on some conditions or configurations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# Define a function that returns a function based on a condition\n",
    "def select_operation(condition):\n",
    "    if condition == \"add\":\n",
    "        return lambda x, y: x + y\n",
    "    elif condition == \"subtract\":\n",
    "        return lambda x, y: x - y\n",
    "\n",
    "# Get the appropriate function based on the condition\n",
    "add_function = select_operation(\"add\")\n",
    "subtract_function = select_operation(\"subtract\")\n",
    "\n",
    "result1 = add_function(5, 3)  # Output: 8\n",
    "result2 = subtract_function(10, 4)  # Output: 6\n",
    "\n",
    "print(result1)\n",
    "print(result2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Functions as Key Functions\n",
    "\n",
    "You can pass functions as key functions to functions like sorted() or max(), allowing you to customize the sorting or selection criteria."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Alice', 95), ('Charlie', 92), ('Bob', 88)]\n"
     ]
    }
   ],
   "source": [
    "# Define a list of tuples\n",
    "students = [(\"Alice\", 95), (\"Bob\", 88), (\"Charlie\", 92)]\n",
    "\n",
    "# Use a lambda function as a key to sort by the second element of each tuple (the grades)\n",
    "sorted_students = sorted(students, key=lambda x: x[1], reverse=True)\n",
    "\n",
    "print(sorted_students)  # Output: [('Alice', 95), ('Charlie', 92), ('Bob', 88)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decorators\n",
    "\n",
    "Decorators are a powerful and widely used feature in Python. They allow you to modify or enhance the behavior of functions or methods without changing their code. Decorators are often used for tasks such as logging, authentication, memoization, and more.\n",
    "\n",
    "In Python, a decorator is a function that takes another function as an argument and extends the behavior of that function without explicitly modifying its source code. Decorators are typically applied using the \"@\" symbol in front of a function definition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Something is happening before the function is called.\n",
      "Hello!\n",
      "Something is happening after the function is called.\n"
     ]
    }
   ],
   "source": [
    "# Here's a basic example of a decorator:\n",
    "\"\"\"\n",
    "In this example:\n",
    "\n",
    "1. We define a decorator function my_decorator, which takes another function func as an argument.\n",
    "Inside my_decorator, we define a nested function called wrapper that wraps around func.\n",
    "\n",
    "2. The wrapper function can execute code before and after the original function func. In this case, it prints messages before and after calling func.\n",
    "\n",
    "3. We apply the my_decorator to the say_hello function using the @ symbol.\n",
    "This is equivalent to writing say_hello = my_decorator(say_hello).\n",
    "\n",
    "4. When we call say_hello, the my_decorator modifies its behavior by adding the before and after messages.\n",
    "\"\"\"\n",
    "def my_decorator(func):\n",
    "    def wrapper():\n",
    "        print(\"Something is happening before the function is called.\")\n",
    "        func()\n",
    "        print(\"Something is happening after the function is called.\")\n",
    "    return wrapper\n",
    "\n",
    "@my_decorator\n",
    "def say_hello():\n",
    "    print(\"Hello!\")\n",
    "\n",
    "say_hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Alice!\n",
      "Hello, Alice!\n",
      "Hello, Alice!\n"
     ]
    }
   ],
   "source": [
    "# Decorators can also take arguments to make them more flexible.\n",
    "# Here's an example with a decorator that takes an argument:\n",
    "\"\"\"\n",
    "In this example, the repeat decorator takes an argument n, which specifies how many times the decorated function should be repeated.\n",
    "The greet function is decorated to repeat the greeting three times when called.\n",
    "\"\"\"\n",
    "def repeat(n):\n",
    "    def decorator(func):\n",
    "        def wrapper(*args, **kwargs):\n",
    "            for _ in range(n):\n",
    "                func(*args, **kwargs)\n",
    "        return wrapper\n",
    "    return decorator\n",
    "\n",
    "@repeat(3)\n",
    "def greet(name):\n",
    "    print(f\"Hello, {name}!\")\n",
    "\n",
    "greet(\"Alice\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decorators are used extensively in Python frameworks, such as Flask, Django and FastAPI, for tasks like route handling, authentication, and more. They provide a clean and modular way to extend the behavior of functions and methods in a program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to pass arguments to decorator functions\n",
    "\n",
    "We can also pass arguments to decorator functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of 1 and 2 is 3\n"
     ]
    }
   ],
   "source": [
    "# We can also pass arguments to decorator functions:\n",
    "\n",
    "def add_numbers_decorator(input_function):\n",
    "    def function_wrapper(a, b):\n",
    "        result = 'The sum of {} and {} is {}'.format(\n",
    "            a, b, input_function(a, b))  # calling the input function with arguments\n",
    "        return result\n",
    "    return function_wrapper\n",
    "\n",
    "@add_numbers_decorator\n",
    "def add_numbers(a, b):\n",
    "    return a + b\n",
    "\n",
    "print(add_numbers(1, 2))  # The sum of 1 and 2 is 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to stack decorators\n",
    "\n",
    "In Python, you can stack multiple decorators on a single function to apply multiple transformations or behaviors to that function. Stacking decorators is a way to modularize and extend the functionality of your functions. The order in which you stack decorators matters because decorators are applied from the innermost to the outermost.\n",
    "\n",
    "Here's how to stack decorators in Python:\n",
    "\n",
    "1. Define your decorators: Create multiple decorator functions, each with its own behavior.\n",
    "\n",
    "2. Apply the decorators to a function: Stack the decorators on top of a function by placing them one above the other using the @ symbol.\n",
    "\n",
    "3. Call the decorated function: When you call the decorated function, the decorators are applied in the order they were stacked."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO, ALICE UPPER! EXCLAMATION\n",
      "HELLO, PEDRO! EXCLAMATION UPPER\n"
     ]
    }
   ],
   "source": [
    "# Here's an example of stacking decorators on a function\n",
    "\n",
    "# First decorator\n",
    "def uppercase_decorator(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        result = func(*args, **kwargs)\n",
    "        return result.upper() +  \" UPPER\"\n",
    "    return wrapper\n",
    "\n",
    "# Second decorator\n",
    "def exclamation_decorator(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        result = func(*args, **kwargs)\n",
    "        return f\"{result}!\" + \" EXCLAMATION\"\n",
    "    return wrapper\n",
    "\n",
    "\n",
    "# Apply decorators to a function\n",
    "@exclamation_decorator  # outermost\n",
    "@uppercase_decorator    # innermost\n",
    "def greet(name):\n",
    "    return f\"Hello, {name}\"\n",
    "\n",
    "# Call the decorated function\n",
    "result = greet(\"Alice\")\n",
    "print(result)  # Output: \"HELLO, ALICE UPPER! EXCLAMATION\"\n",
    "\n",
    "\n",
    "# Apply decorators to a function\n",
    "@uppercase_decorator    # outermost\n",
    "@exclamation_decorator  # innermost\n",
    "def greet(name):\n",
    "    return f\"Hello, {name}\"\n",
    "\n",
    "# Call the decorated function\n",
    "result = greet(\"Pedro\")\n",
    "print(result)  # Output: \"HELLO, PEDRO! EXCLAMATION UPPER\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can stack as many decorators as needed to achieve the desired functionality for your functions. Just remember that the order of stacking affects the order in which the decorators are applied."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-in decorators\n",
    "\n",
    "Python has several built-in decorators that provide useful functionality when applied to functions or methods. These built-in decorators help you with tasks like managing function behavior, access control, and more. Here are some of the most commonly used built-in decorators in Python:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### @staticmethod\n",
    "\n",
    "This decorator is used to define a static method within a class. Static methods are bound to the class and not to an instance of the class. They can be called on the class itself and do not have access to instance-specific attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a static method\n"
     ]
    }
   ],
   "source": [
    "# @staticmethod\n",
    "class MyClass:\n",
    "    @staticmethod\n",
    "    def static_method():\n",
    "        print(\"This is a static method\")\n",
    "\n",
    "MyClass.static_method()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### @classmethod\n",
    "\n",
    "This decorator defines a class method within a class. Class methods are bound to the class and can access or modify class-level attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class variable: 42\n"
     ]
    }
   ],
   "source": [
    "# @classmethod\n",
    "class MyClass:\n",
    "    class_variable = 42\n",
    "\n",
    "    @classmethod\n",
    "    def class_method(cls):\n",
    "        print(f\"Class variable: {cls.class_variable}\")\n",
    "\n",
    "MyClass.class_method()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### @property\n",
    "\n",
    "This decorator allows you to define a method that can be accessed like an attribute. It's used to create getter methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# @property\n",
    "class Circle:\n",
    "    def __init__(self, radius):\n",
    "        self._radius = radius\n",
    "\n",
    "    @property\n",
    "    def radius(self):\n",
    "        return self._radius\n",
    "\n",
    "c = Circle(5)\n",
    "print(c.radius)  # Accessing radius like an attribute"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### @{property_name}.setter\n",
    "\n",
    "This decorator is used in conjunction with the @{property_name} decorator to create a setter method for a property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "# @{property_name}.setter\n",
    "class Circle:\n",
    "    def __init__(self, radius):\n",
    "        self._radius = radius\n",
    "\n",
    "    @property\n",
    "    def radius(self):\n",
    "        return self._radius\n",
    "\n",
    "    @radius.setter\n",
    "    def radius(self, value):\n",
    "        if value < 0:\n",
    "            raise ValueError(\"Radius cannot be negative\")\n",
    "        self._radius = value\n",
    "\n",
    "c = Circle(5)\n",
    "c.radius = 7  # Using the setter\n",
    "\n",
    "print(c.radius)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### @{property_name}.deleter\n",
    "\n",
    "This decorator is used with @{property_name} to create a deleter method for a property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Deleting the radius property\n"
     ]
    }
   ],
   "source": [
    "# @{property_name}.deleter\n",
    "class Circle:\n",
    "    def __init__(self, radius):\n",
    "        self._radius = radius\n",
    "\n",
    "    @property\n",
    "    def radius(self):\n",
    "        return self._radius\n",
    "\n",
    "    @radius.deleter\n",
    "    def radius(self):\n",
    "        print(\"Deleting the radius property\")\n",
    "        del self._radius\n",
    "\n",
    "c = Circle(5)\n",
    "del c.radius  # Using the deleter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### @abstractmethod\n",
    "\n",
    "This decorator is part of the abc (Abstract Base Classes) module. It is used to define abstract methods within an abstract class. Subclasses are required to provide an implementation for abstract methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_abstract_method implemented\n"
     ]
    }
   ],
   "source": [
    "# @abstractmethod\n",
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class MyAbstractClass(ABC):\n",
    "    @abstractmethod\n",
    "    def my_abstract_method(self):\n",
    "        pass\n",
    "\n",
    "class OtherClass(MyAbstractClass):\n",
    "    def my_abstract_method(self):   # Must be implemented\n",
    "        print(\"my_abstract_method implemented\")\n",
    "\n",
    "my_obj = OtherClass()\n",
    "my_obj.my_abstract_method()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are some of the commonly used built-in decorators in Python, each serving a different purpose. You can use them to modify or enhance the behavior of functions, methods, or classes in your code."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}