oneliners.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce\n",
    "import random\n",
    "# import module sys to get the type of exception\n",
    "import sys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple and basic stuff:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Always begin with this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Lambda Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "min_xy = lambda x, y: x if x < y else y\n",
    "print(min_xy(8,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7320508075688772"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dist = (lambda w, v: (sum((wi - vi)**2 for wi, vi in zip(w, v)))**.5)\n",
    "dist((0, 0, 0), (1, 1, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 2, 5, 6, 7, 8, 8]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qsort = (lambda l: l if len(l) <= 1 else qsort([x for x in l[1:] if x < l[0]]) + [l[0]] + qsort([x for x in l[1:] if x >= l[0]]))\n",
    "qsort([1, 2, 5, 7, 8, 2, 6, 8])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 12, 30, 56, 90, 132, 182, 240, 306, 380, 462, 552, 650, 756, 870, 992, 1122, 1260, 1406, 1560]\n"
     ]
    }
   ],
   "source": [
    "print(list(map(lambda n: (lambda m: m+m*m)(2*n+1), range(0, 20))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'alphas:A, alphas:B, alphas:C, alphas:D, alphas:E, alphas:F, alphas:G'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Cut the end part of a string and attach it to the end of another string\n",
    "def foo(string, numbers): return ', '.join(map(lambda s, n: s+str(n), [string for i in numbers], numbers))\n",
    "foo('alphas:', 'ABCDEFG')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Map Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 25, 49]\n"
     ]
    }
   ],
   "source": [
    "n = [1, 3, 5, 7]\n",
    "print(list(map(lambda x: x**2, n)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n"
     ]
    }
   ],
   "source": [
    "print(list(map(lambda x: x+1, range(0, 20))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[True, True, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]\n"
     ]
    }
   ],
   "source": [
    "print(list(map(lambda x, f=lambda x, f: (x<=1) or (f(x-1, f)+f(x-2, f)): f(x, f), range(20))))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Reduce Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    }
   ],
   "source": [
    "n = [1, 2, 3, 4]\n",
    "print(reduce(lambda x, y: x*y, n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Filter Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4]\n"
     ]
    }
   ],
   "source": [
    "n = [1, 2, 3, 4]\n",
    "print (list(filter(lambda x: x > 2, n)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]\n"
     ]
    }
   ],
   "source": [
    "print(list(filter(None, map(lambda y: y*reduce(lambda x, y: x*y != 0, map(lambda x, y=y: y % x, range(2, int(pow(y, 0.5)+1))), 1), range(2, 1000)))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]\n"
     ]
    }
   ],
   "source": [
    "print(list(filter(None, map(lambda y: y*reduce(lambda x, y: x*y != 0, map(lambda x, y=y: y % x, range(2, int(pow(y, 0.5)+1))), 1), range(2, 1000)))))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Map/Reduce/Filter computations:\n",
    "# returns 100! (of course, you could just use math.factorial)\n",
    "\n",
    "reduce(lambda x, y: x * y, range(1, 101))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Argumants \\*args, \\**kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First argument : Hello\n",
      "Next argument through *argv : Welcome!\n",
      "Next argument through *argv : these\n",
      "Next argument through *argv : are\n",
      "Next argument through *argv : few\n",
      "Next argument through *argv : elegant\n",
      "Next argument through *argv : oneliners\n",
      "first == Mr.\n",
      "mid == Ram\n",
      "last == Singh\n"
     ]
    }
   ],
   "source": [
    "# values passed\n",
    "def myFun(arg1, *argv): \n",
    "    print (\"First argument :\", arg1) \n",
    "    for arg in argv: \n",
    "        print(\"Next argument through *argv :\", arg) \n",
    "  \n",
    "myFun('Hello', 'Welcome!', 'these', 'are', 'few', 'elegant', 'oneliners') \n",
    "\n",
    "# Key:value pairs are passed\n",
    "def myFun(arg1, **kwargs):  \n",
    "    for key, value in kwargs.items(): \n",
    "        print (\"%s == %s\" %(key, value)) \n",
    "  \n",
    "# Driver code \n",
    "myFun(\"Hello\", first ='Mr.', mid ='Ram', last='Singh') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Reading lines as arrays from a file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['hello', 'hi', 'good']\n",
      "hello\n",
      "hi\n",
      "good\n"
     ]
    }
   ],
   "source": [
    "lines = [line.strip() for line in open('foo.txt')]\n",
    "print(lines)\n",
    "\n",
    "# file open perform operations and close\n",
    "try:\n",
    "   f = open(\"foo.txt\",encoding = 'utf-8')\n",
    "   # perform file operations\n",
    "finally:\n",
    "   f.close()\n",
    "\n",
    "\n",
    "with open(\"foo.txt\",encoding = 'utf-8') as f:\n",
    "    # perform file operations\n",
    "    # print(f.readline())\n",
    "    for line in f:\n",
    "         print(line, end = '')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Linear Algebra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 8, 10]\n",
      "[6, 10, 13]\n",
      "51\n",
      "[[1], [2], [3]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('a', 1),\n",
       " ('a', 2),\n",
       " ('a', 3),\n",
       " ('b', 1),\n",
       " ('b', 2),\n",
       " ('b', 3),\n",
       " ('c', 1),\n",
       " ('c', 2),\n",
       " ('c', 3)]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def scale(A, x): return [ai*x for ai in A]\n",
    "print(scale([3, 4, 5], 2))\n",
    "\n",
    "A = [1, 2, 3]\n",
    "B = [5, 8, 10]\n",
    "def add(A, B): return [ai+bi for (ai, bi) in zip(A, B)]\n",
    "print(add(A,B))\n",
    "\n",
    "def dot(A, B): return sum([ai*bi for (ai, bi) in zip(A, B)])\n",
    "print(dot(A,B))\n",
    "\n",
    "def CutIntoSubarrays(A): return [list(aj) for aj in zip(A)]\n",
    "print(CutIntoSubarrays(A))\n",
    "\n",
    "cross_product = [(a, b) for a in ['a', 'b', 'c'] for b in [1, 2, 3]]\n",
    "cross_product\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Set Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[],\n",
       " [1],\n",
       " [2],\n",
       " [1, 2],\n",
       " [5],\n",
       " [1, 5],\n",
       " [2, 5],\n",
       " [1, 2, 5],\n",
       " [6],\n",
       " [1, 6],\n",
       " [2, 6],\n",
       " [1, 2, 6],\n",
       " [5, 6],\n",
       " [1, 5, 6],\n",
       " [2, 5, 6],\n",
       " [1, 2, 5, 6]]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set of all subsets ( Method 1 )\n",
    "f = (lambda x: [[y for j, y in enumerate(set(x)) if (i >> j) & 1] for i in range(2**len(set(x)))])\n",
    "f([1, 2, 5, 6])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[],\n",
       " [1],\n",
       " [2],\n",
       " [1, 2],\n",
       " [5],\n",
       " [1, 5],\n",
       " [2, 5],\n",
       " [1, 2, 5],\n",
       " [6],\n",
       " [1, 6],\n",
       " [2, 6],\n",
       " [1, 2, 6],\n",
       " [5, 6],\n",
       " [1, 5, 6],\n",
       " [2, 5, 6],\n",
       " [1, 2, 5, 6]]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set of all subsets ( Method 2 )\n",
    "f = (lambda l: reduce(lambda z, x: z + [y + [x] for y in z], l, [[]]))\n",
    "f([1, 2, 5, 6])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 4, 7], [2, 5, 8], [3, 6, 9]]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Taking transpose of a Matrix (Inverting it would be a dream)\n",
    "a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "inverted_a = [list(i) for i in zip(*a)]\n",
    "inverted_a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'c', '1', '100', 'a10', 'Beta']\n",
      "{'1', 'Beta', '100', 'c', 'a10', 'b', 'a'}\n",
      "['1', 'Beta', '100', 'c', 'a10', 'b', 'a']\n",
      "False\n",
      "True\n",
      "True\n",
      "{'Sachin', 'Rajsekhar', 'Harendra'}\n",
      "{'Sampath', 'Sachin', 'Rajsekhar', 'Harendra', 'Prajin', 'Manish'}\n",
      "{'Sampath'}\n",
      "{'Sampath', 'Prajin', 'Manish'}\n",
      "{'Sachin', 'Rajsekhar', 'Harendra'}\n"
     ]
    }
   ],
   "source": [
    "# List and set operations\n",
    "M = ['a', 'b', 'c', 'c', '1', '100', 'a10']\n",
    "M.append('Beta')\n",
    "\n",
    "print(list(M))\n",
    "print(set(M))\n",
    "print(list(set(M)))  # This gets rid of duplicate elements.\n",
    "S = set([1, 3, 5, 7])\n",
    "X = set([2, 4, 6, 8])\n",
    "S.union(X)\n",
    "S1, S2 = ['1', '5', '3', '7'], ['1', '3', '5', '7']\n",
    "print(S1 == S2)\n",
    "print(set(S1) == set(S2))\n",
    "print(sorted(S1) == sorted(S2))\n",
    "\n",
    "PythonProgrammers = {'Harendra', 'Sampath', 'Rajsekhar', 'Sachin'}\n",
    "CppProgrammers = {'Harendra', 'Manish', 'Sachin', 'Rajsekhar', 'Prajin'}\n",
    "print(PythonProgrammers & CppProgrammers)\n",
    "print(PythonProgrammers | CppProgrammers)\n",
    "print(PythonProgrammers - CppProgrammers)\n",
    "print(PythonProgrammers ^ CppProgrammers)\n",
    "print((PythonProgrammers | CppProgrammers) - (PythonProgrammers ^ CppProgrammers))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. String manipulations "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I want to delete left string\n",
      "kanak\n",
      "python\n",
      "C++14\n",
      "python3.7\n"
     ]
    }
   ],
   "source": [
    "# Strip functions\n",
    "s = ' I want to delete left string \\t '\n",
    "print (s.strip())\n",
    "\n",
    "# Random shuffling\n",
    "random.choice(['alpha', 'beta', 'gamma', 'delta'])\n",
    "\n",
    "#Palindrome Python One-Liner\n",
    "phrase='kanak'\n",
    "phrase.find(phrase[::-1])\n",
    "print(phrase)\n",
    "\n",
    "# To reverse a string in Python.\n",
    "rev = 'python'\n",
    "rev[::-1]\n",
    "print (rev)\n",
    "\n",
    "# Swapping variables:\n",
    "aa = \"python3.7\"\n",
    "bb = \"C++14\"\n",
    "aa, bb = bb, aa\n",
    "print (aa+'\\n'+bb)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0,\n",
       " 2,\n",
       " 4,\n",
       " 6,\n",
       " 8,\n",
       " 10,\n",
       " 12,\n",
       " 14,\n",
       " 16,\n",
       " 18,\n",
       " 20,\n",
       " 22,\n",
       " 24,\n",
       " 26,\n",
       " 28,\n",
       " 30,\n",
       " 32,\n",
       " 34,\n",
       " 36,\n",
       " 38,\n",
       " 40,\n",
       " 42,\n",
       " 44,\n",
       " 46,\n",
       " 48,\n",
       " 50,\n",
       " 52,\n",
       " 54,\n",
       " 56,\n",
       " 58,\n",
       " 60,\n",
       " 62,\n",
       " 64,\n",
       " 66,\n",
       " 68,\n",
       " 70,\n",
       " 72,\n",
       " 74,\n",
       " 76,\n",
       " 78,\n",
       " 80,\n",
       " 82,\n",
       " 84,\n",
       " 86,\n",
       " 88,\n",
       " 90,\n",
       " 92,\n",
       " 94,\n",
       " 96,\n",
       " 98,\n",
       " 100]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List comprehension:\n",
    "#  returns all even numbers between 0 and 101\n",
    "[i for i in range(0, 101) if not i&1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.718281828459045, 7.38905609893065, 20.085536923187668, 54.598150033144236, 148.4131591025766, 403.4287934927351]\n"
     ]
    }
   ],
   "source": [
    "# Parallel Processing \n",
    "import multiprocessing\n",
    "import math\n",
    "\n",
    "print(list(multiprocessing.Pool(processes=4).map(math.exp, range(1,7))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[23, 26, 41, 35]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# THE DATA\n",
    "stock_prices = [23, 24, 26, 29, 41, 29, 35]\n",
    " \n",
    "# print every second list value\n",
    "list(stock_prices[::2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97}\n"
     ]
    }
   ],
   "source": [
    "#write the Sieve of Eratosthenes : The Sieve of Eratosthenes is an ancient algorithm to find the prime numbers up to a specified number n.\n",
    "# THE DATA\n",
    "n=100\n",
    " \n",
    "# THE ONE-LINER\n",
    "primes = reduce( (lambda r,x: r-set(range(x**2,n,x)) if (x in r) else r), range(2,int(n**0.5)), set(range(2,n)))\n",
    "print (primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11. Exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The entry is a\n",
      "-------------------\n",
      "Oops! 'ValueError' occured.\n",
      "ValueError....Next entry.\n",
      "invalid literal for int() with base 10: 'a'\n",
      "\n",
      "The entry is 0\n",
      "-------------------\n",
      "Oops! 'ZeroDivisionError' occured.\n",
      "ZeroDivisionError...Next entry.\n",
      "\n",
      "The entry is -1\n",
      "-------------------\n",
      "Oops! 'ValueError' occured.\n",
      "ValueError....Next entry.\n",
      "That is a negative number!\n",
      "\n",
      "The entry is 2\n",
      "-------------------\n",
      "The reciprocal of 2 is 0.5\n"
     ]
    }
   ],
   "source": [
    "randomList = ['a', 0, -1, 2]\n",
    "\n",
    "for entry in randomList:\n",
    "    try:\n",
    "        print(\"The entry is\", entry)\n",
    "        print('-------------------')\n",
    "        if int(entry) < 0:\n",
    "            raise ValueError(\"That is a negative number!\")\n",
    "        r = 1/int(entry)\n",
    "        break\n",
    "    except ValueError as ve:\n",
    "        print(\"Oops! 'ValueError' occured.\")\n",
    "        print(\"ValueError....Next entry.\")\n",
    "        print(ve)\n",
    "        print()\n",
    "    except (TypeError, ZeroDivisionError): # Catching Specific Exceptions \n",
    "       # handle multiple exceptions\n",
    "       # TypeError and ZeroDivisionError\n",
    "        print(\"Oops! 'ZeroDivisionError' occured.\")\n",
    "        print(\"ZeroDivisionError...Next entry.\")\n",
    "        print()\n",
    "       #pass\n",
    "    except: # Catching Generic Exceptions \n",
    "        print(\"Oops!\",sys.exc_info()[0],\"occured.\")\n",
    "        print(\"Next entry.\")\n",
    "        print()\n",
    "print(\"The reciprocal of\",entry,\"is\",r)"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}