15. Python_Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Startrek Python - Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are the bread and butter of programming. This is what runs apps, security scans, the transporters, holosuites and so much more!\n",
    "\n",
    "- A function is a block of code which only runs when it is called.\n",
    "- You can pass data, known as parameters, into a function.\n",
    "- A function can return data as a result."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "to make a function you need to use the word <code>def</code> followed by function name with (): after"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sayHi says Hi\n"
     ]
    }
   ],
   "source": [
    "def sayHi():\n",
    "    print('sayHi says Hi')\n",
    "    \n",
    "# if you just ran this cell with code above nothing happens \n",
    "\n",
    "# you need to call the function\n",
    "#-- calling function\n",
    "sayHi()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function Arguments  (args)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can have arguments with your functions, this is a good thing.\n",
    "When a function takes arguments it takes variables then does what \n",
    "you tell it to and return the result\n",
    "\n",
    "- args\n",
    "- kwargs = Key Word Arguments, not a Klingon word\n",
    "\n",
    "a function must be called with the correct number of arguments. Meaning that if your function expects 2 arguments, you have to call the function with 2 arguments, not more, and not less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Security Officer Worf on duty\n",
      "Security Officer Wilks on duty\n"
     ]
    }
   ],
   "source": [
    "# a function that takes a last name and returns it in string\n",
    "# this function has 1 arg\n",
    "def SecurityO(LastName):\n",
    "    print('Security Officer {} on duty'.format(LastName))\n",
    "    \n",
    "# call the function with variable\n",
    "SecurityO('Worf')\n",
    "SecurityO('Wilks')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Captains Log: Sisko, Stardate 2374.51\n"
     ]
    }
   ],
   "source": [
    "# 2 args\n",
    "\n",
    "def CaptainsLog(LastName, Stardate):\n",
    "    print('Captains Log: {}, Stardate {}'.format(LastName, Stardate))\n",
    "    \n",
    "# call the function\n",
    "CaptainsLog(\"Sisko\", '2374.51')\n",
    "\n",
    "# make sure stardate is a string\n",
    "# AVOID: TypeError: format() argument 2 must be str, not float"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you do not know how many arguments that will be passed into your function, add a * before the parameter name in the function definition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the latest redshirt to die: Williamz\n"
     ]
    }
   ],
   "source": [
    "def Away_Missions(*redshirts):\n",
    "    print('the latest redshirt to die: {}'.format(redshirts[3]))\n",
    "    \n",
    "# call the function with args\n",
    "Away_Missions('Tayzlor','Smithyoo','Joines','Williamz','Bixby')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Keyword Args"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "arguments with the key = value syntax. The order of things does not matter, maybe to the Dominion it does"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sulu is on the helm\n"
     ]
    }
   ],
   "source": [
    "def Helmsman(helm3, helm2, helm1):\n",
    "    print('{} is on the helm'.format(helm2))\n",
    "    \n",
    "# call the function with kwargs\n",
    "Helmsman(helm1='Unknown', helm2='Sulu', helm3='Chekov')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **kwargs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you do not know how many keyword arguments that will be passed into your function, add two asterisk: ** before the parameter name in the function definition.\n",
    "\n",
    "This way the function will receive a dictionary of arguments, and can access the items accordingly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your access code is alpha-tau-7-7-beta\n"
     ]
    }
   ],
   "source": [
    "def access_code(**codes):           # put kwarg in \" \"\n",
    "    print('Your access code is {}'.format(codes[\"codes1\"]))\n",
    "    \n",
    "# call the function with kwargs\n",
    "access_code(codes1='alpha-tau-7-7-beta', \\\n",
    "            codes2='kappa-8-rho-zeta-12-upsilon')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Default "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am from Luna Colony\n",
      "I am from Mars Colony\n",
      "I am from Bajor\n"
     ]
    }
   ],
   "source": [
    "# default use case\n",
    "def homeworld(my_planet='Earth'):\n",
    "    print(\"I am from \" + my_planet)\n",
    "\n",
    "# call the function with string arg\n",
    "homeworld('Luna Colony')\n",
    "homeworld('Mars Colony')\n",
    "homeworld('Bajor')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List as args"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can send any data types of argument to a function (string, number, list, dictionary etc.), and it will be treated as the same data type inside the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Primary Sensors has been checked\n",
      "Shields has been checked\n",
      "Warp Engines has been checked\n"
     ]
    }
   ],
   "source": [
    "def sys_check(checks):\n",
    "    for x in checks:\n",
    "        print('{} has been checked'.format(x))\n",
    "        \n",
    "systems = ['Primary Sensors','Shields','Warp Engines']\n",
    "\n",
    "# call the function with list var\n",
    "sys_check(systems)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Return Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shields at 21.36 %\n",
      "Shields at 48.06 %\n",
      "Shields at 96.12 %\n"
     ]
    }
   ],
   "source": [
    "# need to quickly boost shield strength by 1.78%\n",
    "# shield values are percents\n",
    "\n",
    "def boost_shields(shield_val):\n",
    "    return shield_val * 1.78\n",
    "\n",
    "print('Shields at {}'.format(boost_shields(12)),'%')\n",
    "print('Shields at {}'.format(boost_shields(27)),'%')\n",
    "print('Shields at {}'.format(boost_shields(54)),'%')\n",
    "\n",
    "# shield value of 12% returns with value of 21.26% after"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the word pass is used in functions with no content\n",
    "def duckduckgo():\n",
    "    pass # pass by, do nothing, avoid errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# * Recursion *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recursion is when a function calls itself. This is very useful for \n",
    "iterating through functions to get a result.\n",
    "\n",
    "- CAUTION IS ADVISED: with recursion as it can be quite easy to slip into writing a function which never terminates, or one that uses excess amounts of memory or processor power."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "... recursions ...\n",
      "result: 1\n",
      "result: 3\n",
      "result: 6\n",
      "result: 10\n",
      "result: 15\n",
      "result: 21\n",
      "result: 28\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "28"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# function name: recurzion\n",
    "# r is data variable, decrements each iteration\n",
    "# function ends when condition is 0\n",
    "\n",
    "def recurzion(r):\n",
    "    # if condition\n",
    "    if (r > 0):\n",
    "        # return a result\n",
    "        result = r + recurzion(r - 1)\n",
    "        print('result: {}'.format(result))\n",
    "    \n",
    "    else:\n",
    "        # set result to 0\n",
    "        result = 0 \n",
    "    # if nothing else, return the result\n",
    "    return result\n",
    "#----------------------------\n",
    "\n",
    "\n",
    "print('... recursions ...')\n",
    "\n",
    "# call the recursive function\n",
    "# the 7 = r\n",
    "recurzion(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}