P04.0_Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computer Programming with Python\n",
    "\n",
    "#### Instructor : Dr. Aydin Demir\n",
    "\n",
    "www.aydindemir.com | GitHub & Instagram: @craxLab | Web: www.craxLab.com\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### _The topics of the week !_\n",
    "\n",
    "- Functions\n",
    "      \n",
    "A function is a code block written to carry out a specified task, which similar with modules. Functions define in the code body, no need to import. They are generally not predefined modules. \n",
    "\n",
    "You can install a new module you need by simply using \"pip\" and call it by using \"import\" command. But you may need more complicated or specific problem to solve, than you may need your own module. \n",
    "\n",
    "With the help of **\"Functions\"**, a program break into smaller codes. So, as your program becomes longer, \"Functions\" help you to manage and organize a readable code. You can all a function more than once."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _How Functions work in Python?_\n",
    "\n",
    "There are three types of functions in Python;\n",
    "\n",
    "## 1. Built-in Functions :\n",
    "\n",
    "These functions are always available. No need to import any module. Such as: abs(), bool(), eval(), max(), print(), help(), sum(), type().\n",
    "\n",
    "For the full list of Built-in functions, visit --> https://docs.python.org/3/library/functions.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sakarya\n"
     ]
    }
   ],
   "source": [
    "print(\"Sakarya\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "-6\n"
     ]
    }
   ],
   "source": [
    "liste = [1,2,5,6,-4,-6]\n",
    "print(max(liste))\n",
    "print(min(liste))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Used-Defined Functions (UDFs) :\n",
    "\n",
    "- A Function starts with **_\" def \"_** keyword and a colon **_\" (:) \"_** marks the end of header line. \n",
    "\n",
    "- Functions name should be unique.\n",
    "\n",
    "- They might or might not need multiple inputs, which are called Parameters or Arguments: information that are passed into a function. A parameter is the variable listed inside the paranthesis and Argument is the value that sent to the function.\n",
    "\n",
    "- It ends with **_\" return \"_** statement if it should output something, otherwise, it will return an object None. The **_\" return \"_** statement is also used to exit a function. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./Figures/def_func.png\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Syntax:**\n",
    "\n",
    "def function_name(arguments/parameters):\n",
    "\n",
    "> \"function_docstring\"\n",
    "\n",
    "> statement(s)                  # is called the body of the function\n",
    "\n",
    "> return [expression]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Define a Function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def welcome(name):\n",
    "    print(f\"Welcome {name}\")\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Call a Function**\n",
    "\n",
    "Use the function name and parenthesis as shown in the example below, to call a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome Ali\n",
      "Welcome Ayşe\n",
      "Welcome Mehmet\n"
     ]
    }
   ],
   "source": [
    "welcome(\"Ali\")\n",
    "welcome(\"Ayşe\")\n",
    "welcome(\"Mehmet\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets define a square function calculating square of a given number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2025"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def kare(x):\n",
    "    y = x**2\n",
    "    return y\n",
    "\n",
    "kare(-45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8100"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# or, other syntax\n",
    "def kare(x):\n",
    "    return x**2\n",
    "\n",
    "kare(90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Function docstring:**\n",
    "\n",
    "A Python docstring is a string used to document a Python module, class, function or method, so programmers can understand what it does without having to read the details of the implementation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def kare(x):\n",
    "    \"\"\"Girilen sayının karesini alan fonksiyon\n",
    "    girilen sayı x, sonuç y\"\"\"\n",
    "    y = x**2\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function kare in module __main__:\n",
      "\n",
      "kare(x)\n",
      "    Girilen sayının karesini alan fonksiyon\n",
      "    girilen sayı x, sonuç y\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(kare)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function print in module builtins:\n",
      "\n",
      "print(...)\n",
      "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "    \n",
      "    Prints the values to a stream, or to sys.stdout by default.\n",
      "    Optional keyword arguments:\n",
      "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "    sep:   string inserted between values, default a space.\n",
      "    end:   string appended after the last value, default a newline.\n",
      "    flush: whether to forcibly flush the stream.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# help(range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Multiple Arguments**\n",
    "\n",
    "Its important to call function with correct number of arguments. Meaning that; the number of the arguments that function expects should be equal to the number of arguments that you call in function.\n",
    "\n",
    "**function_name([arguments])**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example:** A function calculating moment of inertia of a rectangular section\n",
    "\n",
    "<img src=\"./Figures/Examples/Ix.png\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "112500.0\n",
      "135000.0\n",
      "520833.3333333333\n",
      "27462500.0\n"
     ]
    }
   ],
   "source": [
    "def atalet(b, h):\n",
    "    Ix = b*h**3/12\n",
    "    return Ix\n",
    "\n",
    "print(atalet(50,30))\n",
    "print(atalet(60,30))\n",
    "print(atalet(50,50))\n",
    "print(atalet(150,130))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The \"return\" Statement**\n",
    "\n",
    "Simply it prints the result to the console. But, if you want to assign the result to a variable, the return statement sends a result back to the caller and exist the function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(112500.0, 312500.0, 1500)\n",
      "(135000.0, 540000.0, 1800)\n",
      "(520833.3333333333, 520833.3333333333, 2500)\n",
      "(27462500.0, 36562500.0, 19500)\n"
     ]
    }
   ],
   "source": [
    "def atalet(b, h):\n",
    "    Ix = b*h**3/12\n",
    "    Iy = h*b**3/12\n",
    "    A = h*b\n",
    "    return Ix, Iy, A\n",
    "\n",
    "print(atalet(50,30))\n",
    "print(atalet(60,30))\n",
    "print(atalet(50,50))\n",
    "print(atalet(150,130))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "112500.0\n",
      "312500.0\n",
      "1500\n",
      "Ix = 112500.0 cm4, Iy = 312500.0 cm4, A = 1500 cm2\n"
     ]
    }
   ],
   "source": [
    "Ix1, Iy1, A1 = atalet(50,30)\n",
    "\n",
    "print(Ix1)\n",
    "print(Iy1)\n",
    "print(A1)\n",
    "print(f\"Ix = {Ix1} cm4, Iy = {Iy1} cm4, A = {A1} cm2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### _Arguments_\n",
    "\n",
    "We already learned what is \"Argument\" stands for above. Its important to call function with correct number of arguments. Meaning that; the number of the arguments that function expects should be equal to the number of arguments that you call in function.\n",
    "\n",
    "**There are four types of Arguments;**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1. Positional Arguments** (also called \"Required Arguments\")\n",
    "\n",
    "The number of arguments in the function has to be in correct positional order and should match with the function definition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ix = 112500.0 cm4, Iy = 312500.0 cm4, A = 1500 cm2\n",
      "Ix = 312500.0 cm4, Iy = 112500.0 cm4, A = 1500 cm2\n"
     ]
    }
   ],
   "source": [
    "# the change in order will effect the result\n",
    "def atalet(b, h):\n",
    "    Ix = b*h**3/12\n",
    "    Iy = h*b**3/12\n",
    "    A = h*b\n",
    "    return Ix, Iy, A\n",
    "\n",
    "Ix1, Iy1, A1 = atalet(50,30)\n",
    "print(f\"Ix = {Ix1} cm4, Iy = {Iy1} cm4, A = {A1} cm2\")\n",
    "\n",
    "Ix1, Iy1, A1 = atalet(30,50)\n",
    "print(f\"Ix = {Ix1} cm4, Iy = {Iy1} cm4, A = {A1} cm2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. Default Arguments**\n",
    "\n",
    "Assumes a default value if a value is not provided in the function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Two argument is given one of them is \"default\", function asks for only one:_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "98.10000000000001\n"
     ]
    }
   ],
   "source": [
    "# F = m*a\n",
    "\n",
    "def force(m, a):\n",
    "    F = m*a\n",
    "    return F\n",
    "\n",
    "print(force(10, 9.81))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "98.10000000000001\n"
     ]
    }
   ],
   "source": [
    "def force(m, a=9.81):\n",
    "    F = m*a\n",
    "    return F\n",
    "\n",
    "print(force(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "98.10000000000001\n"
     ]
    }
   ],
   "source": [
    "def force(m):\n",
    "    F = m*9.81\n",
    "    return F\n",
    "\n",
    "print(force(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Default argument should follow non-default argument:_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "non-default argument follows default argument (321366172.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"C:\\Users\\drayd\\AppData\\Local\\Temp\\ipykernel_1948\\321366172.py\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    def force( a=9.81, m):\u001b[0m\n\u001b[1;37m                        ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m non-default argument follows default argument\n"
     ]
    }
   ],
   "source": [
    "def force( a=9.81, m):\n",
    "    F = m*a\n",
    "    return F\n",
    "\n",
    "print(force(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(33333.333333333336, 208333.33333333334, 1000)\n"
     ]
    }
   ],
   "source": [
    "def atalet(b, h=20):\n",
    "    Ix = b*h**3/12\n",
    "    Iy = h*b**3/12\n",
    "    A = h*b\n",
    "    return Ix, Iy, A\n",
    "\n",
    "print(atalet(50))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Change the default argument:_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(266666.6666666667, 416666.6666666667, 2000)\n"
     ]
    }
   ],
   "source": [
    "print(atalet(50, 40))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. Keyword Arguments**\n",
    "\n",
    "- If you don't want to keep the right order of parameters in your mind, its easy way to identify arguments by using parameter names.\n",
    "\n",
    "- if you send the arguments with the key = value syntax, the order of the arguments doesn't matter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(416666.6666666667, 266666.6666666667, 2000)\n",
      "(416666.6666666667, 266666.6666666667, 2000)\n"
     ]
    }
   ],
   "source": [
    "print(atalet(h=50, b=40))\n",
    "print(atalet(b=40, h=50))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4. Arbitrary Arguments**\n",
    "\n",
    "If you don't have any idea about the exact number of arguments to call the function, then you can use **\" *args \"** syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INM210\n",
      "INM350\n",
      "INM210\n",
      "INM350\n",
      "INM450\n",
      "INM285\n"
     ]
    }
   ],
   "source": [
    "def dersler(*args):\n",
    "    for i in args:\n",
    "        print(i)\n",
    "        \n",
    "dersler(\"INM210\", \"INM350\")\n",
    "dersler(\"INM210\", \"INM350\",\"INM450\",\"INM285\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(50, 30)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "112500.0"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# No need to use *args\n",
    "def atalet(*boyut):\n",
    "    print(boyut)\n",
    "    Ix = boyut[0]*boyut[1]**3/12\n",
    "    return Ix\n",
    "    \n",
    "atalet(50,30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5. No Argument**\n",
    "\n",
    "Functions can be defined without an argument. Only statements in the functions run.\n",
    "\n",
    "_Lets define a function that checks even a number is positive or negative:_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bir sayı giriniz:-48\n",
      "sayı negatiftir\n"
     ]
    }
   ],
   "source": [
    "def test():\n",
    "    sayi = float(input(\"Bir sayı giriniz:\"))\n",
    "    if sayi >= 0:\n",
    "        print(\"sayı pozitiftir\")\n",
    "    else: print(\"sayı negatiftir\")\n",
    "        \n",
    "test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### _Global and Local Variables_\n",
    "\n",
    "A variable declared inside a function is called **_local variable_**, while a variable not bound to any function but can be accessed outside the function is called **_global variable_**.\n",
    "\n",
    "\n",
    "* Fonsksiyonlardaki değişkenlere dışardan erişilemez, erişilmesini istediğimiz değişkenleri return() içine yazarak döneriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "98.10000000000001\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'g' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_1948\\711032735.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0magirlik\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 10\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mg\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'g' is not defined"
     ]
    }
   ],
   "source": [
    "# W = m*g\n",
    "\n",
    "def agirlik(m):\n",
    "    g = 9.81\n",
    "    W = m*g\n",
    "    return W\n",
    "\n",
    "print(agirlik(10))\n",
    "\n",
    "print(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A variable declared outside the function is the global variable by default. Python provides the **_global_** keyword to use global variable inside the function. If we don't use the global keyword, the function treats it as a local variable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "98.10000000000001\n",
      "9.81\n"
     ]
    }
   ],
   "source": [
    "def agirlik(m):\n",
    "    global g\n",
    "    g = 9.81\n",
    "    W = m*g\n",
    "    return W\n",
    "\n",
    "print(agirlik(10))\n",
    "\n",
    "print(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### map() function:\n",
    "\n",
    "map() function; applies a function to every item in the array, if you have \"list\" of values\n",
    "\n",
    "_Syntax:_ list(map(functionName, listName))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1\n"
     ]
    }
   ],
   "source": [
    "def periyot(f):\n",
    "    T = 1/f\n",
    "    return T\n",
    "\n",
    "f = 10 \n",
    "T = periyot(f)\n",
    "print(T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0, 0.5, 0.3333333333333333, 0.25, 0.06666666666666667, 0.16666666666666666, 0.01282051282051282]\n"
     ]
    }
   ],
   "source": [
    "f = [1,2,3,4,15,6,78]\n",
    "\n",
    "T = []\n",
    "for fi in f:\n",
    "    Ti = periyot(fi)\n",
    "    T.append(Ti)\n",
    "    \n",
    "print(T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0, 0.5, 0.3333333333333333, 0.25, 0.06666666666666667, 0.16666666666666666, 0.01282051282051282]\n"
     ]
    }
   ],
   "source": [
    "T2 = list(map(periyot, f))\n",
    "print(T2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Anonymous Functions :\n",
    "\n",
    "They are also called \"lambda\" functions, they do not use \"def\" keyword. It has no name.\n",
    "\n",
    "_Syntax:_ lambda [arg1, arg2,...argn] : expression\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "225\n"
     ]
    }
   ],
   "source": [
    "def kare(x):\n",
    "    y = x**2\n",
    "    return y\n",
    "\n",
    "sonuc = kare(15)\n",
    "print(sonuc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "225\n"
     ]
    }
   ],
   "source": [
    "kare = lambda x : x**2\n",
    "\n",
    "sonuc = kare(15)\n",
    "print(sonuc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "65104.166666666664\n"
     ]
    }
   ],
   "source": [
    "# Moment of Inertia\n",
    "atalet = lambda b,h: b*h**3/12\n",
    "\n",
    "print(atalet(50,25))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Example:\n",
    "\n",
    "<img src=\"./Figures/Examples/SimpleBeam1.png\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.0\n",
      "1.0\n",
      "30.0\n",
      "60.0\n"
     ]
    }
   ],
   "source": [
    "def kiris(q, L):\n",
    "    W = q*L\n",
    "    V = W/2\n",
    "    return V\n",
    "\n",
    "kiris1 = kiris(10, 2)\n",
    "kiris2 = kiris(1, 2)\n",
    "kiris3 = kiris(5, 12)\n",
    "kiris4 = kiris(10, 12)\n",
    "\n",
    "print(kiris1)\n",
    "print(kiris2)\n",
    "print(kiris3)\n",
    "print(kiris4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**UFAK BİR HEYECAN YAŞAYALIM :**\n",
    "\n",
    "_PROBLEM :_ Verilen sistemin mesnet reaksiyonlarını hesaplayan fonksiyonu yazınız. \n",
    "\n",
    "_SÜRE :_ 10 dakika\n",
    "\n",
    "_ÖDÜL :_ İlk bitirenle ders çıkışı kahve + çikolata sohbeti\n",
    "\n",
    "<img src=\"./Figures/Examples/SimpleBeam2.png\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.9.13"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}