Brush up Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Basics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "# printing any value\n",
    "print(\"Hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable\n",
    "A variable is a reserved memory location to store values. A varaiable name must begin alphabet/underscore followed by alphabets/numbers/underscores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 <class 'int'>\n",
      "99.99 <class 'float'>\n",
      "a <class 'str'>\n",
      "Hello, World! <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "# python data types\n",
    "number = 3\n",
    "float_number = 99.99\n",
    "character = 'a'\n",
    "string = \"Hello, World!\"\n",
    "\n",
    "print(number, type(number))\n",
    "print(float_number, type(float_number))\n",
    "print(character, type(character))\n",
    "print(string, type(string))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "4\n",
      "12\n",
      "3.0\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "# writing basic operations\n",
    "a = 6\n",
    "b = 2\n",
    "print(a+b)\n",
    "print(a-b)\n",
    "print(a*b)\n",
    "print(a/b)\n",
    "print(a%b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 3\n",
      "3 <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "# getting input \n",
    "number = input(\"Enter a number: \")\n",
    "\n",
    "print(number, type(number))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 3\n",
      "3 <class 'int'>\n",
      "Square of the number: 9\n"
     ]
    }
   ],
   "source": [
    "# casting string to integer\n",
    "number = int(input(\"Enter a number: \"))\n",
    "\n",
    "print(number, type(number))\n",
    "print(\"Square of the number:\", number**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Python Built-in Data Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1. List\n",
    "* List is an ordered collection of data. \n",
    "* It is mutable and allow duplicates. \n",
    "* It list is created by enclosing the data items with in square brackets delimited by \",\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[35, 68, 96, 80, 90]\n"
     ]
    }
   ],
   "source": [
    "# Creating a list\n",
    "marks = [35, 68, 96, 80, 90]\n",
    "\n",
    "print(marks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "marks[0] : 35\n",
      "marks[len(marks)-1] : 90\n",
      "marks[-1] : 90\n"
     ]
    }
   ],
   "source": [
    "# Indexing list elements\n",
    "print(\"marks[0] : %d\" % marks[0])\n",
    "print(\"marks[len(marks)-1] : %d\" % marks[len(marks)-1])\n",
    "print(\"marks[-1] : %d\" % marks[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[38, 68, 96, 80, 90]\n"
     ]
    }
   ],
   "source": [
    "# Modifying list elemets\n",
    "marks[0] = 38\n",
    "\n",
    "print(marks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[38, 68, 96, 80, 90]\n",
      "[38, 68, 96, 80, 90]\n",
      "[38, 68, 96, 80, 90]\n",
      "[38, 68, 96, 80, 90]\n",
      "[96, 80]\n"
     ]
    }
   ],
   "source": [
    "# Slicing the list\n",
    "# Syntax: list[start:end(exclusive)]\n",
    "print(marks[0:len(marks)])\n",
    "print(marks[:len(marks)])\n",
    "print(marks[0:])\n",
    "print(marks[:])\n",
    "\n",
    "print(marks[2:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[38, 68, 96, 80, 90, 89]\n",
      "[38, 70, 68, 96, 80, 90, 89]\n",
      "[38, 68, 96, 80, 90, 89]\n"
     ]
    }
   ],
   "source": [
    "# Adding and removing list elements\n",
    "marks.append(89)\n",
    "print(marks)\n",
    "\n",
    "marks.insert(1, 70)\n",
    "print(marks)\n",
    "\n",
    "marks.remove(70)\n",
    "print(marks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[38, 68, 80, 89, 90, 96]\n",
      "[96, 90, 89, 80, 68, 38]\n"
     ]
    }
   ],
   "source": [
    "# sorting list elements\n",
    "print(sorted(marks))\n",
    "print(sorted(marks, reverse=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[68, 96, 80, 90, 89]\n"
     ]
    }
   ],
   "source": [
    "# List Comprehesion\n",
    "pass_mark = 50\n",
    "marks_new = [mark for mark in marks if mark > pass_mark]\n",
    "print(marks_new)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2. Tuple\n",
    "* Tuple is an ordered collection of data. \n",
    "* It is immutable and allow duplicates. \n",
    "* It list is created by enclosing the data items with in round brackets delimited by \",\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(35, 68, 96, 80, 90)\n"
     ]
    }
   ],
   "source": [
    "# Creating a tuple\n",
    "marks = (35, 68, 96, 80, 90)\n",
    "\n",
    "print(marks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "marks[0] : 35\n",
      "marks[len(marks)-1] : 90\n",
      "marks[-1] : 90\n"
     ]
    }
   ],
   "source": [
    "# Indexing tuple elements\n",
    "print(\"marks[0] : %d\" % marks[0])\n",
    "print(\"marks[len(marks)-1] : %d\" % marks[len(marks)-1])\n",
    "print(\"marks[-1] : %d\" % marks[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(35, 68, 96, 80, 90)\n"
     ]
    }
   ],
   "source": [
    "#  Note: We cannot modify the elemnts in a tuple\n",
    "\n",
    "#marks[0] = 38\n",
    "\n",
    "print(marks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(35, 68, 96, 80, 90)\n",
      "(35, 68, 96, 80, 90)\n",
      "(35, 68, 96, 80, 90)\n",
      "(35, 68, 96, 80, 90)\n",
      "(96, 80)\n"
     ]
    }
   ],
   "source": [
    "# Slicing the tuple\n",
    "# Syntax: tuple[start:end(exclusive)]\n",
    "print(marks[0:len(marks)])\n",
    "print(marks[:len(marks)])\n",
    "print(marks[0:])\n",
    "print(marks[:])\n",
    "\n",
    "print(marks[2:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(68, 96, 80, 90)\n"
     ]
    }
   ],
   "source": [
    "# tuple Comprehesion\n",
    "pass_mark = 50\n",
    "marks_new = tuple((mark for mark in marks if mark > pass_mark))\n",
    "print(marks_new)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3. Set\n",
    "* Set is an unordered collection of data. \n",
    "* It is mutable and does not allow duplicates. \n",
    "* It is created by enclosing the data items with in curly brackets delimited by \",\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Bombay', 'Delhi', 'Madras', 'Calcutta'}\n"
     ]
    }
   ],
   "source": [
    "cities = {\"Madras\", \"Delhi\", \"Bombay\", \"Calcutta\", \"Madras\"}\n",
    "\n",
    "print(cities)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6}\n",
      "{4}\n",
      "{1, 2, 3}\n",
      "{1, 2, 3, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "# Set Operations\n",
    "\n",
    "a = {1, 2, 3, 4}\n",
    "b = {4, 5, 6}\n",
    "\n",
    "# Set Union\n",
    "print(a | b)\n",
    "\n",
    "# Set Intersection\n",
    "print(a & b)\n",
    "\n",
    "# Set Difference\n",
    "print(a - b)\n",
    "\n",
    "# Symmetric Difference\n",
    "print(a ^ b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 7}\n",
      "{1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "# Adding and removing set elements\n",
    "a.add(7)\n",
    "print(a)\n",
    "\n",
    "a.remove(7)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4. Dictionary\n",
    "* Dictionary is an unordered collection of key-values pairs. \n",
    "* It is mutable. \n",
    "* It is created by enclosing the key-value parirs (key:value) with in curly brackets delimited by \",\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Gokul', 'reg_no': '15IT026', 'course': 'BTech'}\n"
     ]
    }
   ],
   "source": [
    "student = {\"name\":\"Gokul\", \"reg_no\":\"15IT026\", \"course\":\"BTech\"}\n",
    "\n",
    "print(student)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BTech\n",
      "Key: name ; Value: Gokul\n",
      "Key: reg_no ; Value: 15IT026\n",
      "Key: course ; Value: BTech\n"
     ]
    }
   ],
   "source": [
    "# Accessing elements\n",
    "print(student[\"course\"])\n",
    "\n",
    "for key, value in student.items():\n",
    "    print(\"Key: %s ; Value: %s\" % (key, value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5. String\n",
    "* A string is a sequence of charactes\n",
    "* It is immutable. \n",
    "* It is created by enclosing text with single/double/triple quotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Malayalam\n"
     ]
    }
   ],
   "source": [
    "word = \"Malayalam\"\n",
    "print(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "malayalam\n",
      "MALAYALAM\n",
      "9\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# String operations\n",
    "\n",
    "print(word.lower())\n",
    "print(word.upper())\n",
    "print(len(word))\n",
    "print(word.startswith(\"A\"))\n",
    "print(word.endswith(\"m\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Malay\n"
     ]
    }
   ],
   "source": [
    "# Slicing the string\n",
    "print(word[0:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['M', 'a', 'l', 'a', 'y', 'a', 'l', 'a', 'm']\n"
     ]
    }
   ],
   "source": [
    "# Coverting string to a list of characters\n",
    "print(list(word))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['I', 'love', 'deep', 'learning']\n"
     ]
    }
   ],
   "source": [
    "# splitting the text\n",
    "sentence = \"I love deep learning\"\n",
    "words = sentence.split(\" \")\n",
    "print(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "# finding length of a list\n",
    "print(len(words))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Control Structures\n",
    "\n",
    "<b>'if...else' syntax:</b>\n",
    "    \n",
    "    if CONDITION:\n",
    "        code block 1\n",
    "    elif CONDITION:\n",
    "        code block 2\n",
    "    ...\n",
    "    else:\n",
    "        code block n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3\n",
    "b = 5\n",
    "\n",
    "if a > b:\n",
    "    print(\"a is greater than b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b is greater than a\n"
     ]
    }
   ],
   "source": [
    "if a > b:\n",
    "    print(\"a is greater than b\")\n",
    "else:\n",
    "    print(\"b is greater than a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grade: C\n"
     ]
    }
   ],
   "source": [
    "score = 80\n",
    "grade = None\n",
    "\n",
    "if score > 90:\n",
    "    grade = \"A\"\n",
    "elif score > 80:    \n",
    "    grade = \"B\"\n",
    "elif score > 70:    \n",
    "    grade = \"C\"\n",
    "elif score > 60:    \n",
    "    grade = \"D\"\n",
    "elif score > 50:    \n",
    "    grade = \"E\"\n",
    "else:\n",
    "    grade = \"F\"\n",
    "    \n",
    "print(\"Grade: \" + grade)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>'for' syntax:</b>\n",
    "    \n",
    "    for ELEMENT in SEQUENCE:\n",
    "        code block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mitesh@onefourthlabs.com\n",
      "pratyush@onefourthlabs.com\n",
      "ananya@onefourthlabs.com\n",
      "rohith@onefourthlabs.com\n",
      "prem@onefourthlabs.com\n",
      "gokul@onefourthlabs.com\n"
     ]
    }
   ],
   "source": [
    "ofl_team = [\"mitesh\", \"pratyush\", \"ananya\", \"rohith\", \"prem\", \"gokul\"]\n",
    "for person in ofl_team:\n",
    "    mail = person + \"@onefourthlabs.com\"\n",
    "    print(mail)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mitesh@onefourthlabs.com\n",
      "pratyush@onefourthlabs.com\n",
      "ananya@onefourthlabs.com\n",
      "rohith@onefourthlabs.com\n",
      "prem@onefourthlabs.com\n",
      "gokul@onefourthlabs.com\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(ofl_team)):\n",
    "    mail = ofl_team[i] + \"@onefourthlabs.com\"\n",
    "    print(mail)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>'while' syntax:</b>\n",
    "    \n",
    "    while CONDITION:\n",
    "        code block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 5\n",
      "5! = 120\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Enter a number: \"))\n",
    "\n",
    "n_factorial = 1\n",
    "x = 2\n",
    "while x <= n:\n",
    "    n_factorial = n_factorial * x\n",
    "    x = x+1\n",
    "    \n",
    "print(\"%d! = %d\" % (n, n_factorial))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Functions\n",
    "* A function is a block of code that can be reused. \n",
    "* It is defined using the 'def' keyword in python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Function syntax:</b>\n",
    "\n",
    "    def function_name(parameters):\n",
    "        code...\n",
    "        return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining the function\n",
    "def area_of_square(length, breadth):\n",
    "    area = length*breadth\n",
    "    return area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calling the function\n",
    "area_of_square(2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Harish\n",
      "Hello \n"
     ]
    }
   ],
   "source": [
    "# Function with default arguments\n",
    "def greet(name=\"\"):\n",
    "    print(\"Hello \" + name)\n",
    "\n",
    "greet(\"Harish\")\n",
    "greet()"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}