Python Basics- week 1 & 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Intro to Python and Machine Learning Toolbox\n",
    "\n",
    "1.\tSetting up development environment (20 min)\n",
    "\n",
    "\t+\tPython and Anaconda\n",
    "\t+\tJupyter Notebook\n",
    "\t+ \tImportant libraries, packages and modules\n",
    "\t\n",
    "    \n",
    "2.\tPython Basics (2 hrs)\n",
    "\n",
    "\t+\tBasics\n",
    "\t+\tStrings and formatting\n",
    "\t+\tData structures (Lists, Dictionaries, Tuples and Sets)\n",
    "\t+\tConditional states\n",
    "    +\tLoops\n",
    "\t+\tList and Dict Comprehensions\n",
    "\t+\tInput/output operations (reading and writing files)\n",
    "\t+\tFunctions\n",
    "\t+\tEmbedded functions (all, any, map, lambda, filter)\n",
    "\t+\tExceptions and error handling\n",
    "    +\tModules\n",
    "\n",
    "\n",
    "3.\tExploratory Data Analysis (EDA) with Pandas and Numpy\t(1 hrs)\n",
    "\t\n",
    "\t+\tPandas\n",
    "\t+\tNumpy\n",
    "    +   Pandas Built-in Visualization Tool\n",
    "\t-\tEDA framework\n",
    "\n",
    "\n",
    "4.\tIntro to Machine Learning with Scikit Learn (2-3 hrs)\n",
    "\n",
    "    - Preprocessing\n",
    "\n",
    "    - Regression\n",
    "\n",
    "    - Classification\n",
    "\n",
    "    - Clustering\n",
    "\n",
    "    - Model Selection and Evaluation\n",
    "\n",
    "    - Dimensionality Reduction\n",
    "    \t\n",
    "    - ML Pipeline\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 3.6.5 :: Anaconda, Inc.\r\n"
     ]
    }
   ],
   "source": [
    "# let's check the Python version at first\n",
    "\n",
    "!python -V"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A. Python Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 1. Basics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1>>3.5>>The value of variable a is...>>1>>4\n",
      "cc\n"
     ]
    }
   ],
   "source": [
    "a=1\n",
    "b=3.5\n",
    "\n",
    "print (a, b, \"The value of variable a is...\", a, 4, sep=\">>\")\n",
    "print(\"cc\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "The type of 1.5 is now float..\n"
     ]
    }
   ],
   "source": [
    "a=1.5\n",
    "\n",
    "print (type(a))\n",
    "\n",
    "print (\"The type of\",a,\"is now float..\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello \n",
      "World \n",
      " Hello \n",
      " World \n",
      " sdsdasda\n"
     ]
    }
   ],
   "source": [
    "#int\n",
    "\n",
    "a=1\n",
    "\n",
    "#float\n",
    "\n",
    "b=1.5\n",
    "\n",
    "#string (str)\n",
    "\n",
    "c=\"Hello \\nWorld \\n Hello \\n World \\n sdsdasda\"\n",
    "print (c)\n",
    "#boolean (bool)\n",
    "\n",
    "d= True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can easily convert from one type to another..\n",
    "b=1.8\n",
    "\n",
    "int(b)\n",
    "\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jack Bauer\n"
     ]
    }
   ],
   "source": [
    "name = 'Jack'   # single quotes\n",
    "surname = \"Bauer\"   # double quotes\n",
    "\n",
    "print (name,surname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of a and b is 2.8\n"
     ]
    }
   ],
   "source": [
    "print (\"The sum of a and b is\", a+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.8\n"
     ]
    }
   ],
   "source": [
    "x=a+b\n",
    "\n",
    "print (x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "24\n"
     ]
    }
   ],
   "source": [
    "# addition and subtraction\n",
    "\n",
    "print (4+7)\n",
    "print (56-32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "# multiplication\n",
    "\n",
    "print (type(str(5)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.0\n"
     ]
    }
   ],
   "source": [
    "# division\n",
    "\n",
    "print (56/7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "şekil=\n",
    "şekil.fit(X,y)\n",
    "print (şekil)\n",
    "şekil.predict([1,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# exponent\n",
    "\n",
    "5**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.818181818181818"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "130/11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "130//11\n",
    "\n",
    "# digits after the decimal point are removed "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.56\n"
     ]
    }
   ],
   "source": [
    "# order of operations\n",
    "\n",
    "\"\"\"\n",
    "1. Parentheses\n",
    "2. Exponent\n",
    "3. Multiplication or Division\n",
    "4. Addition or Subtraction\n",
    "\"\"\"\n",
    "\n",
    "m= (a+b)*(a**2)/5+2\n",
    "\n",
    "print (m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# title"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### mini title *dd*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "x=5\n",
    "\n",
    "# we can also do this with -, * and /\n",
    "x+=1\n",
    "print (x)\n",
    "\n",
    "x=x+1\n",
    "\"\"\"\n",
    "x-=3 # this will subract 3 from x and assign to x\n",
    "\"\"\"\n",
    "print (x) #CDSDFDDD\n",
    "#<"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "#module (%)\n",
    "\n",
    "y= x%2\n",
    "\n",
    "print (y)\n",
    "\n",
    "# divides left hand operand by right hand operand and returns remainder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For detailed mathematical operations and functions, please refer to Python \"math\" library"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comparison operators\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "<table class=\"table table-bordered\">\n",
    "<tr>\n",
    "<th style=\"width:10%\">Operator</th><th style=\"width:45%\">What it does</th><th>Example</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>==</td>\n",
    "<td>If two values are equal, returns True, else returns False.</td>\n",
    "<td> 2 == 2 (True) ,  2 == 3 (False)</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>!=</td>\n",
    "<td>If two values are not equal, returns True, else returns False.</td>\n",
    "<td>2 != 2 (False), 2 != 3 (True)</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&gt;</td>\n",
    "<td>If the left hand side value is gretaer than the right hand side, returns True, else returns False. </td>\n",
    "<td> 3 > 2 (True), 2 > 3 (False)</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&lt;</td>\n",
    "<td>If the left hand side value is less than the right hand side, returns True, else returns False. </td>\n",
    "<td> 2 &lt; 3 (True) , 3 &lt; 2 (False) </td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&gt;=</td>\n",
    "<td>If the left hand side value is gretaer than or equal to right hand side, returns True, else returns False.</td>\n",
    "<td> 3 &gt;= 2 (True),3 &gt;= 3 (True) , 2 &gt;= 3 (False)</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&lt;=</td>\n",
    "<td>If the left hand side value is less than or equal to right hand side, returns True, else returns False.</td>\n",
    "<td> 3 &lt;= 2 (False),3 &lt;= 3 (True) , 2 &lt;= 3 (True) </td>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Comparison Operators\n",
    "\n",
    "# equal\n",
    "print (a == b)\n",
    "\n",
    "# not equal\n",
    "print (a != b)\n",
    "\n",
    "# less than\n",
    "print (a < b)\n",
    "\n",
    "# greater than\n",
    "print (a>b)\n",
    "\n",
    "# less than or equal\n",
    "print (a<=b)\n",
    "\n",
    "# greater than or equal\n",
    "print (a>=b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Strings in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.Python.is fun\n",
      "1_Python_is fun\n",
      "July/12/2007\n"
     ]
    }
   ],
   "source": [
    "score_Jack= \"learning\"\n",
    "b=\"Python\"\n",
    "c=\"is fun\"\n",
    "\n",
    "print(a,b,c,sep = \".\")\n",
    "# sep token is used to put custom characters between items.. we can use anything in sep..\n",
    "\n",
    "print(a,b,c,sep = \"_\")\n",
    "\n",
    "print (\"July\",\"12\",\"2007\", sep=\"/\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intro to Python\tML Toolkit\n"
     ]
    }
   ],
   "source": [
    "# If we use end of line symbol (\\n), we can write each item line by line\n",
    "\n",
    "print (\"Intro to Python\",\"ML Toolkit\", sep=\"\\t\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P y t h o n\n",
      "P\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n",
      "P y t h o n\n"
     ]
    }
   ],
   "source": [
    "# * formatting is used to put spaces between each letter in string\n",
    "print(*\"Python\")\n",
    "\n",
    "print(*\"Python\",sep = \"\\n\")\n",
    "\n",
    "a= \"Python\"\n",
    "\n",
    "print (*a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String functions and formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world 35\n",
      "hello world 35.00\n"
     ]
    }
   ],
   "source": [
    "# sprintf style formatting\n",
    "\n",
    "output = 'my life is %s %s %d' % (\"hello\", \"world\", 35)  \n",
    "print (output)\n",
    "\n",
    "output = '%s %s %.2f' % (\"hello\", \"world\", 35)  \n",
    "print (output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the difference between 25 and 15\n"
     ]
    }
   ],
   "source": [
    "first=25\n",
    "second=\"15\"\n",
    "\n",
    "print (\"the difference between %d and %s\" %(first, second))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the name of person is jack. And done !\n",
      "the name of person is jack. And done !\n",
      "the name of person is marry. And done !\n",
      "the name of person is marry. And done !\n",
      "the name of person is john. And done !\n",
      "the name of person is john. And done !\n"
     ]
    }
   ],
   "source": [
    "name_list=[\"jack\", \"marry\", \"john\"]\n",
    "for name in name_list:\n",
    "    print (\"the name of person is %s. And done !\" %(name))\n",
    "    print (\"the name of person is {}. And done !\".format(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.142311 25.324 7.00324324\n",
      "3.142311 25.324 7.00324324\n"
     ]
    }
   ],
   "source": [
    "# .format usage with {}\n",
    "\n",
    "x=\"{} {} {}\".format(3.142311,25.324,7.00324324)\n",
    "\n",
    "print (x)\n",
    "\n",
    "print (\"{} {} {}\".format(3.142311,25.324,7.00324324))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the sum of 31 and 45 is 76\n"
     ]
    }
   ],
   "source": [
    "a = 31\n",
    "b = 45\n",
    "\n",
    "print(\"the sum of {} and {} is {}\".format(a,b,a+b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'learning Python in 5 days'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can reorder the items by specyfying the numbers\n",
    "\n",
    "\"{0} {2} {1} {3}\".format(\"learning\",5,\"Python in\",\"days\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'13.14 25.32 7.003'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can specify the number of digits to be used after . in floats\n",
    "\n",
    "\"{:.2f} {:.2f} {:.3f}\".format(13.142311,25.324,7.00324324)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5714285714285714"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2/3.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 358,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "# If we would like to print the statements in the same line (not in a seperate line), we can use \"end\" parameter of print\n",
    "# The default value of \"end\" is \"\\n\" meaning that after the print statement it will print a new line\n",
    "# so we'd just need to state something else other than \"\\n\"\n",
    "\n",
    "a=\"Hello\"\n",
    "\n",
    "b=\"World\"\n",
    "\n",
    "print (a, end=\" \")\n",
    "\n",
    "print (b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'roermond are cool'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myText=\"roermond is cool\"\n",
    "myText=myText.replace(\"is\",\"are\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=[1,3,5,2]\n",
    "sorted(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 2]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Experfy\n",
      "EXPERFY\n",
      "experfy\n",
      " python \n",
      "pyyython\n"
     ]
    }
   ],
   "source": [
    "s = \"experfy\"\n",
    "\n",
    "print (s.capitalize())  # Capitalize a string\n",
    "\n",
    "print (s.upper())      # Convert a string to uppercase\n",
    "\n",
    "print (s.rjust(3))      # Right-justify a string, padding with spaces\n",
    "\n",
    "s= \"PYTHON\".lower()\n",
    "\n",
    "print (s.center(8))     # Center a string, padding with spaces\n",
    "\n",
    "print (s.replace('y', 'yyy'))  # Replace all instances of one substring with another\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'PYTHON'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# beware that we don't change the variable by using these functions.. if we want:\n",
    "\n",
    "s=s.upper()\n",
    "\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exper\n"
     ]
    }
   ],
   "source": [
    "# strip() function.. default value is whitespace..\n",
    "\n",
    "print ('  exper '.strip())  # Strip leading and trailing whitespace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "perfy\n",
      "experf\n"
     ]
    }
   ],
   "source": [
    "# we can strip any character set from the string.. but only if the string begins or end with that character set\n",
    "\n",
    "s=\"experfy\"\n",
    "\n",
    "print (s.strip(\"ex\"))\n",
    "\n",
    "print (s.strip(\"y\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "experfy.....\n",
      "......experfy\n"
     ]
    }
   ],
   "source": [
    "# if we want to strip just from the beginning or end, we can use lstrip() for the beginnings and rstrip() for the endings..\n",
    "\n",
    "s=\"......experfy.....\"\n",
    "\n",
    "print (s.lstrip(\".\"))\n",
    "\n",
    "print (s.rstrip(\".\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# startswith() and endswith() returns boolean if a certain part of string is at the beginning or at the end of the string.\n",
    "# these two functions are quite useful in if-else statements..\n",
    "\n",
    "s=\"learning Python is quite fun\"\n",
    "\n",
    "s.startswith(\"learn\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.endswith(\"fun\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.startswith(\"Learn\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'er'"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# strings are actually a set or array of characters.. so we can get each letter with brackets [].. note that indices starts with zero..\n",
    "\n",
    "s=\"experfy\"\n",
    "\n",
    "s[3:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'p'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'y'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'f'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ex'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[0:2]\n",
    "\n",
    "# returns the first two letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'exper'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:-2]\n",
    "\n",
    "# discards the last two letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'erf'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[3:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'epr'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[0:6:2]\n",
    "\n",
    "#return the every other letter starting from index 0. \"2\" shows the steps to jump.. so we have the letters at index 0, 2 and 4.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'yfrepxe'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::-1]\n",
    "\n",
    "# reversing the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'p'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=\"python\"\n",
    "s[-len(s)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'e*x*p*e*r*f*y'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# join() function is used the insert certain character(s) between each letter in a string\n",
    "\n",
    "s= \"experfy\"\n",
    "\n",
    "\"*\".join(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['learning', 'python', 'in', '5', 'days']\n"
     ]
    }
   ],
   "source": [
    "s=\"learning:python:in:5:days\"\n",
    "\n",
    "s=s.split(\":\")\n",
    "#print(list(s))\n",
    "print (s)\n",
    "# splits the string by spaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jack Bauer'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name=\"jack bauer\"\n",
    "\n",
    "\" \".join([x.capitalize() for x in name.split()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s_list=s.split()\n",
    "\n",
    "s_list[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['learning python', ' in 5 days']"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=\"learning python, in 5 days\"\n",
    "\n",
    "s.split(\",\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# count() function is used the count the number of certain letter in the string\n",
    "\n",
    "s.count(\"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the second parameter in count() is used to specify the starting point to start counting\n",
    "\n",
    "s.count(\"a\",4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# find(x) : search for \"x\" value inside the string and returns the index of first \"x\" from the beginning. If it cannot find, it returns \"-1\"\n",
    "# rfind(x) : same as find() but search starts from the end of the string.\n",
    "\n",
    "s.find(\"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.rfind(\"a\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### getting inputs from user"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "please enter your name:python\n",
      "please enter your age:3\n",
      "Your name is python and you're 3 years old\n"
     ]
    }
   ],
   "source": [
    "a=input(\"please enter your name:\")\n",
    "b=input(\"please enter your age:\")\n",
    "\n",
    "print (\"Your name is {} and you're {} years old\".format(a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x\n",
      "xxx\n"
     ]
    }
   ],
   "source": [
    "a=input()\n",
    "\n",
    "print (a*3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vvv\n"
     ]
    }
   ],
   "source": [
    "a=\"v\"\n",
    "print (a*3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Data Structures (lists, dictionaries, sets and tuples)\n",
    "\n",
    "#### Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5, 5, True, 6, 'tree', 3.14, 125]"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a list is the Python equivalent of an array, but is resizeable and can contain elements of different types\n",
    "\n",
    "my_list = [3, 4, 5, 5, True, 6, \"tree\", 3.14, 125]\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty_list=list()\n",
    "empty_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can do the same with list() function\n",
    "\n",
    "new_empty_list= list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty_list==new_empty_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, 5, 6, 7, 8]"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=\"experfy\"\n",
    "\n",
    "my_list= list((1,3,4, 5,6,7,8))\n",
    "\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3]"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for slicing, we can do anything we want that we do with strings..\n",
    "\n",
    "my_list[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 6, 8]"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[:-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'e'"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=[1,3,5] \n",
    "b=[6,8,9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 6, 8, 9, 3, 5]"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[a[0]]+b+a[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, 5, 6, 7, 8, 'new_item']"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can add new item by .append() method\n",
    "\n",
    "my_list.append(\"new_item\")\n",
    "\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, 'z', 3, 5, 8, 'new_item']"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# replacing the 3rd and 4th item with new ones\n",
    "\n",
    "my_list[3]=\"z\"\n",
    "\n",
    "my_list[4:6]=3,5\n",
    "\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, 3, 5, 5, 8]"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[3:5]=[3,5]\n",
    "\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, 3, [23, 45], 5, 8]"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can add new list as a list item\n",
    "\n",
    "my_list[4]=[23,45]\n",
    "\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type((a , b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, ([1, 3, 5], [6, 8, 9]), [23, 45], 5, 8]"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, 'z', [23, 45], 5, 8]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can use remove() to remove any item form the he list\n",
    "\n",
    "my_list.remove(\"new_item\")\n",
    "\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, ([1, 3, 5], [6, 8, 9]), [23, 45]]"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list.remove(5)\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[23, 45]"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can remove and return the last element of the list\n",
    "\n",
    "my_list.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, ([1, 3, 5], [6, 8, 9])]"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 5, 8, 1, 8, 3, 6]"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# concatenating two lists\n",
    "\n",
    "a_list=[2,4,5,8]\n",
    "\n",
    "b_list=[1,8,3,6]\n",
    "\n",
    "c_list=a_list+b_list\n",
    "\n",
    "c_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 5, 8, 1, 8, 3, 6, 'www']"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_list=c_list + [\"www\"]\n",
    "\n",
    "d_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'12 1 2017'"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# join () function is used to concatenate each string item in the list with certain character(s). If the items are not string, error pops up\n",
    "\n",
    "my_list= [\"12\",\"1\",\"2017\"]\n",
    "\n",
    "\" \".join(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2030"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "sum([int(x) for x in my_list[1:]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "toplam=0\n",
    "for x in my_list[:-1]:\n",
    "    toplam+=int(x)\n",
    "toplam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_list.remove(d_list[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 5, 8, 1, 8, 3]"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 5, 4, 2, 1]"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can sort the list.. after sorting, the items are ordered and assigned to same list variable\n",
    "\n",
    "d_list.pop()\n",
    "\n",
    "d_list.sort(reverse=True)\n",
    "\n",
    "d_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 8, 6, 5, 4, 3, 2, 1]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can reverse the order\n",
    "\n",
    "d_list.sort(reverse = True)\n",
    "\n",
    "d_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can do the same with putting the list inside sorted() function. But sorted() function doesn't change the order of items.\n",
    "\n",
    "d_list=[1, 5, 3, 2, 7, 6, 9, 8]\n",
    "\n",
    "sorted(d_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_list.sort() \n",
    "\n",
    "d_list=sorted(d_list)\n",
    "\n",
    "d_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5, 6, 7, 8, 9, 1, 2, 3, 5, 6, 7, 8, 9, 1, 2, 3, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can extend the list by multiplying with a number\n",
    "\n",
    "d_list=d_list*3\n",
    "\n",
    "d_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can create a ordered list with list() and range().. this will be quite useful in for-loops..\n",
    "\n",
    "list(range(8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=range(8)\n",
    "a[7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# creating a list in given interval \n",
    "\n",
    "range(2,15)[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# creating a list with given interval and steps\n",
    "\n",
    "a=range(1,12,3)\n",
    "\n",
    "print (a[0])\n",
    "print (a[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6], ['x', 'y', 'z']]"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# multidimensional lists (list of lists)\n",
    "\n",
    "a=[1,2,3]\n",
    "\n",
    "b=[4,5,6]\n",
    "\n",
    "c=[\"x\",\"y\",\"z\"]\n",
    "\n",
    "d_list=[a,b,c]\n",
    "\n",
    "d_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_list[0][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'y'"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_list[2][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[]]"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# how to create emtyp 2-D list\n",
    "\n",
    "d_list=[[]]\n",
    "\n",
    "d_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'axxb'"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"xx\".join([\"a\",\"b\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_list.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(d_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[], [1, 2, 3]]"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_list.append(a)\n",
    "\n",
    "d_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 'python', 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# insert() function is used to insert an item at a certain index\n",
    "\n",
    "my_list = [1,2,3,4,5,6,7,8,9]\n",
    "\n",
    "my_list.insert(2,\"python\")\n",
    "\n",
    "print (my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# index () function returns the item's index or the index of an item\n",
    "\n",
    "my_list.index(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list.index(\"python\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# count() returns the number of given items in the list\n",
    "\n",
    "my_list = [1,2,3,4,4,6,7,8,9]\n",
    "\n",
    "my_list.count(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dictionary is a collection of key-value pairs.\n",
    "\n",
    "my_dict = {\n",
    "  \"key1\": \"value1\",\n",
    "  \"key2\": \"value2\",\n",
    "  \"key3\": \"value3\"\n",
    "}\n",
    "\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'dict_keys' object has no attribute 'index'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-190-48b78c892405>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmy_dict\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"key1\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'dict_keys' object has no attribute 'index'"
     ]
    }
   ],
   "source": [
    "my_dict.keys().index(\"key1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'personal': {'kids': {'boys': {'school': 'mm', 'age': 12}}}}"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bank_records={\n",
    "    \"personal\": {\n",
    "        \"kids\":{\"boys\":\n",
    "                {\"school\":\"mm\", \"age\":12}}\n",
    "                \n",
    "    },\n",
    "}\n",
    "bank_records"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "bank_records[\"personal\"][\"kids\"][x][\"age\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': [1, 2], 'key2': 'value2', 'key3': 'value3'}"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can access the dictionary value with keys.\n",
    "\n",
    "my_dict[\"key1\"]=[1,2]\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['key1', 'key2', 'key3']"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(my_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key1\n",
      "key2\n",
      "key3\n"
     ]
    }
   ],
   "source": [
    "for x in my_dict:\n",
    "    print (x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['key1', 'key2', 'key3']"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# if we want to return the keys as list\n",
    "\n",
    "list(my_dict.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['key1', 'key2', 'key3']"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# if we use list with no keys, we still get the key list\n",
    "\n",
    "list(my_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['value1', 'value2', 'value3'])"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['value1', 'value2', 'value3']"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(my_dict.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the second value in my_dict is value1\n"
     ]
    }
   ],
   "source": [
    "print(\"the second value in my_dict is %s\" %(my_dict[\"key1\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 25, 'key2': 'value2', 'key3': 'value3'}"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can change the value of any key..\n",
    "\n",
    "my_dict[\"key1\"]=25\n",
    "\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 25, 'key2': 'value2', 'key3': 'value3', 'key4': 'value4'}"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can add new key-value pair or edit the existing one with update() (as we use append() in lists)\n",
    "\n",
    "my_dict.update({'key4':\"value4\"})\n",
    "\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key2': 'value2', 'key3': 'value3', 'key4': 'value4'}"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can remove keys with del\n",
    "\n",
    "del my_dict[\"key1\"]\n",
    "\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can create an empty dictionary..\n",
    "\n",
    "empty_dict={}\n",
    "\n",
    "empty_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key2': [1, 2, 3]}"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can use lists as a value\n",
    "\n",
    "empty_dict[\"key2\"]=[1,2,3]\n",
    "\n",
    "empty_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key2': [1, 2, 3], 'key3': {'key5': 45}}"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can use dictionaries itself as a value\n",
    "\n",
    "empty_dict[\"key3\"]={\"key5\":45}\n",
    "\n",
    "empty_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_dict.update({'key3':\"value4\"})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key2': [1, 2, 3], 'key3': {'key5': 45}, 'key4': 'value4'}"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5, 6, 7, 6)"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Tuples are very similar to lists but the only and most important difference is that the tuples are immutable. \n",
    "# So we can use tuples for the list items that shouldn't be changed and it's much faster than lists due to its read-only property\n",
    "\n",
    "my_tuple=(1,2,3,4,5,6,7, 6)\n",
    "\n",
    "my_tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tuple[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tuples have just two methods: index() and count()\n",
    "\n",
    "my_tuple.index(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tuple.count(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-156-78751b23a594>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# if we try to change any item in the tuple, an error pops up\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mmy_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# if we try to change any item in the tuple, an error pops up\n",
    "\n",
    "my_tuple[1]=4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist=list(set(my_tuple))\n",
    "\n",
    "mylist[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sets are another importan container that can hold each unique item only once. It's much faster than lists but not ordered as lists..\n",
    "\n",
    "my_set=set()\n",
    "\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 4, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set=set(my_list)\n",
    "\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 7}"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set={1,5, 7, 2,3,4, 4}\n",
    "\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{' ',\n",
       " '.',\n",
       " 'A',\n",
       " 'E',\n",
       " 'a',\n",
       " 'b',\n",
       " 'c',\n",
       " 'e',\n",
       " 'f',\n",
       " 'h',\n",
       " 'i',\n",
       " 'l',\n",
       " 'm',\n",
       " 'o',\n",
       " 'p',\n",
       " 'r',\n",
       " 's',\n",
       " 't',\n",
       " 'x',\n",
       " 'y',\n",
       " 'z'}"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=\"Experfyz.com is Athe best place to be\"\n",
    "\n",
    "#sorted(list(set(s)))\n",
    "set(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can not access an item of a set \n",
    "\n",
    "from math import pow as zafer\n",
    "\n",
    "zafer(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [],
   "source": [
    "del my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'my_set' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-217-8ac5ee96e9a6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# we can access an item of a set by converting it to list\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_set\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'my_set' is not defined"
     ]
    }
   ],
   "source": [
    "# we can access an item of a set by converting it to list\n",
    "\n",
    "list(my_set)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can a new item to sets with add() method\n",
    "my_set=set(range(9))\n",
    "my_set.add(9)\n",
    "\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 4, 5, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can remove an item from sets with discard() or remove()\n",
    "\n",
    "my_set.discard(3)\n",
    "\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 5, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set.remove(4)\n",
    "\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{7, 9}"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can return the difference between two sets with difference() method\n",
    "\n",
    "set1={1,3,5,7,9}\n",
    "set2={3,5,1,0}\n",
    "\n",
    "set1.difference(set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0}"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set2.difference(set1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 5}"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# What if we want to see the common items in two sets? \n",
    "\n",
    "set1.intersection(set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 3, 5, 7, 9}"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# If we want to join two sets, we can use update() method\n",
    "\n",
    "set1.update(set2)\n",
    "\n",
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 3, 5, 7, 9}"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set2.update(set1)\n",
    "\n",
    "set2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Conditional States and Loops\n",
    "\n",
    "#### if-else statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 is greater than 1\n"
     ]
    }
   ],
   "source": [
    "#“If” statement evaluates whether a statement is True or False. If it is True, it executes what is inside the “if” statement.\n",
    "\n",
    "a=3\n",
    "\n",
    "if a>1:\n",
    "    print (\"%d is greater than 1\" % a)\n",
    "\n",
    "# we must use \":\" after \"if\" statement, indentation before the following line after \"if\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number:4\n",
      "4 is equal to 4\n",
      "6.666666666666667\n",
      "printing out of if clause\n"
     ]
    }
   ],
   "source": [
    "a = int (input(\"Enter a number:\"))\n",
    "\n",
    "if a==4:\n",
    "    print (\"%d is equal to 4\" % a)\n",
    "    m=a*5\n",
    "    k=m/3\n",
    "    print (k)\n",
    "\n",
    "print (\"printing out of if clause\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 is not greater than 1\n"
     ]
    }
   ],
   "source": [
    "# The “else” statement will be executed if the “if” expression is false.\n",
    "\n",
    "a=0\n",
    "\n",
    "if a>1:\n",
    "    print (\"%d is greater than 1\" % a)\n",
    "else:\n",
    "    print (\"%d is not greater than 1\" % a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is greater than 1\n",
      "c is true\n"
     ]
    }
   ],
   "source": [
    "# we can add more than one if statment with \"elif\"\n",
    "\n",
    "a = 2\n",
    "\n",
    "b= a>1\n",
    "\n",
    "c= 6>5\n",
    "\n",
    "d= a>3\n",
    "\n",
    "if b or c:\n",
    "    print (\"a is greater than 1\")\n",
    "    if b*c:\n",
    "        print (\"c is true\")\n",
    "elif d:\n",
    "    print (\"a is not greater than 1\")\n",
    "elif c==True:\n",
    "    print (\"a is not greater than 5\")\n",
    "else:\n",
    "    print (\"a is equal to 0\")\n",
    "\n",
    "# when any of the statements (if or elif ) is True, the whole block is done (no need to check for the following statements)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your score:88\n",
      "Your grade is B+\n"
     ]
    }
   ],
   "source": [
    "# we can use nested if-statements for multiple cascading conditions\n",
    "\n",
    "score = int (input(\"Enter your score:\"))\n",
    "\n",
    "if score>90:\n",
    "    if score>95:\n",
    "        grade=\"A+\"\n",
    "    else:\n",
    "        grade=\"A\"\n",
    "elif score>80:\n",
    "    if score>85:\n",
    "        grade=\"B+\"\n",
    "    else:\n",
    "        grade=\"B\"\n",
    "else:\n",
    "    grade=\"Below B\"\n",
    "    \n",
    "print (\"Your grade is %s\" %grade)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Python with Experfy.com\n"
     ]
    }
   ],
   "source": [
    "s=\"Welcome to Python with Experfy.com\"\n",
    "\n",
    "if \"Python\" in s:\n",
    "    print (s)\n",
    "else:\n",
    "    print (\"not found\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 341,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Welcome', 'to', 'Python', 'with', 'Experfy.com']"
      ]
     },
     "execution_count": 341,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "website found\n"
     ]
    }
   ],
   "source": [
    "if s.endswith(\".com\"):\n",
    "    print (\"website found\")\n",
    "else:\n",
    "    print (\"no website\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### for-loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "for x in set(range(8)):\n",
    "    print (x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 401,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 401,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Before learning for-loop, at first lets learn an important function which is quite useful in for-loops: range()\n",
    "# range(x) is a list\n",
    "\n",
    "list(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 403,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9\n"
     ]
    }
   ],
   "source": [
    "# we can even treat the range() list as string list and use * formatting to write the items in the same line\n",
    "\n",
    "print(*range(10)) # prints the numbers from 0 to 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 404,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 4 5 6 7 8 9\n"
     ]
    }
   ],
   "source": [
    "print(*range(3,10))  # prints the numbers from 3 to 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 405,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 5 7 9 11 13 15 17 19\n"
     ]
    }
   ],
   "source": [
    "print(*range(3,20,2)) # prints every other numbers from 5 to 20 (the third paramater specifies the interval )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 407,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 8 6 4 2\n"
     ]
    }
   ],
   "source": [
    "print(*range(10,0,-2)) # prints the numbers in reverse order with given interval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 345,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# let's see how we can loop through 1 to 10 and print the result.. \n",
    "# we'll use range() for that.. recall that indices start from the first parameter and ends with (last parameter-1)\n",
    "# range(1,11) means 1 to 10 (including)\n",
    "\n",
    "for x in range(1,11):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 "
     ]
    }
   ],
   "source": [
    "# to write each item next to each other, recall the print formatting lesson..\n",
    "\n",
    "for x in range(1,11):\n",
    "    print(x, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 384,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5050"
      ]
     },
     "execution_count": 384,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lets sum up all the values from 1 to 100\n",
    "\n",
    "sum_up=0\n",
    "\n",
    "for x in range(1,101):\n",
    "    sum_up+=x  # sum_up=sum_up+x\n",
    "\n",
    "sum_up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 393,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 "
     ]
    }
   ],
   "source": [
    "# lets write a little bit complex script to print all the prime numbers from 1 to 100\n",
    "\n",
    "for x in range(1,101):\n",
    "    count=0\n",
    "    if x<=2:\n",
    "        print (x,end=\" \")\n",
    "    elif x%2!=0:\n",
    "        for y in range(2,x//2):\n",
    "            if (x%y)==0:\n",
    "                count+=1\n",
    "        if count==0:\n",
    "            print (x, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 4 9 16 25 36 49 64 81 100\n"
     ]
    }
   ],
   "source": [
    "# lets see how we can use the iterator item in calculations\n",
    "\n",
    "new_list=[]\n",
    "\n",
    "for x in range(1,11):\n",
    "    new_list.append(x**2)\n",
    "\n",
    "print (*new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['tiger', 'rabbit', 'tiger', 'cat']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# if we'd like to change the value of a list item and do not know the upper limit to iterate, \n",
    "# we can specifiy the range() limits by the length of the list..\n",
    "# lets change the the value of items at even indices.\n",
    "\n",
    "animals = ['bird', 'rabbit', 'dog', 'cat']\n",
    "\n",
    "for index in range(0,len(animals)):\n",
    "    if index%2==0:\n",
    "        animals[index]=\"tiger\"\n",
    "        \n",
    "animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# we can also iterate within dictionaries.\n",
    "\n",
    "my_dict = {\n",
    "  \"key1\": \"value1\",\n",
    "  \"key2\": \"value2\",\n",
    "  \"key3\": \"value3\"\n",
    "}\n",
    "\n",
    "for x in my_dict:\n",
    "    \n",
    "    print (x, end=\" \")\n",
    "\n",
    "# as you can see, print retuns the dict keys; not the values.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 378,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value1 value2 value3 "
     ]
    }
   ],
   "source": [
    "for x in my_dict.values():\n",
    "    \n",
    "    print (x, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 383,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key1 : value1\n",
      "key2 : value2\n",
      "key3 : value3\n"
     ]
    }
   ],
   "source": [
    "# if we want to access to keys and their corresponding values, we can use the iteritems() method\n",
    "\n",
    "for key, value in my_dict.items():\n",
    "    \n",
    "    print (key,\":\",value)\n",
    "    \n",
    "# we can use anything as keys and values like x,y; a,b etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 >> tiger\n",
      "4 >> rabbit\n",
      "9 >> tiger\n",
      "16 >> cat\n"
     ]
    }
   ],
   "source": [
    "# If we want to loop through more than one list at the same time, we can use zip() functions.\n",
    "\n",
    "for x,y in zip(new_list,animals):\n",
    "    print (x,\">>\",y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### while-loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: 0\n",
      "x: 1\n",
      "x: 2\n",
      "x: 3\n",
      "x: 4\n"
     ]
    }
   ],
   "source": [
    "# A while-loop will keep executing the code block under it as long as a boolean expression is True\n",
    "\n",
    "# While-loop is not being used as often as for-loops.. \n",
    "\n",
    "# A for-loop can only iterate “over” collections of things. A while-loop can do any kind of iteration we want. \n",
    "\n",
    "x = 0 \n",
    "\n",
    "while (x < 5):\n",
    "    print(\"x:\",x)\n",
    "    x += 1 # if we forget to set some change to break the loop, we may trap in infinite loop !!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "# lets iterate over a list or dictionary\n",
    "\n",
    "my_list=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
    "\n",
    "x=0\n",
    "\n",
    "while x< len(my_list):\n",
    "    \n",
    "    print (x**2)\n",
    "    \n",
    "    x+=1\n",
    "\n",
    "# as we can see, it's much easier to do the same with for-loop.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "please enter your age:a\n",
      "please enter your age:s\n",
      "please enter your age:g\n",
      "please enter your age:t\n",
      "please enter your age:12\n",
      "You entered a valid age !\n"
     ]
    }
   ],
   "source": [
    "# one of the most useful application area of while-loop can be forcing the user enter the information in a required format\n",
    "\n",
    "a=input(\"please enter your age:\")\n",
    "\n",
    "while not a.isdigit():\n",
    "    \n",
    "    a=input(\"please enter your age:\")\n",
    "\n",
    "print(\"You entered a valid age !\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "please enter your guess: 34\n",
      "Wrong guess ! Please try again with a bigger number...\n",
      "please enter your guess: 54\n",
      "Wrong guess ! Please try again with a bigger number...\n",
      "please enter your guess: 120\n",
      "Wrong guess ! Please try again with a bigger number...\n",
      "please enter your guess: 150\n",
      "Wrong guess ! Please try again with a smaller number...\n",
      "please enter your guess: 130\n",
      "Wrong guess ! Please try again with a smaller number...\n",
      "please enter your guess: w\n",
      "please enter your guess: 123\n",
      " Well done !! You found the right number after 6 trials\n"
     ]
    }
   ],
   "source": [
    "# let's build a simple \"guess the number game\"\n",
    "\n",
    "target=123\n",
    "\n",
    "counter=1\n",
    "\n",
    "a=input(\"please enter your guess: \")\n",
    "\n",
    "while not a.isdigit():\n",
    "     a=input(\"please enter your guess: \")\n",
    "\n",
    "while int(a)!=target:\n",
    "    \n",
    "    if int(a) < target:\n",
    "        \n",
    "        print (\"Wrong guess ! Please try again with a bigger number...\")\n",
    "        \n",
    "    else:\n",
    "        print (\"Wrong guess ! Please try again with a smaller number...\")\n",
    "    \n",
    "    a=input(\"please enter your guess: \")\n",
    "    \n",
    "    while not a.isdigit():\n",
    "        a=input(\"please enter your guess: \")\n",
    "    \n",
    "    counter+=1\n",
    "    \n",
    "\n",
    "print (\" Well done !! You found the right number after %d trials\" %counter)        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List and Dict Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 4 9 16 25 36 49 64 81 100\n",
      "1 4 9 16 25 36 49 64 81 100\n"
     ]
    }
   ],
   "source": [
    "# List and Dictionary comprehension in Python is a nice way to shorten and simplify the loops as well as increase the process speed.\n",
    "# Recall the following structure.\n",
    "\n",
    "new_list=[]\n",
    "\n",
    "for x in range(1,11):\n",
    "    new_list.append(x**2)\n",
    "\n",
    "print (*new_list)\n",
    "\n",
    "# The same structure can be written with list comprehension.\n",
    "\n",
    "new_list = [x**2 for x in range(1,11)]\n",
    "\n",
    "print (*new_list)\n",
    "\n",
    "# As you can see, we didn't even need to desribe an empty list before the for-loop.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 16, 36, 64, 100]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can also state the conditions inside the list comprehension.\n",
    "\n",
    "new_list = [x**2 for x in range(1,11) if x%2==0]\n",
    "\n",
    "new_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 27, 16, 125, 36, 343, 64, 729, 100]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# What if we want to state some conditions for the left hand side.\n",
    "# Let's try to calculate square of even numbers and cube of odd numbers.\n",
    "\n",
    "new_list = [x**2 if x % 2 == 0 else x**3 for x in range(1,11)]\n",
    "\n",
    "new_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]\n"
     ]
    }
   ],
   "source": [
    "# List comprehensions can also be nested inside each other. Let's write a list of list.\n",
    "\n",
    "print([[1 for x in range(10)] for y in range(10)])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1445"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can also use the built-in functions that can be used by lists.\n",
    "\n",
    "sum([x**2 if x % 2 == 0 else x**3 for x in range(1,11)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's try to use list comprehension for nested for-loops\n",
    "\n",
    "nested_list=[[1,2,3,4,5],[6,7,8,9,10]]\n",
    "\n",
    "nested_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 "
     ]
    }
   ],
   "source": [
    "# printing the list items as a single list\n",
    "\n",
    "for inner_list in nested_list:\n",
    "    \n",
    "    for item in inner_list:\n",
    "        \n",
    "        print (item, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "# do the same with list comprehension\n",
    "# The principle is simple: use the same order you'd use in writing it out as nested for loops\n",
    "\n",
    "items=[item for inner_list in nested_list for item in inner_list]\n",
    "\n",
    "print (items)\n",
    "# beware that we go from outer loop to inner loop (not the opposite)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'c': 6}\n"
     ]
    }
   ],
   "source": [
    "# Now let's look at dict comprehensions. It's quite similar to list comprehensions.\n",
    "\n",
    "d = {'a':1,'b':2,'c':3}\n",
    "\n",
    "d = {key:value*2 for (key,value) in d.items() if value > 2}\n",
    "\n",
    "print(d)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0, 1: 1, 2: 8, 3: 27, 4: 64, 5: 125, 6: 216, 7: 343, 8: 512, 9: 729}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " {x: x**3 for x in range(10)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 5. Input/output operations (reading and writing files)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll learn about Python file operations such as opening a file, reading from it, writing into it, closing it and various file methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sample txt file:\n",
    "<font color=blue> \n",
    "We launched Experfy to bring together the world's most prestigious analytics talent that not only possesses algorithmic skills but also deep domain knowledge. \n",
    "We want to help enterprises hire the world's best analytics talent to increase speed of decision making, manage risk and understand customer needs. \n",
    "</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# open file in current directory in reading mode\n",
    "\n",
    "f = open(\"sample.txt\")    # this is a file object/ handler\n",
    "\n",
    "# we could also specify a path for the file (f = open(\"C:/sample.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# there are multiple file modes in Python but we'll deal with the most useful ones\n",
    "\n",
    "# 'r'\tOpen a file for reading. (default)\n",
    "# 'w'\tOpen a file for writing. Creates a new file if it does not exist or overwrites the file if it exists.\n",
    "# 'a'\tOpen for appending at the end of the file without rewriting it. Creates a new file if it does not exist.\n",
    "\n",
    "f = open(\"sample.txt\", \"r\") # we open the file in reading mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# when we're dealing with file operations, we need to close the file properly to prevent unexpected beahviours\n",
    "\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We launched\n",
      " Experfy\n",
      "We launched\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "# CLosing the file properly is quite important we need to guarentee that it's closed after we're done with it.\n",
    "# One of the safest way to ensure if it's closed, we can use \"with..as\" statement\n",
    "# This ensures that the file is closed when the block inside with is exited (close() method is executed internally)\n",
    "\n",
    "with open(\"sample.txt\", \"r\") as f:\n",
    "    text=f.read(11) # read first 10 characters\n",
    "    text_2=f.read(8) # read the next 10 characters\n",
    "    f.seek(0) # move the cursor to position 0\n",
    "    text_3=f.read(11)\n",
    "    position=f.tell() # the position of cursor\n",
    "\n",
    "print (text)\n",
    "print (text_2)\n",
    "print (text_3)\n",
    "print (position)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We launched Experfy to bring together the world's most prestigious analytics talent that not only possesses algorithmic skills but also deep domain knowledge. \n",
      "We want to help enterprises hire the world's best analytics talent to increase speed of decision making, manage risk and understand customer needs. \n"
     ]
    }
   ],
   "source": [
    "with open(\"sample.txt\", \"r\") as f:\n",
    "    first_line=f.read() # read till the end of file\n",
    "\n",
    "print (first_line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We launched Experfy to bring together the world's most prestigious analytics talent that not only possesses algorithmic skills but also deep domain knowledge. \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# we can also read the file line by line (reads till the end of line.. \"\\n\")\n",
    "\n",
    "with open(\"sample.txt\", \"r\") as f:\n",
    "    line=f.readline()\n",
    "    \n",
    "print (line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\"We want to help enterprises hire the world's best analytics talent to increase speed of decision making, manage risk and understand customer needs. \"]\n"
     ]
    }
   ],
   "source": [
    "# we can read the rest of the lines just with single command: f.readlines()\n",
    "\n",
    "with open(\"sample.txt\", \"r\") as f:\n",
    "    line=f.readline()\n",
    "    rest_of_lines=f.readlines()\n",
    "    \n",
    "print (rest_of_lines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is line 1\n",
      "This is line 2\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# now lets see how we can write to files\n",
    "\n",
    "with open(\"sample_new.txt\",'w') as f: # we created a new file named sample_new.txt\n",
    "    f.write(\"This is line 1\\n\")\n",
    "    f.write(\"This is line 2\\n\")\n",
    "\n",
    "# and read this file\n",
    "\n",
    "with open(\"sample_new.txt\", \"r\") as f:\n",
    "    lines=f.read()\n",
    "\n",
    "print (lines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is line 1\n",
      "This is line 2\n",
      "This is line 3\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#now let's append a new line to this file\n",
    "\n",
    "with open(\"sample_new.txt\",'a') as f: \n",
    "    f.write(\"This is line 3\\n\")\n",
    "\n",
    "# and read this file\n",
    "\n",
    "with open(\"sample_new.txt\", \"r\") as f:\n",
    "    lines=f.read()\n",
    "\n",
    "print (lines)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Functions are used to encapsulate repetitive works so that we can use it wit a single line of command.\n",
    "# A function is a piece of code written to carry out a specified task\n",
    "# The heading of a function contains def, the name of the function, parentheses, and finally a colon.\n",
    "# let's write a function summing up two values given\n",
    "\n",
    "def my_function(x,y):\n",
    "    \n",
    "    return x+y # return statement is optional.\n",
    "\n",
    "my_function(3,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can use this function as if it's a variable\n",
    "\n",
    "my_function(3,5)*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# let's wire a function returning all the values smaller than a parameter as a list.\n",
    "\n",
    "def make_list_less_than(x):\n",
    "    \n",
    "    small_list=[]\n",
    "    for y in range(x):\n",
    "        small_list.append(y)\n",
    "    \n",
    "    return small_list\n",
    "\n",
    "#end of function\n",
    "\n",
    "print (make_list_less_than(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# We can shorten this function by using list comprehensions\n",
    "\n",
    "def make_list_less_than(x):\n",
    "    \n",
    "    small_list=[y for y in range (x)]\n",
    "    \n",
    "    return small_list\n",
    "\n",
    "#end of function\n",
    "\n",
    "print (make_list_less_than(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "# we don't need to set a parameter for a function\n",
    "\n",
    "def greetings():\n",
    "    \n",
    "    print (\"Hello\")\n",
    "    \n",
    "greetings() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your name:John\n",
      "Your surname :Bach\n",
      "Welcome John Bach\n"
     ]
    }
   ],
   "source": [
    "# let's write a log-in function accepting an input from the user and returns as a greeting\n",
    "\n",
    "def login_dict():\n",
    "    \n",
    "    name=input(\"Your name:\")\n",
    "    surname=input(\"Your surname :\")\n",
    "    print (\"Welcome {} {}\".format(name,surname))\n",
    "    \n",
    "    return\n",
    "\n",
    "# end of function\n",
    "\n",
    "login_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36 49 64 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625\n"
     ]
    }
   ],
   "source": [
    "# let's write another function calculating the squares of values (excluding the end values) in given interval\n",
    "\n",
    "def sqr_interval(x,y):\n",
    "    \n",
    "    result=[z*z for z in range(x+1,y)]\n",
    "    \n",
    "    return result\n",
    "\n",
    "print (*sqr_interval(5,26))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# we can set default values for parameters used in functions and change that values\n",
    "\n",
    "def conditional_greeting (name, lastname, n=True, ln=True): \n",
    "# default argument shouldn't come before non-default arguments\n",
    "    \n",
    "    name_surname=\"\"\n",
    "    if n:\n",
    "        name_surname+=name\n",
    "    if ln:\n",
    "        name_surname+=lastname\n",
    "    \n",
    "    return \"Hello \"+name_surname\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello John'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conditional_greeting(\"John\",\"Bach\",True,False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello JohnBach'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conditional_greeting(\"John\",\"Bach\",True,True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'emoclew'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now lets a function writing a string in reverse order\n",
    "\n",
    "def reverse(s):\n",
    "    \n",
    "    return s[::-1]\n",
    "\n",
    "reverse(\"welcome\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Embedded functions\n",
    "\n",
    "#### Embedded functions are built-in features that do most of the work for us in much faster and simpler way (Pythonic Way !).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### all ( ) and any( )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# all() function returns True if all values in a list are True; at least one value is False, it returns False\n",
    "\n",
    "my_list=[True, True, True, True]\n",
    "\n",
    "all(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list=[True, False, True, True]\n",
    "\n",
    "all(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# any() function returns False if all values in a list are False; at least one value is True, it returns False.\n",
    "\n",
    "my_list=[True, False, False, True]\n",
    "\n",
    "any(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list=[False, False, False, False]\n",
    "\n",
    "any(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# if we had to do the same without all() and any(), we had to use if-else conditions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### enumerate ( )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index : 0 animal : bird\n",
      "index : 1 animal : rabbit\n",
      "index : 2 animal : dog\n",
      "index : 3 animal : cat\n"
     ]
    }
   ],
   "source": [
    "# enumerate () is used to iterate over lists using both index and items\n",
    "# it does the same thing as dict.items() does for dictionaries..\n",
    "\n",
    "animals = ['bird', 'rabbit', 'dog', 'cat']\n",
    "\n",
    "# lets write each item with its index number; but without using enumerate()\n",
    "\n",
    "index=0\n",
    "\n",
    "for animal in animals:\n",
    "    print (\"index : {} animal : {}\".format(index,animal))\n",
    "    index+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index : 0 animal : bird\n",
      "index : 1 animal : rabbit\n",
      "index : 2 animal : dog\n",
      "index : 3 animal : cat\n"
     ]
    }
   ],
   "source": [
    "# now let's do the same with enumerate()\n",
    "\n",
    "for index,animal in enumerate(animals):\n",
    "    print (\"index : {} animal : {}\".format(index,animal))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "# lambda functions are another way of defining the functions\n",
    "# it can be useful when you need to create a function that is going to be used only once \n",
    "# or when you don't want to bother defining all the routines for function\n",
    "\n",
    "def sqr (x):\n",
    "    \n",
    "    return x**2\n",
    "\n",
    "print (sqr(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "lambda_sqr= lambda x: x**2\n",
    "\n",
    "print (lambda_sqr(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = lambda x, y : x + y\n",
    "\n",
    "f(3,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35 is odd\n"
     ]
    }
   ],
   "source": [
    "is_even=lambda x: print (\"{} is even\".format(x)) if x % 2==0 else print (\"{} is odd\".format(x))\n",
    "\n",
    "is_even(35)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### filter "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The filter filters out items based on a test function which is a filter and apply functions to pairs of item \n",
    "# The first parameter in filter () must be boolean\n",
    "# This function will be applied to every element of the list l. \n",
    "# Only if first parameter returns True will the element of the list be included in the result list.\n",
    "\n",
    "def is_even(x):\n",
    "    \n",
    "    if x%2==0:\n",
    "        \n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "\n",
    "list(filter (is_even, range(1,10)))\n",
    "\n",
    "# there is no () or parameter when calling the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can do the same with lambda fıunction\n",
    "\n",
    "list(filter (lambda x: True if x % 2==0 else False, range(1,10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's list the even values smaller than a given value\n",
    "\n",
    "def get_even(x):\n",
    "    \n",
    "    result = []\n",
    "    for a in range(0,x):\n",
    "        if a%2==0:\n",
    "            result.append(a)\n",
    "    return result\n",
    "\n",
    "get_even(24)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now we can write the same with lambda and filter in much simpler and fsater way\n",
    "\n",
    "list(filter((lambda x: x%2==0), range(0,24)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### map "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25]"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  map function applies a passed-in function to each item in an iterable object \n",
    "# and returns a list containing all the function call result.\n",
    "# it takes a function as the first parameter, and an iterable object as the second parameter\n",
    "\n",
    "items = [1, 2, 3, 4, 5]\n",
    "\n",
    "def sqr(x): \n",
    "    \n",
    "    return x ** 2\n",
    "\n",
    "list(map(sqr, items))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map((lambda x: x **2), items))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 4 3 16 5 36 7 64 9 100 11 144 13 196 15 256 17 324 19 400 21 484 23\n"
     ]
    }
   ],
   "source": [
    "# lets list the squares if the number is even; else just itself\n",
    "\n",
    "result=list(map((lambda x: x**2 if x%2==0 else x), range(0,24)))\n",
    "\n",
    "print (*result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Exceptions and error handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An exception is an error that happens during execution of a program. When that error occurs, Python generate an exception that can be handled, which avoids your program to crash.\n",
    "\n",
    "Exceptions are convenient in many ways for handling errors and special conditions in a program. When you think that you have a code which can produce an error then you can use exception handling so that rest of your code can be executed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "try:\n",
    "    some statements here\n",
    "except:\n",
    "    exception handling\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "The code within the try clause will be executed statement by statement.\n",
    "\n",
    "If an exception occurs, the rest of the try block will be skipped and the except clause will be executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter a number:a\n",
      "Please enter just numbers ! \n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    x=input(\"enter a number:\")\n",
    "    print (x**x)\n",
    "except:\n",
    "    print (\"Please enter just numbers ! \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if we know what kind of errors can be thrown, we can specify certain behaviours !\n",
    "\n",
    "except IOError:\n",
    "    print('An error occurred trying to read the file.')\n",
    "\n",
    "except ValueError:\n",
    "    print('Non-numeric data found in the file.')\n",
    "\n",
    "except ImportError:\n",
    "    print \"NO module found\"\n",
    "\n",
    "except EOFError:\n",
    "    print('EOF error !')\n",
    "\n",
    "except KeyboardInterrupt:\n",
    "    print('You cancelled the operation.')\n",
    "\n",
    "except:\n",
    "    print('An error occurred.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter a number:a\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    x=input(\"enter a number:\")\n",
    "    print (x**x)\n",
    "except:\n",
    "    x=2\n",
    "    print (x**x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter a number:a\n",
      "The code is still running\n"
     ]
    }
   ],
   "source": [
    "# if you don't want to specify anything after \"except\", you can just use \"pass\"\n",
    "\n",
    "try:\n",
    "    x=input(\"enter a number:\")\n",
    "    print (x**x)\n",
    "except:\n",
    "    pass\n",
    "\n",
    "print (\"The code is still running\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "division by zero\n"
     ]
    }
   ],
   "source": [
    "# we can also catch and print the error\n",
    "\n",
    "try:\n",
    "    x=1/0\n",
    "except Exception as e:\n",
    "    print (e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many other error handling options but we just covered the most useful ones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A module is a file consisting of Python code. A module can define functions, classes and variables. A module can also include runnable code.\n",
    "\n",
    "We can use previously written scripts by importing the code into our code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# lets first learn how to create a plain python (.py) file and then try to use that file's functions in our code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing example.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile example.py \n",
    "# this command is used to create a python file within a Jupyter Notebook's cell\n",
    "\n",
    "def make_list_in_range(x,y):\n",
    "    \n",
    "    new_list=[]\n",
    "    for a in range(x+1,y):\n",
    "        new_list.append(a)\n",
    "    \n",
    "    return new_list\n",
    "\n",
    "def make_list_of_even(x,y):\n",
    "    \n",
    "    new_list=[]\n",
    "    for a in range(x+1,y):\n",
    "        if a%2==0:\n",
    "            new_list.append(a)\n",
    "    \n",
    "    return new_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'make_list_in_range' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-104-cb46a6072de2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmake_list_in_range\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m34\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'make_list_in_range' is not defined"
     ]
    }
   ],
   "source": [
    "# lets see what happens when we want to use these functions\n",
    "\n",
    "make_list_in_range(1,34)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# it throws error as it's in another .py file. So we need to import that file at first\n",
    "\n",
    "import example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example.make_list_in_range(1,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33\n"
     ]
    }
   ],
   "source": [
    "print (*example.make_list_in_range(1,34))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32\n"
     ]
    }
   ],
   "source": [
    "print (*example.make_list_of_even(1,34))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# if we'd like to shorten the file name while using...\n",
    "\n",
    "import example as ex\n",
    "\n",
    "ex.make_list_in_range(1,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# it's time to talk a little bit of importing the other modules and packages embedded in Python\n",
    "\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from math import sqrt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# if we still do not want to use any handle to call a method, we can import all the methods of a given module\n",
    "\n",
    "from math import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ceil(3.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'acos',\n",
       " 'acosh',\n",
       " 'asin',\n",
       " 'asinh',\n",
       " 'atan',\n",
       " 'atan2',\n",
       " 'atanh',\n",
       " 'ceil',\n",
       " 'copysign',\n",
       " 'cos',\n",
       " 'cosh',\n",
       " 'degrees',\n",
       " 'e',\n",
       " 'erf',\n",
       " 'erfc',\n",
       " 'exp',\n",
       " 'expm1',\n",
       " 'fabs',\n",
       " 'factorial',\n",
       " 'floor',\n",
       " 'fmod',\n",
       " 'frexp',\n",
       " 'fsum',\n",
       " 'gamma',\n",
       " 'gcd',\n",
       " 'hypot',\n",
       " 'inf',\n",
       " 'isclose',\n",
       " 'isfinite',\n",
       " 'isinf',\n",
       " 'isnan',\n",
       " 'ldexp',\n",
       " 'lgamma',\n",
       " 'log',\n",
       " 'log10',\n",
       " 'log1p',\n",
       " 'log2',\n",
       " 'modf',\n",
       " 'nan',\n",
       " 'pi',\n",
       " 'pow',\n",
       " 'radians',\n",
       " 'sin',\n",
       " 'sinh',\n",
       " 'sqrt',\n",
       " 'tan',\n",
       " 'tanh',\n",
       " 'tau',\n",
       " 'trunc']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(math) # we can see all the methods inside the math module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# if we want to see the methods that can be used with a module, there is a shortcut for this in Jupyter..\n",
    "# press Tab after dot\n",
    "# if we want a detailed explanation for a method, we can use Shift+Tab+Tab\n",
    "\n",
    "math.sqrt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module math:\n",
      "\n",
      "NAME\n",
      "    math\n",
      "\n",
      "MODULE REFERENCE\n",
      "    https://docs.python.org/3.6/library/math\n",
      "    \n",
      "    The following documentation is automatically generated from the Python\n",
      "    source files.  It may be incomplete, incorrect or include features that\n",
      "    are considered implementation detail and may vary between Python\n",
      "    implementations.  When in doubt, consult the module reference at the\n",
      "    location listed above.\n",
      "\n",
      "DESCRIPTION\n",
      "    This module is always available.  It provides access to the\n",
      "    mathematical functions defined by the C standard.\n",
      "\n",
      "FUNCTIONS\n",
      "    acos(...)\n",
      "        acos(x)\n",
      "        \n",
      "        Return the arc cosine (measured in radians) of x.\n",
      "    \n",
      "    acosh(...)\n",
      "        acosh(x)\n",
      "        \n",
      "        Return the inverse hyperbolic cosine of x.\n",
      "    \n",
      "    asin(...)\n",
      "        asin(x)\n",
      "        \n",
      "        Return the arc sine (measured in radians) of x.\n",
      "    \n",
      "    asinh(...)\n",
      "        asinh(x)\n",
      "        \n",
      "        Return the inverse hyperbolic sine of x.\n",
      "    \n",
      "    atan(...)\n",
      "        atan(x)\n",
      "        \n",
      "        Return the arc tangent (measured in radians) of x.\n",
      "    \n",
      "    atan2(...)\n",
      "        atan2(y, x)\n",
      "        \n",
      "        Return the arc tangent (measured in radians) of y/x.\n",
      "        Unlike atan(y/x), the signs of both x and y are considered.\n",
      "    \n",
      "    atanh(...)\n",
      "        atanh(x)\n",
      "        \n",
      "        Return the inverse hyperbolic tangent of x.\n",
      "    \n",
      "    ceil(...)\n",
      "        ceil(x)\n",
      "        \n",
      "        Return the ceiling of x as an Integral.\n",
      "        This is the smallest integer >= x.\n",
      "    \n",
      "    copysign(...)\n",
      "        copysign(x, y)\n",
      "        \n",
      "        Return a float with the magnitude (absolute value) of x but the sign \n",
      "        of y. On platforms that support signed zeros, copysign(1.0, -0.0) \n",
      "        returns -1.0.\n",
      "    \n",
      "    cos(...)\n",
      "        cos(x)\n",
      "        \n",
      "        Return the cosine of x (measured in radians).\n",
      "    \n",
      "    cosh(...)\n",
      "        cosh(x)\n",
      "        \n",
      "        Return the hyperbolic cosine of x.\n",
      "    \n",
      "    degrees(...)\n",
      "        degrees(x)\n",
      "        \n",
      "        Convert angle x from radians to degrees.\n",
      "    \n",
      "    erf(...)\n",
      "        erf(x)\n",
      "        \n",
      "        Error function at x.\n",
      "    \n",
      "    erfc(...)\n",
      "        erfc(x)\n",
      "        \n",
      "        Complementary error function at x.\n",
      "    \n",
      "    exp(...)\n",
      "        exp(x)\n",
      "        \n",
      "        Return e raised to the power of x.\n",
      "    \n",
      "    expm1(...)\n",
      "        expm1(x)\n",
      "        \n",
      "        Return exp(x)-1.\n",
      "        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.\n",
      "    \n",
      "    fabs(...)\n",
      "        fabs(x)\n",
      "        \n",
      "        Return the absolute value of the float x.\n",
      "    \n",
      "    factorial(...)\n",
      "        factorial(x) -> Integral\n",
      "        \n",
      "        Find x!. Raise a ValueError if x is negative or non-integral.\n",
      "    \n",
      "    floor(...)\n",
      "        floor(x)\n",
      "        \n",
      "        Return the floor of x as an Integral.\n",
      "        This is the largest integer <= x.\n",
      "    \n",
      "    fmod(...)\n",
      "        fmod(x, y)\n",
      "        \n",
      "        Return fmod(x, y), according to platform C.  x % y may differ.\n",
      "    \n",
      "    frexp(...)\n",
      "        frexp(x)\n",
      "        \n",
      "        Return the mantissa and exponent of x, as pair (m, e).\n",
      "        m is a float and e is an int, such that x = m * 2.**e.\n",
      "        If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.\n",
      "    \n",
      "    fsum(...)\n",
      "        fsum(iterable)\n",
      "        \n",
      "        Return an accurate floating point sum of values in the iterable.\n",
      "        Assumes IEEE-754 floating point arithmetic.\n",
      "    \n",
      "    gamma(...)\n",
      "        gamma(x)\n",
      "        \n",
      "        Gamma function at x.\n",
      "    \n",
      "    gcd(...)\n",
      "        gcd(x, y) -> int\n",
      "        greatest common divisor of x and y\n",
      "    \n",
      "    hypot(...)\n",
      "        hypot(x, y)\n",
      "        \n",
      "        Return the Euclidean distance, sqrt(x*x + y*y).\n",
      "    \n",
      "    isclose(...)\n",
      "        isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0) -> bool\n",
      "        \n",
      "        Determine whether two floating point numbers are close in value.\n",
      "        \n",
      "           rel_tol\n",
      "               maximum difference for being considered \"close\", relative to the\n",
      "               magnitude of the input values\n",
      "            abs_tol\n",
      "               maximum difference for being considered \"close\", regardless of the\n",
      "               magnitude of the input values\n",
      "        \n",
      "        Return True if a is close in value to b, and False otherwise.\n",
      "        \n",
      "        For the values to be considered close, the difference between them\n",
      "        must be smaller than at least one of the tolerances.\n",
      "        \n",
      "        -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That\n",
      "        is, NaN is not close to anything, even itself.  inf and -inf are\n",
      "        only close to themselves.\n",
      "    \n",
      "    isfinite(...)\n",
      "        isfinite(x) -> bool\n",
      "        \n",
      "        Return True if x is neither an infinity nor a NaN, and False otherwise.\n",
      "    \n",
      "    isinf(...)\n",
      "        isinf(x) -> bool\n",
      "        \n",
      "        Return True if x is a positive or negative infinity, and False otherwise.\n",
      "    \n",
      "    isnan(...)\n",
      "        isnan(x) -> bool\n",
      "        \n",
      "        Return True if x is a NaN (not a number), and False otherwise.\n",
      "    \n",
      "    ldexp(...)\n",
      "        ldexp(x, i)\n",
      "        \n",
      "        Return x * (2**i).\n",
      "    \n",
      "    lgamma(...)\n",
      "        lgamma(x)\n",
      "        \n",
      "        Natural logarithm of absolute value of Gamma function at x.\n",
      "    \n",
      "    log(...)\n",
      "        log(x[, base])\n",
      "        \n",
      "        Return the logarithm of x to the given base.\n",
      "        If the base not specified, returns the natural logarithm (base e) of x.\n",
      "    \n",
      "    log10(...)\n",
      "        log10(x)\n",
      "        \n",
      "        Return the base 10 logarithm of x.\n",
      "    \n",
      "    log1p(...)\n",
      "        log1p(x)\n",
      "        \n",
      "        Return the natural logarithm of 1+x (base e).\n",
      "        The result is computed in a way which is accurate for x near zero.\n",
      "    \n",
      "    log2(...)\n",
      "        log2(x)\n",
      "        \n",
      "        Return the base 2 logarithm of x.\n",
      "    \n",
      "    modf(...)\n",
      "        modf(x)\n",
      "        \n",
      "        Return the fractional and integer parts of x.  Both results carry the sign\n",
      "        of x and are floats.\n",
      "    \n",
      "    pow(...)\n",
      "        pow(x, y)\n",
      "        \n",
      "        Return x**y (x to the power of y).\n",
      "    \n",
      "    radians(...)\n",
      "        radians(x)\n",
      "        \n",
      "        Convert angle x from degrees to radians.\n",
      "    \n",
      "    sin(...)\n",
      "        sin(x)\n",
      "        \n",
      "        Return the sine of x (measured in radians).\n",
      "    \n",
      "    sinh(...)\n",
      "        sinh(x)\n",
      "        \n",
      "        Return the hyperbolic sine of x.\n",
      "    \n",
      "    sqrt(...)\n",
      "        sqrt(x)\n",
      "        \n",
      "        Return the square root of x.\n",
      "    \n",
      "    tan(...)\n",
      "        tan(x)\n",
      "        \n",
      "        Return the tangent of x (measured in radians).\n",
      "    \n",
      "    tanh(...)\n",
      "        tanh(x)\n",
      "        \n",
      "        Return the hyperbolic tangent of x.\n",
      "    \n",
      "    trunc(...)\n",
      "        trunc(x:Real) -> Integral\n",
      "        \n",
      "        Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method.\n",
      "\n",
      "DATA\n",
      "    e = 2.718281828459045\n",
      "    inf = inf\n",
      "    nan = nan\n",
      "    pi = 3.141592653589793\n",
      "    tau = 6.283185307179586\n",
      "\n",
      "FILE\n",
      "    /Users/vkocaman/anaconda/envs/py36/lib/python3.6/lib-dynload/math.cpython-36m-darwin.so\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help (math) # help() lists all the methods and explanations"
   ]
  },
  {
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}