02. Values&Variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Values and Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "Hello World\n",
      "Welcome to Python Valley, The Place of Fun\n",
      "3.5\n",
      "1234\n",
      "1234\n",
      "False\n",
      "3 120 0\n"
     ]
    }
   ],
   "source": [
    "#Integer Values\n",
    "print(5)\n",
    "\n",
    "#String Values\n",
    "print(\"Hello World\")\n",
    "print('Welcome to Python Valley, The Place of Fun')\n",
    "\n",
    "#Floating Point Values\n",
    "print(3.5)\n",
    "\n",
    "#Mind the qouts around a number, its a string\n",
    "print(\"1234\")\n",
    "print(1234)\n",
    "\n",
    "#Boolean value\n",
    "print(False)\n",
    "\n",
    "#Tricky Integer Number. \",\" will tell the interpreter that these three different numbers\n",
    "print(3,120,000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# To get the type of a value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'str'>\n",
      "<class 'float'>\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print(type(45))\n",
    "print(type(\"45\"))\n",
    "print(type(45.543))\n",
    "print(type(True))\n",
    "#type(45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "#Integer Values\n",
    "print(type(5))\n",
    "\n",
    "#String Values\n",
    "print(type(\"Hello World\"))\n",
    "print(type(\"Welcome to Python Valley, The Place of Fun\"))\n",
    "\n",
    "#Floating Point Values\n",
    "print(type(3.5))\n",
    "\n",
    "#Mind the qouts around a number, its a string\n",
    "print(type(\"1234\"))\n",
    "\n",
    "#Boolean value\n",
    "print(type(True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to my Class, My dear Students\n",
      "750\n",
      "3.5\n",
      "True\n",
      "<class 'str'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "greeting = \"Welcome to my Class, My dear Students\"     #A string type Variable\n",
    "Marks = 750      #An Integer Variable\n",
    "CGPA = 3.5       #A float Variable\n",
    "Pass = True      #A boolean Variable\n",
    "\n",
    "print(greeting)\n",
    "print(Marks)\n",
    "print(CGPA)\n",
    "print(Pass)\n",
    "\n",
    "# Print the Type of All the Above Variables\n",
    "print(type(greeting))\n",
    "print(type(Marks))\n",
    "print(type(CGPA))\n",
    "print(type(Pass))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variable Naming Rules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# and       del     from     None     True \n",
    "# as        elif    global   nonlocal try\n",
    "# assert    else    if       not      while\n",
    "# break     except  import   or       with\n",
    "# class     False   in       pass     yield\n",
    "# continue  finally is       raise\n",
    "# def       for     lambda   return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-4-d9dfed68d0c1>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-4-d9dfed68d0c1>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    9Marks=780  #invalid\u001b[0m\n\u001b[0m     ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "9Marks=780  #invalid\n",
    "\n",
    "print(Marks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "670\n"
     ]
    }
   ],
   "source": [
    "marks=670\n",
    "print(marks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Statements \n",
    "A Statement is a unit of code that python interpreter can execute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "Hello\n",
      "x\n"
     ]
    }
   ],
   "source": [
    "print(1)\n",
    "print(\"Hello\")\n",
    "x = 5\n",
    "x = 10\n",
    "print(\"x\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operators and Operands (Arithmetic Operators)\n",
    "# Operators are special Symbols that represent computations i.e addition and multiplication. The values the operators are applied to are called Operands"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result =  13\n",
      "Subtraction >>  7\n",
      "Multiplication >>  30\n",
      "Division (float) >>  3.3333333333333335\n",
      "Division (integer) >>  3\n",
      "Division (Remainder) >>  1\n",
      "Exponentiation >>  1000\n"
     ]
    }
   ],
   "source": [
    "num1 = 10\n",
    "num2 = 3\n",
    "result = num1 + num2\n",
    "print(\"result = \", result)\n",
    "result = num1 - num2\n",
    "print(\"Subtraction >> \", result)\n",
    "result = num1 * num2\n",
    "print(\"Multiplication >> \", result)\n",
    "result = num1 / num2\n",
    "print(\"Division (float) >> \", result)\n",
    "result = num1 // num2\n",
    "print(\"Division (integer) >> \", result)\n",
    "result = num1 % num2\n",
    "print(\"Division (Remainder) >> \", result)\n",
    "result = num1**num2\n",
    "print(\"Exponentiation >> \", result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value of x =  10\n",
      "Value of x =  11\n",
      "Value of x =  12\n",
      "Value of x =  22\n",
      "Value of x =  2\n"
     ]
    }
   ],
   "source": [
    "# Increment decrement operators\n",
    "x = 10\n",
    "print(\"Value of x = \", x)\n",
    "x = x+1\n",
    "print(\"Value of x = \", x)\n",
    "x +=1\n",
    "print(\"Value of x = \", x)\n",
    "x+=10\n",
    "print(\"Value of x = \", x)\n",
    "\n",
    "x =+2\n",
    "print(\"Value of x = \", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Expressions \n",
    "# A combination of values, variables and operators \n",
    "# A value or variable itself is consider as an expression \n",
    "# Different types of Expression (Arithmetic, Relational, Logical) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "23500\n"
     ]
    }
   ],
   "source": [
    "print(2+4)\n",
    "Basic = 25000\n",
    "tax = 1500\n",
    "Salary = Basic - tax\n",
    "print(Salary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Order of Operators (Precedence Rules)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n",
      "20\n",
      "4\n",
      "0\n",
      "8\n",
      "75.0\n",
      "75.0\n",
      "Quotient is  2 and Remainder is  1\n",
      "Division result in float is  2.3333333333333335\n"
     ]
    }
   ],
   "source": [
    "# PEMDAS rules are observed by Python for Arithmetic Expression Evaluation\n",
    "print(2+3*4)\n",
    "print((2+3)*4)\n",
    "print(2*(3-1))\n",
    "print(1+1**5-2)\n",
    "print((1+1)**(5-2))\n",
    "\n",
    "# Parentheses are also used to make the expressions easier for reading\n",
    "minutes = 45\n",
    "print(minutes*100/60)\n",
    "print((minutes*100)/60)\n",
    "\n",
    "# Quotient and Remainder\n",
    "\n",
    "quotient = 7//3\n",
    "remainder = 7%3\n",
    "floatResult = 7/3\n",
    "print(\"Quotient is \",quotient, \"and Remainder is \", remainder)\n",
    "print(\"Division result in float is \", floatResult)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I Like Programming\n",
      "I Like Python\n",
      "I Like Programming, I Like Python\n",
      "Programmer 2018\n"
     ]
    }
   ],
   "source": [
    "# Operation on Strings\n",
    "print(\"I Like Programming\")\n",
    "print(\"I Like Python\")\n",
    "print(\"I Like Programming,\"+\" I Like Python\")\n",
    "#print(\"Programmer \" + 2018)\n",
    "print(\"Programmer\", 2018)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "220\n",
      "100120\n",
      "Test Test Test Test \n"
     ]
    }
   ],
   "source": [
    "first = 100\n",
    "second = 120\n",
    "print(first + second)\n",
    "first = '100'\n",
    "second = '120'\n",
    "print(first + second)\n",
    "\n",
    "first = 'Test '\n",
    "second = 4\n",
    "print(first * second)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String Control Codes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\u00072\u00073\u00074\u00075\u00076\n"
     ]
    }
   ],
   "source": [
    "#print('A\\nB\\nC')\n",
    "#print('D\\tE\\tF')\n",
    "#print('WX\\bYZ')\n",
    "print('1\\a2\\a3\\a4\\a5\\a6')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Did you know that 'word' is a word?\n",
      "Did you know that \"word\" is a word?\n",
      "Did you know that 'word' is a word?\n",
      "Did you know that \"word\" is a word?\n"
     ]
    }
   ],
   "source": [
    "print(\"Did you know that 'word' is a word?\")\n",
    "print('Did you know that \"word\" is a word?')\n",
    "print('Did you know that \\'word\\' is a word?')\n",
    "print(\"Did you know that \\\"word\\\" is a word?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Controling the Print Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is first Message : This is Second Message \n"
     ]
    }
   ],
   "source": [
    "print('This is first Message : ', end='')\n",
    "print('This is Second Message ')      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ABC\n",
      "X\n",
      "Y\n",
      "Z\n"
     ]
    }
   ],
   "source": [
    "print('A', end='')\n",
    "print('B', end='')\n",
    "print('C', end='')\n",
    "print()\n",
    "print('X')\n",
    "print('Y')\n",
    "print('Z')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 15 20 25\n",
      "10,15,20,25\n",
      "10152025\n",
      "10:15:20:25\n",
      "10-----15-----20-----25\n"
     ]
    }
   ],
   "source": [
    "w, x, y, z = 10, 15, 20, 25\n",
    "print(w, x, y, z)\n",
    "print(w, x, y, z, sep=',')\n",
    "print(w, x, y, z, sep='')\n",
    "print(w, x, y, z, sep=':')\n",
    "print(w, x, y, z, sep='-----')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Taking Input from User in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python built-in function \"input()\" is used for taking input\n",
    "\n",
    "inp = input()\n",
    "print(\"You Entered the Text : \" + inp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please Enter a Message : this is message\n",
      "Your Text is :  this is message\n"
     ]
    }
   ],
   "source": [
    "# Good Programming Tip : Always Print a Message Before Taking Input\n",
    "text = input(\"Please Enter a Message : \")\n",
    "print(\"Your Text is : \", text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How many Hours You Worked ? 6\n",
      "What is the Rate per Hour ? 15\n",
      "Your Salary is :  90\n"
     ]
    }
   ],
   "source": [
    "# For getting Numeric Values , Always Convert them to required type, as input() function always return string,\n",
    "# no matter whatever you type\n",
    "hours = input(\"How many Hours You Worked ? \")\n",
    "rate = input(\"What is the Rate per Hour ? \")\n",
    "#salary = hours * rate\n",
    "\n",
    "salary = int(hours) * int(rate)\n",
    "print(\"Your Salary is : \", salary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Naming Variable Conventions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "437.5\n",
      "437.5\n",
      "437.5\n"
     ]
    }
   ],
   "source": [
    "a = 35.0\n",
    "b = 12.50\n",
    "c = a * b\n",
    "print(c)\n",
    "\n",
    "hours = 35.0\n",
    "rate = 12.50\n",
    "pay = hours * rate\n",
    "print(pay)\n",
    "\n",
    "\n",
    "x1q3z9ahd = 35.0\n",
    "x1q3z9afd = 12.50\n",
    "x1q3p9afd = x1q3z9ahd * x1q3z9afd\n",
    "print(x1q3p9afd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}