Programming+Practice+Exercise+1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The Python Programming Language\n",
    "\n",
    "Python is a widely used general-purpose, high-level programming language.\n",
    "Its design philosophy emphasizes code readability, and its syntax allows\n",
    "programmers to express concepts in fewer lines of code than would be\n",
    "possible in languages such as C++ or Java.\n",
    "\n",
    "[More...](https://en.wikipedia.org/wiki/Python_(programming_language)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Questions :\n",
    "\n",
    "What is the *syntax* of a programming language?\n",
    "\n",
    "What is a \"high level\" langauge\n",
    "\n",
    "What software do you need to \"run\" python code?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Record your answer here:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercise : Operators\n",
    "\n",
    "Explore how the python operators work\n",
    "```python \n",
    "+ - / * \n",
    "```\n",
    "\n",
    "Think about TYPES (integers, reals, strings) while you explore\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2+2.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "4 / 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'helloworld'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"hello\"+\"world\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# write your own expression:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Record your findings here:\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise : More operators\n",
    "\n",
    "Now explore these:\n",
    "\n",
    "``` python\n",
    "//    %  **\n",
    "\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "2//3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "2**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "2%3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Record your findings here:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise: Using the modulo operator to loop though a series of numbers\n",
    "\n",
    "Think of a clock - what numbers does it have? 1, 2, 3, 4, ... all the way to 12. What happens after 12? It goes back to 1 again. A 24h clock is no different - it goes from 1,2,3..12,13,14...22,23,24 and then loops back to 1.\n",
    "\n",
    "How can you program a sequence like this? One that begins with 1 but then loops back to 1 once it has reached its maximum?\n",
    "\n",
    "With the modulo operator its easy. Let's test this out with a 12 hour clock. WHen numbers are LESS than 12, if you %12, you just get the number itself. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "3 % 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "5 % 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What about when numbers are larger than 12... well let's start with 12 itself. What do you think the following results in?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "12 % 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "12%13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "15%12\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reflection: Modulo operator\n",
    "\n",
    "Does this make sense? Does it work? Do you have any questions? Where (else) can this be used?\n",
    "\n",
    "[Read more about Modulo arithmetic here](https://www.khanacademy.org/computing/computer-science/cryptography#modarithmetic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Comparision Operators\n",
    "\n",
    "Explore the Python comparison operators\n",
    "\n",
    "```python\n",
    ">  < >=  <= !=  == \n",
    "```\n",
    "\n",
    "What TYPE does a comparision return?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "2 >3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "2 != 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\"hello\" > \"world\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "True == False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Record your findings here:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Storing data - Variables (and constants)\n",
    "\n",
    "Computers are stupid, if they don't \"write things down\" they will “forget” .\n",
    "\n",
    "We use VARIABLES or CONSTANTS which creates space in computer memory to store data.\n",
    "All variables have a DATA-TYPE (integer, real (float), string, boolean)\n",
    "\n",
    "All variables have NAMES and VALUES. The names never change, but the values can.\n",
    "All contants have NAMES and VALUES. Neither change! Then why use constants? Because words (like  ```DISTTOMOON ```) are more meaningful to human programmers than number (like  ```238855 ``` miles)\n",
    "\n",
    "\n",
    "## Ada-style Naming convention\n",
    "\n",
    "Variables should use **camelCase** naming, and start with a lower-case letter.\n",
    "\n",
    "Boolean variables should sound like a question.\n",
    "\n",
    "Constants should be in CAPITALS and come as close the the beginning of a program as appropriate\n",
    "\n",
    "```python\n",
    "# no:\n",
    "Name = 'Alex'\n",
    "user_age = 16\n",
    "userTired = true\n",
    "dist_Moon = 238855\n",
    "\n",
    "# yes:\n",
    "DISTMOON = 23885\n",
    "name = 'Alex'\n",
    "userAge = 16\n",
    "isUserTired = true\n",
    "```\n",
    "\n",
    "### Note: \n",
    "\n",
    "A ```#``` (hash) symbol precedes a comment. This line of code will be ignored by the interpreter and allows the programmer to write notes to themselves or others"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Program the formula for the area of a circle\n",
    "\n",
    "The formula is: **pi** times **radius** squared\n",
    "\n",
    "Pi is a constant, while radius should be a variable, otherwise your program will always work out the area of the same circle\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "PI = 3.14  #you can make this as accurate as you want \n",
    "radius = 12 # change this as appropirate\n",
    "PI * radius**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Note: there is a library for Maths constants!\n",
    "\n",
    "[Python Maths functions](https://docs.python.org/3.0/library/math.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math\n",
    "math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "PI = math.pi\n",
    "radius = 12\n",
    "PI * radius**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task: Solve this problem\n",
    "\n",
    "In the classic game PACMAN, Pacman can score by \"eating\" dots and also eating flashing dots (energizers).\n",
    "The small dots are worth ten points each, and the  large, flashing dots/energizers are worth 50 points each.\n",
    "\n",
    "Write Python code that will calculate a players score based on the amount of dots and energizers that the player has eaten.\n",
    "\n",
    "Think about what you will make CONTSTANTS and what will be VARIABLES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#write and test your code here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}