Learning Python 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# My first jupyter notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common string methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "string_1 = \"Hello World. It is Sunday the 26th of August 2018\"\n",
    "first = \"Mr.\"\n",
    "last = \"Bean\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO WORLD. IT IS SUNDAY THE 26TH OF AUGUST 2018\n",
      "hello world. it is sunday the 26th of august 2018\n",
      "Hello World. It Is Sunday The 26Th Of August 2018\n"
     ]
    }
   ],
   "source": [
    "print(string_1.upper())\n",
    "print(string_1.lower())\n",
    "print(string_1.title())\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String Concatenation & String Interpolation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mr. Bean\n",
      "Hello MR. Bean\n",
      "Hello mr. How are you?\n",
      "Hello Mr. Bean\n",
      "Hello Mr. Bean.\n"
     ]
    }
   ],
   "source": [
    "message = \"Hello \" + first.lower() + \" How are you?\"\n",
    "\n",
    "print(first + \" \" + last)\n",
    "print(\"Hello\", first.upper(), last)\n",
    "print(message)\n",
    "print(\"Hello {} {}\".format(first, last)) #String Interpolation (old)\n",
    "print(f\"Hello {first} {last}.\") #String Interpolation (new)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stripping Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stipped on the left: Banana    \n",
      "Stripped on the right:      Banana\n",
      "Stripped on both sides: Banana\n"
     ]
    }
   ],
   "source": [
    "unstripped = \"     Banana    \"\n",
    "stripped_left = unstripped.lstrip()\n",
    "stripped_right = unstripped.rstrip()\n",
    "stripped = unstripped.strip()\n",
    "\n",
    "print(\"Stipped on the left:\", stripped_left)\n",
    "print(\"Stripped on the right:\", stripped_right)\n",
    "print(\"Stripped on both sides:\", stripped)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding whitespace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t Banana\n"
     ]
    }
   ],
   "source": [
    "print(\"\\t\",stripped)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mr. \n",
      " Mr. \n",
      " Bean \n",
      " HELLO\n"
     ]
    }
   ],
   "source": [
    "print(first, \"\\n\",first, \"\\n\", last, \"\\n\", \"HELLO\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why are all words apart from the first indented by one space?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.6\n",
      "Mr. is 4.6 years old\n"
     ]
    }
   ],
   "source": [
    "inte = 2 #integer\n",
    "flo = 2.3 #float\n",
    "\n",
    "print(inte*flo)\n",
    "print(first, \"is\", inte*flo, \"years old\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "bicycles = ['trek', 'cannondale', 'redline', 'specialized']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "trek\n",
      "specialized\n"
     ]
    }
   ],
   "source": [
    "print(bicycles[0]) #access first element\n",
    "print(bicycles[-1]) #access last element\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My first bicycle was a Trek.\n"
     ]
    }
   ],
   "source": [
    "message = \"My first bicycle was a \" + bicycles[0].title() + \".\"\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Changed the first element to ducati\n",
      "['ducati', 'cannondale', 'redline', 'specialized']\n"
     ]
    }
   ],
   "source": [
    "bicycles[0] = \"ducati\"\n",
    "print(\"Changed the first element to\", bicycles[0])\n",
    "print(bicycles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common List methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['trek', 'cannondale', 'redline', 'specialized', 'cube']\n",
      "['YT', 'trek', 'cannondale', 'redline', 'specialized', 'cube']\n",
      "['trek', 'cannondale', 'redline', 'specialized', 'cube']\n"
     ]
    }
   ],
   "source": [
    "bicycles = ['trek', 'cannondale', 'redline', 'specialized']\n",
    "bicycles.append(\"cube\") #appends cube to the end of the list\n",
    "print(bicycles)\n",
    "\n",
    "bicycles.insert(0,\"YT\") #inserts YT at index 0, -->shifts all indexes\n",
    "print(bicycles)\n",
    "\n",
    "del bicycles[0] #removing first element, using the del statement\n",
    "print(bicycles)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Counting items in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number 1 is 2 in lst\n"
     ]
    }
   ],
   "source": [
    "lst = [1,1,2,2,2,3,3,4,5,6,6,7,7,7,7,7,8,9]\n",
    "requested = 1\n",
    "print(f\"The number {requested} is {lst.count(requested)} in lst\")\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pop( ) method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['honda', 'yamaha', 'suzuki']\n",
      "['honda', 'yamaha']\n",
      "You popped: suzuki\n",
      "['honda']\n",
      "You popped: yamaha\n"
     ]
    }
   ],
   "source": [
    "#The pop() method removes an item from a list, but it lets you work with that \n",
    "#item after removing it.\n",
    "\n",
    "motorcycles = ['honda', 'yamaha', 'suzuki'] \n",
    "print(motorcycles)\n",
    "\n",
    "popped_motorcycle = motorcycles.pop()   #pop last item\n",
    "print(motorcycles)\n",
    "print(\"You popped:\", popped_motorcycle)\n",
    "\n",
    "popped_motorcycle = motorcycles.pop(1)  #pop item at index 1\n",
    "print(motorcycles)\n",
    "print(\"You popped:\", popped_motorcycle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remove( ) method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['honda', 'yamaha', 'suzuki', 'ducati']\n",
      "['honda', 'yamaha', 'suzuki']\n"
     ]
    }
   ],
   "source": [
    "motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']\n",
    "print(motorcycles)\n",
    "motorcycles.remove('ducati') #removes item based on value\n",
    "print(motorcycles)\n",
    "\n",
    "#The remove() method deletes only the first occurrence of the value you specify. \n",
    "#If there’s a possibility the value appears more than once in the list, you’ll need to \n",
    "#use a loop to determine if all occurrences of the value have been removed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sorting a list PERMANENTLY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['audi', 'bmw', 'subaru', 'toyota']\n",
      "['toyota', 'subaru', 'bmw', 'audi']\n"
     ]
    }
   ],
   "source": [
    "cars = ['bmw', 'audi', 'toyota', 'subaru'] \n",
    "cars.sort() #sort() changes the order permanently\n",
    "print(cars)\n",
    "cars.sort(reverse=True) \n",
    "print(cars)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sorting a list temporarily"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['audi', 'bmw', 'subaru', 'toyota']\n",
      "['bmw', 'audi', 'toyota', 'subaru']\n"
     ]
    }
   ],
   "source": [
    " cars = ['bmw', 'audi', 'toyota', 'subaru']\n",
    "print(sorted(cars)) #sorted lets you display a sorted list but it does not affect the actual order of the list\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reverse a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['bmw', 'audi', 'toyota', 'subaru']\n",
      "['subaru', 'toyota', 'audi', 'bmw']\n"
     ]
    }
   ],
   "source": [
    "cars = ['bmw', 'audi', 'toyota', 'subaru']\n",
    "print(cars)\n",
    "\n",
    "cars.reverse() #reverses the list permanently\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Length of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "cars = ['bmw', 'audi', 'toyota', 'subaru']  \n",
    "print(len(cars))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Length of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(len(cars))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alice\n",
      "david\n",
      "carolina\n"
     ]
    }
   ],
   "source": [
    "magicians = ['alice', 'david', 'carolina'] \n",
    "for magician in magicians: #retrieve first item from the list and store it in the var magigian. In the next round store the second item and so on \n",
    "    print(magician)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using singular and plural names can help you identify whether a section of code is working with a single element from the list or the entire list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Range( )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "one_to_ten = list(range(0,11))\n",
    "print(one_to_ten)\n",
    "\n",
    "for x in range(5):\n",
    "    print(x)\n",
    "    \n",
    "squares = []\n",
    "for value in range(1,11):\n",
    "    square = value**2\n",
    "    squares.append(square) \n",
    "    \n",
    "print(squares)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Min, Max, Sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "9\n",
      "45\n"
     ]
    }
   ],
   "source": [
    "digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]\n",
    "print(min(digits))\n",
    "print(max(digits))\n",
    "print(sum(digits))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "# instead of using a for loop (see above) you can also do:\n",
    "squares = [value**2 for value in range(1,11)]\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['martina', 'michael']\n",
      "['charles', 'martina', 'michael']\n",
      "['martina', 'michael', 'florence', 'eli']\n",
      "['florence', 'eli']\n"
     ]
    }
   ],
   "source": [
    "players = ['charles', 'martina', 'michael', 'florence', 'eli']\n",
    "print(players[1:3])\n",
    "print(players[:3]) #omitting the first index means starting at the beginning\n",
    "print(players[1:]) #omitting the second index means including the last one\n",
    "print(players[-2:]) #start at the second last, till the end\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copying a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['charles', 'martina', 'michael', 'florence', 'eli']\n",
      "['charles', 'martina', 'michael', 'florence', 'eli', 'yes']\n",
      "['charles', 'martina', 'michael', 'florence', 'eli', 'no']\n"
     ]
    }
   ],
   "source": [
    "pl = players[:] #use [:] to copy the list\n",
    "# if you just did pl = players python just connects pl to the already existing players list\n",
    "\n",
    "print(pl)\n",
    "players.append(\"yes\")\n",
    "pl.append(\"no\")\n",
    "print(players)\n",
    "print(pl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Enumerate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TO-DO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An immutable list is called Tuple in python. A tuple uses parentheses instead of square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "dimensions = (200, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional Statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BMW\n"
     ]
    }
   ],
   "source": [
    "car = 'bmw'\n",
    "\n",
    "if car == 'bmw':\n",
    "    print(car.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fiat\n"
     ]
    }
   ],
   "source": [
    "car = 'fiat'\n",
    "\n",
    "if car != 'bmw':\n",
    "    print(car.lower())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean And"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "both underaged\n"
     ]
    }
   ],
   "source": [
    "age_0 = 15\n",
    "age_1 = 17\n",
    "if age_0 <= 21 and age_1 <= 21:\n",
    "    print(\"both underaged\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean Or"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "at least one underaged\n"
     ]
    }
   ],
   "source": [
    "age_0 = 15\n",
    "age_1 = 22\n",
    "if age_0 <= 21 or age_1 <= 21:\n",
    "    print(\"at least one underaged\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Value in list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "martina in players\n",
      "john not in players\n"
     ]
    }
   ],
   "source": [
    "players = ['charles', 'martina', 'michael', 'florence', 'eli']\n",
    "player = 'martina'\n",
    "player2 = \"john\"\n",
    "\n",
    "if player in players:\n",
    "    print(f\"{player} in players\")\n",
    "    \n",
    "if player2 not in players:\n",
    "    print(f\"{player2} not in players\")\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If-Else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorry, you are too young to vote.\n",
      "Please register to vote as soon as you turn 18!\n"
     ]
    }
   ],
   "source": [
    "age = 17\n",
    "if age >= 18:\n",
    "    print(\"You are old enough to vote!\") \n",
    "    print(\"Have you registered to vote yet?\")\n",
    "else:\n",
    "    print(\"Sorry, you are too young to vote.\")\n",
    "    print(\"Please register to vote as soon as you turn 18!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If-Elif-Else"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python executes only one block in an if-elif-else chain. It runs each conditional test in order until one passes. When a test passes, the code following that test is executed and Python skips the rest of the tests."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your admission cost is $5.\n"
     ]
    }
   ],
   "source": [
    "age = 12\n",
    "if age < 4:\n",
    "    print(\"Your admission cost is $0.\")\n",
    "elif age < 18:\n",
    "    print(\"Your admission cost is $5.\")\n",
    "else:\n",
    "    print(\"Your admission cost is $10.\") \n",
    "    \n",
    "#You can use as many elif blocks in your code as you like. \n",
    "#Python does not require an else block at the end of an if-elif chain.  \n",
    "#Without every block of code must pass a specific test in order to be executed.\n",
    "#The else block is a catchall statement. \n",
    "#It matches any condition that wasn’t matched by a specific if or elif test, \n",
    "#and that can sometimes include invalid or even malicious data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing multiple conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adding mushrooms.\n",
      "Adding extra cheese.\n",
      "\n",
      "Finished making your pizza!\n"
     ]
    }
   ],
   "source": [
    "#If more than one condition could be true and you want to catch them all, use multiple if statements\n",
    "\n",
    "requested_toppings = ['mushrooms', 'extra cheese']\n",
    "if 'mushrooms' in requested_toppings: \n",
    "    print(\"Adding mushrooms.\")\n",
    "if 'pepperoni' in requested_toppings: \n",
    "    print(\"Adding pepperoni.\")\n",
    "if 'extra cheese' in requested_toppings: \n",
    "    print(\"Adding extra cheese.\")\n",
    "print(\"\\nFinished making your pizza!\")\n",
    "\n",
    "#if-elif-else: Python doesn’t run any tests beyond the first test that passes in an if-elif-else chain. \n",
    "\n",
    "#easier to do with a for loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking that list is not empty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are you sure you want a plain pizza?\n"
     ]
    }
   ],
   "source": [
    "requested_toppings = []\n",
    "if requested_toppings:\n",
    "    for requested_topping in requested_toppings:\n",
    "        print(\"Adding \" + requested_topping + \".\")\n",
    "        print(\"\\nFinished making your pizza!\")\n",
    "else:\n",
    "    print(\"Are you sure you want a plain pizza?\")\n",
    "\n",
    "#When the name of a list is used as the condition in an if statement, \n",
    "#python returns True if there is at least one item in the list. \n",
    "#If the list is empty python returns False and the else will run."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dictionary in Python is a collection of key-value pairs. Each key is connected to a value, and you can use a key to access the value associated with that key. A key’s value can be a number, a string, a list, or even another dictionary. In Python, a dictionary is wrapped in braces, {}, with a series of key- value pairs inside the braces. When you provide a key, Python returns the value associated with that key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Example:\n",
    "alien_0 = {'color': 'green', 'points': 5}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing a value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "green\n"
     ]
    }
   ],
   "source": [
    "print(alien_0['color'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding a new key-value pair"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 25}\n"
     ]
    }
   ],
   "source": [
    "# To add a new pair, dictname['key'] = value\n",
    "alien_0['x_position'] = 0 \n",
    "alien_0['y_position'] = 25\n",
    "print(alien_0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hint: Python doesn’t care about the order in which you store each key-value pair; it cares only about the connection between each key and its value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modifying a value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 100}\n"
     ]
    }
   ],
   "source": [
    "#same syntax as adding a new key-value pair\n",
    "alien_0['y_position'] = 100\n",
    "print(alien_0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Removing key-value pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'color': 'green', 'x_position': 0, 'y_position': 100}\n"
     ]
    }
   ],
   "source": [
    "del alien_0['points']\n",
    "print(alien_0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Looping through a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can loop through all of a dictionary’s key-value pairs, through its keys, or through its values. To loop through just the keys you use .keys(), for just the values .values() for both use .items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "user_0 = {\n",
    "    'username': 'efermi',\n",
    "    'first': 'enrico',\n",
    "    'last': 'fermi',\n",
    "            }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "username\n",
      "first\n",
      "last\n",
      "username\n",
      "first\n",
      "last\n"
     ]
    }
   ],
   "source": [
    "for key in user_0.keys():\n",
    "    print(key)\n",
    "#or\n",
    "for key in user_0: # .keys() is the default behaviour\n",
    "    print(key)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "efermi\n",
      "enrico\n",
      "fermi\n"
     ]
    }
   ],
   "source": [
    "for value in user_0.values():\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "username : efermi\n",
      "first : enrico\n",
      "last : fermi\n"
     ]
    }
   ],
   "source": [
    "for key, value in user_0.items():\n",
    "    print(key, \":\", value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check if somethinng is in keys/items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "efermi what is your score?\n"
     ]
    }
   ],
   "source": [
    "if \"score\" not in user_0.keys():\n",
    "    print(f\"{user_0['username']} what is your score?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set( ) function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Python', 'R', 'C'}\n"
     ]
    }
   ],
   "source": [
    "# use set() to pull all unique items from a list\n",
    "lst = [\"C\", \"R\", \"Python\", \"C\", \"R\", \"Python\"]\n",
    "print(set(lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sorted( ) function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['C', 'C', 'Python', 'Python', 'R', 'R']\n"
     ]
    }
   ],
   "source": [
    "#returns a sorted list\n",
    "lst = [\"C\", \"R\", \"Python\", \"C\", \"R\", \"Python\"]\n",
    "print(sorted(lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{20: 2, 1: 2, -1: 2, 2: 2, -2: 2, 3: 2, 5: 3, 4: 2}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Exercise: Find the odd int\n",
    "\n",
    "lst = [20,1,-1,2,-2,3,3,5,5,1,2,4,20,4,-1,-2,5]\n",
    "\n",
    "def find_it(seq):\n",
    "    numbers = {}\n",
    "    for x in seq: #loop through seq and either create item in numbers dict or update it's count\n",
    "        if x in numbers.keys():\n",
    "            numbers[x] +=1\n",
    "        else:\n",
    "            numbers[x]= 1\n",
    "    print(numbers)        \n",
    "    for number, count in numbers.items(): #loop through numbers dict and if the count of one number is odd, return that number\n",
    "        if count%2 == 1:\n",
    "            return number\n",
    "    \n",
    "\n",
    "find_it(lst)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nesting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A list of dicts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'color': 'green', 'points': 5}\n",
      "{'color': 'yellow', 'points': 10}\n",
      "{'color': 'red', 'points': 15}\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "alien_0 = {'color': 'green', 'points': 5}\n",
    "alien_1 = {'color': 'yellow', 'points': 10}\n",
    "alien_2 = {'color': 'red', 'points': 15}\n",
    "aliens = [alien_0, alien_1, alien_2]\n",
    "for alien in aliens:\n",
    "       print(alien)\n",
    "        \n",
    "print(aliens[1]['points'])        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists in Dicts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You ordered a thick-crust pizza with the following toppings:\n",
      "\tmushrooms\n",
      "\textra cheese\n"
     ]
    }
   ],
   "source": [
    "pizza = {\n",
    "       'crust': 'thick',\n",
    "       'toppings': ['mushrooms', 'extra cheese'],\n",
    "       }\n",
    "\n",
    "# Summarize the order.\n",
    "print(\"You ordered a \" + pizza['crust'] + \"-crust pizza \" +\n",
    "                \"with the following toppings:\")\n",
    "for topping in pizza['toppings']: print(\"\\t\" + topping)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can nest a list inside a dictionary any time you want more than one value to be associated with a single key in a dictionary. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A dict in a dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Username: aeinstein\n",
      "\tFull name: Albert Einstein\n",
      "\tLocation: Princeton\n",
      "\n",
      "Username: mcurie\n",
      "\tFull name: Marie Curie\n",
      "\tLocation: Paris\n"
     ]
    }
   ],
   "source": [
    "users = {\n",
    "    'aeinstein': {\n",
    "        'first': 'albert',\n",
    "        'last': 'einstein',\n",
    "        'location': 'princeton',\n",
    "        },\n",
    "    'mcurie': {\n",
    "           'first': 'marie',\n",
    "           'last': 'curie',\n",
    "           'location': 'paris',\n",
    "           },\n",
    "}\n",
    "\n",
    "for username, user_info in users.items():\n",
    "    print(\"\\nUsername: \" + username)\n",
    "    full_name = user_info['first'] + \" \" + user_info['last']\n",
    "    location = user_info['location']\n",
    "                                                     \n",
    "    print(\"\\tFull name: \" + full_name.title()) \n",
    "    print(\"\\tLocation: \" + location.title())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Input()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tell me something, and I will repeat it back to you: g\n",
      "g\n"
     ]
    }
   ],
   "source": [
    "message = input(\"Tell me something, and I will repeat it back to you: \")\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How old are you? 10\n",
      "I'm 5.0\n"
     ]
    }
   ],
   "source": [
    "#in order to use your input as an integer and not a string use int()\n",
    "age = int(input(\"How old are you? \"))/2\n",
    "print(f\"I'm {age}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "#modulo divides one number by the other and returns the remainder\n",
    "print(4 % 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# A while loop runs as long as, or while, a certain condition is true.\n",
    "\n",
    "current_number = 1\n",
    "while current_number <= 5:\n",
    "                  print(current_number)\n",
    "                  current_number += 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Flags"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter 'quit' to end the program: quit\n"
     ]
    }
   ],
   "source": [
    "# For a program that should run only as long as many conditions are true, \n",
    "# you can define one variable that determines whether or not the entire pro- gram is active. \n",
    "# This variable, called a flag, acts as a signal to the program\n",
    "\n",
    "active = True\n",
    "while active:\n",
    "    message = input(\"Enter 'quit' to end the program: \")\n",
    "    if message == 'quit':\n",
    "        active = False\n",
    "    else: \n",
    "        print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exiting a loop with: break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type a city name or 'quit: 'quit\n"
     ]
    }
   ],
   "source": [
    "# To exit a while loop immediately without running any remaining code in the loop, \n",
    "# regardless of the results of any conditional test, use the break statement to exit the loop.\n",
    "\n",
    "while True:\n",
    "    city = input(\"Type a city name or 'quit: '\")\n",
    "    if city == 'quit':\n",
    "        break\n",
    "    else:\n",
    "        print(\"I'd love to go to \" + city.title() + \"!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!, Jesse\n"
     ]
    }
   ],
   "source": [
    "def greet_user(name):\n",
    "    \"\"\"Display a simple greeting.\"\"\"\n",
    "    print(\"Hello!,\", name)\n",
    "greet_user(\"Jesse\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Argument vs. Parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet_user(username):\n",
    "    pass\n",
    "# username is a parameter\n",
    "greet_user(\"Jesse\")\n",
    "# Jesse is a argument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keyword Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you call a function, the order of the arguments needs to correspond with the order of the parameters you specified when you built the function.\n",
    "If you want to pass in the arguments in a differnt order you need to use keyword arguments, like this:\n",
    "\n",
    "describe_pet(animal_type='hamster', pet_name='harry')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Default values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can provide default values for each parameter. If an argument for the parameter is given in the function call, Python will use the provided argument, if not it will use the default. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "I have a dog.\n",
      "My dog's name is Willie.\n",
      "\n",
      "I have a cat.\n",
      "My cat's name is Willie.\n"
     ]
    }
   ],
   "source": [
    "def describe_pet(pet_name, animal_type='dog'):\n",
    "    \"\"\"Display information about a pet.\"\"\"\n",
    "    print(\"\\nI have a \" + animal_type + \".\")\n",
    "    print(\"My \" + animal_type + \"'s name is \" + pet_name.title() + \".\")\n",
    "describe_pet(pet_name='willie')\n",
    "describe_pet(pet_name='willie', animal_type=\"cat\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you use default values, any parameter with a default value needs to be listed after all the parameters that don’t have default values. This allows Python to continue interpreting positional arguments correctly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Return Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_formatted_name(first_name, last_name):\n",
    "    \"\"\"Return a full name, neatly formatted.\"\"\" \n",
    "    full_name = first_name + ' ' + last_name\n",
    "    return full_name.title()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The return statement takes a value from inside the function and sends it back to the line that called the function.\n",
    "When you call a function that returns a value, you need to provide a variable where the return value can be stored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jimi Hendrix\n"
     ]
    }
   ],
   "source": [
    "musician = get_formatted_name('jimi', 'hendrix') \n",
    "print(musician)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optional Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jimi Hendrix\n",
      "John Lee Hooker\n"
     ]
    }
   ],
   "source": [
    "def get_formatted_name(first_name, last_name, middle_name=''): #optional arguemnts have an empty string as default value\n",
    "    \"\"\"Return a full name, neatly formatted.\"\"\"\n",
    "    if middle_name:\n",
    "        full_name = first_name + ' ' + middle_name + ' ' + last_name\n",
    "    else:\n",
    "        full_name = first_name + ' ' + last_name\n",
    "    return full_name.title()\n",
    "\n",
    "musician = get_formatted_name('jimi', 'hendrix')\n",
    "print(musician)\n",
    "musician = get_formatted_name('john', 'hooker', 'lee') \n",
    "print(musician)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Returning a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'first': 'jimi', 'last': 'hendrix'}\n"
     ]
    }
   ],
   "source": [
    "def build_person(first_name, last_name):\n",
    "    \"\"\"Return a dictionary of information about a person.\"\"\"\n",
    "    person = {'first': first_name, 'last': last_name}\n",
    "    return person\n",
    "\n",
    "musician = build_person('jimi', 'hendrix')  \n",
    "print(musician)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'first': 'jimi', 'last': 'hendrix', 'age': 27}\n"
     ]
    }
   ],
   "source": [
    "def build_person(first_name, last_name, age=''):\n",
    "    \"\"\"Return a dictionary of information about a person.\"\"\"\n",
    "    person = {'first': first_name, 'last': last_name}\n",
    "    if age: #age is True if the string is not empty\n",
    "        person['age'] = age\n",
    "        return person\n",
    "    \n",
    "musician = build_person('jimi', 'hendrix', age=27)\n",
    "print(musician)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Passing a list into a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Hannah!\n",
      "Hello, Ty!\n",
      "Hello, Margot!\n"
     ]
    }
   ],
   "source": [
    "def greet_users(names):\n",
    "    \"\"\"Print a simple greeting to each user in the list.\"\"\"\n",
    "    for name in names:\n",
    "        msg = \"Hello, \" + name.title() + \"!\"\n",
    "        print(msg)\n",
    "        \n",
    "usernames = ['hannah', 'ty', 'margot'] \n",
    "greet_users(usernames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modifying a list in a function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any changes made to the list inside the function’s body are permanent.\n",
    "If you don't want a function to modify your list you should pass a copy of the list into the function. You can do that by: \n",
    "\n",
    "def name(list_copy[:])\n",
    "\n",
    "The slice notation [:] makes a copy of the list to send to the function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Passing an arbitrary number of items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('pepperoni',)\n",
      "('mushrooms', 'green peppers', 'extra cheese')\n"
     ]
    }
   ],
   "source": [
    "def make_pizza(*toppings):\n",
    "    \"\"\"Print the list of toppings that have been requested.\"\"\"\n",
    "    print(toppings)\n",
    "    \n",
    "make_pizza('pepperoni')\n",
    "make_pizza('mushrooms', 'green peppers', 'extra cheese')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The asterisk in the parameter name *toppings tells Python to make an empty tuple called toppings and pack whatever values it receives into this tuple. \n",
    "If you want a function to accept several different kinds of arguments, the parameter that accepts an arbitrary number of arguments must be placed last in the function definition. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Passing arbitrary items and putting in dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A double ** before a function parameter causes python to create a new dict and pack whatever key-value pairs it receives into that dict. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def find_nb(m):\n",
    "    x = 0\n",
    "    n = 1\n",
    "    while x != m:   \n",
    "        if x > m:\n",
    "            return -1 \n",
    "        x += + n^3 \n",
    "        n += 1\n",
    "    return n    \n",
    "\n",
    "find_nb(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modules "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'pizza'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-70-fb9e221d019e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#Importing entire module\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mpizza\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;31m#call function after importing entire module\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mpizza\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmakepizza\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'pizza'"
     ]
    }
   ],
   "source": [
    "#Importing entire module\n",
    "import pizza\n",
    "#call function after importing entire module\n",
    "pizza.makepizza()\n",
    "\n",
    "#Import specific functions\n",
    "from pizza import dough\n",
    "#call fucntion\n",
    "dough()\n",
    "\n",
    "#Importt function as alias\n",
    "from pizza import dough as dh\n",
    "\n",
    "#Import module as alias\n",
    "import pizza as pz\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Styling fucntions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- descriptive, lowercase name, only letters and underscores\n",
    "- docstring\n",
    "- if parameter has default value, use no spaces around = \n",
    "- same for function calls, no spaces around the = \n",
    "- all import statements at beginning of file\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classes have attributes and methods and are the blueprint for specific instances of the class, called objects. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The __init__( ) method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The __init__() method is a special method Python runs automatically whenever we create a new instance based on the Dog class. \n",
    "This method has two leading underscores and two trailing under- scores, a convention that helps prevent Python’s default method names from conflicting with your method names. \n",
    "Self must be included because when we later create an instance of the class, python will automatically pass the self argument for every method call in order to reference the specific instance and give it access to the classes attributes and methods. \n",
    "When we create an instance of a class we pass in all the arguments soecified in the __init__() method apart from the self argument. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog():\n",
    "    \"\"\"A simple attempt to model a dog.\"\"\"\n",
    "    def __init__(self, name, age):\n",
    "        \"\"\"Initialize name and age attributes.\"\"\"\n",
    "        self.name = name \n",
    "        self.age = age\n",
    "        self.weight = 30 #setting default value\n",
    "    def sit(self):\n",
    "        \"\"\"Simulate a dog sitting in response to a command.\"\"\" \n",
    "        print(self.name.title() + \" is now sitting.\")\n",
    "    def roll_over(self):\n",
    "        \"\"\"Simulate rolling over in response to a command.\"\"\"\n",
    "        print(self.name.title() + \" rolled over!\")\n",
    "    def c_age(self, new_age):\n",
    "        \"\"\"Change the dogs age\"\"\"\n",
    "        self.age = new_age\n",
    "    def inc_age(self, years):\n",
    "        \"\"\"Increment age by given value\"\"\"\n",
    "        self.age += years\n",
    "    def description(self):\n",
    "        print(f\"This dog is called {self.name}, he/she is {self.age} years old and weighs {self.weight}kg.\")\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making an instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dog = Dog(\"Buzz\", 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Class styling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Capitalisation indicates a class, like Dog()\n",
    "A lowercase variable, like my_dog, indicates an instance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accesing attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My dog's name is Buzz.\n",
      "My dog is 3 years old.\n"
     ]
    }
   ],
   "source": [
    "print(\"My dog's name is \" + my_dog.name.title() + \".\")\n",
    "print(\"My dog is \" + str(my_dog.age) + \" years old.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calling methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Buzz is now sitting.\n",
      "Buzz rolled over!\n"
     ]
    }
   ],
   "source": [
    "my_dog.sit()\n",
    "my_dog.roll_over()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modifying an attribute's value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "27\n",
      "37\n"
     ]
    }
   ],
   "source": [
    "# Directly\n",
    "my_dog.age = 6\n",
    "print(my_dog.age)\n",
    "\n",
    "# Through a method, needs change to Class.\n",
    "my_dog.c_age(27)\n",
    "print(my_dog.age)\n",
    "\n",
    "#Increment an attribute's value instead of giving it an entirely new value\n",
    "my_dog.inc_age(10)\n",
    "print(my_dog.age)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you need a class that is more specialised than an alredy exisiting class you can inherit from the parent class. The child class automatically inherits all attributes and methods from the parent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This dog is called Bobby, he/she is 12 years old and weighs 30kg.\n",
      "blue\n"
     ]
    }
   ],
   "source": [
    "#Parent class must be in samel file and appear before child class\n",
    "class Husky(Dog): #name of parent class goes in ()\n",
    "    \"\"\"Represents aspects of a dog, specific to a Husky\"\"\"\n",
    "    def __init__(self, name, age, eyes): #all attributes that are needed to create instance, from parent and new ones, specific to the child\n",
    "        \"\"\"Initialise attributes of parent class\"\"\"\n",
    "        super().__init__(name, age) #makes connection to parent, only put attributes here that belong to the parent class\n",
    "        self.eyes = eyes\n",
    "        \n",
    "my_husky = Husky(\"Bobby\", 12, \"blue\")  \n",
    "my_husky.description()\n",
    "print(my_husky.eyes)\n",
    "\n",
    "\n"
   ]
  }
 ],
 "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.6.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "256px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}