datatypes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables and Data Types\n",
    "\n",
    "## Choosing Good Identifiers\n",
    "\n",
    "An identifier is just a name label, so it could refer to more or less anything including commands, so\n",
    "it helps to keep things readable and understandable if you choose sensible names. You need to be\n",
    "careful to avoid choosing names that are already being used in your current Python session to identify\n",
    "your new variables. Choosing the same name as something else can make the original item with that\n",
    "name inaccessible.\n",
    "\n",
    "\n",
    "This could be particularly bad if the name you choose is an essential part of the Python language,\n",
    "but luckily Python does not allow you to name variables after any essential parts of the language.\n",
    "\n",
    "## Python Keywords\n",
    "\n",
    "The following words are the keywords, which form the basis of the Python language. You are not allowed\n",
    "to use these words to name your variables, because these are the core commands of Python."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "• False             • elif                      • lambda\n",
    "• None              • else                      • nonlocal \n",
    "• True              • except                    • not\n",
    "• and               • finally                   • or\n",
    "• as                • for                       • pass\n",
    "• assert            • from                      • raise\n",
    "• break             • global                    • return\n",
    "• class             • if                        • try\n",
    "• continue          • import                    • while\n",
    "• def               • in                        • with\n",
    "• del               • is                        • yield"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Variables and Assigning Values\n",
    "\n",
    "In many programming languages, there are two stages to creating a variable: The first is to create the\n",
    "container and stick an identifying label on it; this is called initialization. The second is to put a value into\n",
    "it; this is called assignment.\n",
    "\n",
    "variable = value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "number = 0\n",
    "roll_width = 1.4\n",
    "price_per_metre = 5\n",
    "filename = 'data.txt'\n",
    "trace = False\n",
    "sentence = \"this is a whole lot of nothing\"\n",
    "total_price = roll_width * price_per_metre"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Working with Dynamic Typing\n",
    "\n",
    "In Python, once a value has been assigned to a variable, the interpreter will then decide what sort of\n",
    "value it is (i.e., a number, some text, or some other relevant quality). This is known as dynamic typing (it\n",
    "has nothing to do with how many words per minute you can input from the keyboard)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b = 3\n",
    "c = 'word'\n",
    "trace = False\n",
    "b + c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "whos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "counter = 100          # An integer assignment\n",
    "miles   = 1000.0       # A floating point\n",
    "name    = \"John\"       # A string\n",
    "\n",
    "print counter\n",
    "print miles\n",
    "print name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple Assignment\n",
    "\n",
    "Python allows you to assign a single value to several variables simultaneously."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = b = c = 1\n",
    "d,e,f = 2,3,\"john\"\n",
    "print(a,b,c,d,e,f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "m = 300\n",
    "n = 400\n",
    "m = n\n",
    "print(id(m))\n",
    "print(id(n))\n",
    "n = 600\n",
    "print(m)\n",
    "print(id(m))\n",
    "print(id(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "name = \"Bob\"\n",
    "Age = 54\n",
    "has_W2 = True\n",
    "print(name, Age, has_W2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "age = 1\n",
    "Age = 2\n",
    "aGe = 3\n",
    "AGE = 4\n",
    "a_g_e = 5\n",
    "_age = 6\n",
    "age_ = 7\n",
    "_AGE_ = 8\n",
    "\n",
    "print(age, Age, aGe, AGE, a_g_e, _age, age_, _AGE_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(age+Age)\n",
    "print('hi'*Age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "del age\n",
    "print(age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python Numbers\n",
    "\n",
    "There are three numeric types in Python:\n",
    "\n",
    "    int\n",
    "    float\n",
    "    complex\n",
    "\n",
    "Variables of numeric types are created when you assign a value to them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 1    # int\n",
    "y = 2.8  # float\n",
    "z = 1j   # complex\n",
    "print(type(x))\n",
    "print(type(y))\n",
    "print(type(z))\n",
    "\n",
    "x = 1\n",
    "y = 35656222554887711\n",
    "z = -3255522\n",
    "\n",
    "print(type(x))\n",
    "print(type(y))\n",
    "print(type(z))\n",
    "\n",
    "x = 35e3\n",
    "y = 12E4\n",
    "z = -87.7e100\n",
    "\n",
    "print(type(x))\n",
    "print(type(y))\n",
    "print(type(z))\n",
    "\n",
    "x = 3+5j\n",
    "y = 5j\n",
    "z = -5j\n",
    "\n",
    "print(type(x))\n",
    "print(type(y))\n",
    "print(type(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### In the Beginning Was the Void\n",
    "\n",
    "Python has a special predefined value called None, which represents nothing. The value None\n",
    "has its own type and is useful where you want to create a variable but don’t want to specify its value (and\n",
    "therefore its type) just yet. Assigning values such as 0 or \"\" to a variable will create an int or str type\n",
    "variable. You can assign the value None like this, which produces a NoneType variable. Don’t forget it starts\n",
    "with a capital N.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "information = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Quotes\n",
    "\n",
    "    \"A text string enclosed by double quotes and all on one line.\"\n",
    "\n",
    "    'A text string enclosed by single quotes, all on one line again.'\n",
    "\n",
    "    '''A text string including multiple lines of text\n",
    "    line breaks\n",
    "    and other formatting\n",
    "    can be enclosed in triple quotes.\n",
    "    '''\n",
    "    \n",
    "    \"\"\"or even:\n",
    "    triple double quotes.\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(\"Example Heading\\n\\nFollowed by a line\\nor two of text\\n \\tName\\n\\tRace\\n\\tGender\\nDon't forget to escape \\'\\\\\\'.\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accepting User Input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "string=raw_input(\"Enter a string: \")\n",
    "string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction to Intrinsic Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    cmp(ob1,ob2)\n",
    "\n",
    "The cmp() function compares two Python objects, ob1 and ob2, and returns 0 if\n",
    "ob1 equals ob2, 1 if ob1 is greater than ob2, and -1 if ob1 is less than ob2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a,b=hex(34),34\n",
    "print a\n",
    "cmp(0x22,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cmp((1,2,3,4),(1,2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cmp([123,'abc',888],[123,'abc'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cmp(13,13)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to the functions that can be performed on all data types, there are func-\n",
    "tions that can be performed only on sequence types, such as the **len(), max(), and\n",
    "min() functions**.The len() function is used to find the length of a\n",
    "sequence. The max() and min() functions can be used to find the element with the\n",
    "minimum and maximum values, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(max('abc'))\n",
    "print(min('abc'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(max(2,3,5,5))\n",
    "print(min(5,-2,5,6,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Intrinsic Operations for Numeric Data Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(int('14'))\n",
    "print(float(10))\n",
    "print(complex(11))\n",
    "print(abs(-44))\n",
    "print(divmod(10,6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Intrinsic Operations for Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **repr()** function. You can pass an object of any data type to the repr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(repr(76))\n",
    "print(repr(76+4j))\n",
    "print(repr(10.34))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making Choices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conditional statements transform the script from being just a list of instructions to something that can\n",
    "make decisions on the fly based on the information that it receives. It would be useful to be able to tell\n",
    "the program to perform different actions according to whether certain conditions are satisfied. You\n",
    "could write this out in pseudocode like this:\n",
    "\n",
    "    if one condition is true:\n",
    "        then perform one set of actions;\n",
    "    if another condition is true:\n",
    "        then perform another set of actions.\n",
    "        \n",
    "Each if-then pair is a conditional statement. Before we get into that, let’s look at how to specify\n",
    "conditions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Values can be compared using the following comparison operators:\n",
    "\n",
    "    •  <: Less than\n",
    "    • <=: Less than or equal\n",
    "    •  >: Greater than\n",
    "    • >=: Greater than or equal\n",
    "    • ==: Equal\n",
    "    • !=: Not equal\n",
    "    \n",
    "These affect the fundamental data types in different ways, each time giving us an answer of True or False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(-2 < 5)\n",
    "print(49 > 37)\n",
    "print(7.65 != 6.0)\n",
    "print(-5 <= -2)\n",
    "print(7 < -7)\n",
    "print(23.5 > 37.75)\n",
    "print(-5 >= 5)\n",
    "print(3.2 != 3.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "variable = 3.0\n",
    "variable == 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"alpha\" < \"omega\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"case\" == \"Case\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"net\" < \"network\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "len(\"alpha\") < len(\"omega\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cool = False\n",
    "icecream = False\n",
    "hot = True\n",
    "coffee = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cool and coffee"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "not cool and coffee"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cool or icecream"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "hot and coffee"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "hot and not icecream"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(hot and coffee) or (cool and icecream)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "var1 = 14\n",
    "(var1 > 6) and (var1 < 17)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Taking Control of the Process\n",
    "\n",
    "Sometimes, you need to make a choice about what happens next during the execution of the program\n",
    "using what is known as a **control flow statement**. In your scripts, you can now use the results of\n",
    "comparisons to create conditional statements. They are a form of control flow statement that allow\n",
    "different actions to be performed based on whether certain conditions hold true.In Python, conditional\n",
    "statements are constructed using the **if, elif, and else** keywords.\n",
    "    \n",
    "    if condition:\n",
    "        # Perform some actions\n",
    "        print \"Condition is True\"\n",
    "    elif condition != True:\n",
    "        # Perform some other actions\n",
    "        print \"Condition is not True\"\n",
    "    else:\n",
    "        # Perform default or fall-through actions\n",
    "        print \"Anomaly: Condition is neither True nor False\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "weight = float(input(\"How many pounds does your suitcase weigh? \"))\n",
    "if weight > 50:\n",
    "    print(\"There is a $25 charge for luggage that heavy.\")\n",
    "print(\"Thank you for your business.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a=10\n",
    "if(a>10):\n",
    "    print(\"Value of a is greater than 10\")\n",
    "else :\n",
    "    print(\"Value of a is 10\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "temperature = float(input('What is the temperature? '))\n",
    "if temperature > 35:\n",
    "    print('Wear shorts.')\n",
    "else:\n",
    "    print('Wear long pants.')\n",
    "print('Get some exercise outside.')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "totalHours = float(input('Enter hours worked: '))\n",
    "hourlyWage = float(input('Enter dollars paid per hour: '))\n",
    "if hours <= 40:\n",
    "    totalWages = hourlyWage*totalHours\n",
    "else:\n",
    "    overtime = totalHours - 40\n",
    "    totalWages = hourlyWage*40 + (1.5*hourlyWage)*overtime\n",
    "print('Wages for {totalHours} hours at ${hourlyWage:.2f} per hour are ${totalWages:.2f}.'.format(**locals()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "weight = float(input('Enter suitcase weight: '))\n",
    "if weight > 120:\n",
    "    print('Sorry, we can not take a suitcase that heavy.')\n",
    "elif weight > 50:\n",
    "    print('There is a $25 charge for luggage that heavy.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "birthyear = input('Enter your birth year: ')\n",
    "age = 2018 - birthyear\n",
    "if (age >= 11):\n",
    "    print (\"You are eligible to see the Football match.\")\n",
    "    if (age <= 20 or age >= 60):\n",
    "        print(\"Ticket price is $12\")\n",
    "    else:\n",
    "        print(\"Tic kit price is $20\")\n",
    "else:\n",
    "    print (\"You're not eligible to buy a ticket.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "var1 = input('Enter element to identify datatype: ')\n",
    "if (type(var1) == int):\n",
    "    print(\"Type of the variable is Integer\")\n",
    "elif (type(var1) == float):\n",
    "    print(\"Type of the variable is Float\")\n",
    "elif (type(var1) == complex):\n",
    "    print(\"Type of the variable is Complex\")\n",
    "elif (type(var1) == bool):\n",
    "    print(\"Type of the variable is Bool\")\n",
    "elif (type(var1) == str):\n",
    "    print(\"Type of the variable is String\")\n",
    "elif (type(var1) == tuple):\n",
    "    print(\"Type of the variable is Tuple\")\n",
    "elif (type(var1) == dict):\n",
    "    print(\"Type of the variable is Dictionaries\")\n",
    "elif (type(var1) == list):\n",
    "    print(\"Type of the variable is List\")\n",
    "else:\n",
    "    print(\"Type of the variable is Unknown\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a,b,c = 10,34,23\n",
    "\n",
    "if a > b or a > c:\n",
    "    print(\"At least one of the conditions are True\")\n",
    "\n",
    "if a < b and c > a:\n",
    "    print(\"Both conditions are True\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now Repeat That\n",
    "\n",
    "Often, you will want to repeat the same process over a range of different values. Writing this out\n",
    "longhand is not only tedious but contrary to the principles of good programming. Ideally, you should\n",
    "have to write out a set of instructions or piece of information only once. This can be achieved using a\n",
    "loop, which means that certain statements are executed repeatedly.\n",
    "There are two main methods of creating a loop in Python: **the while and for statements**. Let’s look at\n",
    "the while statement first.\n",
    "\n",
    "### Looping with the while Statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "result = 1\n",
    "while result < 500:\n",
    "    result *= 2\n",
    "    print result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Finding Average value entered by users\n",
    "\n",
    "counter = 0\n",
    "total = 0\n",
    "number = 0\n",
    "while number >= 0:\n",
    "    total += number\n",
    "    print(total)\n",
    "    counter += 1\n",
    "    number = int(input(\"Enter a positive number\\nor a negative to exit: \"))\n",
    "    print(counter)\n",
    "average = total / (counter-1)\n",
    "print(counter)\n",
    "print(\"Average values of entered values: \",average)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "name = 'Goa'\n",
    "guess = raw_input(\"So I'm thinking of a vacation spot. Try to guess it: \")\n",
    "pos = 0\n",
    "\n",
    "while guess != name and pos < len(name):\n",
    "    print(\"Nope, that's not it! Hint: letter \")\n",
    "    print(pos + 1, \"is\", name[pos] + \". \")\n",
    "    guess = raw_input(\"Guess again: \")\n",
    "    pos = pos + 1\n",
    "\n",
    "if pos == len(name) and name != guess:\n",
    "    print(\"Too bad, you couldn't get it.  The vacation spot was\", name + \".\")\n",
    "else:\n",
    "    print(\"\\nGreat, you got it in\", pos + 1,  \"guesses!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import random                      # Import the random module \n",
    "\n",
    "number = random.randrange(1, 1000) # Get random number between [1 and 1000)\n",
    "guesses = 0\n",
    "guess = int(input(\"Guess my number between 1 and 1000: \"))\n",
    "\n",
    "while guess != number:\n",
    "    guesses += 1\n",
    "    if guess > number:\n",
    "        print(guess, \"is too high.\") \n",
    "    elif guess < number:\n",
    "        print(guess, \" is too low.\")\n",
    "    guess = int(input(\"Guess again: \"))\n",
    "\n",
    "print(\"\\n\\nGreat, you got it in\", guesses,  \"guesses!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#  The break statement\n",
    "\n",
    "for i in [12, 16, 17, 24, 29]:\n",
    "    if i % 2 == 1:  # if the number is odd\n",
    "        break        # immediately exit the loop\n",
    "    print(i)\n",
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# The continue statement\n",
    "for i in [12, 16, 17, 24, 29, 30]:\n",
    "    if i % 2 == 1:      # if the number is odd\n",
    "        pass        # don't process it\n",
    "    print(i)\n",
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}