011_Python_Input_Output_Import.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Introduction** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/01_Python_Introduction)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Input, Output and Import\n",
    "\n",
    "This class focuses on two built-in functions **`print()`** and **`input()`** to perform I/O task in Python. Also, you will learn to import modules and use them in your program.\n",
    "\n",
    "Python provides numerous **[built-in functions](https://github.com/milaan9/04_Python_Functions/tree/main/002_Python_Functions_Built_in)** that are readily available to us at the Python prompt.\n",
    "\n",
    "Some of the functions like **`print()`** and **`input()`** are widely used for standard input and output operations respectively. Let us see the output section first."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Python Output Using `print()` function\n",
    "\n",
    "We use the **`print()`** function to output data to the standard output device (screen). We can also **[output data to a file](https://github.com/milaan9/05_Python_Files/blob/main/001_Python_File_Input_Output.ipynb)**, but this will be discussed later.\n",
    "\n",
    "An example of its use is given below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:38:42.903413Z",
     "start_time": "2021-10-02T08:38:42.882906Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This sentence is output to the screen\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "print('This sentence is output to the screen')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:38:43.026458Z",
     "start_time": "2021-10-02T08:38:42.906342Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of a is 9\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "a = 9\n",
    "print('The value of a is', a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the second **`print()`** statement, we can notice that space was added between the **[string](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String.ipynb)** and the value of variable **`a`**. This is by default, but we can change it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Syntax** of the **`print()`** function is:\n",
    "\n",
    "```python\n",
    "print(*objects, sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
    "```\n",
    "\n",
    "Here, objects is the value(s) to be printed.\n",
    "\n",
    "The **`sep`** separator is used between the values. It defaults into a space character.\n",
    "\n",
    "After all values are printed, **`end`** is printed. It defaults into a new line.\n",
    "\n",
    "The **`file`** is the object where the values are printed and its default value is **`sys.stdout`** (screen). Here is an example to illustrate this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:38:43.200289Z",
     "start_time": "2021-10-02T08:38:43.030366Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4\n",
      "1#2#3#4\n",
      "1*2*3*4&"
     ]
    }
   ],
   "source": [
    "print(1, 2, 3, 4)\n",
    "print(1, 2, 3, 4, sep='#')   # It will separate your elements with '#'\n",
    "print(1, 2, 3, 4, sep='*', end='&')  # It will separate your elements with '*' and end with '&'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Output formatting\n",
    "\n",
    "Sometimes we would like to format our output to make it look attractive. This can be done by using the **`str.format()`** method. This method is visible to any string object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:38:43.315521Z",
     "start_time": "2021-10-02T08:38:43.207124Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of x is 6 and y is 12\n"
     ]
    }
   ],
   "source": [
    "x = 6; y = 12\n",
    "print('The value of x is {} and y is {}'.format(x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the curly braces **`{}`** are used as placeholders. We can specify the order in which they are printed by using numbers (tuple index)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:38:43.468840Z",
     "start_time": "2021-10-02T08:38:43.319429Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love Mango and Banana\n",
      "I love Banana and Mango\n"
     ]
    }
   ],
   "source": [
    "print('I love {0} and {1}'.format('Mango','Banana'))\n",
    "print('I love {1} and {0}'.format('Mango','Banana'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can even use keyword arguments to format the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:38:43.575285Z",
     "start_time": "2021-10-02T08:38:43.472749Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Mark, Good morning!\n"
     ]
    }
   ],
   "source": [
    "print('Hello {name}, {greeting}!'.format(greeting = 'Good morning', name = 'Mark'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also format strings like the old **`sprintf()`** style used in C programming language. We use the **`%`** operator to accomplish this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:38:43.756437Z",
     "start_time": "2021-10-02T08:38:43.579194Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of x is 12.35\n",
      "The value of x is 12.346\n"
     ]
    }
   ],
   "source": [
    "x = 12.34567890\n",
    "print('The value of x is %0.2f' %x)  # \"%0.2\" means only 2 number after decimal\n",
    "\n",
    "print('The value of x is %0.3f' %x)  # \"%0.3\" means only 3 number after decimal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Python Input Using `input()` function\n",
    "\n",
    "Up until now, our programs were static. The value of variables was defined or hard coded into the source code.\n",
    "\n",
    "To allow flexibility, we might want to take the input from the user. In Python, we have a built-in function **`input()`** to accept user input.\n",
    "\n",
    "**Syntax**:\n",
    "\n",
    "```python\n",
    "input([prompt])\n",
    "```\n",
    "\n",
    "where **`prompt`** is the string we wish to display on the screen. It is optional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:38:49.322840Z",
     "start_time": "2021-10-02T08:38:43.764252Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 90\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'90'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num = input('Enter a number: ')\n",
    "num"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we can see that the entered value **`90`** is a string, not a number. To convert this into a number we can use **`int()`** or **`float()`** functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:38:49.356046Z",
     "start_time": "2021-10-02T08:38:49.325771Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "90"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int('90')  # converting string '90' to integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:38:49.447843Z",
     "start_time": "2021-10-02T08:38:49.367766Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "90.0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float('90')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:38:49.575282Z",
     "start_time": "2021-10-02T08:38:49.451748Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6P\n"
     ]
    }
   ],
   "source": [
    "a = \"6\"  # Is this a STRING character\n",
    "b = \"P\"  # IS this a STRING chracter\n",
    "c = a + b\n",
    "print(c) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:38:50.362880Z",
     "start_time": "2021-10-02T08:38:49.579190Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: '6+3'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-12-b4c816180ad9>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'6+3'\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# ERROR! cannot add numbers as string data type\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: invalid literal for int() with base 10: '6+3'"
     ]
    }
   ],
   "source": [
    "int('6+3') # ERROR! cannot add numbers as string data type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This same operation can be performed using the **`eval()`** function. But **`eval`** takes it further. It can evaluate even expressions, provided the input is a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:38:53.640709Z",
     "start_time": "2021-10-02T08:38:53.621182Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval('6+3') # Eval function can add numbers in string data type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:38:54.253017Z",
     "start_time": "2021-10-02T08:38:54.241296Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval('3*6')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accepting User Inputs (as both integer and string)\n",
    "\n",
    "**`input(prompt)`** prompts for and returns input as a string. Hence, if the user inputs a integer, the code should convert the string to an integer and then proceed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:39:07.564534Z",
     "start_time": "2021-10-02T08:38:55.970790Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, \n",
      "How are you?I'm fine, thanks and you?\n"
     ]
    }
   ],
   "source": [
    "a = input(\"Hello, \\nHow are you?\") # \\n means new line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:39:28.302329Z",
     "start_time": "2021-10-02T08:39:11.084068Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type something here and it will be stored in variable abc \t999999\n"
     ]
    }
   ],
   "source": [
    "abc = input(\"Type something here and it will be stored in variable abc \\t\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:39:28.471274Z",
     "start_time": "2021-10-02T08:39:28.460533Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(abc) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: **`type( )`** returns the format or the type of a variable or a number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:39:42.854575Z",
     "start_time": "2021-10-02T08:39:31.634854Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Student Name: Arthur\n",
      "Enter Major: IT\n",
      "Enter University: Oxford\n",
      "\n",
      "\n",
      "Printing Student Details\n",
      "Name Major University\n",
      "Arthur IT Oxford\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Enter Student Name: \")\n",
    "major = input(\"Enter Major: \")\n",
    "university = input(\"Enter University: \")\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"Printing Student Details\")\n",
    "print(\"Name\", \"Major\", \"University\")\n",
    "print(name, major, university)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:39:50.664632Z",
     "start_time": "2021-10-02T08:39:45.749108Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number: 007\n",
      "Enter name: Bond\n",
      "\n",
      "\n",
      "Printing type of a input value\n",
      "type of number <class 'str'>\n",
      "type of name <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "number = input(\"Enter number: \")\n",
    "name = input(\"Enter name: \")\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"Printing type of a input value\")\n",
    "print(\"type of number\", type(number))\n",
    "print(\"type of name\", type(name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accepting User Inputs (only as integer)\n",
    "\n",
    "A useful function to use in conjunction with this is **`eval()`** which takes a string and evaluates it as a python expression.\n",
    "\n",
    "*Note:* In notebooks it is often easier just to modify the code than to prompt for input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:40:01.840902Z",
     "start_time": "2021-10-02T08:40:00.158777Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xyz = 66\n",
      "66\n",
      "<class 'str'>\n",
      "66 = 66\n"
     ]
    }
   ],
   "source": [
    "xyz =  input(\"xyz = \")\n",
    "print(xyz)\n",
    "print(type(xyz))\n",
    "\n",
    "xyzValue=eval(xyz)  # change input to integer data type from string data type\n",
    "print(xyz,'=',xyzValue)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:40:05.221765Z",
     "start_time": "2021-10-02T08:40:05.207119Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "99"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(\"99\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:40:14.438563Z",
     "start_time": "2021-10-02T08:40:07.353115Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter first number: 3\n",
      "Enter second number: 6\n",
      "\n",
      "\n",
      "First Number:  3\n",
      "Second Number:  6\n",
      "Addition of two number is:  9\n"
     ]
    }
   ],
   "source": [
    "# program to calculate addition of two input numbers\n",
    "\n",
    "first_number = int(input(\"Enter first number: \"))  # converting input value to integer\n",
    "second_number = int(input(\"Enter second number: \"))  # converting input value to integer\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"First Number: \", first_number)\n",
    "print(\"Second Number: \", second_number)\n",
    "sum1 = first_number + second_number\n",
    "print(\"Addition of two number is: \", sum1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Practice Problem\n",
    "\n",
    "Accept one integer and one float number from the user and calculate the addition of both the numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:40:36.154886Z",
     "start_time": "2021-10-02T08:40:22.103609Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter first number: 6\n",
      "Enter second number: 3.9\n",
      "Final result is:  9.9\n"
     ]
    }
   ],
   "source": [
    "num1 = int(input(\"Enter first number: \"))  \n",
    "num2 = float(input(\"Enter second number: \"))  \n",
    "\n",
    "result=(num1+num2)\n",
    "print(\"Final result is: \", result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:40:59.401965Z",
     "start_time": "2021-10-02T08:40:56.640739Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter first number: 1\n",
      "Enter second number: 2\n",
      "Enter third number: 3\n",
      "\n",
      "\n",
      "First Number:  1\n",
      "Second Number:  2\n",
      "Third Number:  3\n",
      "Final result is:  9\n"
     ]
    }
   ],
   "source": [
    "# Write code to get three numbers and add first 2 number and multiply with third number\n",
    "\n",
    "num1 = int(input(\"Enter first number: \"))   # converting input value to integer\n",
    "num2 = int(input(\"Enter second number: \"))  # converting input value to integer\n",
    "num3 = int(input(\"Enter third number: \"))   # converting input value to integer\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"First Number: \", num1)\n",
    "print(\"Second Number: \", num2)\n",
    "print(\"Third Number: \", num3)\n",
    "\n",
    "result=(num1+num2)*num3\n",
    "print(\"Final result is: \", result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:41:10.570920Z",
     "start_time": "2021-10-02T08:41:03.424919Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter first number: 5\n",
      "Enter second number: 6\n",
      "Enter third number: 7\n",
      "Enter fourth number: 8\n",
      "\n",
      "\n",
      "First Number:  5\n",
      "Second Number:  6\n",
      "Third Number:  7\n",
      "Fourth number:  8\n",
      "Final result is:  40.857142857142854\n"
     ]
    }
   ],
   "source": [
    "# Write a code to get four numbers: \n",
    "#Step 1. Multiply first and fourth number \n",
    "#Step 2. Divide second and third number \n",
    "#Step3. Add Step 1 and Step 2 outputs.\n",
    "\n",
    "num1 = int(input(\"Enter first number: \")) \n",
    "num2 = int(input(\"Enter second number: \")) \n",
    "num3 = int(input(\"Enter third number: \"))\n",
    "num4 = int(input(\"Enter fourth number: \"))\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"First Number: \", num1)\n",
    "print(\"Second Number: \", num2)\n",
    "print(\"Third Number: \", num3)\n",
    "print(\"Fourth number: \", num4)\n",
    "\n",
    "result=(num1*num4)+(num2/num3)\n",
    "print(\"Final result is: \", result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:41:15.815058Z",
     "start_time": "2021-10-02T08:41:14.456663Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number: 3\n",
      "cube of 3 is 27\n"
     ]
    }
   ],
   "source": [
    "# Write a code to get cube of the number\n",
    "\n",
    "def cube(x):\n",
    "    return x*x*x\n",
    "\n",
    "a=int(input(\"Enter number: \"))\n",
    "print(\"cube of\",a,\"is\",cube(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accept float input from User\n",
    "\n",
    "Let’s see how to accept float value from a user in Python. You need to convert user input to the float number using the **`float()`** function as we did for the integer value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:41:36.311167Z",
     "start_time": "2021-10-02T08:41:30.634897Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter float number: 9\n",
      "\n",
      "\n",
      "input float number is:  9.0\n",
      "type is: <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "float_number = float(input(\"Enter float number: \"))  # converting input value to float\n",
    "print(\"\\n\")\n",
    "print(\"input float number is: \", float_number)\n",
    "print(\"type is:\", type(float_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get multiple input values from a user in one line\n",
    "\n",
    "In Python, It is possible to get multiple values from the user in one line. i.e., In Python, we can accept two or three values from the user in one **`input()`** call.\n",
    "\n",
    "For example, in a single execution of the **`input()`** function, we can ask the user his/her name, age, and phone number and store it in three different variables. Lets see how to do this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:42:18.784825Z",
     "start_time": "2021-10-02T08:41:58.604150Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your Name, Age, Phone_number separated by space: Clark 36 13756537093\n",
      "\n",
      "\n",
      "User Details:  Clark 36 13756537093\n"
     ]
    }
   ],
   "source": [
    "name, age, phone = input(\"Enter your Name, Age, Phone_number separated by space: \").split()\n",
    "print(\"\\n\")\n",
    "print(\"User Details: \", name, age, phone)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accept multiline input from a user\n",
    "\n",
    "As you know, the input() function does not allow the user to enter put lines separated by a newline. If the user tries to enter multiline input, it prints back only the first line. Let’s see how to gets multiple line input.\n",
    "\n",
    "As you know, the input() function does not allow the user to enter put lines separated by a newline. If the user tries to enter multiline input, it prints back only the first line. Let’s see how to gets multiple line input.\n",
    "\n",
    "We can use for loop. In each iteration, we can get input string from the user and then .join() them using \\n, or you can also concatenate each input string using + operator separated by \\n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:42:54.527996Z",
     "start_time": "2021-10-02T08:42:30.068031Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tell me about yourself\n",
      "Hello! I am happy to learn Python and I love travelling.\n",
      "Also, I love cooking and singing.\n",
      "\n",
      "\n",
      "\n",
      "Final text input\n",
      "Hello! I am happy to learn Python and I love travelling.\n",
      "Also, I love cooking and singing.\n"
     ]
    }
   ],
   "source": [
    "MultiLine = []\n",
    "print(\"Tell me about yourself\")\n",
    "while True:\n",
    "    line = input()\n",
    "    if line:\n",
    "        MultiLine.append(line)\n",
    "    else:\n",
    "        break\n",
    "finalText = '\\n'.join(MultiLine)\n",
    "print(\"\\n\")\n",
    "print(\"Final text input\")\n",
    "print(finalText)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Format output strings by its positions\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:43:32.535822Z",
     "start_time": "2021-10-02T08:43:12.278007Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter First Name: Ethan\n",
      "Enter Last Name: Hunt\n",
      "Enter Organization Name: Mission Impossible\n",
      "\n",
      "\n",
      "Ethan, Hunt works at Mission Impossible\n",
      "Hunt, Ethan works at Mission Impossible\n",
      "FirstName Ethan, LastName Hunt works at Mission Impossible\n",
      "Ethan, Hunt Ethan, Hunt works at Mission Impossible\n"
     ]
    }
   ],
   "source": [
    "firstName = input(\"Enter First Name: \")\n",
    "lastName = input(\"Enter Last Name: \")\n",
    "organization = input(\"Enter Organization Name: \")\n",
    "\n",
    "print(\"\\n\")\n",
    "print('{0}, {1} works at {2}'.format(firstName, lastName, organization))\n",
    "print('{1}, {0} works at {2}'.format(firstName, lastName, organization))\n",
    "print('FirstName {0}, LastName {1} works at {2}'.format(firstName, lastName, organization))\n",
    "print('{0}, {1} {0}, {1} works at {2}'.format(firstName, lastName, organization))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing output string arguments by name\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:43:49.939149Z",
     "start_time": "2021-10-02T08:43:41.487002Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Name: David\n",
      "Enter marks: 85\n",
      "\n",
      "\n",
      "Student: Name:  David, Marks: 85%\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Enter Name: \")\n",
    "marks = input(\"Enter marks: \")\n",
    "\n",
    "print(\"\\n\")\n",
    "print('Student: Name:  {firstName}, Marks: {percentage}%'.format(firstName=name, percentage=marks))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output text alignment specifying a width"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:43:58.976262Z",
     "start_time": "2021-10-02T08:43:56.126654Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter text: Python\n",
      "\n",
      "\n",
      "Python                   \n",
      "         Python          \n",
      "                   Python\n"
     ]
    }
   ],
   "source": [
    "text = input(\"Enter text: \")\n",
    "\n",
    "print(\"\\n\")\n",
    "# left aligned\n",
    "print('{:<25}'.format(text)) # Right aligned print('{:>25}'.format(text))\n",
    "# centered\n",
    "print('{:^25}'.format(text))\n",
    "# right aligned\n",
    "print('{:>25}'.format(text))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Specifying a sign while displaying output numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:44:19.214552Z",
     "start_time": "2021-10-02T08:44:05.983107Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Positive Number: 9\n",
      "Enter Negative Number: -4\n",
      "\n",
      "\n",
      "+9.000000; -4.000000\n",
      "9.000000; -4.000000\n"
     ]
    }
   ],
   "source": [
    "positive_number = float(input(\"Enter Positive Number: \"))\n",
    "negative_number = float(input(\"Enter Negative Number: \"))\n",
    "\n",
    "print(\"\\n\")\n",
    "# sign '+' is for both positive and negative number\n",
    "print('{:+f}; {:+f}'.format(positive_number, negative_number))\n",
    "\n",
    "# sign '-' is only for negative number\n",
    "print('{:f}; {:-f}'.format(positive_number, negative_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Display output Number in various type format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:44:35.334673Z",
     "start_time": "2021-10-02T08:44:33.383991Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number: 63\n",
      "\n",
      "\n",
      "The number is:63\n",
      "Output number in octal format : 77\n",
      "Output number in binary format: 111111\n",
      "Output number in hexadecimal format: 3f\n"
     ]
    }
   ],
   "source": [
    "number = int(input(\"Enter number: \"))\n",
    "\n",
    "print(\"\\n\")\n",
    "# 'd' is for integer number formatting\n",
    "print(\"The number is:{:d}\".format(number))\n",
    "\n",
    "# 'o' is for octal number formatting, binary and hexadecimal format\n",
    "print('Output number in octal format : {0:o}'.format(number))\n",
    "\n",
    "# 'b' is for binary number formatting\n",
    "print('Output number in binary format: {0:b}'.format(number))\n",
    "\n",
    "# 'x' is for hexadecimal format\n",
    "print('Output number in hexadecimal format: {0:x}'.format(number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Display numbers in floating-point format\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:44:43.634966Z",
     "start_time": "2021-10-02T08:44:41.776568Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter float Number: 33\n",
      "\n",
      "\n",
      "Output Number in The float type :33.000000\n",
      "padding for output float number33.00\n",
      "Output Exponent notation3.300000e+01\n",
      "Output Exponent notation3.300000E+01\n"
     ]
    }
   ],
   "source": [
    "number = float(input(\"Enter float Number: \"))\n",
    "\n",
    "print(\"\\n\")\n",
    "# 'f' is for float number arguments\n",
    "print(\"Output Number in The float type :{:f}\".format(number))\n",
    "\n",
    "# padding for float numbers\n",
    "print('padding for output float number{:5.2f}'.format(number))\n",
    "\n",
    "# 'e' is for Exponent notation\n",
    "print('Output Exponent notation{:e}'.format(number))\n",
    "\n",
    "# 'E' is for Exponent notation in UPPER CASE\n",
    "print('Output Exponent notation{:E}'.format(number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output String justification\n",
    "\n",
    "Let’s see how to use **`str.rjust()`**,   **`str.ljust()`** and **`str.center()`** to justify text output on screen and console."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:44:55.586629Z",
     "start_time": "2021-10-02T08:44:51.817099Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter String: Jupyter\n",
      "\n",
      "\n",
      "Left justification Jupyter*****************************************************\n",
      "Right justification *****************************************************Jupyter\n",
      "Center justification **************************Jupyter***************************\n"
     ]
    }
   ],
   "source": [
    "text = input(\"Enter String: \")\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"Left justification\", text.ljust(60, \"*\"))\n",
    "print(\"Right justification\", text.rjust(60, \"*\"))\n",
    "print(\"Center justification\", text.center(60, \"*\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Python `Import` function\n",
    "\n",
    "When our program grows bigger, it is a good idea to break it into different modules.\n",
    "\n",
    "A module is a file containing Python definitions and statements. **[Python modules](https://github.com/milaan9/04_Python_Functions/blob/main/007_Python_Function_Module.ipynb)** have a filename and end with the extension **`.py`**.\n",
    "\n",
    "Definitions inside a module can be imported to another module or the interactive interpreter in Python. We use the **`import`** keyword to do this.\n",
    "\n",
    "For example, we can import the **`math`** module by typing the following line:\n",
    "\n",
    "```python\n",
    ">import math\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the module in the following ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:45:06.474816Z",
     "start_time": "2021-10-02T08:45:06.457245Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(math.pi) # do not have to make vairable for pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now all the definitions inside **`math`** module are available in our scope. We can also import some specific attributes and functions only, using the **`from`** keyword. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:45:09.349329Z",
     "start_time": "2021-10-02T08:45:09.328826Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import pi\n",
    "pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While importing a module, Python looks at several places defined in **`sys.path`**. It is a list of directory locations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T08:45:11.706263Z",
     "start_time": "2021-10-02T08:45:11.689668Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['C:\\\\Users\\\\Deepak\\\\01_Learn_Python4Data\\\\01_Python_Introduction',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\python38.zip',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\DLLs',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3',\n",
       " '',\n",
       " 'C:\\\\Users\\\\Deepak\\\\AppData\\\\Roaming\\\\Python\\\\Python38\\\\site-packages',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\locket-0.2.1-py3.8.egg',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\win32',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\win32\\\\lib',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\Pythonwin',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\IPython\\\\extensions',\n",
       " 'C:\\\\Users\\\\Deepak\\\\.ipython']"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "sys.path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also add our own location to this list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}