02-python-programming-skill-assessment/Python_Programming_Skill_Assessment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "22c15c7a",
   "metadata": {},
   "source": [
    "# Python Programming Skill Assessment\n",
    "\n",
    "This notebook comprises python programming skill assessment which may include the topics below:\n",
    "\n",
    "1. Developing packages and unit testing with pytest\n",
    "2. Object-oriented programming\n",
    "3. Using and writing functions\n",
    "4. Control flow and loops\n",
    "5. Defining data structures, including numpy and pandas objects\n",
    "6. Techniques for establishing code efficiencies"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16326372",
   "metadata": {},
   "source": [
    "## Question 1\n",
    "\n",
    "what would be the output of the code snippet?\n",
    "\n",
    "**Correct answer**\n",
    "\n",
    "`4`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7880b8d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "ints = set([1, 1, 2, 3, 3, 3, 4])\n",
    "print(len(ints))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75dfbeb2",
   "metadata": {},
   "source": [
    "## Question 2\n",
    "\n",
    "**Complete the code to return the output**\n",
    "\n",
    "**Expected Output**\n",
    "\n",
    "`153`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7a8e538d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "153\n"
     ]
    }
   ],
   "source": [
    "def add_many(*args):\n",
    "    s = 0\n",
    "    for n in args:\n",
    "        s += n\n",
    "    print(s)\n",
    "    \n",
    "add_many(100, 50, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd711d65",
   "metadata": {},
   "source": [
    "## Question 3\n",
    "\n",
    "Complete the statement using a list comprehension with appropriate logic and operations such that it matches the output.\n",
    "\n",
    "**Complete the code to return the output**\n",
    "\n",
    "**Expected Output**\n",
    "\n",
    "`[0, 3, 6, 9, 12]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b7197c67",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 3, 6, 9, 12]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i * 3 for i in range(5)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bda1e279",
   "metadata": {},
   "source": [
    "## Question 4\n",
    "\n",
    "**Complete the code to return the output**\n",
    "\n",
    "**Expected Output**\n",
    "\n",
    "`'Michael'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7a0bdaa6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Michael'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "m = Person('Michael')\n",
    "m.name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9300879",
   "metadata": {},
   "source": [
    "## Question 5\n",
    "\n",
    "Get the value of the \"three\" key using a dictionary method.\n",
    "\n",
    "**Complete the code to return the output**\n",
    "\n",
    "**Expected Output**\n",
    "\n",
    "`3`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f80b5608",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {\n",
    "    'one': 1,\n",
    "    'two': 2,\n",
    "    'three': 3,\n",
    "    'four': 4\n",
    "}\n",
    "\n",
    "d.get('three')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58e20f08",
   "metadata": {},
   "source": [
    "## Question 6\n",
    "\n",
    "**Complete the code to return the output**\n",
    "\n",
    "`f(3, 3)`\n",
    "\n",
    "**Expected Output**\n",
    "\n",
    "`9`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ecd5a7b2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = lambda x, y: x * y\n",
    "\n",
    "f(3, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "600111eb",
   "metadata": {},
   "source": [
    "## Question 7\n",
    "\n",
    "Create a class called `Color` that has one attribute `rgb_value` that needs to be set when a new object is created.\n",
    "\n",
    "**Select the code to return the output**\n",
    "\n",
    "**Expected Output**\n",
    "\n",
    "`'#00ff66'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "acad4dd6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'#00ff66'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Color:\n",
    "    def __init__(self, rgb_value):\n",
    "        self.rgb_value = rgb_value\n",
    "\n",
    "c = Color('#00ff66')\n",
    "c.rgb_value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c11364a",
   "metadata": {},
   "source": [
    "## Question 8\n",
    "\n",
    "Appropriately call the function below.\n",
    "\n",
    "**Complete the code to return the output**\n",
    "\n",
    "**Expected Output**\n",
    "\n",
    "`'I know how to call this function.'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8fef7875",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I know how to call this function.'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = lambda : \"I know how to call this function.\"\n",
    "x()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34f66405",
   "metadata": {},
   "source": [
    "## Question 9\n",
    "\n",
    "**Complete the code to return the output**\n",
    "\n",
    "**Expected Output**\n",
    "\n",
    "`{1, 2, 3}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4ab22aa6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = (1, 2, 3)\n",
    "s = set(x)\n",
    "\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93385577",
   "metadata": {},
   "source": [
    "## Question 10\n",
    "\n",
    "**Complete the code to return the output**\n",
    "\n",
    "**Expected Output**\n",
    "\n",
    "```\n",
    "0 : a\n",
    "1 : b\n",
    "2 : c\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f16c4891",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 :  a\n",
      "1 :  b\n",
      "2 :  c\n"
     ]
    }
   ],
   "source": [
    "letters = ['a', 'b', 'c']\n",
    "for ii, x in enumerate(letters):\n",
    "    print(ii, \": \", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe41f4f4",
   "metadata": {},
   "source": [
    "## Question 11\n",
    "\n",
    "Define a function that squares a single input argument. Complete the docstring for the function.\n",
    "\n",
    "**Complete the code to return the output**\n",
    "\n",
    "**Expected Output**\n",
    "\n",
    "`'Returns the square of the argument x'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "20528616",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Returns the square of the argument x'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def square(x):\n",
    "    \"\"\"Returns the square of the argument x\"\"\"\n",
    "    return x * x\n",
    "\n",
    "square.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd6ed514",
   "metadata": {},
   "source": [
    "## Question 12\n",
    "\n",
    "**Complete the code to return the output**\n",
    "\n",
    "**Expected Output**\n",
    "```\n",
    "h\n",
    "e\n",
    "o\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "63f51edc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h\n",
      "e\n",
      "o\n"
     ]
    }
   ],
   "source": [
    "for i in \"hello\":\n",
    "    if i == \"l\":\n",
    "        continue\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f59e852",
   "metadata": {},
   "source": [
    "## Question 13\n",
    "\n",
    "**Complete the code to return the output**\n",
    "\n",
    "**Expected Output**\n",
    "\n",
    "`'numpy'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c7700cd0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'numpy'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = ['numpy', 'pandas', 'requests']\n",
    "lst_gen = (pkg for pkg in lst)\n",
    "next (lst_gen)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ae0a42a",
   "metadata": {},
   "source": [
    "## Question 14\n",
    "\n",
    "**Complete the code to return the output**\n",
    "\n",
    "**Expected Output**\n",
    "\n",
    "`' a '`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "80fe2c9a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' a '"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"a\"\n",
    "s.center(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dc49bf7",
   "metadata": {},
   "source": [
    "## Question 15\n",
    "\n",
    "As you regularly perform similar importing and cleaning tasks on your data you have decided to create a class definition for this process. Create an appropriate method so that you can initialize your class `CustomETL`, with and attribute `filepath`.\n",
    "\n",
    "**Complete the code to return the output**\n",
    "\n",
    "**Expected Output**\n",
    "\n",
    "`test_data.csv`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1a543f1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test_data.csv\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "class CustomETL:\n",
    "    def __init__(self, filepath):\n",
    "        self.filepath = filepath\n",
    "    \n",
    "    def read_file(self):\n",
    "        self.data = pd.read_csv(self.filepath)\n",
    "        \n",
    "example = CustomETL('test_data.csv')\n",
    "print(example.filepath)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}