Loops, range, Comprehensions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic If Else Statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It was True\n"
     ]
    }
   ],
   "source": [
    "# If statements in Python allows the system \n",
    "# to perform other alternative actions\n",
    "if True:\n",
    "    print ('It was True')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I will print when x is anything not True\n"
     ]
    }
   ],
   "source": [
    "x = False\n",
    "if x:\n",
    "    print ('x was True')\n",
    "else:\n",
    "    print ('I will print when x is anything not True')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to the Bank\n",
      "Welcome to Auto shop!\n",
      "Where are you\n"
     ]
    }
   ],
   "source": [
    "loc = 'Bank'\n",
    "if loc == 'Auto Shop':\n",
    "    print ('Welcome to Auto shop!')\n",
    "elif loc == 'Bank':\n",
    "    print ('Welcome to the Bank')\n",
    "else:\n",
    "    print ('Where are you')\n",
    "    \n",
    "loc = 'Auto Shop'\n",
    "if loc == 'Auto Shop':\n",
    "    print ('Welcome to Auto shop!')\n",
    "elif loc == 'Bank':\n",
    "    print ('Welcome to the Bank')\n",
    "else:\n",
    "    print ('Where are you')\n",
    "\n",
    "loc = 'Mall'\n",
    "if loc == 'Auto Shop':\n",
    "    print ('Welcome to Auto shop!')\n",
    "elif loc == 'Bank':\n",
    "    print ('Welcome to the Bank')\n",
    "else:\n",
    "    print ('Where are you')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# for Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# For loops is will help us to iterate over a sequence of items or any \n",
    "# other iterable item like strings, lists, tuples and keys or values of dicts\n",
    "l = [1, 2, 3, 4, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for elements in l:\n",
    "    print (elements)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "something\n",
      "something\n",
      "something\n",
      "something\n",
      "something\n"
     ]
    }
   ],
   "source": [
    "for num in l:\n",
    "    print ('something')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here is an odd 1\n",
      "Here is an even 2\n",
      "Here is an odd 3\n",
      "Here is an even 4\n",
      "Here is an odd 5\n"
     ]
    }
   ],
   "source": [
    "for num in l:\n",
    "    if num % 2 == 0:\n",
    "        print ('Here is an even', num)\n",
    "    else:\n",
    "        print ('Here is an odd', num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "list_sum = 0\n",
    "for num in l:\n",
    "    list_sum += num\n",
    "print (list_sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s = 'This is a string!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T\n",
      "h\n",
      "i\n",
      "s\n",
      " \n",
      "i\n",
      "s\n",
      " \n",
      "a\n",
      " \n",
      "s\n",
      "t\n",
      "r\n",
      "i\n",
      "n\n",
      "g\n",
      "!\n"
     ]
    }
   ],
   "source": [
    "for letter in s:\n",
    "    print (letter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tup = (1,2.3,4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2.3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for item in tup:\n",
    "    print (item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l = [(2,4), (6,8), (10,12)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 4)\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print (l[0])\n",
    "print (l[0][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 4)\n",
      "(6, 8)\n",
      "(10, 12)\n"
     ]
    }
   ],
   "source": [
    "for tup in l:\n",
    "    print (tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "6\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for (t1, t2) in l:\n",
    "    print (t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "14\n",
      "22\n"
     ]
    }
   ],
   "source": [
    "for (t1, t2) in l:\n",
    "    print (t1+t2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d = {'k1':1, 'k2':2, 'k3':3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k1\n",
      "k2\n",
      "k3\n"
     ]
    }
   ],
   "source": [
    "for item in d:\n",
    "    print (item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k1\n",
      "1\n",
      "k2\n",
      "2\n",
      "k3\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for k,v in d.items():\n",
    "    print (k)\n",
    "    print (v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# While loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is currently 0\n",
      "x is currently 1\n",
      "x is currently 2\n",
      "x is currently 3\n",
      "x is currently 4\n",
      "x is currently 5\n",
      "x is currently 6\n",
      "x is currently 7\n",
      "x is currently 8\n",
      "x is currently 9\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x < 10:\n",
    "    print ('x is currently', x)\n",
    "    x += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is currently 0\n",
      "x is currently 1\n",
      "x is currently 2\n",
      "x is currently 3\n",
      "x is currently 4\n",
      "x is currently 5\n",
      "x is currently 6\n",
      "x is currently 7\n",
      "x is currently 8\n",
      "x is currently 9\n",
      "All Done\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x < 10:\n",
    "    print ('x is currently', x)\n",
    "    x += 1\n",
    "\n",
    "else:\n",
    "    print ('All Done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# break, continue and pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is currently: 0\n",
      "x is still less than 10, adding 1 to x\n",
      "continuing\n",
      "x is currently: 1\n",
      "x is still less than 10, adding 1 to x\n",
      "continuing\n",
      "x is currently: 2\n",
      "x is still less than 10, adding 1 to x\n",
      "x has reached 3!\n",
      "x is currently: 3\n",
      "x is still less than 10, adding 1 to x\n",
      "continuing\n",
      "x is currently: 4\n",
      "x is still less than 10, adding 1 to x\n",
      "continuing\n",
      "x is currently: 5\n",
      "x is still less than 10, adding 1 to x\n",
      "continuing\n",
      "x is currently: 6\n",
      "x is still less than 10, adding 1 to x\n",
      "continuing\n",
      "x is currently: 7\n",
      "x is still less than 10, adding 1 to x\n",
      "continuing\n",
      "x is currently: 8\n",
      "x is still less than 10, adding 1 to x\n",
      "continuing\n",
      "x is currently: 9\n",
      "x is still less than 10, adding 1 to x\n",
      "continuing\n"
     ]
    }
   ],
   "source": [
    "# sometimes it is necessary to use break statement for while\n",
    "x = 0\n",
    "while x <10:\n",
    "    print ('x is currently:', x)\n",
    "    print ('x is still less than 10, adding 1 to x')\n",
    "    x += 1\n",
    "    if x == 3:\n",
    "        print ('x has reached 3!')\n",
    "    else:\n",
    "        print ('continuing')\n",
    "        continue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is currently: 0\n",
      "x is still less than 10, adding 1 to x\n",
      "continuing\n",
      "x is currently: 1\n",
      "x is still less than 10, adding 1 to x\n",
      "continuing\n",
      "x is currently: 2\n",
      "x is still less than 10, adding 1 to x\n",
      "x has reached 3!\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x <10:\n",
    "    print ('x is currently:', x)\n",
    "    print ('x is still less than 10, adding 1 to x')\n",
    "    x += 1\n",
    "    if x == 3:\n",
    "        print ('x has reached 3!')\n",
    "        break\n",
    "    else:\n",
    "        print ('continuing')\n",
    "        continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 10)\n"
     ]
    }
   ],
   "source": [
    "print (range(0, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x= range(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 5)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = 5\n",
    "stop = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(5, 20, 2)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(start,stop,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i now equal to: 0\n",
      "i now equal to: 1\n",
      "i now equal to: 2\n",
      "i now equal to: 3\n",
      "i now equal to: 4\n",
      "i now equal to: 5\n"
     ]
    }
   ],
   "source": [
    "sumsquares = 0\n",
    "for i in range(0, 6):\n",
    "          print (\"i now equal to:\", i)\n",
    "          sumsquares = sumsquares + i**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "-2\n",
      "-4\n",
      "-6\n",
      "-8\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, -10, -2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# generator allows generation of \"generated\" objects that are provided\n",
    "# at that instance but does not store every instance generated into\n",
    "# memory. Specifically for pyton 2 there is xrange but in 3 range is xrange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = range(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x2 = list(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x == x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 6)\n",
      "[0, 1, 2, 3, 4, 5]\n",
      "<class 'range'>\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "print (x)\n",
    "print (x2)\n",
    "print (type(x))\n",
    "print (type(x2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# In addition to sequence operations and list methods, Python includes a\n",
    "# more advances operation called a list comprehension\n",
    "# List comprehension allows us to build our lists using a different notation\n",
    "# You can think of it as essentially a one line for loop built inside\n",
    "# of brackets\n",
    "list = [x for x in 'word']\n",
    "# you start by defining what the output should be then show where to get \n",
    "# the inputs for the outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['w', 'o', 'r', 'd']\n"
     ]
    }
   ],
   "source": [
    "print (list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['w', 'o', 'r', 'd']\n"
     ]
    }
   ],
   "source": [
    "l = []\n",
    "for letter in 'word':\n",
    "    l.append(letter)\n",
    "\n",
    "print (l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "lst = [x**2 for x in range(0,11)]\n",
    "print (lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "lst = [number for number in range(11) if number % 2 == 0]\n",
    "print (lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 10, 20.3, 23.6]\n"
     ]
    }
   ],
   "source": [
    "celsius = [0, 10, 20.3, 23.6]\n",
    "farenheit = [temp for temp in celsius]\n",
    "print (farenheit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[32.0, 50.0, 68.53999999999999, 74.48]\n"
     ]
    }
   ],
   "source": [
    "celsius = [0, 10, 20.3, 23.6]\n",
    "farenheit = [(temp * (9/5.0) + 32) for temp in celsius]\n",
    "print (farenheit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "lst = [x**2 for x in [x**2 for x in range(11)]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 16, 81, 256, 625, 1296, 2401, 4096, 6561, 10000]\n"
     ]
    }
   ],
   "source": [
    "print (lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}