Higher-Computing-Pre-Defined-Functions-H.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pre-Defined Functions (Higher)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At Higher we need to know about 4 new pre-defined functions:\n",
    "\n",
    "+ ord()\n",
    "+ char()\n",
    "+ int()\n",
    "+ modulus\n",
    "\n",
    "We also need to know about __sub-strings__, although creating sub-strings doesn't make use of any pre-defined function, we're going to put them in here too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ord() and Char()\n",
    "\n",
    "These functions are used to perform actions on ASCII codes and characters.\n",
    "\n",
    "<img src=\"ascii_table.gif\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember from N5 that the characters up to 31 (inclusive) are control characters and are not generally printable on the screen. ASCII also extends past 126 and these are usually foreign language characters. For our purpose we are going to stay in the range 32-126, although you should note that 32 is the space character (it is visible?)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using ord()\n",
    "\n",
    "The parameter to ord is an ASCII character, the function returns the ASCII value of the character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "65\n"
     ]
    }
   ],
   "source": [
    "print(ord('A'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Activity__: change the parameter to the ord() function above so that it prints the ASCII value of 'z'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using chr()\n",
    "This function is pronounced 'char'. It performs the opposite function of ord() and returns the ASCII character associated with the ASCII value that it is passed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "S\n"
     ]
    }
   ],
   "source": [
    "print(chr(83))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Activity__: change the parameter to chr() above so that it prints the ASCII character with a value of 101."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using int()\n",
    "\n",
    "int() is often used when converting input to an integer number, however it can also be used to convert a floating point/real number to an integer by dropping everything after the decimal point. It is different to round() in that it does not pay any attention to the values after the decimal point.\n",
    "\n",
    "Look at the program below. A company that produces lifts needs to calculate how many people will fit in the lifts they make. Each person needs a total space of 3.5 cubic metres. Based on the lift dimensions it will calculate how many people will fit in the lift. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person_space = 3.5\n",
    "lift_height = float(input(\"Please enter the lift height(m): \"))\n",
    "lift_width = float(input(\"Please enter the lift width(m): \"))\n",
    "lift_depth = float(input(\"Please enter the lift depth(m): \"))\n",
    "\n",
    "# There are three ways to calculate this ... but only one is correct\n",
    "max_num_people = (lift_height * lift_width * lift_depth) / person_space\n",
    "# max_num_people = round((lift_height * lift_width * lift_depth) / person_space, 0)\n",
    "# max_num_people = int((lift_height * lift_width * lift_depth) / person_space)\n",
    "\n",
    "print(\"The maximum number of people that this lift can contain is: \", max_num_people)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Leaving the calculation on __line 7__ uncommented, run the program above with the following lift dimensions: height: 3m, width: 4.25m and depth: 4m. Record the answer.\n",
    "\n",
    "Now comment out line 7 and uncomment __line 8__. Using the same dimensions above, record the answer.\n",
    "\n",
    "Finally, comment out line 8 and uncomment __line 9__. Record the answer when using the same dimensions.\n",
    "\n",
    "Only one of the answers can actually be correct. Which one is it and why?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modulus\n",
    "\n",
    "Modulus is the mathematical function which calculates a remainder. For example, the modulus of 7/2 is 1 (Two threes, remainder one).\n",
    "\n",
    "In Python the modulus operator is %."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "remainder = 103 % 24\n",
    "print(remainder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Rewrite the above expression to calculate the remainder of 103/24."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sub-Strings\n",
    "\n",
    "In programming, it is often useful to be able to create sub-strings. For example, when creating a username based on someone's first name and surname, we might want to use the first 3 letters of their first name and concatentate this with their surname.\n",
    "\n",
    "In Python, when creating sub-strings, it is important to understand that strings can be referred to in a similar way to arrays.\n",
    "\n",
    "<img src=\"string-array.png\">\n",
    "\n",
    "\n",
    "### Usage 1\n",
    "\n",
    "Using the string above, we can do this to print particular characters from the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Cheesecake\"\n",
    "print(\"The fifth character is:\", my_string[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can create sub-strings using a notation of [__starting character__:__stop_at_character__]. This is will create the sub-string starting at character __starting_character__ and ending (and not including) __stop_at_character__. In Python, this technique for creating sub-strings is called __slicing__. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Cheesecake\"\n",
    "print(my_string[0:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Another example\n",
    "my_string = \"Cheesecake\"\n",
    "print(my_string[0:6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Another example\n",
    "my_string = \"Cheesecake\"\n",
    "print(my_string[1:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Activity__: how would you create the sub-string 'cake' from the example above? __Hint__: unlike with normal arrays you don't need to worry about going off the end."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usage 2\n",
    "\n",
    "When writing sub-string slices we don't need to include either the first part of the slice or the second part of the slice if we want to refer to the beginning or end of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Cheesecake\"\n",
    "\n",
    "# This...\n",
    "print(my_string[0:6])\n",
    "\n",
    "# can be written as...\n",
    "print(my_string[:6])\n",
    "\n",
    "# and this...\n",
    "print(my_string[6:10])\n",
    "\n",
    "# can be written as...\n",
    "print(my_string[6:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usage 3\n",
    "\n",
    "Finally, it can sometimes be helpful to work backwards from the end of the string - for example, we might want the last four characters of a string. When working from the back, we need to adjust our numbering system:\n",
    "\n",
    "<img src=\"string-array-backwards.png\">\n",
    "\n",
    "To slice the last four characters of the string we can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Cheesecake\"\n",
    "print(my_string[-4:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Actual Cheesecake\n",
    "\n",
    "<img src=\"cheesecake.jpg\">"
   ]
  }
 ],
 "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.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}