Introduction to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is a general purpose programming language which is comparatively easier to start with programming having high flexibility with its application on multiple fields from web development, AI,data science, machine learning, gaming and so on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is computer program?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computer programs are simply pieces of instructions which allows computers to perform certain tasks based on kinds of inputs \n",
    "it has while giving instructions and produces the output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keywords and identifiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keywords are the reserved words in Python or any other language which has a specific meaning to them and they are case sensitive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
     ]
    }
   ],
   "source": [
    "import keyword\n",
    "print(keyword.kwlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Identifiers are the names given to entities like classes, functions, variables, etc. in Python which helps to identify and\n",
    "differentiate one identifiers by another. There are few rules of Defining identifiers and they are:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-Identifiers can be a combination of letters in lowercase (a to z) or uppercase (A to Z) or digits (0 to 9) or an underscore _. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-An identifier cannot start with a digit. 1variable is invalid, but variable1 is a valid name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-Keywords cannot be used as identifiers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-2-7506226bc341>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-2-7506226bc341>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    class=2\u001b[0m\n\u001b[1;37m         ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "class=2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-We cannot use special symbols like !, @, #, $, % etc. in our identifier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-3-8faf8eb4a6dd>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-3-8faf8eb4a6dd>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    @a=2\u001b[0m\n\u001b[1;37m      ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "@a=2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-An identifier can be of any length."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables and Data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables are the like the containers which stores certain values that can be changed or modified. It is storing some data into some memory location. \n",
    "While defining a variable, we dont have to explicitly declare the data type as Python is type-inferred language, it automatically knows which data type the particular data belongs once its assigned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "##Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'str'>\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "#Assigning value to a variable\n",
    "a=10\n",
    "b='Manisha'\n",
    "c=True\n",
    "print(type(a))\n",
    "print(type(b))\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "Bhandari\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#Assigning values to multiple variables\n",
    "a,b,c=11,'Bhandari',False\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "#changing the value of a variable\n",
    "a=11\n",
    "a=12\n",
    "print(a)#Here value at the memory location where a is stored is changed from 11 to 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Data Type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every value in Python is called an “object”. And every object has a specific data type.Since everything is an object in Python programming, data types are actually classes and variables are instance (object) of these classes. The three most-used data types are as follows:\n",
    "1.Integer: Represents non decimal numbers\n",
    "2.Float: Represents decimal numbers\n",
    "3.Strings: Represents character.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "#Integer type.\n",
    "a=100\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "#Float type.\n",
    "b=10.5\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "#String\n",
    "name='Manisha'\n",
    "print(type(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#type conversion\n",
    "a=10\n",
    "float(a) #converts integer a to float a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b=10.50\n",
    "int(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'9'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=9\n",
    "str(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comments, Indentation and Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comments:\n",
    "As we can see in the above code, we are writing some strings with 'hash' before them, they are called comments, which will be skipped by Python interpreter while executing the code. All the other code excepts for the comments will be run. Adding comments can be of great help for us to understand which block of code doing what so that you can revisit your code sometime in future and modify or work efficiently and it will make it easy for others to understand your code as well.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indentation: Unlike other programming language which uses {} as to separate their code blocks, Python uses Indentation. A proper indentation is required so that our code looks readable and does not produce errors. Normally, we use 1 tab or 4 whitespaces."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Statements: Any instructions that is executed by the interpreter that produces certain output are statements. We can consider anything which are not  comments as statements in general term."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "#program to print numbers from 0 to 4.\n",
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the statements written inside 'hash' has been skipped by Python interpreter while executing the code, however it gives us good idea of what the code is doing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#multiline comments.\n",
    "#This is very basic.\n",
    "#It is getting complicated now.\n",
    "#It seeems impossible.\n",
    "#I did not know I could do this until I completed it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nThis is very basic.\\nIt is getting complicated now.\\nIt seems impossible.\\nI did not know I could do this until I completed it.\\n'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#We can also define multiline comments through '''' ''' or \"\"\" \"\"\".\n",
    "'''\n",
    "This is very basic.\n",
    "It is getting complicated now.\n",
    "It seems impossible.\n",
    "I did not know I could do this until I completed it.\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nThis is very basic.\\nIt is getting complicated now.\\nIt seems impossible.\\nI did not know I could do this until I completed it.\\n'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "This is very basic.\n",
    "It is getting complicated now.\n",
    "It seems impossible.\n",
    "I did not know I could do this until I completed it.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Manisha Bhandari'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#statements.\n",
    "my_name='Manisha' # this is a single line statement.\n",
    "my_name='Manisha \\\n",
    "Bhandari'\n",
    "my_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#we can also write multiline statements in a single line but they need to be separated by commas.\n",
    "a=10;b=10;c=True\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Standard Input/Output and Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has standard print() function to display the output on the screen while input() to let user input any value in the program.\n",
    "Print() statement only displays the output but not return anything to any memory location."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "a=10\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "11\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=input()\n",
    "print(a)\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: Input will return any value as a string so if you need to input any other datatype values, you need to explicitly mention their types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "12\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b=int(input())\n",
    "print(b)\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-24-ca730b97bf8a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here since a is a string and b is integer, we can not add them together, if you want to perform the arithmetic operations, you can convert the string to float or int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23.0"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(a)+b #converting string 'a' into float and adding with b."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of c is  10\n"
     ]
    }
   ],
   "source": [
    "c=10\n",
    "print('The value of c is ',c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operators are special symbols that allow us to perform some arithmetic or logical operations "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.Arithmetic operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.Comparison Operators\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3.Logical Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4.Bitwise operators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5.Assignment operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6.Special operators.\n",
    "6.1 Identity operators\n",
    "6.2 Membership operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are sequences of characters,using the syntax of either single quotes \n",
    "or double quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi\n",
      "Hello\n",
      "Day's\n"
     ]
    }
   ],
   "source": [
    "##example\n",
    "print('Hi')\n",
    "print(\"Hello\")\n",
    "print(\"Day's\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are ordered sequences that means we can use indexing and slicing to grab sub-sections of the string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing starts are 0.\n",
    "string=\"ABCDEF\"  \n",
    "Index: A:0,B:1,C:2,D:3,E:4,F:5\n",
    "Reverse Index: F:-1,E:-2,D:-3,C:-4,B:-5,A:0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Slicing allows you to grab a subsection of multiple characters\n",
    "[start:stop:step]\n",
    "Start: numberical index for the slice start\n",
    "Stop: index you will go upto but not include\n",
    "Step: size of the \"jump\" you take."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'World'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"World\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hi,you are amazing'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hi,you are amazing\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-33-2649b189c01d>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-33-2649b189c01d>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    'Today is teacher's day\u001b[0m\n\u001b[1;37m                      ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "'Today is teacher's day"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is confusing Python as it thinks string has been ended after teacher and before s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Today is teacher's day\""
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Today is teacher's day\" #we can use two quotes instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##checking length of string\n",
    "len(\"I am Manisha.\") #all the characters including white spaces are calculated as one character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "31\n",
      "I\n",
      ".\n",
      " ho\n",
      "I hope you have an amazing day.\n",
      "Ihp o aea mzn\n"
     ]
    }
   ],
   "source": [
    "#slicing\n",
    "string=\"I hope you have an amazing day.\"\n",
    "print(len(string))\n",
    "print(string[0])\n",
    "print(string[-1])\n",
    "print(string[1:4])\n",
    "print(string[0:31])\n",
    "print(string[0:25:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Formatting for printing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ".format() method and \n",
    "f-strings(formatted string literals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ".format():'String here {}'.format('something')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Manisha\n",
      "You are Amazing\n",
      "You are amazing\n",
      "You are amazing\n",
      "You are amazing\n"
     ]
    }
   ],
   "source": [
    "string=\"Manisha\"\n",
    "print(\"My name is {}\".format(string))\n",
    "print(\"You are {}\".format('Amazing'))\n",
    "print('{} {} {}'.format('You','are','amazing'))\n",
    "print('{0} {1} {2}'.format('You','are','amazing'))\n",
    "print('{y} {a} {b}'.format(y='You',a='are',b='amazing'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Float formatting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "value.width.precision f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.142857142857143\n"
     ]
    }
   ],
   "source": [
    "pi=22/7\n",
    "print(pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of pi is 3.143\n"
     ]
    }
   ],
   "source": [
    "print(\"The value of pi is {p:1.3f}\".format(p=pi)) #1 is width which indicates white spaces."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### f string formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "name=\"manisha\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello,my name is manisha\n"
     ]
    }
   ],
   "source": [
    "print(f\"Hello,my name is {name}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}