Functions.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyM/MXlEgZDtHNrSUSk1UMyX",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/alirezasaharkhiz9/MyPythonWorkshop-at-FerdowsiUniversity/blob/main/Functions.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Functions\n",
        "\n",
        "### Introduction to Functions\n",
        "This lecture will consist of explaining what a function is in Python and how to create one. Functions will be one of our main building blocks when we construct larger and larger amounts of code to solve problems.\n",
        "\n",
        "### What is a function?\n",
        "Formally, a function is a useful device that groups together a set of statements so they can be run more than once. They can also let us specify parameters that can serve as inputs to the functions.\n",
        "\n",
        "On a more fundamental level, functions allow us to not have to repeatedly write the same code again and again. If you remember back to the lessons on strings and lists, remember that we used a function len() to get the length of a string. Since checking the length of a sequence is a common task you would want to write a function that can do this repeatedly at command.\n",
        "\n",
        "Functions will be one of most basic levels of reusing code in Python, and it will also allow us to start thinking of program design (we will dive much deeper into the ideas of design when we learn about Object Oriented Programming).\n",
        "\n",
        "\n",
        "### Why even use functions?\n",
        "Put simply, you should use functions when you plan on using a block of code multiple times. The function will allow you to call the same block of code without having to write it multiple times. This in turn will allow you to create more complex Python scripts. To really understand this though, we should actually write our own functions!\n",
        "\n",
        "## Function Topics\n",
        "- def keyword\n",
        "- parameters, arguments\n",
        "- Default parameters\n",
        "- Using return\n",
        "- What is the difference between return and print?\n",
        "- DocStrings\n",
        "- Clean Code\n",
        "- *args and double *kwargs\n",
        "- Scope\n",
        "- Lambda Expressions\n",
        "- Built-in Functions"
      ],
      "metadata": {
        "id": "EoaaeMgLE_sP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# print()\n",
        "# max()\n",
        "# sorted()"
      ],
      "metadata": {
        "id": "vT2Rmo30u_CQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## def keyword"
      ],
      "metadata": {
        "id": "-llpqbNSJwA9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# def function_name():\n",
        "#   dastorat"
      ],
      "metadata": {
        "id": "_E0NbSTiv2mL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "saDD9dvtD-mP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a4b1509f-13c1-4d26-ed8a-decf97cf739f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "alireza saharkhiz\n"
          ]
        }
      ],
      "source": [
        "def printName():\n",
        "  print('alireza saharkhiz')\n",
        "\n",
        "printName()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_number():\n",
        "  print(50+50)\n",
        "\n",
        "sum_number()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LkOtJDkMwjzR",
        "outputId": "0d007b23-0f89-4a72-d6f8-db177d3317dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "100\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## parameters, arguments"
      ],
      "metadata": {
        "id": "nQOSxLzoJyc3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_number(a, b):\n",
        "  print(a+b)\n",
        "\n",
        "sum_number(10, 20)"
      ],
      "metadata": {
        "id": "u-MW4iiJJ0mW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9add1448-821e-4551-ae64-285ff47869a4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "30\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_number(number):\n",
        "  print(number + 10)\n",
        "\n",
        "sum_number(number=210)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5gYZLS96xfue",
        "outputId": "554b81a5-48b0-475a-efe3-78c5a4e8665f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "220\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Default parameters"
      ],
      "metadata": {
        "id": "WbMXCdteJ0-9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_number(number=10):\n",
        "  print(number + 10)\n",
        "\n",
        "sum_number(20)"
      ],
      "metadata": {
        "id": "6OhG3XhOJ3W9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "44e3943f-a7d4-46ac-a54d-0ba611485b5d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "30\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Using return\n",
        "\n",
        "So far we've only seen print() used, but if we actually want to save the resulting variable we need to use the return keyword.\n",
        "\n",
        "Let's see some example that use a return statement. return allows a function to return a result that can then be stored as a variable, or used in whatever manner a user wants."
      ],
      "metadata": {
        "id": "43qFHxzZJ3yu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_number(number):\n",
        "  return number + 10\n",
        "\n",
        "x = sum_number(20)\n",
        "print(x)"
      ],
      "metadata": {
        "id": "uXTD4l-jJ5z5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "57d6f21c-f7d9-4322-e800-efd5d6bef281"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "30\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## What is the difference between return and print?\n",
        "\n",
        "The return keyword allows you to actually save the result of the output of a function as a variable. The print() function simply displays the output to you, but doesn't save it for future use. Let's explore this in more detail\n",
        "\n"
      ],
      "metadata": {
        "id": "e62LplEdJ6Ja"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_number(number):\n",
        "  return number + 10\n",
        "\n",
        "x = sum_number(20)\n",
        "print(x)"
      ],
      "metadata": {
        "id": "jo3o-Eb7J95q",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4bc087bb-4ff1-4846-9a20-fc01ad8ad95b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "30\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_number(number):\n",
        "  print(number + 10)\n",
        "\n",
        "x = sum_number(20)\n",
        "print(x)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AK-du5gYzAvV",
        "outputId": "5ffd4ff6-fe5c-4b74-bd29-ff094430487b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "30\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## DocStrings"
      ],
      "metadata": {
        "id": "Frnj8Y69J-N_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def info():\n",
        "  return 'alireza saharkhiz'\n",
        "\n",
        "x = info()\n",
        "print(x)"
      ],
      "metadata": {
        "id": "kNRiNc_sKCXg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a7a054e6-c0f6-46b3-d097-53266378d931"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "alireza saharkhiz\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print()"
      ],
      "metadata": {
        "id": "TzhWTfl4oZs5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def info():\n",
        "\n",
        "  '''\n",
        "  this function return my name\n",
        "  '''\n",
        "\n",
        "  return 'alireza saharkhiz'\n",
        "\n",
        "x = info()\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OsGc41RdouFL",
        "outputId": "5587d5be-9cea-4c49-f3d9-cb4c0f0b4c4a"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "alireza saharkhiz\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def minMax(myList):\n",
        "  '''\n",
        "  this function return min and max number in list\n",
        "  '''\n",
        "  return min(myList), max(myList)\n",
        "\n",
        "x = minMax([10, 20, 30, 40, 50])\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QXUBGSSKpOGW",
        "outputId": "c8a2e7ea-9128-49b0-c9fe-43b85ef1c48f"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(10, 50)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Clean Code"
      ],
      "metadata": {
        "id": "mQ2RV0oQKCrp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def isEven(num):\n",
        "  if num % 2 == 0:\n",
        "    return True\n",
        "  else:\n",
        "    return False\n",
        "\n",
        "x = isEven(3)\n",
        "print(x)"
      ],
      "metadata": {
        "id": "oIp92yUcKGVU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e0565615-624b-4e89-86c0-2f00ce746ae0"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def isEven(num):\n",
        "  return num % 2 == 0\n",
        "\n",
        "x = isEven(3)\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r244wcq5q83B",
        "outputId": "36ba0e8d-1b9f-4841-968e-42fe3658aa55"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## args and kwargs\n",
        "\n",
        "args: When a function parameter starts with an asterisk, it allows for an arbitrary number of arguments, and the function takes them in as a tuple of values.\n",
        "\n",
        "kwargs: Similarly, Python offers a way to handle arbitrary numbers of keyworded arguments. Instead of creating a tuple of values, **kwargs builds a dictionary of key/value pairs."
      ],
      "metadata": {
        "id": "yicgrNAEKF9_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_number(a, b, c):\n",
        "  return a + b + c\n",
        "\n",
        "\n",
        "x = sum_number(4, 3, 1)\n",
        "print(x)"
      ],
      "metadata": {
        "id": "hmky6Sb3KLEq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3f323ea8-4e1c-409c-c56d-3bbed3ce22b9"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_number(*args):\n",
        "  return args\n",
        "\n",
        "x = sum_number(4, 3, 1, 2, 3)\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A2CwYIP0sPiB",
        "outputId": "28906f8a-3ed4-4a0d-ec61-d973a78e929e"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(4, 3, 1, 2)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_number(*args):\n",
        "  result = 0\n",
        "  # args (4, 3, 1, 2, 3)\n",
        "  for i in args:\n",
        "    # i = 4\n",
        "    # i = 3\n",
        "    result += i\n",
        "  return result\n",
        "\n",
        "x = sum_number(4, 3, 7)\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sePzf5F0sutM",
        "outputId": "3ccdd00e-4151-4968-c4dc-9ad6542d33bc"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "14\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# **kwargs\n",
        "\n",
        "def info(**kwargs):\n",
        "  return kwargs.keys()\n",
        "\n",
        "x = info(name='alireza', family='saharkhiz')\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nYnlVsFztQQB",
        "outputId": "7a08d758-3127-4cba-9894-5425386929d9"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dict_keys(['name', 'family'])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Scope\n",
        "\n",
        "#### local variable\n",
        "#### global variable"
      ],
      "metadata": {
        "id": "9J1ACpSqKNVw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 15\n",
        "\n",
        "def a():\n",
        "  x = 10\n",
        "  return x\n",
        "\n",
        "print(a())\n",
        "print(x)"
      ],
      "metadata": {
        "id": "PFCNV4qNKOSu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "89b4535a-5a7d-4098-a7e1-cf963630ba30"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = 15\n",
        "\n",
        "def a():\n",
        "  global x\n",
        "  x = 10\n",
        "  return x\n",
        "\n",
        "print(a())\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7SoGdhO8vdpQ",
        "outputId": "98a83981-c538-4dd3-8b37-c9d9792112d0"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x=15\n",
        "x=10\n",
        "x=20"
      ],
      "metadata": {
        "id": "0_soYhT-xHKg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Lambda Expressions\n",
        "One of Pythons most useful (and for beginners, confusing) tools is the lambda expression. lambda expressions allow us to create \"anonymous\" functions. This basically means we can quickly make ad-hoc functions without needing to properly define a function using def."
      ],
      "metadata": {
        "id": "aiLMJXa1KQYG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lambda parameters: dastorat"
      ],
      "metadata": {
        "id": "sSgBVbAkKRdU"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = lambda a: a ** 2\n",
        "print(x(3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JOVc9wNFyDAh",
        "outputId": "bc436a06-7c6d-40c2-9d48-78299bac31f6"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def x(a):\n",
        "  return a ** 2\n",
        "\n",
        "print(x(3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IDIukO2yyQYv",
        "outputId": "e8a840f8-06fe-408f-cc19-00153f6471d3"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Built-in Functions"
      ],
      "metadata": {
        "id": "ZMvBpjWhKT7H"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### map()"
      ],
      "metadata": {
        "id": "WSFGfQLuL8lC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "myList = [4, 5, 3, 2, 1]\n",
        "\n",
        "x = map(lambda a: a**2, myList)\n",
        "print(list(x))\n",
        "\n",
        "x = map(lambda a: a + 10, myList)\n",
        "print(list(x))"
      ],
      "metadata": {
        "id": "kkSQ8bqOKUzU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c3ee233b-1905-460a-998b-60e34907d324"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[16, 25, 9, 4, 1]\n",
            "[14, 15, 13, 12, 11]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### filter()"
      ],
      "metadata": {
        "id": "33n8u2v7L-2m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = filter(lambda a: a % 2 == 0, myList)\n",
        "print(list(x))"
      ],
      "metadata": {
        "id": "tO3Hy7MxMCEy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7082755d-fc14-4540-8edc-10637eb0baf2"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[4, 2]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = filter(lambda a: a > 3, myList)\n",
        "print(list(x))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v1ymo04N0D51",
        "outputId": "8c9a83cb-bd90-41a2-cf1d-352dd286bd63"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[4, 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = 'AliReza SaharKhiz'\n",
        "\n",
        "x = filter(lambda a: a.isupper(), x)\n",
        "print(list(x))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rqTrxohD0xCu",
        "outputId": "8ba5e73f-6db8-4344-808f-046d25adce75"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['A', 'R', 'S', 'K']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = 'AliReza SaharKhiz'\n",
        "\n",
        "x = map(lambda a: a.upper(), x)\n",
        "print(list(x))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Nz2x4qCM1sEh",
        "outputId": "ac875192-c5bf-46f8-8720-4053deb516d5"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['A', 'L', 'I', 'R', 'E', 'Z', 'A', ' ', 'S', 'A', 'H', 'A', 'R', 'K', 'H', 'I', 'Z']\n"
          ]
        }
      ]
    }
  ]
}