F_Day_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " [Byte Video](https://www.youtube.com/watch?v=4mrN6IYsMz8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting strated with Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Contents\n",
    "\n",
    "# 1. Hello World\n",
    "# 2. Variables\n",
    "# 3. Numbers\n",
    "# 4. Casting\n",
    "# 5. Strings\n",
    "# 6. Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hello World!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25.0\n"
     ]
    }
   ],
   "source": [
    "#print('Hello World!') \n",
    "\"hello\"\n",
    "num = 12.5\n",
    "print(num*2)\n",
    "#print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hi'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'hi'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20.48\n",
      "20\n",
      " 10.24  10.24 \n",
      "28\n",
      "7*57*57*57*57*5\n"
     ]
    }
   ],
   "source": [
    "print(10.24 * 2)# number(float )\n",
    "print(10 * 2)# integer\n",
    "print(\" 10.24 \" *2)# string\n",
    "print(7*4)\n",
    "print(\"7*5\" * 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ":gbgvbng\n",
      "Enter your value: bg\n",
      "bg\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your name: 4\n",
      "44\n"
     ]
    }
   ],
   "source": [
    "age = input('Enter your name: ')\n",
    "print(age*2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter your age :5\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "age  = int(input('enter your age :'))\n",
    "print(age*5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<type 'str'>, <type 'int'>, <type 'float'>, <type 'bool'>, <type 'complex'>)\n"
     ]
    }
   ],
   "source": [
    "x = '10.24'\n",
    "y = 10\n",
    "z = 10.52\n",
    "a = True\n",
    "b = 1 + 2j\n",
    "\n",
    "print(type(x), type(y), type(z), type(a), type(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = int('20')\n",
    "print(x+y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "how are you?\n"
     ]
    }
   ],
   "source": [
    "print(\"how are you?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter your namepradip\n",
      "Hi,  pradip\n"
     ]
    }
   ],
   "source": [
    "name = input('enter your name')   #this concept is from python basics\n",
    "print(\"Hi, \", name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using input()\n",
    "-  read name, age, gender(isfamale), salary\n",
    "- explained data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a comment\n",
    "# shortcut to commenting a line is (Ctrl + /)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "world\n"
     ]
    }
   ],
   "source": [
    "# Multi line strings\n",
    "\n",
    "'''Python will ignore string literals that are not assigned to a variable,\n",
    "you can add a multiline string (triple quotes) in your code,\n",
    "and place you comment inside it:'''\n",
    "\n",
    "x  = '''hello\n",
    "world'''\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\n"
     ]
    }
   ],
   "source": [
    "a=input()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b= int(a)\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'int'>\n",
      "<type 'str'>\n"
     ]
    }
   ],
   "source": [
    "x = 20\n",
    "print(type(x))                     \n",
    "\n",
    "y = '10'\n",
    "print(type(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable Names\n",
    "\n",
    "A variable can have a short name (like x and y) or a more descriptive name (age, car_name, total_volume).\n",
    "\n",
    "Rules for Python variables:\n",
    "\n",
    "    A variable name must start with a letter or the underscore character\n",
    "\n",
    "    A variable name cannot start with a number\n",
    "\n",
    "    A variable name can only contain alpha-numeric characters and underscores (A-z, 0-9, and _ )\n",
    "\n",
    "    Variable names are case-sensitive (age, Age and AGE are three different variables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a+b= 30\n",
      "a*b= 200\n",
      "0.5\n",
      "-10\n",
      "10\n",
      "100\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 30\n",
    "b = 20\n",
    "print(\"a+b=\",a+b)\n",
    "print(\"a*b=\",a*b)\n",
    "print(a/b)\n",
    "print(a-b)\n",
    "print(a%b)\n",
    "\n",
    "20*1+10= 10\n",
    "print(a**2)\n",
    "a**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('A = ', 20, 30, 'C = ', 40)\n",
      "(20, 30)\n"
     ]
    }
   ],
   "source": [
    "a = 20\n",
    "b = 30\n",
    "c = 40\n",
    "print('A = ', a, b, 'C = ', c)\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Orange', 'Banana', 'Cherry')\n"
     ]
    }
   ],
   "source": [
    "# Multiple Assigning\n",
    "\n",
    "a, b, c = \"Orange\", \"Banana\", \"Cherry\"\n",
    "\n",
    "print(a, b, c)\n",
    "# print(y)\n",
    "# print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('10', '10', '10')\n"
     ]
    }
   ],
   "source": [
    "# Assigning same value to multiple variables\n",
    "\n",
    "x = y = z = '10'\n",
    "print(x, y, z)\n",
    "# print(y)\n",
    "# print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "# + operator\n",
    "\n",
    "x = 10\n",
    "y = 20\n",
    "# c = x+y\n",
    "print(x+y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"Hi \"\n",
    "y = \"How \"\n",
    "z = \"are \"\n",
    "w = \"you? \"\n",
    "a = x+y+z+w\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1020\n"
     ]
    }
   ],
   "source": [
    "a = '10'\n",
    "b = '20'\n",
    "print(a+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python is awesome\n"
     ]
    }
   ],
   "source": [
    "# for strings, + works as a combining operator\n",
    "\n",
    "x = \"Python is \"\n",
    "y = \"awesome\"\n",
    "z =  x + y\n",
    "print(x + y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "# for numbers, + works as an addition operator\n",
    "\n",
    "x = 5\n",
    "y = 10\n",
    "print(x + y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3+20.2j)\n"
     ]
    }
   ],
   "source": [
    "x = 1 + 10.2j\n",
    "y = 2 + 10j\n",
    "z = x + y\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'int'>\n",
      "<type 'int'>\n",
      "<type 'int'>\n"
     ]
    }
   ],
   "source": [
    "'''Integer'''\n",
    "# if x bit 0-2^x -1\n",
    "\n",
    "\n",
    "x = 1\n",
    "y = 35656222554887711\n",
    "z = -3255522\n",
    "\n",
    "print(type(x))\n",
    "print(type(y))\n",
    "print(type(z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'float'>\n",
      "<type 'float'>\n",
      "<type 'float'>\n",
      "<type 'float'>\n"
     ]
    }
   ],
   "source": [
    "'''Float'''\n",
    "\n",
    "x = 1.10\n",
    "y = 1.0\n",
    "z = -35.59\n",
    "print(type(x))\n",
    "print(type(y))\n",
    "print(type(z))\n",
    "\n",
    "# '''Float can also be scientific numbers with an \"e\" to indicate the power of 10.'''\n",
    "\n",
    "# x = 35e6\n",
    "# y = 12e4\n",
    "# z = -87.7e100\n",
    "\n",
    "# print(x)\n",
    "# print(y)\n",
    "# print(z)\n",
    "# print(type(x))\n",
    "# print(type(y))\n",
    "# print(type(z))\n",
    "\n",
    "\n",
    "\n",
    "x = 35e3\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.2e+11\n"
     ]
    }
   ],
   "source": [
    "x = 22e10\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'bool'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = True\n",
    "print(type(x))\n",
    "\n",
    "str\n",
    "int\n",
    "float\n",
    "complex\n",
    "bool"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Casting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There may be times when you want to specify a type on to a variable.\n",
    "This can be done with casting. Python is an object-orientated language,\n",
    "and as such it uses classes to define data types, including its primitive types.\n",
    "\n",
    "Casting in python is therefore done using constructor functions:\n",
    "\n",
    "1. int() - constructs an integer number from an integer literal, a float literal (by rounding down to the previous whole number), or a string literal (providing the string represents a whole number).\n",
    "        \n",
    "2. float() - constructs a float number from an integer literal, a float literal or a string literal (providing the string represents a float or an integer).\n",
    "          \n",
    "3. str() - constructs a string from a wide variety of data types, including strings, integer literals and float literals'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.0\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = float(x)\n",
    "print(y)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1.0, 2.8, '\\n', 3.0, '\\n', 4.2)\n",
      "(<type 'float'>, <type 'float'>, <type 'float'>, <type 'float'>)\n"
     ]
    }
   ],
   "source": [
    "x = float(1)        # x will be 1.0\n",
    "y = float(2.8)      # y will be 2.8\n",
    "z = float(\"3\")      # z will be 3.0\n",
    "w = float(\"4.2\")    # w will be 4.2\n",
    "\n",
    "print(x, y,'\\n',z,'\\n', w)      # '\\n is used for new line'\n",
    "\n",
    "print(type(x), type(y), type(z), type(w) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 10\n",
    "\n",
    "c = a+b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('hi', 'Hello')\n"
     ]
    }
   ],
   "source": [
    "print('hi', 'Hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('hello world', 'hello world')\n"
     ]
    }
   ],
   "source": [
    "h = 'hello world'\n",
    "g = \"hello world\"\n",
    "print(h, g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "a = \"Hello\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi \n",
      "my\n",
      "name\n",
      "is \n",
      "Pradip\n"
     ]
    }
   ],
   "source": [
    "# Multiline string\n",
    "\n",
    "a = \"\"\"Hi \n",
    "my\n",
    "name\n",
    "is \n",
    "Pradip\"\"\"\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b[4:8] =  5432\n",
      "a[2:7]= 23456\n"
     ]
    }
   ],
   "source": [
    "a = \"0123456789\"\n",
    "b =  \"987654321\"\n",
    "# b[start_index:end_index] 3,4\n",
    "print(\"b[4:8] = \",b[4:8])\n",
    "print(\"a[2:7]=\",a[2:7])\n",
    "#b[1:6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Accessing a letter in a string\n",
    "\n",
    "a = \"0123456789\"\n",
    "b =  \"987654321\"\n",
    "b[6]\n",
    "#print(b[3:8])\n",
    "#print(a[1:6])# fisrt is included second is excluded\n",
    "\n",
    "# getting a range of characters\n",
    "print(a[-6])          # var[starting_point : ending point : step]\n",
    "\n",
    "# print(a[::])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcd\n"
     ]
    }
   ],
   "source": [
    "# Substring. Get the characters from position 2 to position 5 (not included):\n",
    "\n",
    "b = \"abcdefghij\"\n",
    "print(b[0:4])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "# The strip() method removes any whitespace from the beginning or the end:\n",
    "\n",
    "a = \"   Hello, World!   \"\n",
    "print(a.strip())        # returns \"Hello, World!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19\n"
     ]
    }
   ],
   "source": [
    "#The len() method returns the length of a string:\n",
    "\n",
    "a = \"Hello  how are you?\"\n",
    "print(len(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello, world!\n"
     ]
    }
   ],
   "source": [
    "#The lower() method returns the string in lower case:\n",
    "\n",
    "a = \"HELLO, WORLD!\"\n",
    "print(a.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO, WORLD!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'hello, world!'"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The upper() method returns the string in upper case:\n",
    "\n",
    "a = \"hello, world!\"\n",
    "print(a.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Friend! world\n"
     ]
    }
   ],
   "source": [
    "# The replace() method replaces a string with another string:\n",
    "\n",
    "a = \"Hello, World! world\"\n",
    "\n",
    "print(a.replace(\"World\", \"Friend\" ))\n",
    "# a.replace\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['0, 1, 2,3,4']\n"
     ]
    }
   ],
   "source": [
    "# The split() method splits the string into substrings if it finds instances of the separator:\n",
    "string = \"0, 1, 2,3,4\"\n",
    "x = string.split(' ,')\n",
    "print(x)    # returns ['Hello', ' World!']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 'hello'\n",
    "\n",
    "a.capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.0\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "a = 1.75\n",
    "b= 100\n",
    "print(math.sqrt(b))\n",
    "print(math.ceil(a))\n",
    "print(math.floor(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "a = 'Hello'\n",
    "a.capitalize()\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python Operators:\n",
    "\n",
    "Operators are used to perform operations on variables and values.\n",
    "\n",
    "Python divides the operators in the following groups:\n",
    "\n",
    "    Arithmetic operators\n",
    "    Assignment operators\n",
    "    Comparison operators\n",
    "    Logical operators\n",
    "    Identity operators\n",
    "    Membership operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arithmetic operators\n",
    "    \n",
    "    Arithmetic operators are used with numeric values to perform common mathematical operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.8 2\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "+\tAddition\tx + y\t\n",
    "\n",
    "-\tSubtraction\tx - y\t\n",
    "\n",
    "*\tMultiplication\tx * y\t\n",
    "\n",
    "/\tDivision\tx / y\t\n",
    "\n",
    "%\tModulus\tx % y\t\n",
    "\n",
    "**\tExponentiation\tx ** y\t\n",
    "\n",
    "//\tFloor division\tx // y '''\n",
    "\n",
    "x = 14\n",
    "y = 5\n",
    "c = x/y\n",
    "z = x//y\n",
    "print(c , z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python Assignment Operators\n",
    "\n",
    "    Assignment operators are used to assign values to variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "#x= x+5\n",
    "x += 5   # x = x + 5\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# =    \tx = 5   \t    x = 5\n",
    "\n",
    "# x = 5\n",
    "\n",
    "# #    +=   \tx += 5  \t    x = x + 5\n",
    "\n",
    "# x = x + 5\n",
    "# x += 5\n",
    "\n",
    "# print(x)\n",
    "    \n",
    "# #    -=   \tx -= 3  \t    x = x - 3\n",
    "\n",
    "# x -= 5\n",
    "# print(x)\n",
    "   \n",
    "# #    *=   \tx *= 3  \t    x = x * 3\n",
    "\n",
    "# x *= 5\n",
    "# print(x)\n",
    "\n",
    "   \n",
    "#    /=   \tx /= 3  \t    x = x / 3\n",
    "   \n",
    "#    %=   \tx %= 3  \t    x = x % 3\n",
    "   \n",
    "#    //=  \tx //= 3 \t    x = x // 3\n",
    "\n",
    "x = 10\n",
    "x//= 3\n",
    "x = x//3\n",
    "   \n",
    "#    **=  \tx **= 3 \t    x = x ** 3\n",
    "x = 10\n",
    "x **= 5\n",
    "x = x**5\n",
    "\n",
    "\n",
    "   \n",
    "x = 10\n",
    "x//=3\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n",
      "3.33333333333\n"
     ]
    }
   ],
   "source": [
    "x = 10.0\n",
    "print(x//3)\n",
    "print(x/3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python Comparison Operators\n",
    "\n",
    "    Comparison operators are used to compare two values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "b = 20\n",
    "print(a<b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "y is greatest\n"
     ]
    }
   ],
   "source": [
    "'''==   \tEqual                       \tx == y\n",
    "\n",
    "   !=   \tNot equal                   \tx != y\n",
    "   \n",
    "   >    \tGreater than                \tx > y\n",
    "   \n",
    "   <    \tLess than                   \tx < y\n",
    "   \n",
    "   >=   \tGreater than or equal to    \tx >= y\n",
    "   \n",
    "   <=   \tLess than or equal to       \tx <= y'''\n",
    "\n",
    "print('\\n')\n",
    "\n",
    "\n",
    "x = 100\n",
    "y = 2000\n",
    "z = 300\n",
    "if x>y and x>z :\n",
    "    print('x is greatest')\n",
    "elif y>x and y>z:\n",
    "    print('y is greatest')\n",
    "else:\n",
    "    print('z is greatest')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17 odd\n"
     ]
    }
   ],
   "source": [
    "a=17\n",
    "if a%2==0:\n",
    "    print(a, \"is even\")\n",
    "else:\n",
    "    print(a, \"odd\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python Logical Operators\n",
    "\n",
    "    Logical operators are used to combine conditional statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "'''and  \tReturns True if both statements are true                    \tx < 5 and  x < 10\n",
    "\n",
    "   or   \tReturns True if one of the statements is true               \tx < 5 or x < 4\n",
    "   \n",
    "   not  \tReverse the result, returns False if the result is true     \tnot(x < 5 and x < 10)'''\n",
    "\n",
    "a = 40\n",
    "b = 20\n",
    "c = 30\n",
    "\n",
    "print(not c<b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python Identity Operators\n",
    "\n",
    "    Identity operators are used to compare the objects, not if they are equal, but if they are actually the same object, with the same memory location:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "\n",
      "\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "'''is       \tReturns true if both variables are the same object      \tx is y'''\n",
    "\n",
    "x = 'hi'\n",
    "y = 'hi'\n",
    "\n",
    "print(x is y)\n",
    "print('\\n')\n",
    "'''is not   \tReturns true if both variables are not the same object  \tx is not y'''\n",
    "\n",
    "x = 10\n",
    "y = 10\n",
    "print(x is not y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python Membership Operators\n",
    "    \n",
    "    Membership operators are used to test if a sequence is presented in an object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "'''in       \tReturns True if a sequence with the specified value is present in the object    \tx in y'''\n",
    "\n",
    "f = [1, 2, 3, 4]    # List, will see in collection datatypes\n",
    "e = 2\n",
    "print(e in f)\n",
    "\n",
    "\n",
    "'''not in   \tReturns True if a sequence with the specified value is not present in the object\tx not in y'''\n",
    "\n",
    "f = [1, 2, 3, 4]\n",
    "e = 5\n",
    "print(e not in f)\n",
    "print('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}