class_06_assignments.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment No.3 (Using maths operators)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### This assignment also explains order of precedence of math operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x + y * y / z = 23.0\n",
      "\n",
      "x - y / z * y = 7.0\n",
      "\n",
      "x * y = 62.0\n",
      "\n",
      "x / y = 1.75\n",
      "\n",
      "x // y = 3\n",
      "\n",
      "x + x ** y - z = 50638\n",
      "\n",
      "x * y - x % z = 59\n"
     ]
    }
   ],
   "source": [
    "x = 15\n",
    "y = 4\n",
    "z = 2\n",
    "\n",
    "# Output: x + y * y / z = 23.0\n",
    "print('x + y * y / z =', x+y*y/z)\n",
    "\n",
    "# Output: x - y  / z * y = 7.0\n",
    "print('\\nx - y / z * y =', x-y/z*y)\n",
    "\n",
    "# Output: x * y + y / z = 62.0\n",
    "print('\\nx * y =', round(x*y+y/z,3))\n",
    "\n",
    "# Output: x / y - y / z = 1.75\n",
    "print('\\nx / y =', x/y-y/z)\n",
    "\n",
    "# Output: x // y = 3 \n",
    "print('\\nx // y =', x//y)     # This truncates decimal portion hence answer from '3.75' will be printed as '3'\n",
    "\n",
    "# Output: x + x ** y - z = 50638\n",
    "print('\\nx + x ** y - z =', x+x**y-z)\n",
    "\n",
    "#Output: x * y - x % z = 59\n",
    "\n",
    "print('\\nx * y - x % z =', x*y-x%z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment No.2 (String Formatting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First Method of String Formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter student's name: Zafar Abbas\n",
      "Please enter student's grade: AI Q1 ISB\n",
      "Please enter student's section: Morning (9 to 12 am)\n",
      "Please enter student's Roll No: PIAIC12345\n",
      "\n",
      "Name\t:\tZafar Abbas\n",
      "Grade\t:\tAI Q1 ISB\n",
      "Section\t:\tMorning (9 to 12 am)\n",
      "Roll No\t:\tPIAIC12345\n",
      "Campus\t:\tBahria University, Islamabad\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Please enter student's name: \")\n",
    "grade = input(\"Please enter student's grade: \")\n",
    "section = input(\"Please enter student's section: \")\n",
    "roll_no = input(\"Please enter student's Roll No: \")\n",
    "campus = \"Bahria University, Islamabad\"\n",
    "\n",
    "# \"\"\"\n",
    "# PIAIC ISLAMABAD\n",
    "# name = {}\n",
    "# grade={}\n",
    "# section={}\n",
    "# roll_no={}\n",
    "# campus={}\n",
    "# \"\"\".format(name, grade, section, roll_no,campus)\n",
    "\n",
    "print(\"\\nName\\t:\\t\" + name)\n",
    "print(\"Grade\\t:\\t\" + grade)\n",
    "print(\"Section\\t:\\t\" + section)\n",
    "print(\"Roll No\\t:\\t\" + roll_no)\n",
    "print(\"Campus\\t:\\t\" + campus)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Second Method of String Formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter student's name: Zafar Abbas\n",
      "Please enter student's grade: AI Q1 Isb\n",
      "Please enter student's section: Morning\n",
      "Please enter student's Roll No: PIAIC12345\n",
      "\n",
      "Name\t:\tZafar Abbas\n",
      "Grade\t:\tAI Q1 Isb\n",
      "Section\t:\tMorning\n",
      "Roll No\t:\tPIAIC12345\n",
      "Campus\t:\tBahria University, Islamabad\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Please enter student's name: \")\n",
    "grade = input(\"Please enter student's grade: \")\n",
    "section = input(\"Please enter student's section: \")\n",
    "roll_no = input(\"Please enter student's Roll No: \")\n",
    "campus = \"Bahria University, Islamabad\"\n",
    "\n",
    "\"\"\"\n",
    "PIAIC ISLAMABAD\n",
    "name = {}\n",
    "grade={}\n",
    "section={}\n",
    "roll_no={}\n",
    "campus={}\n",
    "\"\"\".format(name, grade, section, roll_no,campus)\n",
    "\n",
    "print(\"\\nName\\t:\\t{}\\nGrade\\t:\\t{}\\nSection\\t:\\t{}\\nRoll No\\t:\\t{}\\nCampus\\t:\\t{}\".format(name,grade,section,roll_no,campus))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Third Method of String Formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter student's name: Zafar Abbas\n",
      "Please enter student's grade: AI Q1 ISB\n",
      "Please enter student's section: Morning\n",
      "Please enter student's Roll No: PIAIC12345\n",
      "\n",
      "Name\t:\tZafar Abbas\n",
      "Grade\t:\tAI Q1 ISB\n",
      "Section\t:\tMorning\n",
      "Roll No\t:\tPIAIC12345\n",
      "Campus\t:\tBahria University, Islamabad\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Please enter student's name: \")\n",
    "grade = input(\"Please enter student's grade: \")\n",
    "section = input(\"Please enter student's section: \")\n",
    "roll_no = input(\"Please enter student's Roll No: \")\n",
    "campus = \"Bahria University, Islamabad\"\n",
    "\n",
    "\"\"\"\n",
    "PIAIC ISLAMABAD\n",
    "name = {}\n",
    "grade={}\n",
    "section={}\n",
    "roll_no={}\n",
    "campus={}\n",
    "\"\"\".format(name, grade, section, roll_no,campus)\n",
    "\n",
    "print(f\"\\nName\\t:\\t{name}\\nGrade\\t:\\t{grade}\\nSection\\t:\\t{section}\\nRoll No\\t:\\t{roll_no}\\nCampus\\t:\\t{campus}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Forth Method of String Formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter student's name: Zafar Abbas Bukhary\n",
      "Please enter student's grade: Artificial Intelligence Q1 ISB\n",
      "Please enter student's section: Morning (0900 to 1200)\n",
      "Please enter student's Roll No: PIAIC12345\n",
      "\n",
      "Student Name\t: Artificial Intelligence Q1 ISB\n",
      "Student Class\t: Morning (0900 to 1200)\n",
      "Student Roll No\t: PIAIC12345\n",
      "Student Section\t: Zafar Abbas Bukhary\n",
      "Student Campus\t: Bahria University, Islamabad\n"
     ]
    }
   ],
   "source": [
    "\n",
    "name = input(\"Please enter student's name: \")\n",
    "grade = input(\"Please enter student's grade: \")\n",
    "section = input(\"Please enter student's section: \")\n",
    "roll_no = input(\"Please enter student's Roll No: \")\n",
    "campus = \"Bahria University, Islamabad\"\n",
    "\n",
    "\"\"\"\n",
    "PIAIC ISLAMABAD\n",
    "name = {}\n",
    "grade={}\n",
    "section={}\n",
    "roll_no={}\n",
    "campus={}\n",
    "\"\"\".format(name, grade, section, roll_no,campus)\n",
    "\n",
    "print(\"\\nStudent Name\\t: %s\\nStudent Class\\t: %s\\nStudent Roll No\\t: %s\\nStudent Section\\t: %s\\nStudent Campus\\t: %s\"\n",
    "      %(grade,section,roll_no,name,campus))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment No.1 (String Methods)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List & Use of names of all the valid attributes/base attributes & Methods of String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"zafar Abbas\"\n",
    "students = ['zafar','adnan','ismail','zafar']\n",
    "cities = ('Islamabad','Karachi','Lahore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'list'>\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "print(type(name))\n",
    "print(type(students))\n",
    "print(type(cities))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'capitalize',\n",
       " 'casefold',\n",
       " 'center',\n",
       " 'count',\n",
       " 'encode',\n",
       " 'endswith',\n",
       " 'expandtabs',\n",
       " 'find',\n",
       " 'format',\n",
       " 'format_map',\n",
       " 'index',\n",
       " 'isalnum',\n",
       " 'isalpha',\n",
       " 'isascii',\n",
       " 'isdecimal',\n",
       " 'isdigit',\n",
       " 'isidentifier',\n",
       " 'islower',\n",
       " 'isnumeric',\n",
       " 'isprintable',\n",
       " 'isspace',\n",
       " 'istitle',\n",
       " 'isupper',\n",
       " 'join',\n",
       " 'ljust',\n",
       " 'lower',\n",
       " 'lstrip',\n",
       " 'maketrans',\n",
       " 'partition',\n",
       " 'replace',\n",
       " 'rfind',\n",
       " 'rindex',\n",
       " 'rjust',\n",
       " 'rpartition',\n",
       " 'rsplit',\n",
       " 'rstrip',\n",
       " 'split',\n",
       " 'splitlines',\n",
       " 'startswith',\n",
       " 'strip',\n",
       " 'swapcase',\n",
       " 'title',\n",
       " 'translate',\n",
       " 'upper',\n",
       " 'zfill']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Zafar abbas'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.capitalize()    # this method will Capitalize the first character of string 'name'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'zafar abbas'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The casefold() method is an aggressive lower() method\n",
    "# which convert strings to casefolded strings for caseless matching\n",
    "\n",
    "name.casefold()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'                   zafar Abbas                    '"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.center(50)     # this method will centerlize the string 'name' with 50 character-space from both sides"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.count('a')       # this will return the number of characters used in string 'name'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is : zafar Abbas\n",
      "The encoded version is: b'zafar Abbas'\n"
     ]
    }
   ],
   "source": [
    "# The string encode() method returns encoded version of the given string\n",
    "\n",
    "# string 'name' is by-default unicode\n",
    "\n",
    "# print string\n",
    "print('My name is :', name)\n",
    "\n",
    "# default encoding to utf-8\n",
    "string_utf = name.encode()\n",
    "# print result\n",
    "print('The encoded version is:', string_utf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The endswith() method returns True if a string ends with the specified suffix. If not, it returns False\n",
    "name.endswith('s')   # string 'name' ends with character 's', so it will return 'True' otherwise, 'False'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zafarrr\tabbas\n",
      "zafarrr   abbas\n"
     ]
    }
   ],
   "source": [
    "# The expandtabs() method returns a copy of string with all tab characters '\\t' replaced with whitespace characters\n",
    "# until the next multiple of tabsize parameter\n",
    "\n",
    "name = 'zafarrr\\tabbas'  # default tab stops are 8,16,24\n",
    "name.expandtabs()\n",
    "print(name)\n",
    "\n",
    "name=name.expandtabs(5) # now tab stops are 5,10,15,20\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "# The find() method returns the index of first occurrence of the substring (if found). If not found, it returns -1\n",
    "\n",
    "name = 'zafar Abbas'\n",
    "name\n",
    "\n",
    "print(name.find('Abb'))     # starting from '0', character 'A' is at 6th index\n",
    "print(name.find('bukhary'))  # 'bukhary' is not in string 'name', thus index returns position '-1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Zafar, your balance is 230.2346.\n",
      "Hello Zafar, your balance is 120.946.\n",
      "Hello Zafar, your balance is 95.568.\n",
      "Hello Zafar, your balance is 9546.75.\n"
     ]
    }
   ],
   "source": [
    "# The string format() method formats the given string into a nicer output in Python\n",
    "\n",
    "# default arguments\n",
    "print(\"Hello {}, your balance is {}.\".format(\"Zafar\", 230.2346))\n",
    "\n",
    "# positional arguments\n",
    "print(\"Hello {0}, your balance is {1}.\".format(\"Zafar\", 120.946))\n",
    "\n",
    "# keyword arguments\n",
    "print(\"Hello {name}, your balance is {blc}.\".format(name=\"Zafar\", blc=95.568))\n",
    "\n",
    "# mixed arguments\n",
    "print(\"Hello {0}, your balance is {blc}.\".format(\"Zafar\", blc=9546.75))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 -5\n",
      "4 -5 0\n",
      "Zafar Abbas 12345\n"
     ]
    }
   ],
   "source": [
    "# The format_map() method is similar to str.format(**mapping) except that str.format(**mapping) creates \n",
    "# a new dictionary whereas str.format_map(mapping) doesn't.\n",
    "\n",
    "fraction = {'x':4,'y':-5}\n",
    "print('{x} {y}'.format_map(fraction))\n",
    "\n",
    "fraction = {'x':4,'y':-5, 'z': 0}\n",
    "print('{x} {y} {z}'.format_map(fraction))\n",
    "\n",
    "name = {'Name':'Zafar Abbas','Roll No':12345}\n",
    "print('{Name} {Roll No}'.format_map(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'zafar Abbas'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Substring 'is fun': 19\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "substring not found",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-118-8d68afb8cbba>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Substring 'is fun':\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msentence\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Java'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     10\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Substring 'Java':\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: substring not found"
     ]
    }
   ],
   "source": [
    "# The index() method returns the index of a substring inside the string (if found).\n",
    "# If the substring is not found, it raises an exception.\n",
    "\n",
    "sentence = 'Python programming is fun.'\n",
    "\n",
    "result = sentence.index('is fun')\n",
    "print(\"Substring 'is fun':\", result)\n",
    "\n",
    "result = sentence.index('Java')\n",
    "print(\"Substring 'Java':\", result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Return True if the string is an alpha-numeric string, False otherwise\n",
    "\n",
    "name = 'zafarAbbas123'\n",
    "print(name.isalnum())\n",
    "\n",
    "name = 'zafar Abbas'\n",
    "print(name.isalnum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Return True if the string is an alphabetic string, False otherwise.\n",
    "\n",
    "name = 'ZafarAbbas'\n",
    "print(name.isalpha())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return True if all characters in the string are ASCII, False otherwise.\n",
    "\n",
    "name.isascii()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Return True if the string is a decimal string, False otherwise.\n",
    "\n",
    "s = \"28212\"\n",
    "print(s.isdecimal())\n",
    "\n",
    "# contains alphabets\n",
    "s = \"32ladk3\"\n",
    "print(s.isdecimal())\n",
    "\n",
    "# contains alphabets and spaces\n",
    "s = \"My name is Zafar 14572pk\"\n",
    "print(s.isdecimal())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Return True if the string is a digit string, False otherwise.\n",
    "\n",
    "num = '38548'\n",
    "print(num.isdigit())\n",
    "\n",
    "name = 'Zafar Abbas'\n",
    "print(name.isdigit())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Return True if the string is a valid Python identifier, False otherwise.\n",
    "\n",
    "name = 'ZafarAbbas'\n",
    "print(name.isidentifier()) # condition is 'True'\n",
    "\n",
    "name1 = 'Zafar Abbas'\n",
    "print(name1.isidentifier())   # condition is 'False'\n",
    "\n",
    "name2 = '33Zafar'\n",
    "print(name2.isidentifier())   # condition is 'False'\n",
    "\n",
    "name3 = 'Zafar72'\n",
    "print(name3.isidentifier())   # condition is 'True'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Return True if the string is a lowercase string, False otherwise.\n",
    "\n",
    "name = 'zafar abbas'\n",
    "print(name.islower())    # condition is 'True'\n",
    "\n",
    "name1 = 'Zafar'\n",
    "print(name1.islower())   # condition is 'False'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Return True if the string is a numeric string, False otherwise.\n",
    "\n",
    "name = 'Zafar Abbas'\n",
    "print(name.isnumeric())   # 'name' string is non-numeric, so 'False'\n",
    "\n",
    "num = '12345'\n",
    "print(num.isnumeric())    # 'num' string is numeric, so 'True'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zafar Abbas\n",
      "True\n",
      "\n",
      "Is new Line is printable?\n",
      "False\n",
      "\n",
      "Is empty string printable?\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Return True if the string is printable, False otherwise.\n",
    "\n",
    "name = 'Zafar Abbas'\n",
    "print(name)\n",
    "print(name.isprintable())\n",
    "\n",
    "name1 = '\\nIs new Line is printable?'\n",
    "print(name1)\n",
    "print(name1.isprintable())\n",
    "\n",
    "name3 = ''\n",
    "print('\\nIs empty string printable?')\n",
    "print(name3.isprintable())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Return True if the string is a whitespace string, False otherwise.\n",
    "\n",
    "name = '     '\n",
    "print(name.isspace())   # this string has white / blank space, so condtion is 'True'\n",
    "\n",
    "name1 = ''\n",
    "print(name1.isspace())   # this string has no white / blank space, so condtion is 'False'\n",
    "\n",
    "name2 = ' a '\n",
    "print(name2.isspace())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Return True if the string is a title-cased string, False otherwise.\n",
    "\n",
    "name = 'Zafar Abbas'\n",
    "print(name.istitle())\n",
    "\n",
    "name1 = 'Zafar abbas'\n",
    "print(name1.istitle())\n",
    "\n",
    "name2 = 'zafar abbas'\n",
    "print(name2.istitle())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Return True if the string is an uppercase string, False otherwise.\n",
    "\n",
    "name = 'ZAFAR ABBAS'\n",
    "print(name.isupper())  # string 'name' is in upper letters, hence condition returns 'True'\n",
    "\n",
    "name1 = 'Zafar Abbas'\n",
    "print(name1.isupper())  # string 'name1' is not in upper letters, hence condition returns 'False'\n",
    "\n",
    "name2 = 'zafar abbas'\n",
    "print(name2.isupper())  # string 'name1' is not in upper letters, hence condition returns 'False'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zafar, adnan, ismail\n",
      "Java >> Python >> Ruby\n",
      "Morning ... Night ... Evening\n"
     ]
    }
   ],
   "source": [
    "# Concatenate any number of strings.\n",
    "\n",
    "name =  {'zafar', 'adnan', 'ismail'}\n",
    "separator = ', '\n",
    "print(separator.join(name))\n",
    "\n",
    "lang = {'Python', 'Java', 'Ruby'}\n",
    "sep = ' >> '\n",
    "print(sep.join(lang))\n",
    "\n",
    "shift = {'Morning','Evening','Night'}\n",
    "seprate = ' ... '\n",
    "print(seprate.join(shift))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Zafar          '"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The string ljust() method returns a left-justified string of a given minimum width.\n",
    "\n",
    "name = 'Zafar'\n",
    "name.ljust(15)  #it prints string at left side and leaves blank spaces upto 15 characters in total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'          Zafar'"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The string rjust() method returns a right-justified string of a given minimum width.\n",
    "\n",
    "name = 'Zafar'\n",
    "name.rjust(15)  #it prints string at right side and leaves blank spaces upto 15 characters in total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zafar abbas\n",
      "ZAFAR ABBAS\n"
     ]
    }
   ],
   "source": [
    "name = 'zafar abbas'\n",
    "\n",
    "print(name.lower())    # Return a copy of the string converted to lowercase.\n",
    "\n",
    "print(name.upper())    # Return a copy of the string converted to upper-case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     zafar Abbas    *\n",
      "zafar Abbas    *\n",
      "*      zafar Abbas\n",
      "Zafar     Abbas\n",
      "\n",
      "\n",
      "this is good \n",
      "   this is good \n",
      "his is good \n",
      "www.piaic.org/\n"
     ]
    }
   ],
   "source": [
    "name = '     zafar Abbas    *'\n",
    "\n",
    "print(name)\n",
    "\n",
    "print(name.lstrip())    #  Removes whitespace at left side of string.\n",
    "\n",
    "name1 = '*      zafar Abbas       '\n",
    "print(name1.rstrip())    #  Removes whitespace at right side of string.\n",
    "\n",
    "name2 = '   Zafar     Abbas      '\n",
    "print(name2.strip())    #  Removes whitespace from both sides of string but not from between the string.\n",
    "\n",
    "print('\\n')\n",
    "\n",
    "\n",
    "random_string = '   this is good '\n",
    "\n",
    "# Leading whitepsace are removed\n",
    "print(random_string.lstrip())\n",
    "\n",
    "# Argument doesn't contain space\n",
    "# No characters are removed.\n",
    "print(random_string.lstrip('sti'))\n",
    "\n",
    "print(random_string.lstrip('s ti'))\n",
    "\n",
    "website = 'https://www.piaic.org/'\n",
    "print(website.lstrip('https://.'))    # removes the characters in 'arguements' i.e. 'https://.''"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}