Python Advanced Programming Assignment-10.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Advanced Programming Assignment-10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging as lg\n",
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "lg.basicConfig(filename = \"logfile.log\", level = lg.INFO, format = '%(asctime)s %(name)s %(message)s')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Create a function that takes the width, height and character and returns a picture frame as a 2D list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_frame(w, h, char_val):\n",
    "    \"\"\"\n",
    "    This function takes the width, height and character and returns a picture frame as a 2D list.\n",
    "    \"\"\"\n",
    "    \n",
    "    try:\n",
    "        lg.info(\"Input by user, width : {}, height : {}, character: {}\".format(w, h, char_val))\n",
    "        \n",
    "        if h <= 2 or w <= 2:\n",
    "            print(\"Frame's width is not more than 2.\")\n",
    "            return \"invalid\"\n",
    "        \n",
    "        if not len(char_val) == 1:\n",
    "            print(\"character input has to be 1 byte long\")\n",
    "            return \"invalid\"\n",
    "            \n",
    "        a = [[] for i in range(h)]\n",
    "        \n",
    "        for i in range(h):\n",
    "            for j in range(w):\n",
    "                if i == 0 or i == (h-1) or j == 0 or j == (w-1):\n",
    "                    a[i].append(char_val)\n",
    "                else:\n",
    "                    a[i].append(' ')\n",
    "        \n",
    "        for i in range(len(a)):\n",
    "            a[i] = [''.join(a[i])]\n",
    "        \n",
    "        return a\n",
    "        \n",
    "    except Exception as e:\n",
    "        print(\"Check logs for error\")\n",
    "        lg.error(\"Error occured here\")\n",
    "        lg.exception(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['####'], ['#  #'], ['#  #'], ['#  #'], ['####']]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_frame(4, 5, \"#\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['**********'], ['*        *'], ['**********']]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_frame(10, 3, \"*\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frame's width is not more than 2.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'invalid'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_frame(2, 5, \"0\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Write three functions:\n",
    "\n",
    "  1. boolean_and\n",
    "  2. boolean_or\n",
    "  3. boolean_xor\n",
    "  \n",
    "### These functions should evaluate a list of True and False values, starting from the leftmost element and evaluating pairwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def boolean_and(list_of_bool):\n",
    "    \"\"\"\n",
    "    This function takes as input a list of booleans - True or False,\n",
    "    and returns the results from the AND operation.\n",
    "    \"\"\"\n",
    "    \n",
    "    try:\n",
    "        \n",
    "        lg.info(\"Input by user : {}\".format(list_of_bool))\n",
    "        \n",
    "        result = True\n",
    "        \n",
    "        for i in list_of_bool:\n",
    "            result = result and i\n",
    "        \n",
    "        return result\n",
    "        \n",
    "    except Exception as e:\n",
    "        print(\"Check logs for error\")\n",
    "        lg.error(\"Error occured here\")\n",
    "        lg.exception(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "boolean_and([True, True, False, True])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def boolean_or(list_of_bool):\n",
    "    \"\"\"\n",
    "    This function takes as input a list of booleans - True or False,\n",
    "    and returns the results from the OR operation.\n",
    "    \"\"\"\n",
    "    \n",
    "    try:\n",
    "        \n",
    "        lg.info(\"Input by user : {}\".format(list_of_bool))\n",
    "        \n",
    "        result = False\n",
    "        \n",
    "        for i in list_of_bool:\n",
    "            result = result or i\n",
    "        \n",
    "        return result\n",
    "        \n",
    "    except Exception as e:\n",
    "        print(\"Check logs for error\")\n",
    "        lg.error(\"Error occured here\")\n",
    "        lg.exception(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "boolean_or([True, True, False, False]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def boolean_xor(list_of_bool):\n",
    "    \"\"\"\n",
    "    This function takes as input a list of booleans - True or False,\n",
    "    and returns the results from the XOR operation.\n",
    "    \"\"\"\n",
    "    \n",
    "    try:\n",
    "        \n",
    "        lg.info(\"Input by user : {}\".format(list_of_bool))\n",
    "        \n",
    "        result = (list_of_bool[0] != list_of_bool[1])\n",
    "        \n",
    "        for i in range(2, len(list_of_bool)):\n",
    "            result = (result != list_of_bool[i])\n",
    "        \n",
    "        return result\n",
    "        \n",
    "    except Exception as e:\n",
    "        print(\"Check logs for error\")\n",
    "        lg.error(\"Error occured here\")\n",
    "        lg.exception(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "boolean_xor([True, True, False, False]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Create a function that creates a box based on dimension n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_box(n):\n",
    "    \"\"\"\n",
    "    This function creates a box based on dimension n.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        \n",
    "        lg.info(\"Input by user : {}\".format(n))\n",
    "        \n",
    "        a = [\"\" for i in range(n)]\n",
    "\n",
    "        for i in range(n):\n",
    "            for j in range(n):\n",
    "                if i == 0 or i == (n-1) or j == 0 or j == (n-1):\n",
    "                    a[i] += \"#\"\n",
    "                else:\n",
    "                    a[i] += ' '\n",
    "                    \n",
    "        return a\n",
    "    \n",
    "    except Exception as e:\n",
    "        print(\"Check logs for error\")\n",
    "        lg.error(\"Error occured here\")\n",
    "        lg.exception(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['#####', '#   #', '#   #', '#   #', '#####']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "make_box(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['###', '# #', '###']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "make_box(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['##', '##']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "make_box(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['#']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "make_box(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Given a common phrase, return False if any individual word in the phrase contains duplicate letters. Return True otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def no_duplicate_letters(phrase_input):\n",
    "    \n",
    "    \"\"\"\n",
    "    This function takes as input a common phrase, return False if any individual word \n",
    "    in the phrase contains duplicate letters. Return True otherwise.\n",
    "    \"\"\"\n",
    "    \n",
    "    try:\n",
    "        \n",
    "        lg.info(\"Input by user : {}\".format(phrase_input))\n",
    "        \n",
    "        for word in phrase_input.split(\" \"):\n",
    "            \n",
    "            if not len(word) == len(set(word.lower())):\n",
    "                return False\n",
    "            \n",
    "        else:\n",
    "            return True\n",
    "    \n",
    "    except Exception as e:\n",
    "        print(\"Check logs for error\")\n",
    "        lg.error(\"Error occured here\")\n",
    "        lg.exception(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "no_duplicate_letters(\"Fortune favours the bold.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "no_duplicate_letters(\"You can lead a horse to water, but you can't make him drink.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "no_duplicate_letters(\"Look before you leap.\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "no_duplicate_letters(\"An apple a day keeps the doctor away.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Write a regular expression that will match the states that voted yes to President Trump's impeachment. You must use RegEx positive lookahead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "txt = \"Texas = no, California = yes, Florida = yes, Michigan = no\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['California = yes', 'Florida = yes']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.findall(\"[a-zA-Z]+ *= *yes\", txt)"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}