P-E-functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b3c0145c",
   "metadata": {},
   "source": [
    "# Python: Everything\n",
    "- 28) **Functions** \n",
    "    - Definition of a function\n",
    "    - Example: Compute factorial of an integer\n",
    "    - Calling by-reference or by-value in function calling\n",
    "    - Example: Compute Fibonacci numbers\n",
    "    - Having a variable number of arguments\n",
    "    - Having a variable number of keyword arguments\n",
    "<br>----------------------------------------------\n",
    "<br> https://www.pinterest.com/HamedShahHosseini/programming-languages/\n",
    "<br>https://github.com/ostad-ai/Python-Everything"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5aa91cce",
   "metadata": {},
   "source": [
    "**Functions:** are pieces of codes which are only run when we call them. A function definition begins with keyword *def*. \n",
    "<br>A function may have zero or more arguments.\n",
    "<br>A function may also send values by keyword *return*.\n",
    "<br> The following function computes the **Factorial** of an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "568f3eb5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Factorial(5) is 120\n"
     ]
    }
   ],
   "source": [
    "def facto(n):\n",
    "    result=1\n",
    "    if n==0 or n==1:\n",
    "        pass\n",
    "    else:\n",
    "        for i in range(2,n+1):\n",
    "            result*=i\n",
    "    return result\n",
    "n=5\n",
    "print(f'Factorial({n}) is {facto(n)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35474859",
   "metadata": {},
   "source": [
    "<br>**Hint:** arguments send to a function can be changed inside a function, if the arguments are mutable objects such as lists, dictionary, and sets. Therefore, they are called **by-reference**. In contrast, passing immutable objects as arguments to a functions, we pass them **by value**; so any change inside the function will have no effect outside the function.\n",
    "<br>**Mutable:** an object is called mutable if its value can be modified or changed after it is created. Examples are: lists, sets, and dictionaries.\n",
    "<br>**Immutable:** is an object that once it is created, it cannot be modified. Examples are numbers, strings, and tuples."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1ade53a",
   "metadata": {},
   "source": [
    "Example below shows a function definiton that gets a list and changes it inside"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c819d4a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List before calling by reference: ['Hello']\n",
      "List after calling by reference: ['Hello', 'World']\n"
     ]
    }
   ],
   "source": [
    "def change_list(my):\n",
    "    my.append('World')\n",
    "\n",
    "mylist=['Hello']\n",
    "print(f'List before calling by reference: {mylist}')\n",
    "change_list(mylist)\n",
    "print(f'List after calling by reference: {mylist}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9746c031",
   "metadata": {},
   "source": [
    "Example here shows a fucntion that gets a number, changes it isnide fucntion, but it has n oeffect on the number outside the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "94ba4365",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number before calling function: 25\n",
      "Number inside function: 26\n",
      "Number after calling function: 25\n"
     ]
    }
   ],
   "source": [
    "def change_number(number):\n",
    "    number+=1;\n",
    "    print(f'Number inside function: {number}')\n",
    "number=25\n",
    "print(f'Number before calling function: {number}')\n",
    "change_number(number)\n",
    "print(f'Number after calling function: {number}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80294988",
   "metadata": {},
   "source": [
    "Let's define a function to compute numbers in Fibonacci series. We can have **default values** for arguments in the definition of function, as shown below.\n",
    "<br> $F_0=0, F_1=1,$\n",
    "<br>and $F_n=F_{n-1}+F_{n-2}$ for $n>1$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "0ca133a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fibonacci numbers: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n",
      "Fibonacci numbers: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n",
      "Fibonacci numbers: [0, 1, 1, 2, 3, 5, 8, 13]\n"
     ]
    }
   ],
   "source": [
    "def fibo(n=10):\n",
    "    result=[]\n",
    "    f0,f1=0,1\n",
    "    while len(result)<n:\n",
    "        result.append(f0)\n",
    "        f0,f1=f1,f0+f1\n",
    "    return result\n",
    "# calling function without argument means that \n",
    "# the default value for argument is used\n",
    "print(f'Fibonacci numbers: {fibo()}')\n",
    "# setting values for arguments in function call\n",
    "print(f'Fibonacci numbers: {fibo(12)}')\n",
    "# setting values for arguments via kwarg=value\n",
    "print(f'Fibonacci numbers: {fibo(n=8)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6165847",
   "metadata": {},
   "source": [
    "A function may have a variable number of arguments, by putting a * before the argument name. Example below multiplies a variable number of arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b2c7aee2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Three numbers to multiply: 6\n",
      "Three numbers to multiply: 56\n"
     ]
    }
   ],
   "source": [
    "def mult(*args):\n",
    "    result=1\n",
    "    for arg in args:\n",
    "        result*=arg\n",
    "    return result\n",
    "print(f'Three numbers to multiply: {mult(2,3)}')\n",
    "print(f'Three numbers to multiply: {mult(7,2,4)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1a64f12",
   "metadata": {},
   "source": [
    "Another example for a variable number of arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "22275727",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello.World\n",
      "See.You.Bye\n"
     ]
    }
   ],
   "source": [
    "def concat(*args,separator='.'):\n",
    "    return separator.join(args)\n",
    "print(concat('Hello','World'))\n",
    "print(concat('See','You','Bye'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5353c8ff",
   "metadata": {},
   "source": [
    "We can also have a variable number of keyword arguments by putting a ** before name of the argument. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "f956e098",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value of sine(0) is 0.0\n",
      "Value of sine(1) is 0.8414709848078965\n",
      "Value of sine(2) is 0.9092974268256817\n",
      "Value of cosine(0) is 1.0\n",
      "Value of cosine(1) is 0.5403023058681397\n",
      "Value of cosine(2) is -0.4161468365471424\n"
     ]
    }
   ],
   "source": [
    "from math import sin,cos\n",
    "def operation(*args,**kwargs):\n",
    "    for key,value in kwargs.items():\n",
    "        for arg in args:\n",
    "            print(f'Value of {key}({arg}) is {value(arg)}')\n",
    "\n",
    "operation(0,1,2,sine=sin,cosine=cos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1004dd57",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}