Upwork Python Test.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## upwork python test\n",
    "\n",
    "Some code to train and remember\n",
    "\n",
    "**Info**\n",
    "- http://upworktestru.com/python-test-upwork-answers-questions/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What would be the output of the following code?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def change_list(list1, list2):\n",
    "    list1.append('four') # it is link\n",
    "    list2 = ['and', 'we', 'can', 'not', 'lie']\n",
    "outer_list1 = ['one', 'two', 'three'] # goes as link (parameter) to def and gets modified by .append() in def\n",
    "outer_list2 = ['we', 'like', 'proper', 'English']\n",
    "change_list(outer_list1, outer_list2)\n",
    "print(outer_list1)\n",
    "print(outer_list2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The side option of the pack manager may be**\n",
    "- LEFT\n",
    "- RIGHT\n",
    "- BOTTOM\n",
    "- TOP\n",
    "- **All of the above**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Type of each sys.argv**\n",
    "- sys.argv is a list in Python, which contains the command-line arguments passed to the script. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How to get JSON to load into an OrderedDict in python?**\n",
    "- By simply using json.loads(D) where D is Ordered dictionary\n",
    "- **By specifying the object_pairs_hook argument to JSONDecoder**\n",
    "- Ordered dictionary is not supported yet\n",
    "- By simply using json.dumps(D) where D is Ordered dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import json\n",
    "import collections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "json.JSONDecoder(object_pairs_hook=collections.OrderedDict).decode('{\"foo\":1, \"x\": 7, \"bar\": 2, \"k\": [1,2,3]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# OR\n",
    "json.loads('{\"f\":3, \"z\": [1,2,3], \"k\": \"asd\"}', object_pairs_hook=collections.OrderedDict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following code samples will flatten the «irregular» list below:**\n",
    "\n",
    "L = [[[1, 2, 3], [4, 5]], 6] to [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "Note: There may be more than one right answer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "L = [[[1, 2, 3], [4, 5]], 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "def Flatten(L):\n",
    "    a = str(L)\n",
    "    b,crap = re.subn(r'[\\[,\\]]', ' ', a)\n",
    "    c = b.split()\n",
    "    d = [int(x) for x in c]\n",
    "    return(d)\n",
    "Flatten(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "g = str(L).replace('[', '').replace(']', '')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "flattenedList = [int(x) for x in g.split(',') if x.strip()]\n",
    "flattenedList"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which statement is true regarding the \\__all\\__ module level variable?**\n",
    "- It is a list of strings defining what symbols in a module will be exported when from <module> import * is used on the module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Regarding Secure hashes and message digests in Python 3 using standard module hashlib, which of the following is true ?**\n",
    "- `hexdigest()` function will return a hexadecimal string representation of the underlying hash algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Regarding Thread Synchronization Primitives in Python, which of the following is incorrect ?**\n",
    "- Event Objects (`threading.Event`) can be used to have one or more threads wait for something to occur. Setting an event will unblock all waiting threads simultaneously (if any)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which method in the following is used to convert raw json objects to Json in python?**\n",
    "- json.loads()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "json.loads()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What is the difference between the two methods, «foo is None», and «foo == None», for the purposes of determining if the type of an object is None?**\n",
    "- «is» always returns True if it compares the same object instance whereas the value returned by «==» is determined by the \\__eq\\__() method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following environment variable for Python is an alternative module search path?**\n",
    "- PYTHONHOME"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following is the correct way to empty a list, using theList as an example?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "theList = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del theList[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# OR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "theList[:] = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**sys.path is initialized from which of the following locations ?**\n",
    "- The directory containing the input script.\n",
    "- PYTHONPATH enviroment variable.\n",
    "- The installation-dependent default.\n",
    "- **All of the above**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following is true regarding urlopen function from the standard module urllib in Python 2?**\n",
    "- When opening HTTPS URLs, it does not attempt to validate the server certificate."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What is the type of inf?**\n",
    "- Float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "infi, nan, inf = -1E400, float('nan'), float('inf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Check whether an object x is an instance of class A, use _____.?**\n",
    "- isinstance(x, A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How to convert a json string to Python object?**\n",
    "- json.loads()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "json.loads('{\"s\": \"xxx\", \"z\": {\"k\": [1,2,3], \"b\": \"zzzzz\"}}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following is the correct way to output the name of any function (including builtin functions) using Python?**\n",
    "- theFunction.\\__name__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following is incorrect to say about CPython’s garbage collection mechanism ?**\n",
    "- The garbage collector is a deterministic process, so that heuristics are never used to improve performance of garbage collection."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What would the output of the following code be:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def a():\n",
    "    print('a executed')\n",
    "    return []\n",
    "\n",
    "def b(x=a()):\n",
    "    x.append(5)\n",
    "    x.append(1)\n",
    "    print(x)\n",
    "    \n",
    "b()\n",
    "b()\n",
    "b()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The output of executing string.ascii_letters can also be achieved by ____?**\n",
    "- string.ascii_lowercase+string.ascii_uppercase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import string\n",
    "#string.ascii_letters\n",
    "string.ascii_lowercase+string.ascii_uppercase"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Considering this Python 2.x snippet**\n",
    "- No matter what exception happens, the program will not stop and will print ‘General exception’ in the console, as Exception is the first base class in the Python exception hierarchy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3.x\n",
    "while(True):\n",
    "    try:\n",
    "        doWork()\n",
    "    except TypeError:\n",
    "        print('Type error')\n",
    "    except Exception:\n",
    "        print('General exception')\n",
    "    except (GeneratorExit, KeyboardInterrupt):\n",
    "        print('Existing exception')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following statements are correct about assertions in Python?\n",
    "Note: There may be more than one right answer.**\n",
    "- The «assert» statements are removed when the compilation is optimized.\n",
    "- Asserts should be used to test conditions that should never happen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What would be the most correct statement to describe above function?**\n",
    "- This function takes the name of a directory and prints out the paths files within that directory as well as any files contained in contained directories."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def secret_function(sPath):\n",
    "    import os\n",
    "    for sChild in os.listdir(sPath):\n",
    "        sChildPath = os.path.join(sPath,sChild)\n",
    "        if os.path.isdir(sChildPath):\n",
    "            secret_function(sChildPath)\n",
    "        else:\n",
    "            print(sChildPath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "secret_function('.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following will be the output of the below code snippet?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares = []\n",
    "for x in range(5):\n",
    "    squares.append(lambda: x**2)\n",
    "    x = 8\n",
    "\n",
    "for i in range(5):\n",
    "    print(squares[i]())\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How can a list of dictionaries be sorted by the values of the dictionaries?**\n",
    "\n",
    "- Right answers are the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list_of_dicts = [{'d': 1, 'k': 2, 'name': 3}, {'name': 2, 3: 6, 'k': 5}, {'name': 0, 'k': 888, 2: 999}]\n",
    "a_list_of_dicts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# first sample\n",
    "from operator import itemgetter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sortedlist = sorted(a_list_of_dicts, key = itemgetter('name'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sortedlist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# second sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def mykey(adictionary):\n",
    "    return adictionary['k']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sortedlist = sorted(a_list_of_dicts, key=mykey)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sortedlist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following statement is incorrect regarding Python language?**\n",
    "- Python is an interpreted language. That means that, unlike languages like C and its variants, Python does not need to be compiled before it is run."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which is not used to install Python packages?**\n",
    "- installtools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What is the correct way to delete a directory that is not empty using Python?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import shutil #first create dir: import os; os.makedirs('./test/', exist_ok=True)\n",
    "shutil.rmtree('./test')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following is false regarding urlretrieve function from the standard module urllib in Python 2?**\n",
    "- It returns a tuple (filename, headers, filesize) where filename is the local file name under which the object can be found."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following is the correct way to determine a variable’s type in Python?**\n",
    "- type(variable_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What gets printed on the console for the following Python 2.x code?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A0 = dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))\n",
    "A1 = range(5)\n",
    "A2 = sorted([i for i in A1 if i in A0])\n",
    "A3 = sorted([A0[s] for s in A0])\n",
    "A4 = [i for i in A1 if i in A3]\n",
    "A5 = {i:i*i for i in A1}\n",
    "A6 = [[i,i*i] for i in A1]\n",
    "print(A6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What will be the output of following code?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "items = set()\n",
    "items.add('google')\n",
    "items.add('apple')\n",
    "items.add('microsoft')\n",
    "print(items)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Regarding Unicode in Python 3, which of the following is incorrect ?**\n",
    "- One can create a string using the `decode()` method of `bytes` type, and it will use by default ‘latin_1’ encoding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y = '念念sdf念ss'.encode()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = y.decode()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following is the best way of checking if a string could be represented as a number?\n",
    "**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def is_number(s):\n",
    "    try:\n",
    "        float(s)\n",
    "        return True\n",
    "    except ValueError:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "is_number('.1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# THE BEST ONE, I THINK!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import re\n",
    "check_regexp = re.compile('^\\d*\\.?\\d*$')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check_regexp.findall('00.2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "check_replace = lambda x: x.replace('.','',1).isdigit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check_replace('00.223')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following can be used to create a directory?**\n",
    "- os.mkdir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following will be the output of the below code snippet?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = []\n",
    "y = x\n",
    "y.append(10)\n",
    "z = 5\n",
    "w = z\n",
    "z = z - 1\n",
    "print(y)\n",
    "print(x)\n",
    "print(z)\n",
    "print(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Type of math.trunc()***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(math.trunc(0.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What will be the output of following code snippet?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def f(x): \n",
    "    return x % 2 != 0 and x % 3 != 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=filter(f, range(1, 20))\n",
    "print(list(result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What are the states/features supported by a RLock object?**\n",
    "- Locked\n",
    "- Owning thread\n",
    "- Recursion level\n",
    "- Unlocked\n",
    "- **All of the above**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following is incorrect regarding modules in Python?**\n",
    "- Each module can only be imported once per interpreter session. And If you change a module the interpreter will __automatically__ reload it for you."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following is the best method for accessing the index of a list while executing in a loop?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sequence = [1,2,3,4,5,6]\n",
    "for i, e in enumerate(sequence):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What gets printed in the code below ?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x, l=[]):\n",
    "#     l = [7,7,7] # diff result by re-assigning \n",
    "    for i in range(x):\n",
    "        l.append(i * i)\n",
    "    return l\n",
    "\n",
    "f(2)\n",
    "f(3, [3, 2, 1])\n",
    "print(f(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Consider the code, and choose the correct statement:**\n",
    "- Class B inherits A, but the data field i in A is not inherited."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    def __init__(self, i = 0):\n",
    "        self.i = i\n",
    "        \n",
    "class B(A):\n",
    "    def __init__(self, j = 0):\n",
    "        self.j = j\n",
    "        \n",
    "def main():\n",
    "    b = B()\n",
    "    print(b.i)\n",
    "    print(b.j)\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which option in sqllite.connect() method avoids OperationalError telling that the database file is locked?**\n",
    "- check_same_thread"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlite3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sqlite3.connect() #check by SHIFT+TAB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The __ function can be used to check if a file f exists?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import os # Can be checked by these functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.path.isfile('Test scripts.ipynb') # Test whether a path is a regular file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.path.exists('Test scripts.ipynb') # Test whether a path exists.  Returns False for broken symbolic links"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What will be the output of following code?\n",
    "print «\\x48\\x49!»**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('\\x48\\x49!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Considering the following code snippet:-\n",
    "def test (a, b, c): pass\n",
    "Which of the following is a true statement?**\n",
    "- It defines a function that essentially does nothing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def test(a, b, c): \n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**In Python, a string literal is enclosed in _____? (check all that apply)\n",
    "Note: There may be more than one right answer.**\n",
    "- single-quotes\n",
    "- double-quotes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following is the correct way to print to stderr in Python?**\n",
    "- sys.stderr.write('my_error')\n",
    "- print >> sys.stderr, 'my_error' # works! Python 2 only\n",
    "- from \\__future\\__ import print_function; print('my_error', file=sys.stderr)\n",
    "- **All of these**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.stderr.write('my_error')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print >> sys.stderr, 'my_error' # works! Python 2 only"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('my_error', file=sys.stderr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**In Python 3, which of the following is correct regarding data types Lists, Tuples, Dictionaries and Sets ?**\n",
    "- If `a_set` is a Set instance, then `a_set.difference(a_set)` will always return an empty Set object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "se = set({1,2,3,4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "se.difference(se)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following will be the output of the below code snippet?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo(x=[]):\n",
    "    x.append(1)\n",
    "    print(x)\n",
    "foo()\n",
    "foo()\n",
    "foo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following is the correct way to flush output of Python print?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.stdout.flush()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A hashing function ____?**\n",
    "- maps a key to an index in the hash table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What is the method to retrieve the list of all active thread objects?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import threading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "threading.enumerate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**__________ measures how full the hash table is?**\n",
    "- Load factor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following will be the output of the below code snippet?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "def foo():\n",
    "    print(x)\n",
    "x = x - 1\n",
    "foo()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which is the correct syntax for Python dictionary comprehension?**\n",
    "- dict((key, value) for (key, value) in sequence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sequence = list(zip(range(10), range(50,60)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict((key, value) for (key, value) in sequence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which user input method will act like a file-object on which read and readline functions can be called?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.stdin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What will be the output of following code?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f2(n, result):\n",
    "    if n == 0:\n",
    "        return 0\n",
    "    else:\n",
    "        return f2(n - 1, n + result)\n",
    "print(f2(2, 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What is the best way to randomly select an item from list?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from random import choice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo = ['a', 'b', 'c', 'd', 'e']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(choice(foo))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which code snippet below will not return True?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 in [1,0] == True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What will be the output of following code?**\n",
    "- 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import threading\n",
    "k = 10\n",
    "x = 0\n",
    "m = threading.Lock()\n",
    "\n",
    "def foo():\n",
    "    global x\n",
    "    for i in xrange(k):\n",
    "        with m:\n",
    "            x += 1\n",
    "def bar():\n",
    "    global x\n",
    "    for i in xrange(k):\n",
    "        with m:\n",
    "            x -= 1\n",
    "            \n",
    "t1 = threading.Thread(target=foo)\n",
    "t2 = threading.Thread(target=bar)\n",
    "t1.start()\n",
    "t2.start()\n",
    "t1.join()\n",
    "t2.join()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following are the characteristics of the \\__init\\__.py file?\n",
    "Note: There may be more than one right answer.**\n",
    "- \\__init\\__.py can be an empty file, but it can also execute initialization code for the package or set the \\__all\\__ variable.\n",
    "- The \\__init\\__.py files are required to make Python treat the directories as if they contain packages.\n",
    "- The \\__init\\__.py files are used to define the classes’ basic initializations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What will be the output of following code?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = lambda p: p * 2\n",
    "t = lambda p: p * 3\n",
    "x = 2\n",
    "x = d(x)\n",
    "x = t(x)\n",
    "x = d(x)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What is the output of the following?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t=(1,2,4,3,5)\n",
    "t[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What is the output of «Dummy Text is my text».strip(‘Te’) —**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'Dummy Text is my text'.strip('Te')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What will be the following code output?**\n",
    "- 64.0 # the code is strange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "res = math.pow(4, 3)\n",
    "def addition(x, y):\n",
    "    return (x+y)\n",
    "def subtract(x, y):\n",
    "    return (x-y)\n",
    "def multiply(x, y):\n",
    "    return (x*y)\n",
    "def divide(x, y):\n",
    "    return (x%y)\n",
    "#import mathExample\n",
    "print(mathExample.res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following will be the output of the below code snippet?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class foo:\n",
    "    def normal_call(self):\n",
    "        print('normal_call')\n",
    "    def call(self):\n",
    "        print('first_call')\n",
    "        self.call = self.normal_call\n",
    "y = foo()\n",
    "y.call()\n",
    "y.call()\n",
    "y.call()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What command is used to get the hostname of the computer the Python script is running on?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import socket\n",
    "print(socket.gethostname())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following is used to get the name of a thread?**\n",
    "- getName()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import threading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "threading.main_thread().getName()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What will be printed in the --above-- Python code?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "orig = {'1': 1, '2': 2}\n",
    "a_copy = orig.copy()\n",
    "orig['1'] = 5\n",
    "sum = orig['1'] + a_copy['1']\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following will clone a list in Python? (choose all that apply)\n",
    "Note: There may be more than one right answer.**\n",
    "\n",
    "- new_list = old_list[:]\n",
    "- new_list = list(old_list)\n",
    "- import copy; new_list = copy.copy(old_list)\n",
    "- import copy; new_list = copy.deepcopy(old_list)\n",
    "\n",
    "\n",
    "- All answers are correct. All are shallow except deep: new_list = copy.deepcopy(old_list)\n",
    "- https://stackoverflow.com/questions/2612802/how-to-clone-or-copy-a-list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**On a Unix-like system, what does Python’s sleep.time() function block?**\n",
    "- The thread."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**From the following which is not a good recommendation for Threading in Python?**\n",
    "- Use an event model, such as Twisted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://pypi.python.org/pypi/multitasking\n",
    "# https://stackoverflow.com/questions/2846653/how-to-use-threading-in-python\n",
    "\n",
    "# http://twistedmatrix.com/documents/10.1.0/core/howto/deferredindepth.html\n",
    "# http://ezyang.com/twisted/defer2.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which piece of code best describes the way to parse data from JSON file?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "from pprint import pprint\n",
    "with open('data.json') as data_file:\n",
    "    data = json.load(data_file)\n",
    "    pprint(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What will be the output of following code?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def val1(param):\n",
    "    return param\n",
    "def val2(param):\n",
    "    return param * 2\n",
    "def val3(param):\n",
    "    return param + 5\n",
    "result = val1(val2(val3(1)))\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "**Which of the following code snippets can be used to get the multiples of 2 from the list**\n",
    "- All of these"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = [1, 2, 3, 4, 5, 6, 7, 8, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = filter(lambda x: x % 2 == 0, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b = [x for x in a if x % 2 == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def filterfunc(x):\n",
    "    return x % 2 == 0\n",
    "b = filter(filterfunc, a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following code snippets converts the hexademical number 0x1000 to a decimal correctly?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int('1000', 16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the function immediately terminates the program?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "sys.exit() # quit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following is the proper way to declare custom exceptions in modern Python?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class MyException(Exception):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Considering Python 2.5, what will be the output of following code?**\n",
    "- True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fp = None\n",
    "with open('data.json', 'r') as fp:\n",
    "    cont = fp.read()\n",
    "print(fp.closed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What will be the output of following code?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addItem(l):\n",
    "    l += [0]\n",
    "mylist = [1, 2, 3, 4, 5]\n",
    "addItem(mylist)\n",
    "print(len(mylist))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What is the result of the following code:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "listOne = [1, 3, 5]\n",
    "listTwo = [2, 4, 6]\n",
    "listNew = listOne + listTwo\n",
    "print(listNew)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Regarding the code below, what’s correct statement ?**\n",
    "- book.isbn will contain the value 12345."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Book:\n",
    "    def __init__(self, isbn):\n",
    "        self.isbn = isbn\n",
    "        isbn = 'test'\n",
    "book = Book(12345)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "book.isbn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What will be the output of the code below?**\n",
    "- 0 1 2 3 4 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'messha'\n",
    "for i in range(len(s)):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following will remove duplicate elements from a list (O(n)), whilst preserving order?**\n",
    "\n",
    "seen = set()\n",
    "\n",
    "seen_add = seen.add\n",
    "\n",
    "mylist = [ x for x in mylist if x not in seen and not seen_add(x)]\n",
    "\n",
    "- good arcticle: https://www.peterbe.com/plog/fastest-way-to-uniquify-a-list-in-python-3.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Bellow are the answers for the example (not all, only interesting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mylist = [1,0,0,2,3,4,5,5,6,7,7,7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seen = set()\n",
    "seen_add = seen.add\n",
    "[x for x in mylist if x not in seen and not seen_add(x)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reduce - similar to dynamic programming\n",
    "from functools import reduce\n",
    "reduce(lambda x, y: x if y in x else x + [y], mylist, [])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# fastest with order preserving!!! \n",
    "list(dict.fromkeys(mylist))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fastest w/o order preserving\n",
    "list(set(mylist))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# not interesting\n",
    "[x for i,x in enumerate(mylist) if x not in mylist[:i]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Consider the following Python code: test = 1/2**\n",
    "\n",
    "**What is the value of ‘test’ in Python 2.7 and 3.5, respectively ?**\n",
    "\n",
    "- 0 and 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "test = 1/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following is the correct method for changing a global variable inside a function?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "globvar = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def change_globvar():\n",
    "    global globvar\n",
    "    globvar = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "change_globvar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which one of these answers will catch an exception, but do nothing with it?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    doSomething()\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Suppose we have a User class, how do we make a new User object?**\n",
    "- a = User()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What will be the output of the following?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "new_list = list(filter(lambda x: (x%2 == 0), my_list))\n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following one is reentrant lock type?**\n",
    "- RLock"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Given the two dictionaries ‘x’ and ‘y’, which of these codes would not create a final, merged dictionary ‘z’?**\n",
    "- z = x.update(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = {'a':1, 'b': 2}\n",
    "y = {'b':10, 'c': 11}\n",
    "# z = {‘a’: 1, ‘c’: 11, ‘b’: 10}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2.7\n",
    "z = dict(x.items() + y.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = x.copy()\n",
    "z.update(y)\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = dict(x, **y)\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "z = x.update(y)\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = dict(list(x.items()) + list(y.items()))\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How can an element be removed from a list using its list index?**\n",
    "- del myList[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "myList = ['11', '22', '33', 55]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del myList[0]\n",
    "myList"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following is NOT correct regarding unittest in Python 3?**\n",
    "- tearDown() from unittest.TestCase is called only once per class, immediately before the first test method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import unittest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tc = unittest.TestCase()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tc.setUp()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following would create an instance of Firm class correctly?**\n",
    "- Firm = Firm('client', 2000)\n",
    "- Firm = Firm()\n",
    "- Firm = Firm('server', 2000)\n",
    "- **None of the above**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Firm:\n",
    "    def __init__(self, s, i):\n",
    "        self.s = s\n",
    "        self.i = i\n",
    "        \n",
    "    def k(self):\n",
    "        print(self.s)\n",
    "        print(self.i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Firm = Firm('client', 2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Firm.k()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Firm = Firm()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What will be the output of the following code?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def name(X, Y, Z, **opt):\n",
    "    if opt.get('number') == 'Y':\n",
    "        return Y\n",
    "    \n",
    "res = name(1, 2, 3, action = 'sum', number = 'Y')\n",
    "print('Result: %d' % res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following will throw an exception in Python?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raise Exception('Here is an Exception!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What is the output of the following code?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class A(object):\n",
    "    def __init__(self):\n",
    "        print('Constructor A was called')\n",
    "        \n",
    "class B(A):\n",
    "    def __init__(self):\n",
    "        print('Constructor B was called')\n",
    "        \n",
    "class C(B):\n",
    "    def __init__(self):\n",
    "        super(C, self).__init__()\n",
    "        print('Constructor C was called')\n",
    "        \n",
    "class D(C):\n",
    "    def __init__(self):\n",
    "        super(D, self).__init__()\n",
    "        print('Constructor D was called')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**In Python 3, which of the following is incorrect regarding data structures ?**\n",
    "- A Dictionary is an unordered set of key-value pairs, but becomes essentially immutable once a key already exists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {1: 4, 5: 7}\n",
    "d['z'] = 'suck'\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What is the correct syntax that will set the variable «var1» to the value «correct» if variable «a» is greater than 1?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3\n",
    "var1 = 'correct' if a > 1 else None\n",
    "var1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What will be the output of following code?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "counter = 1\n",
    "def count():\n",
    "    global counter\n",
    "    t = (1, 2, 3)\n",
    "    for i, v in enumerate(t):\n",
    "        counter += i + v\n",
    "count()\n",
    "print(counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**In Python 2.x, which of the following is the way to check to make sure that the variable ‘x’ is not a string?**\n",
    "- assert isinstance(x, basestring)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "assert isinstance(x, str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What is the type of x?\n",
    "x = 10.0//5**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 10.0//5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What is the output if the following code is executed?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a1 = 0\n",
    "b2 = 1\n",
    "c3 = 2\n",
    "def fru_box():\n",
    "    a1 = b2 + c3\n",
    "    print((a1, '\\t', b2, '\\t', c3))\n",
    "    return\n",
    "fru_box()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**In the following code, what will be printed ?**\n",
    "- AttributeError will be raised."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class parent:\n",
    "    def __init__(self, param):\n",
    "        self.v1 = param\n",
    "        \n",
    "class child(parent):\n",
    "    def __init__(self, param):\n",
    "        self.v2 = param\n",
    "        \n",
    "obj = child(5)\n",
    "print('%d %d' % (obj.v1, obj.v2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Which of the following snippets will return the list of all occurances of ‘b’ in\n",
    "a = [‘a’,’b’,’c’,’b’] ?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = ['a', 'b', 'c', 'b']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b = [item for item in a if item == 'b']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}