loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionary Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-27T14:46:37.010510Z",
     "start_time": "2018-05-27T14:46:37.005497Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys([100, 102, 103, 104])\n",
      "dict_values(['abc', 'xyz', 'lmn', 'def'])\n",
      "dict_items([(100, 'abc'), (102, 'xyz'), (103, 'lmn'), (104, 'def')])\n"
     ]
    }
   ],
   "source": [
    "d = {100:'abc', 102:'xyz', 103:'lmn', 104:'def'}\n",
    "\n",
    "print(d.keys())\n",
    "\n",
    "print(d.values())\n",
    "\n",
    "print(d.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-28T06:59:51.989069Z",
     "start_time": "2018-05-28T06:59:51.983563Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\"don't\", 'me', 'Please', 'sort']\n"
     ]
    }
   ],
   "source": [
    "# d = eval(input('Enter Dictionary: '))\n",
    "\n",
    "# print(sum(d.values()))\n",
    "\n",
    "print(sorted(\"Please don't sort me\".split(), key=str.lower))\n",
    "# {'a':100,'b':75,'c':90, 'd': 100, 'e':95}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-27T16:09:41.156477Z",
     "start_time": "2018-05-27T16:08:44.194584Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Dictionary: {'a':100,'b':75,'c':90, 'd': 100, 'e':95}\n",
      "[('b', 75), ('c', 90), ('e', 95), ('a', 100), ('d', 100)]\n"
     ]
    }
   ],
   "source": [
    "import operator\n",
    "\n",
    "d = eval(input('Enter Dictionary: '))\n",
    "\n",
    "sorted_d = sorted(d.items(), key=operator.itemgetter(1))\n",
    "\n",
    "print(sorted_d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Membership Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>in and not in</b> are membership operators in Python.\n",
    "\n",
    "Used to find whether a value or variable is found in a sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-28T07:05:28.934187Z",
     "start_time": "2018-05-28T07:05:28.929176Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "lst = [1,2,3,4]\n",
    "\n",
    "print(5 in lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-28T07:06:59.266839Z",
     "start_time": "2018-05-28T07:06:59.261826Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "dict = {1:'a', 2:'b'}\n",
    "\n",
    "print(2 not in dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-28T07:07:53.240036Z",
     "start_time": "2018-05-28T07:07:53.232939Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "s = 'Python'\n",
    "\n",
    "print('P' in s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## while loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-28T07:16:03.029318Z",
     "start_time": "2018-05-28T07:16:03.014570Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The count is:   0\n",
      "The count is:   1\n",
      "The count is:   2\n",
      "The count is:   3\n",
      "The count is:   4\n",
      "The count is:   5\n",
      "The count is:   6\n",
      "The count is:   7\n",
      "The count is:   8\n",
      "The count is:   9\n",
      "Good bye! count is:  10\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "while(count < 10):\n",
    "    print('The count is:  ', count)\n",
    "    count = count + 1\n",
    "print('Good bye! count is: ', count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-26T12:28:15.698509Z",
     "start_time": "2018-05-26T12:28:15.693997Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Product = 120\n"
     ]
    }
   ],
   "source": [
    "tup = (1,2,3,4,5)\n",
    "\n",
    "prod = 1\n",
    "index = 0\n",
    "\n",
    "while index < len(tup):\n",
    "    prod *= tup[index]\n",
    "    index += 1\n",
    "\n",
    "print('Product = {}'.format(prod))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### while....else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-28T07:23:33.929194Z",
     "start_time": "2018-05-28T07:23:33.921193Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No more numbers in tuple.\n",
      "Product = 120\n"
     ]
    }
   ],
   "source": [
    "tup = (1,2,3,4,5)\n",
    "\n",
    "prod = 1\n",
    "index = 0\n",
    "\n",
    "while index < len(tup):\n",
    "    prod *= tup[index]\n",
    "    index += 1\n",
    "else:\n",
    "    print('No more numbers in tuple.')\n",
    "\n",
    "print('Product = {}'.format(prod))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-26T15:47:15.771672Z",
     "start_time": "2018-05-26T15:47:12.807696Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 5\n",
      "16\n",
      "8\n",
      "4\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "def collatz(number):\n",
    "    if number % 2 == 0:\n",
    "        print(number // 2)\n",
    "        return number // 2\n",
    "    elif number % 2 == 1:\n",
    "        result = 3 * number + 1\n",
    "        print(result)\n",
    "        return result\n",
    "\n",
    "num = int(input('Enter a number: '))\n",
    "\n",
    "while num != 1:\n",
    "    num = collatz(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-26T15:51:09.047649Z",
     "start_time": "2018-05-26T15:51:09.044141Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Product = 120\n"
     ]
    }
   ],
   "source": [
    "tup = (1,2,3,4,5)\n",
    "\n",
    "prod = 1\n",
    "\n",
    "for item in tup:\n",
    "    prod *= item\n",
    "\n",
    "print('Product = {}'.format(prod))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-26T15:53:24.867100Z",
     "start_time": "2018-05-26T15:53:24.863090Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The count is:   0\n",
      "The count is:   1\n",
      "The count is:   2\n",
      "The count is:   3\n",
      "The count is:   4\n",
      "The count is:   5\n",
      "The count is:   6\n",
      "The count is:   7\n",
      "The count is:   8\n",
      "The count is:   9\n",
      "Good bye!\n"
     ]
    }
   ],
   "source": [
    "for count in range(10):\n",
    "    print('The count is:  ', count)\n",
    "print('Good bye!')\n",
    "\n",
    "# try range(1, 10, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-28T07:54:28.023220Z",
     "start_time": "2018-05-28T07:54:28.018707Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "40\n",
      "50\n",
      "60\n"
     ]
    }
   ],
   "source": [
    "# Iterating directly element by element\n",
    "\n",
    "\n",
    "# Iterating by sequence index\n",
    "lst = [10,20,30,40,50,60]\n",
    "for index in range(len(lst)):\n",
    "    print(lst[index])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-27T16:29:06.269555Z",
     "start_time": "2018-05-27T16:29:06.256095Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LIST ITERATION: \n",
      "10 20 30 40 50 60 \n",
      "TUPLE ITERATION: \n",
      "10 20 30 40 50 60 \n",
      "STRING ITERATION: \n",
      "P y t h o n \n",
      "DICTIONARY ITERATION: \n",
      "xyz 123\n",
      "abc 345\n"
     ]
    }
   ],
   "source": [
    "print('LIST ITERATION: ')\n",
    "lst = [10,20,30,40,50,60]\n",
    "for element in lst:\n",
    "    print(element, end=' ')\n",
    "print()\n",
    "\n",
    "print('TUPLE ITERATION: ')\n",
    "tup = (10,20,30,40,50,60)\n",
    "for element in tup:\n",
    "    print(element, end=' ')\n",
    "print()\n",
    "\n",
    "print('STRING ITERATION: ')\n",
    "myStr = 'Python'\n",
    "for element in myStr:\n",
    "    print(element, end=' ')\n",
    "print()\n",
    "\n",
    "print('DICTIONARY ITERATION: ')\n",
    "dict = {}\n",
    "dict['xyz'] = 123\n",
    "dict['abc'] = 345\n",
    "for key in dict:\n",
    "    print(key, dict[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### for.....else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-27T03:53:22.112032Z",
     "start_time": "2018-05-27T03:53:22.096617Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You have exhausted the list\n",
      "Product = 120\n"
     ]
    }
   ],
   "source": [
    "tup = (1,2,3,4,5)\n",
    "\n",
    "prod = 1\n",
    "\n",
    "for item in tup:\n",
    "    prod *= item\n",
    "else:\n",
    "    print('You have exhausted the list')\n",
    "\n",
    "print('Product = {}'.format(prod))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-28T08:03:01.951895Z",
     "start_time": "2018-05-28T08:03:01.941868Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i: 0, j:0\n",
      "i: 0, j:1\n",
      "i: 0, j:2\n",
      "i: 1, j:0\n",
      "i: 1, j:1\n",
      "i: 1, j:2\n",
      "i: 2, j:0\n",
      "i: 2, j:1\n",
      "i: 2, j:2\n",
      "i: 3, j:0\n",
      "i: 3, j:1\n",
      "i: 3, j:2\n",
      "i: 4, j:0\n",
      "i: 4, j:1\n",
      "i: 4, j:2\n",
      "i: 5, j:0\n",
      "i: 5, j:1\n",
      "i: 5, j:2\n",
      "i: 6, j:0\n",
      "i: 6, j:1\n",
      "i: 6, j:2\n",
      "i: 7, j:0\n",
      "i: 7, j:1\n",
      "i: 7, j:2\n",
      "i: 8, j:0\n",
      "i: 8, j:1\n",
      "i: 8, j:2\n",
      "i: 9, j:0\n",
      "i: 9, j:1\n",
      "i: 9, j:2\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "\n",
    "while i < 10:\n",
    "    j = 0\n",
    "    while j < 3:\n",
    "        print('i: {}, j:{}'.format(i, j))\n",
    "        j += 1\n",
    "        \n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-28T08:09:17.932127Z",
     "start_time": "2018-05-28T08:09:17.926647Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prime Numbers between 1 & 11 are: \n",
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "num_1 = 1\n",
    "num_2 = 11\n",
    "\n",
    "print('Prime Numbers between {} & {} are: '.format(num_1,num_2))\n",
    "\n",
    "for num in range(num_1, num_2+1):\n",
    "    if num > 1:\n",
    "        isDivisible = False\n",
    "        for index in range(2, num):\n",
    "            if num % index == 0:\n",
    "                isDivisible = True\n",
    "        if not isDivisible:\n",
    "            print(num)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## BREAK & CONTINUE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-27T04:06:33.272402Z",
     "start_time": "2018-05-27T04:06:33.265224Z"
    }
   },
   "source": [
    "<img src = \"1.jpg\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-27T04:32:35.020303Z",
     "start_time": "2018-05-27T04:32:35.011591Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The count is:   0\n",
      "The count is:   1\n",
      "The count is:   2\n",
      "The count is:   3\n",
      "The count is:   4\n",
      "Good bye!\n"
     ]
    }
   ],
   "source": [
    "for count in range(10):\n",
    "    if count == 5:\n",
    "        break\n",
    "    print('The count is:  ', count)\n",
    "print('Good bye!')\n",
    "# try else"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src = \"2.jpg\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-27T15:09:27.512288Z",
     "start_time": "2018-05-27T15:09:27.508280Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The count is:   0\n",
      "The count is:   1\n",
      "The count is:   2\n",
      "The count is:   3\n",
      "The count is:   4\n",
      "The count is:   6\n",
      "The count is:   7\n",
      "The count is:   8\n",
      "The count is:   9\n",
      "Good bye!\n"
     ]
    }
   ],
   "source": [
    "for count in range(10):\n",
    "    if count == 5:\n",
    "        continue\n",
    "    print('The count is:  ', count)\n",
    "print('Good bye!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-28T08:17:28.941451Z",
     "start_time": "2018-05-28T08:17:23.611233Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number to check if its even or odd: 7\n",
      "Wrong Number!!\\nGAME OVER\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    num = int(input(\"Enter a number to check if its even or odd: \"))\n",
    "    if num % 2 == 0:\n",
    "        print('Congratulations, you entered an even number.')\n",
    "    else:\n",
    "        break\n",
    "print('Wrong Number!!\\\\nGAME OVER')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assignment Discussions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "Q.4- From a list containing ints, strings and floats, make three lists to store them separately <br />\n",
    "Q.7- Create a user defined dictionary and get keys corresponding to the value using for loop.<br />\n",
    "Q.8- Take inputs from user to make a list. Again take one input from user and search it in the list and delete that element, if found. Iterate over list using for loop.\n",
    "</p>"
   ]
  }
 ],
 "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": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}