Python_hello.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# print(\"Hello Python!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is a high level and very powerful programming language, which is very easy and has more features. It is mainly used in Data Science, ML/DL, Data Visualization, Web Development and many more. So here in this notebook we'll be talking about some basic stuffs in python<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>_________________________________________________________</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Defining the datatype, no problem python does that for you"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"naruto\" # String\n",
    "roll = 123456 # int\n",
    "hokage = True # boolean\n",
    "chakra_nature = [\"wind\", \"fire\", \"earth\", \"lightning\", \"water\", \"yang\", \"yin\", \"lava\", \"boil\"] # list\n",
    "relations = {\"children\":[\"boruto\", \"himawari\"], \"wife\":\"hinata\", \"rival\":\"sasuke\",\n",
    "             \"teacher\":[\"Iruka\", \"kakashi\", \"jiraya\"]} # Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets print some stuffs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name and roll : naruto 123456\n",
      "Hokage:  True\n",
      "Chakra Nature:  ['wind', 'fire', 'earth', 'lightning', 'water', 'yang', 'yin', 'lava', 'boil']\n",
      "Children:  ['boruto', 'himawari']\n"
     ]
    }
   ],
   "source": [
    "print(\"Name and roll : %s %d\" % (name, roll))\n",
    "print(\"Hokage: \", hokage)\n",
    "print(\"Chakra Nature: \", chakra_nature)\n",
    "print(\"Children: \", relations[\"children\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can know the data type just by using the type method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'> <class 'int'> <class 'bool'> <class 'list'> <class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "print(type(name), type(roll), type(hokage), type(chakra_nature), type(relations))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arithmetic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.5\n",
      "7\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "x = (1 + 2) * 5 / 2\n",
    "print(x)\n",
    "x = (1 + 2) * 5 // 2 #double slash is for integer division \n",
    "print(x)\n",
    "print(x%2) # modulo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function(x): # Here x is the parameters\n",
    "    # Write your stuff\n",
    "    return x * 2 # we wanna return the square of the input here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OUPTUT 1: 14\n",
      "OUTPUT 2: hellohello\n"
     ]
    }
   ],
   "source": [
    "# Calling the function\n",
    "output = my_function(7)\n",
    "print(\"OUPTUT 1:\",output)\n",
    "# What if we give a string as an input?\n",
    "output = my_function(\"hello\")\n",
    "print(\"OUTPUT 2:\", output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions in python are <i>first-class</i>, means we can assign them to variables and pass them like any other argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def function_one(x):\n",
    "    x += 2\n",
    "    return x\n",
    "\n",
    "def function_two(function_one):\n",
    "    return function_one(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OUTPUT : 9\n"
     ]
    }
   ],
   "source": [
    "output = function_two(function_one)\n",
    "print(\"OUTPUT :\", output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Short Anonymous functions or <b>lambdas</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# here we've stored the function in a variable and the name of the variable is not the name of the function..\n",
    "# its anonymous yknow\n",
    "anonymous_function = lambda x: x ** 2 # btw here ** is a mathematical operator meaning to the power of"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "anonymous_function(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Default parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "YOSH!!\n",
      "Hello there\n"
     ]
    }
   ],
   "source": [
    "# if nothing is given in the parameter then the default value will be used\n",
    "def print_stuff(stuff = \"YOSH!!\"): \n",
    "    print(stuff)\n",
    "    \n",
    "print_stuff()\n",
    "print_stuff(\"Hello there\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Its one of the most fundamental data structure in Python. A list is an ordered collection of data. (Its similar to array in other languages but with MORE POWERS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Homogeneous:  [1, 2, 3, 4, 5] \n",
      "Heterogeneous: ['naruto', 12346, True] \n",
      "List of lists: [[1, 2, 3, 4, 5], ['naruto', 12346, True], []]\n"
     ]
    }
   ],
   "source": [
    "homogeneous_list = [1,2,3,4,5]\n",
    "heterogeneous_list = [\"naruto\", 12346, True]\n",
    "list_of_lists = [homogeneous_list, heterogeneous_list, []]\n",
    "\n",
    "# .format will fill up {} accordingly\n",
    "print(\"Homogeneous:  {} \\nHeterogeneous: {} \\nList of lists: {}\".format(homogeneous_list, \n",
    "                                                                        heterogeneous_list, list_of_lists))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "First element:  1\n",
      "Last element:  9\n",
      "First to 5th element:  [1, 2, 3, 4, 5]\n",
      "Last 5 elements:  [5, 6, 7, 8, 9]\n",
      "All elements starting from 5th and not including the last 2:  [6, 7]\n",
      "new list:  [6, 7]\n"
     ]
    }
   ],
   "source": [
    "l = [1,2,3,4,5,6,7,8,9]\n",
    "print(len(l)) # Length of list\n",
    "print(\"First element: \", l[0])\n",
    "print(\"Last element: \", l[-1])\n",
    "print(\"First to 5th element: \", l[:5])\n",
    "print(\"Last 5 elements: \", l[-5:])\n",
    "print(\"All elements starting from 5th and not including the last 2: \", l[5:-2])\n",
    "# Say we want the above in another variable\n",
    "new_l = l[5:-2]\n",
    "print(\"new list: \",new_l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check if an element is there in a list or not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False \n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = \"naruto\" in [\"sasuke\", \"obito\", \"hinata\", \"shisui\"]\n",
    "b = \"shisui\" in [\"sasuke\", \"obito\", \"hinata\", \"shisui\"]\n",
    "print(\"{} \\n{}\".format(a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add one element at a time to a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3]\n",
    "x.append(4)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Concatenate lists "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "x.extend([5,6,7])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or we can just add'em"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "x += [8,9]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "<br>\n",
    "You can say these are immutable lists. The data inside a tuple cannot be modified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unable to modify\n"
     ]
    }
   ],
   "source": [
    "l = [1,2,3]\n",
    "t = (1,2,3)\n",
    "# change the first element of list\n",
    "l[0] = 10\n",
    "# try to change the first element of a tuple\n",
    "try:\n",
    "    t[0] = 10\n",
    "except TypeError:\n",
    "    print(\"Unable to modify\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are a convenient way to return multiple values from functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "together: (10, 25) \n",
      "Separated: 10 25\n"
     ]
    }
   ],
   "source": [
    "def mul_pow(x,y):\n",
    "    return (x*y), (x**y)\n",
    "# getting them in one variable\n",
    "mul_and_pow = mul_pow(5,2)\n",
    "mul, poww = mul_pow(5,2)\n",
    "print(\"together: {} \\nSeparated: {} {}\".format(mul_and_pow, mul, poww))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Cool way to swap values in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before: x: 1 and y: 2\n",
      "After: x: 2 and y: 1\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "y = 2\n",
    "print(\"Before: x: {} and y: {}\".format(x,y))\n",
    "x,y = y,x #MAGIC!!\n",
    "print(\"After: x: {} and y: {}\".format(x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Its another fundamental data structure that associates values with keys and allows to quickly retrive the value corresponding to a given key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Uzumaki Naruto\n"
     ]
    }
   ],
   "source": [
    "my_dict = {\"name\":\"Uzumaki Naruto\", \"roll\": \"1234356\", \"rank\":\"gennin\"}\n",
    "\n",
    "# Here \"name\" is the key and \"Uzumaki Naruto\" is the value\n",
    "print(my_dict[\"name\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the value of a key by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Uzumaki Boruto\n"
     ]
    }
   ],
   "source": [
    "my_dict[\"name\"] = \"Uzumaki Boruto\"\n",
    "print(my_dict[\"name\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Uzumaki Boruto', 'roll': '1234356', 'rank': 'gennin', 'village': 'konoha'}\n"
     ]
    }
   ],
   "source": [
    "# We can even add new keys to the existing dictionary\n",
    "my_dict[\"village\"] = \"konoha\"\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['name', 'roll', 'rank', 'village'])\n",
      "dict_values(['Uzumaki Boruto', '1234356', 'gennin', 'konoha'])\n",
      "dict_items([('name', 'Uzumaki Boruto'), ('roll', '1234356'), ('rank', 'gennin'), ('village', 'konoha')])\n"
     ]
    }
   ],
   "source": [
    "# To print all keys in a dictionary\n",
    "print(my_dict.keys())\n",
    "# To print all values in a dictionary\n",
    "print(my_dict.values())\n",
    "# To print (key, value) tuples\n",
    "print(my_dict.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is another data structure that only holds distinct elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'A', 'B'}\n"
     ]
    }
   ],
   "source": [
    "# define a set\n",
    "my_set = set()\n",
    "my_set.add('A')\n",
    "my_set.add('B')\n",
    "my_set.add('A')\n",
    "print(my_set) # even after we've added 'A' 2 times it doesn't add the second 'A' cause its not distinct"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is helpful in finding distinct items in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7, 8}\n"
     ]
    }
   ],
   "source": [
    "my_list = [1,2,3,3,3,4,5,6,7,8,7,8,4]\n",
    "print(set(my_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Control Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>if-else</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We are in elif\n"
     ]
    }
   ],
   "source": [
    "if 10 > 20:\n",
    "    print(\"We are in if\")\n",
    "elif 30<50:\n",
    "    print(\"We are in elif\")\n",
    "else:\n",
    "    print(\"We are in else\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use ternary for simple if else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "odd\n"
     ]
    }
   ],
   "source": [
    "x = 21\n",
    "value = \"even\" if x % 2 == 0 else \"odd\"\n",
    "print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>While Loop</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 is greater than 0\n",
      "4 is greater than 0\n",
      "3 is greater than 0\n",
      "2 is greater than 0\n",
      "1 is greater than 0\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "while n > 0:\n",
    "    print(\"%d is greater than 0\" % n)\n",
    "    n -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>For Loop</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value of i is : 0\n",
      "value of i is : 1\n",
      "value of i is : 2\n",
      "value of i is : 3\n",
      "value of i is : 4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(\"value of i is : %d\" % i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can even iterate through values in a list using for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naruto\n",
      "sasuke\n",
      "kakashi\n",
      "hinata\n"
     ]
    }
   ],
   "source": [
    "names = [\"naruto\",\"sasuke\", \"kakashi\", \"hinata\"]\n",
    "\n",
    "for name in names:\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we want the element and its index? Don't worry there a cool stuff called enumerate which returns (index, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index: 0 and name: naruto\n",
      "index: 1 and name: sasuke\n",
      "index: 2 and name: kakashi\n",
      "index: 3 and name: hinata\n"
     ]
    }
   ],
   "source": [
    "for index, name in enumerate(names):\n",
    "    print(\"index: %d and name: %s\" %(index, name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Continue and break in for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    if i==4:\n",
    "        continue # jump to the next iteration\n",
    "    elif i == 7:\n",
    "        break # Exit the loop\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now those are the basic stuffs in python. In the next notebook we'll be talking about the some more advanced features in python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>_________________________________________________________</h1>"
   ]
  }
 ],
 "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
}