Basic Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Terminologies\n",
    "Python is a powerful high-level, object oriented programming language certificated by \"Guido van Rossum\".\n",
    "\n",
    "### 1. Identifier: Identifier is a “name” having some numbers, letters, characters & special characters.\n",
    "\n",
    "### 2. Constant: Constant is an “identifier” whose value cannot be change throughout the execution of a program.\n",
    "i.e \n",
    "    pi = 3.1416,       Total_Nummber = 100\n",
    "    \n",
    "### 3. Variable: Variable is an “identifier” whose value can be change throughout the execution of a program.\n",
    "\n",
    "##### Syntax:\n",
    "\n",
    "#####    name = value\n",
    "i.e\n",
    "    CGPA = 3.46,          num = 5,             name = 'Nasir'\n",
    "    \n",
    "### Variable Rules:\n",
    "\n",
    "    i. Variable name should start with \"alphabets\" or underscore (_).\n",
    "    ii. Except underscore (_), there is no other specoa; symbol are allowed in the middle of variable declaration.\n",
    "    iii. No-Space\" are allowed in variable declaration.\n",
    "    \n",
    "### 4. Escape Character (\\): \n",
    "Escape Sequence are control characters which are used to move cursor and print the given characters. The syntax for Escape sequence is \\t, \\n, For Double Quote \\\"  \\\", For Single Quote \\'  \\'. \n",
    "\n",
    "### 5. Indentation:\n",
    "Python relies on indentation, using whitespace (blankspace) to define scope in the code. Other programming languages often use curly-brackets for this purpose.\n",
    "Indentation often use in if-else statement, for loops, while loop or when you use :, then it use for indentation. \n",
    "\n",
    "### 6. Index: An index represents the position number of an array's elements. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Datatypes \n",
    "Data-Type: Data-type represents the different type of data which is use to store in a variable.\n",
    "\n",
    "There are “two” type of Data-Type, Built-In Datatype and User-Define Datatypes.   \n",
    "### 1. Built-In Datatype \n",
    "    1. Numeric Datatype: It is a type of Built-In Datatype which contain numeric value such as \"Integer\", \"Float\" & \"Complex\" numbers.  \n",
    "    2. Boolean Datatype: It is a type of Built-In Datatype which contain \"True\" & \"False\" values.\n",
    "    3. Sequence Datatype: It allows to store multiple value in well-organized way. There are several type of sequence datatype like \"String\", \"List\", \"Tupel\", \"Set\", \"Map\", \"Dictionary\" & \"Range\".\n",
    "    \n",
    "### 2. User-Define Datatype\n",
    "    1. Array\n",
    "    2. Class\n",
    "    3. Module\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convertion of Datatype\n",
    "There are \"two\" type of converstion in Datatype\n",
    "1. Implicit: In this kind of type, Python automatically convert one datatype into another datatype.\n",
    "2. Explicit: In this kind of type, Programmer can change their datatype according to the requirements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operator\n",
    "Operator is a symbol that is use to perform some specific operations, and there are “seven” types of operator.\n",
    "1. Arithmetic Operator (+, -, *, /, %(Modulus_remainder), ** (Exponent), // (Floor Division_Round-off))\n",
    "2. Comparison Operator (<, >, <=, >=, ==, !=)\n",
    "3. Logical Operator (and (Both Expression Must Be True), or (One Expression Must Be True ), not (Interchange Their Expression))\n",
    "4. Assignment Operator (=, +=, -=, *=, /=, %=, **=, //=)\n",
    "5. Bitwise Operator (Not Commonly Used, &, |, ^, ~, <<, >>)\n",
    "6. Membership Operator (in, not/out in)\n",
    "7. Identity Operator (is (reurn \"True\" if both variables have same objects), is not (reurn \"True\" if both variables have not same objects)) like x is y, x is not y\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numeric Datatype (Integer, Float, Complex)\n",
    "### Integer: An integer is a number which does not contain any decimal-point or fraction-part.\n",
    "\n",
    "### Float: A float is a number which contain decimal-point or fraction-part.\n",
    "\n",
    "### Complex: A complex  is a number which is written in the form of \"a + bj\".\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Integer\n",
    "a = 10\n",
    "type (a)\n",
    "print (\"Type of given number is \", type (a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Float\n",
    "b = 10.5\n",
    "type (b)\n",
    "print (\"Type of given number is \", type (b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Complex\n",
    "complex_number = 5 + 7j\n",
    "type (complex_number )\n",
    "print (\"Type of given number is \", type (complex_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boolean Datatype (True, False Statements)\n",
    "### The Boolen DataType is use to represents the boolean value True (1) or False(0). It is use for condition based program for example, 2 > 1 then say true other wise false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The given statement is  True\n"
     ]
    }
   ],
   "source": [
    "if 2<5:\n",
    "    print(\"The given statement is \", True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter 1st Number:12\n",
      "Enter 2nd Number:12\n",
      "12  is equal 12 , given statement is True\n"
     ]
    }
   ],
   "source": [
    "num1= int(input(\"Enter 1st Number:\"))\n",
    "num2= int(input(\"Enter 2nd Number:\"))\n",
    "if num1==num2:\n",
    "    print (num1,\" is equal\", num2,\", given statement is\",True)\n",
    "else:\n",
    "    print (num1, \"is not equal to \", num2,\", given statement is\",True)\n",
    "    if num1 < num2:\n",
    "        print (num1, \"is less than \", num2)\n",
    "    else:\n",
    "        if num1 > num2:\n",
    "            print (num1, \"is greater than \", num2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sequence Datatype (String, List, Tuple, Set, Map, Range, Dictionary)\n",
    "### 1. String Type \" \" or ' ': String is a collection of characters.\n",
    "\n",
    "### 2. List [ ]: List is a collection of characters which is ordered and changeable.\n",
    "\n",
    "### 3. Tuple (): Tuple look like \"List [ ]\" statement, but it cannot change it's value after the execution. \n",
    "\n",
    "### 4. Set { }: Set is a collection of characters which is unordered and unindexed.\n",
    "\n",
    "### 5. Map {+}: Set is a collection of characters which is used in the form of pair like {\"Name\" : \"Nasir\"}. It look like \"Dictionary {}\"\n",
    "\n",
    "### 6. Dictionary { }: Dictionary is a collection of characters which is unordered but can be changeable and indexed. In Python dictionaries are written with curly brackets, and they have \"keys\" and \"values\".\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. String \" \" or '  '"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  String is a collection of characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string_name= \"Nasir Ali.\"\n",
    "type(string_name)\n",
    "print(\"Your string name is \", string_name, \"The type of your identifier is \", type(string_name))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (string_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#If we want to recall only string index value then we will use [] bracket ad it's cell name\n",
    "#In Python the initial value always begin from 0 to n...th \n",
    "welcome = \"Hello, World!\"\n",
    "print (welcome[0])\n",
    "print (welcome[1])\n",
    "print (welcome[2])\n",
    "print (welcome[3])\n",
    "print (welcome[4])\n",
    "print (welcome[5])\n",
    "print (welcome[6])\n",
    "print (welcome[7])\n",
    "print (welcome[8])\n",
    "print (welcome[9])\n",
    "print (welcome[10])\n",
    "print (welcome[11])\n",
    "print (welcome[12])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for specific length \n",
    "x = \"Say, Hello!\"\n",
    "print (x[0:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (x[5:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also print it in opposite direction \n",
    "print (x[-1])"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "strip () Method: The strip() method is use to removes any whitespace from the beginning and ending point. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#strip () Method\n",
    "y = \"    Hello, World!     \"\n",
    "print (y) \n",
    "print (y.strip())  # return \"Hello, World!\""
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "len() Method: The len() is use to return the length of a string, list, tuple, set, dictionary..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17\n",
      "17\n",
      "The given string length is  17\n"
     ]
    }
   ],
   "source": [
    "#there are two way to find the length of a string \n",
    "z = \"My Name is Nasir.\"\n",
    "outcome = len(z)\n",
    "print (outcome)\n",
    "\n",
    "#here is another way\n",
    "print (len(z))\n",
    "\n",
    "#you can also add string for showing length\n",
    "print (\"The given string length is \", len(z))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "lower() Method: The lower () method is use to return the string in lower case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (z.lower())"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "upper() Method: The upper () method is use to return the string in upper case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (z.upper())"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "replace () Method: The replace() method is use to replace a string with another string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (z.replace(\"N\", \"Y\"))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "split() Method: The split() method is use to seprate the string into peices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['My Name ', ' Nasir.']\n"
     ]
    }
   ],
   "source": [
    "print (z.split(\"is\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['', ' Name is Nasir.']\n"
     ]
    }
   ],
   "source": [
    "print (z.split(\"My\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. List [ ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List is a collection of characters which is 'ordered' and 'changeable'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_list_name = [\"apple\", \"banana\", \"mango\", \"cherry\"]\n",
    "print(fruit_list_name)\n",
    "type(fruit_list_name)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Access Item Values:\n",
    "We can access the list items by referring to the index number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#we can also recall desired list by slecting element as we did in string\n",
    "print (fruit_list_name[0])\n",
    "print (fruit_list_name[1])\n",
    "print (fruit_list_name[2])\n",
    "print (fruit_list_name[3])"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Chnage Item Values:\n",
    "We can change the value of a specific item, refer to the index number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#let's suppose change the second item (banana)\n",
    "fruit_list_name = [\"apple\", \"banana\", \"mango\", \"cherry\"]\n",
    "fruit_list_name[1] = \"blackberry\"\n",
    "print (fruit_list_name)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Loop Through a List\n",
    "By using \"for\" loop, we can loop through the list items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_list_name = [\"apple\", \"banana\", \"mango\", \"cherry\"]\n",
    "for x in fruit_list_name: # x is a variable which can be call in print statement\n",
    "    print (x)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Check If Item Exist:\n",
    "To determine if a specified item is present in a list use the in keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#let's suppose check if \"apple\" is present in the list.\n",
    "fruit_list_name = [\"apple\", \"banana\", \"mango\", \"cherry\"]\n",
    "if \"apple\" in fruit_list_name:\n",
    "    print (\"Yes, 'apple' is in the fruits list\")\n",
    "else:\n",
    "    print (\"No, 'apple' is not in the fruits list\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's take input from the user\n",
    "fruit_list_name = [\"apple\", \"banana\", \"mango\", \"cherry\"]\n",
    "name = str(input(\"Enter the name of fruit:\"))\n",
    "if name in fruit_list_name:\n",
    "    print (\"Yes,\", name, \" is in the fruits list\")\n",
    "else:\n",
    "    print (\"No,\", name, \" is not in the fruits list\")"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "List Length:\n",
    "To determin how many items a list have, use len() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_list_name = [\"apple\", \"banana\", \"mango\", \"cherry\"]\n",
    "print(len(fruit_list_name))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Add Item at the end of List:\n",
    "To add an items to the end of the list, use the append() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_list_name = [\"apple\", \"banana\", \"mango\", \"cherry\"]\n",
    "fruit_list_name.append(\"orrange\")\n",
    "print (fruit_list_name)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Add Item at the specified index in a List:\n",
    "To add an item at eh specified index, use the inser () method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_list_name = [\"apple\", \"banana\", \"mango\", \"cherry\"]\n",
    "fruit_list_name.insert(1, \"orrange\")\n",
    "print (fruit_list_name)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Remove Item:\n",
    "There are several methods to remove items from a list.\n",
    "\n",
    "1. The remove () method removes the specified item.\n",
    "\n",
    "2. The pop () method removes the specified index, (or the last item if index isnot specified)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Using remove () method\n",
    "fruit_list_name = [\"apple\", \"banana\", \"mango\", \"cherry\"]\n",
    "fruit_list_name.remove(\"banana\")\n",
    "print (fruit_list_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Using pop () method\n",
    "fruit_list_name = [\"apple\", \"banana\", \"mango\", \"cherry\"]\n",
    "fruit_list_name.pop()\n",
    "print (fruit_list_name)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Deleteing The List:\n",
    "The del keyword can delete the secified index and it can also delete the list completely."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Delet The Specified Index\n",
    "fruit_list_name = [\"apple\", \"banana\", \"mango\", \"cherry\"]\n",
    "del fruit_list_name[0]\n",
    "print (fruit_list_name)\n",
    "\n",
    "del fruit_list_name[1]\n",
    "print (fruit_list_name)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Delet The Complet List\n",
    "fruit_list_name = [\"apple\", \"banana\", \"mango\", \"cherry\"]\n",
    "number = [\"1\",\"2\", \"3\", \"4\", \"5\", \"6\"]\n",
    "del number\n",
    "print (number)# this will cause an erro because  \"list\" no logner exist.\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Empty List:\n",
    "The clear () method expties the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_list_name = [\"apple\", \"banana\", \"mango\", \"cherry\"]\n",
    "fruit_list_name.clear()\n",
    "print (fruit_list_name)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_list_name = [\"apple\", \"banana\", \"mango\", \"cherry\"]\n",
    "fruit_list_name.reverse()\n",
    "print (fruit_list_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Methods: Python has a set of built-in method that you can use!\n",
    "    append():  Add an element at the end of the list\n",
    "    insert():  Add an element at the specified position\n",
    "    remove():  Remove the specified element\n",
    "    pop():     Remove the at the end of element in list\n",
    "    reverse(): Reverse the the whole List \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Tuple () "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuple look like \"List [ ]\" statement, but it cannot change it's value after the execution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_list_name = (\"apple\", \"banana\", \"mango\", \"cherry\")\n",
    "print(fruit_list_name)\n",
    "type(fruit_list_name)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Access Item Values:\n",
    "We can access the list items by referring to the index number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_list_name = (\"apple\", \"banana\", \"mango\", \"cherry\")\n",
    "print(fruit_list_name[1])\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Changing Item Values:\n",
    "Once a tuple is created, We cannot change the value of tuple because these are unchangeable ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#let's suppose change the second item (banana)\n",
    "fruit_list_name = (\"apple\", \"banana\", \"mango\", \"cherry\")\n",
    "fruit_list_name[1] = \"blackberry\" # the vales will remain the same because, tuples are unchangeable.\n",
    "print (fruit_list_name)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Check If Item Exist:\n",
    "To determine if a specified item is present in a list use the 'in' keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#let's suppose check if \"apple\" is present in the list.\n",
    "fruit_list_name = (\"apple\", \"banana\", \"mango\", \"cherry\")\n",
    "if \"apple\" in fruit_list_name:\n",
    "    print (\"Yes, 'apple' is in the fruits list\")\n",
    "else:\n",
    "    print (\"No, 'apple' is not in the fruits list\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's take input from the user\n",
    "fruit_list_name = (\"apple\", \"banana\", \"mango\", \"cherry\")\n",
    "name = str(input(\"Enter the name of fruit:\"))\n",
    "if name in fruit_list_name:\n",
    "    print (\"Yes,\", name, \" is in the fruits list\")\n",
    "else:\n",
    "    print (\"No,\", name, \" is not in the fruits list\")"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "List Length:\n",
    "To determin how many items a list have, use len() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_list_name = (\"apple\", \"banana\", \"mango\", \"cherry\")\n",
    "print(len(fruit_list_name))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Add Items:\n",
    "Once a tuple is created, we cannot add items to it because tuples are unchangeable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-e3a1a6bcb8e5>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mfruit_list_name\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m\"apple\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"banana\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"mango\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"cherry\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mfruit_list_name\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"orrange\"\u001b[0m\u001b[1;33m)\u001b[0m   \u001b[1;31m# it will generate an error because tuple are unchageable\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mfruit_list_name\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "fruit_list_name = (\"apple\", \"banana\", \"mango\", \"cherry\")\n",
    "fruit_list_name.append(\"orrange\")   # it will generate an error because tuple are unchageable\n",
    "print (fruit_list_name)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Remove Item:\n",
    "There are several methods to remove items from a list.\n",
    "1. The remove () method removes the specified item.\n",
    "2. The pop () method removes the specified index, (or the last item if index isnot specified)\n",
    "But, we cannot remove anything from tuple because tuples are unchangeable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Methods: Python has a set of built-in method that you can use!\n",
    "    index(): searches the tuple for a specified value and returns the position of where it was found.\n",
    "    count(): returns the numbers of times a specifeid value occurs in a tuple.\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4.Sets { }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set is a collection of characters which is 'unordered' and 'unindexed'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Mudessir', 'Ansar', 'Ali-Adil'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "freinds_list_names = {\"Mudessir\", \"Ansar\", \"Ali-Adil\"}\n",
    "print (freinds_list_names)  # you will see unordered output\n",
    "type (freinds_list_names)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Access Item Values:\n",
    "We cannot access the items in a set by referring to an index, since sets are unordered that has no index.\n",
    "But we can loop through the set items using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'set' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-7-382e025515a8>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m#we can also recall desired list by slecting element as we did in string\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mfreinds_list_names\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# we cannot access by reffering element because set are unorder\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'set' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "#we can also recall desired list by slecting element as we did in string\n",
    "print (freinds_list_names[1]) # we cannot access by reffering element because set are unorder"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Loop through the set and print the values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "freinds_list_names = {\"Mudessir\", \"Ansar\", \"Ali-Adil\"}\n",
    "for x in freinds_list_names:\n",
    "    print (x)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Chnage Items:\n",
    "Once a set is created, we cannot change its items, but we can add new items."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Add Items:\n",
    "To add one item to a set, use the add() method.\n",
    "To add more than one item to a set use update() method. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "freinds_list_names = {\"Mudessir\", \"Ansar\", \"Ali-Adil\"}\n",
    "freinds_list_names.add(\"Hamza\")\n",
    "print (freinds_list_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "freinds_list_names = {\"Mudessir\", \"Ansar\", \"Ali-Adil\"}\n",
    "freinds_list_names.update([\"Nasir\", \"Yasir\", \"Adil\"])\n",
    "print (freinds_list_names)\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Get the Length of a Set:\n",
    "To determmin how many iterms a set have, use the len() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len (freinds_list_names)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Remove Item:\n",
    "To remove an item in a set, use the remove(), or the disard() method.\n",
    "pop () also work to remove set elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove \"Nasir\" by using remove() method.\n",
    "freinds_list_name = {\"Mudessir\", \"Ansar\", \"Ali-Adil\"}\n",
    "freinds_list_name.remove(\"Mudessir\")\n",
    "print (freinds_list_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also use discard ()\n",
    "freinds_list_name.discard(\"Ali-Adil\")\n",
    "print (freinds_list_name)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Clear Items:\n",
    "To clear the items in set use clear () method\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "freinds_list_names = {\"Mudessir\", \"Ansar\", \"Ali-Adil\"}\n",
    "freinds_list_names.clear()\n",
    "print (freinds_list_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Methods: Python has a set of built-in method that you can use!\n",
    "\n",
    "    add():     Add one item to a set.\n",
    "    update():  Add more than one item to a set.\n",
    "    remove():  Remove the specified element\n",
    "    clear():   Remove all elements from a set.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Dictionaries { }\n",
    "#### A dictionary is a collection characters which is unorded but can be changeable and indexed. In Python dictionaries are written with curly, and they have \"keys\" and \"values\". "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "car_dict = {\n",
    "    \"Brand\":\"Honda\",\n",
    "    \"Model\":\"City\",\n",
    "    \"Year\":\"2020\"    \n",
    "}\n",
    "print (car_dict)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Accessessing Items:\n",
    "We can access the items of a dictionary by referring to its \"key_name\", inside a squeare bracket."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "car_dict[\"Model\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#we can also make a variable to show a dictionary\n",
    "x = car_dict [\"Year\"]\n",
    "print (x)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Change Value:\n",
    "We can change the value of a specific item by referring to it's key name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Chnage the \"year\" to 2021\n",
    "car_dict = {\n",
    "    \"Brand\":\"Honda\",\n",
    "    \"Model\":\"City\",\n",
    "    \"Year\":\"2020\"    \n",
    "}\n",
    "car_dict [\"Year\"] = 2021\n",
    "print (car_dict)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Loop Through Dictionary:\n",
    "We can loop through a dictionary by using a for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Adil': 1990, 'Yasir': 1993, 'Nasir': 1995, 'Murtaza': 1997, 'Qaiser': 2000}\n"
     ]
    }
   ],
   "source": [
    "name_dict = {\n",
    "        \"Adil\": 1990,\n",
    "        \"Yasir\": 1993,\n",
    "        \"Nasir\": 1995,\n",
    "        \"Murtaza\": 1997,\n",
    "        \"Qaiser\": 2000\n",
    "}\n",
    "print (name_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adil\n",
      "Yasir\n",
      "Nasir\n",
      "Murtaza\n",
      "Qaiser\n"
     ]
    }
   ],
   "source": [
    "# print all value in the dicionary, one by one\n",
    "for x in name_dict:\n",
    "    print (x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Important: Loop thourgh both keys and values, by using item() fuction:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adil : 1990\n",
      "Yasir : 1993\n",
      "Nasir : 1995\n",
      "Murtaza : 1997\n",
      "Qaiser : 2000\n"
     ]
    }
   ],
   "source": [
    "for x,y in name_dict.items():\n",
    "    print (x,y)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Check \"If\" key exsit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "car_dict = {\n",
    "    \"Brand\":\"Honda\",\n",
    "    \"Model\":\"City\",\n",
    "    \"Year\":\"2020\"    \n",
    "}\n",
    "print (car_dict)\n",
    "if \"Brand\" in car_dict:\n",
    "    print (\"Yes, 'Brand' is one of the keys in the car dictionary\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#By using input method get to know if the item exit\n",
    "car_dict = {\n",
    "    \"Brand\":\"Honda\",\n",
    "    \"Model\":\"City\",\n",
    "    \"Year\":\"2020\"    \n",
    "}\n",
    "print (car_dict)\n",
    "name = str(input(\"Searching Name:\"))\n",
    "    \n",
    "if name in car_dict:\n",
    "    print (\"Yes,\",name,\"is one of the keys in the car dictionary\")\n",
    "else:\n",
    "    print (\"No,\",name,\"is not keys in the car dictionary\")"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Dictionary Length:\n",
    "To determin how many items (key-value pars) a dictionary have, use the len() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print he number of item in the dictionary\n",
    "print (len(car_dict))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Adding Items:\n",
    "    Adding an item to the dictionary is done by using assigning a value to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#By using input method get to know if the item exit\n",
    "car_dict = {\n",
    "    \"Brand\":\"Honda\",\n",
    "    \"Model\":\"City\",\n",
    "    \"Year\":\"2020\"    \n",
    "}\n",
    "car_dict[\"Colors\"] = \"Black\"\n",
    "print (car_dict)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Remove Item:\n",
    "There are several methods to remove items from a list.\n",
    "\n",
    "pop() Method:The pop() method removes the specified index, (or the last item if index isnot specified)\n",
    "\n",
    "del Method: The del method is use to delete the dictionary.\n",
    "\n",
    "clear () Method: The clear() method is use clrear the whole index in dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pop () method\n",
    "car_dict = {\n",
    "    \"Brand\":\"Honda\",\n",
    "    \"Model\":\"City\",\n",
    "    \"Year\":\"2020\" ,\n",
    "    \"Color\": \"Black\"\n",
    "}\n",
    "print (car_dict)\n",
    "print (\"After removing item in the given dictinoary.\")\n",
    "car_dict.pop(\"Color\")\n",
    "print (car_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#del method\n",
    "car_dict = {\n",
    "    \"Brand\":\"Honda\",\n",
    "    \"Model\":\"City\",\n",
    "    \"Year\":\"2020\" ,\n",
    "    \"Color\": \"Black\"\n",
    "}\n",
    "del car_dict\n",
    "print (car_dict)   # this will cause an error because \"car_dict\" no longer exist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#del method\n",
    "car_dict = {\n",
    "    \"Brand\":\"Honda\",\n",
    "    \"Model\":\"City\",\n",
    "    \"Year\":\"2020\" ,\n",
    "    \"Color\": \"Black\"\n",
    "}\n",
    "car_dict.clear()\n",
    "print (\"Your dicationary items has been clear.\",car_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Methods: Python has a set of built-in method that you can use!\n",
    "\n",
    "    Add Dictionaty: dict_var_name [\"type_name\"] = \"information\":  Add an element at the end of the diciationay\n",
    "    pop(): Remove the at the end of element in dictionary\n",
    "    del: Delete the complete dicationry(no longer exist)\n",
    "    clear(): Removes all the elements from the dictionary "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conditional Statements\n",
    "## 1. if-else statement\n",
    "## 2. if-elif statement\n",
    "## 2. Nested if-else statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. if-else statement:\n",
    "#### if-statement is used for decision-making operations. \n",
    "#### It is used to execute an instruction only if a condtion is Ture. If the condition is false, then the optional else statement runs which contains some code for the else condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter 1st Number:10\n",
      "Enter 2nd Number:12\n",
      "10 is less than 12\n"
     ]
    }
   ],
   "source": [
    "num1 = int(input(\"Enter 1st Number:\"))\n",
    "num2 = int(input(\"Enter 2nd Number:\"))\n",
    "if num1 < num2:                  #remember: 1st number should be less than 2nd number\n",
    "    print (num1, \"is less than\", num2)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "if-else statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter 1st Number:10\n",
      "Enter 2nd Number:12\n",
      "10 is less than 12\n"
     ]
    }
   ],
   "source": [
    "num1 = int(input(\"Enter 1st Number:\"))\n",
    "num2 = int(input(\"Enter 2nd Number:\"))\n",
    "if num1 < num2:                 \n",
    "    print (num1, \"is less than\", num2)\n",
    "else:\n",
    "    print (num1, \"is greater than\", num2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. if-elif statement: if...elif statement is used to show a multi-way decision based on several conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter 1st Number:10\n",
      "Enter 2nd Number:12\n",
      "10 is less than 12\n"
     ]
    }
   ],
   "source": [
    "num1 = int(input(\"Enter 1st Number:\"))\n",
    "num2 = int(input(\"Enter 2nd Number:\"))\n",
    "if num1 < num2:                 \n",
    "    print (num1, \"is less than\", num2)\n",
    "elif num1 > num2: \n",
    "    print (num1, \"is greater than\", num2)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "elif-else statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter 1st Number:15\n",
      "Enter 2nd Number:15\n",
      "15 is equal to  15\n"
     ]
    }
   ],
   "source": [
    "num1 = int(input(\"Enter 1st Number:\"))\n",
    "num2 = int(input(\"Enter 2nd Number:\"))\n",
    "if num1 < num2:                 \n",
    "    print (num1, \"is less than\", num2)\n",
    "elif num1 > num2: \n",
    "    print (num1, \"is greater than\", num2)\n",
    "else:\n",
    "    print (num1,\"is equal to \", num2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Nested if-else & if-elif: Inside a loop in if-elif & if-elif, there is another loop called Nested loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1= int(input(\"Enter 1st Number:\"))\n",
    "num2= int(input(\"Enter 2nd Number:\"))\n",
    "if num1==num2:\n",
    "    print (num1,\" is equal\", num2,\", given statement is\",True)\n",
    "else:\n",
    "    print (num1, \"is not equal to \", num2,\", given statement is\",True)\n",
    "    if num1 < num2:\n",
    "        print (num1, \"is less than \", num2)\n",
    "    else:\n",
    "        if num1 > num2:\n",
    "            print (num1, \"is greater than \", num2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loop Statements\n",
    "#### Python has two primitive loop commands\n",
    "## 1. While\n",
    "## 2. For \n",
    "\n",
    "### Nested Loop: Inside a loop there is another loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# While Loop:\n",
    "\n",
    "### While Loop Without Else Statement\n",
    "#### A while loop is used to  can execute a set of statements as long as a condition is true. \n",
    "\n",
    "#### Syntax:Before \"while\" loop, we must need to add a conditional variable\n",
    "            i = 0        or       i = 1\n",
    "            while (condition):\n",
    "              statement(using 'print' command)\n",
    "            \n",
    "\n",
    "### While Loop With Else Statement\n",
    "#### In While loop, if the condition is True, it executes the Statement-1, if the condition is False (which may be the first time it is tested) the Statement*2, of the else clause is executed and the loop terminated. The else suite will be always executed irrespective of the statement in the loop are executed or not.\n",
    "#### Syntax: Before \"while\" loop, we must need to add a conditional variable\n",
    "            i = 0        or       i = 1\n",
    "            while (condition):\n",
    "               Statement-1 (using 'print' command)\n",
    "            else:\n",
    "               Statement-2 (using 'print' command)\n",
    "\n",
    "\n",
    "            \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While Loop Without Else Statement\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "#check if the condition like 1 less than 4\n",
    "\n",
    "i=1\n",
    "while i<4: # it check the condition like 1 less than 4\n",
    "    print (i)\n",
    "    i += 1     # i = i+1, increment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While Loop With Else Statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "while condition is false so else part executed.\n"
     ]
    }
   ],
   "source": [
    "#check if the condition like 1 less than 4\n",
    "\n",
    "i = 1\n",
    "while i<4: \n",
    "    print(i)\n",
    "    i += 1    # b = b + 2, increment\n",
    "\n",
    "else:\n",
    "    print(\"while condition is false so else part executed.\")"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The Break Statement:\n",
    "With the help of break-statement, we can stop the loop even the while condition is true.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "#exit the while loop when i is 3\n",
    "i=1\n",
    "while (i<6):\n",
    "    print (i)\n",
    "    if i ==3 :\n",
    "        break\n",
    "    i += 1\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The Continue Statement:\n",
    "With the help of continue-statement, we can stop the 'current-iteration', and continue with the next statement.\n",
    "\n",
    "The continue statement will be within the block of code under the loop statement, usally after a conditional if-statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "#continue to the next iteratino if it is 3:\n",
    "i=0\n",
    "while (i<6):\n",
    "    i += 1    # i = i+1\n",
    "    if i == 3:     # it will not consider the digit 3 because i have mentioned another condition in a while-loop\n",
    "        continue\n",
    "    print (i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# For Loop\n",
    "\n",
    "### For Loop Without Else Statement\n",
    "####  A for loop is used for iteration over a sequence (that is either a list, a tuple, a dictionary, a set or a string)\n",
    "\n",
    "#### With the for loop we can execute a set of statement, once for each item in list, tuple, set etc....\n",
    "#### Syntax:The 'for' loop does not require an indexing variable to set beforehand.\n",
    "\n",
    "    far var in sequence:\n",
    "             statements\n",
    "            \n",
    "     'far' & 'in' cannot be changed, other 2 can be \n",
    "\n",
    "### For  Loop With Else Statement\n",
    "#### A for loop is used for iteration over a sequence (that is either a list, a tuple, a dictionary, a set or a string)\n",
    "#### The else suite will  be always executed irrespective of the statement in the loop are executed or not.  \n",
    "\n",
    "#### Syntax:The 'for' loop does not require an indexing variable to set beforehand.\n",
    "\n",
    "    far var in sequence:\n",
    "             statements\n",
    "     else:\n",
    "            statements\n",
    "     'far' & 'in' cannot be changed, other 2 can be             \n",
    "\n",
    "### Nested For-Loop\n",
    "#### Syntax:The 'for' loop does not require an indexing variable to set beforehand.\n",
    "    for i in range(n):\n",
    "        for j in range(y):\n",
    "                statements\n",
    "        statements\n",
    "\n",
    "        or\n",
    "\n",
    "    for i in range(n):\n",
    "        statements\n",
    "        for j in range(y):\n",
    "            statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For Loop Without Else Statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cherry\n",
      "banana\n",
      "apple\n"
     ]
    }
   ],
   "source": [
    "#How to assigne string with range function by using for_loop\n",
    "# print each fruit in a fruit list:\n",
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for x in fruits:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N\n",
      "a\n",
      "s\n",
      "i\n",
      "r\n"
     ]
    }
   ],
   "source": [
    "#How to assigne string with range function by using for_loop\n",
    "string = \"Nasir\"\n",
    "for character in string:          #chracter is a variable, we cal also choose any single letter exept of using word\n",
    "    print(character)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String Length: 5\n",
      "0 = N\n",
      "1 = a\n",
      "2 = s\n",
      "3 = i\n",
      "4 = r\n"
     ]
    }
   ],
   "source": [
    "# How to assigne string with range function by using for_loop\n",
    "string = \"Nasir\"\n",
    "length_of_string = len(string)\n",
    "print(\"String Length:\", length_of_string)\n",
    "for i in range(length_of_string):\n",
    "    print(i, \"=\", string[i])\n",
    "                                \n",
    "            #later "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The Break Statement:\n",
    "With the help of break-statement, we can stop the loop even the while condition is true.\n",
    "\n",
    "In Python, the break-statement with provides an opportunity to exit from loop when an eternal condition is reaced. \n",
    "\n",
    "1. We can put 'break-statement' with in the loop.\n",
    "2. Generally, 'break-statement'in apply just after 'if' statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n"
     ]
    }
   ],
   "source": [
    "# exit the loop when x is \"banana\"\n",
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for x in fruits:\n",
    "    print(x)\n",
    "    if x == \"banana\":\n",
    "        break\n",
    "# it will exit the loop, when x is \"banana\", but this time the break comes before the print"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Range Function\n",
    "#### The loop through a set of code a specified number of times, we can use the range () function. \n",
    "#### The range() function returns a sequence of numbers, starting from 0(by default), and ends at a specified number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "#Using the range() function:\n",
    "for x in range (6):\n",
    "    print (x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that range (6) is not the values of 0 to 6, but values 0 to 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# the same thing we can also perform with while-loop\n",
    "i=0\n",
    "while i<6: # it check the condition like 1 less than 4\n",
    "    print (i)\n",
    "    i += 1     # i = i+1, increment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hence, we observed that in while-loop we must need to define a variable but in for-loop we do not need to add a variable........."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The range() function defaults start to 0 as a string value, however it is possible to specify the starting value by adding a parameter in range like range(2,6), which means value will start from 2 to 6 (but not including 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "#starting from 2 using range() function, remmber range() function will take 0 by defalt in starting point \n",
    "for x in range(2,6):\n",
    "    print (x)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The range() function defaults to increment the sequence by 1, however it is possible to specify the increment value by adding a third parament like range(3, 27, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "6\n",
      "9\n",
      "12\n",
      "15\n",
      "18\n",
      "21\n",
      "24\n",
      "27\n"
     ]
    }
   ],
   "source": [
    "#Increment the sequence with 3 (default is 3)\n",
    "for x in range(3, 30, 3):\n",
    "    print (x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number is  1\n",
      "Number is  2\n",
      "Number is  3\n",
      "Out of the loop\n"
     ]
    }
   ],
   "source": [
    "number =0\n",
    "for number in range(6):\n",
    "    number = number +1\n",
    "    if number == 4:\n",
    "        break \n",
    "    print (\"Number is \", number)\n",
    "print (\"Out of the loop\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For Loop With Else Statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "Finally Finish\n"
     ]
    }
   ],
   "source": [
    "#Using the range() function:\n",
    "for x in range (1,4):\n",
    "    print (x)\n",
    "else:\n",
    "    print (\"Finally Finish\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested For Loop\n",
    "#### A nested loop means inside a loop there is another loop.\n",
    "#### The \"inner loop\" will be executed one time for each iteration of the ''outer loop''."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outer Loop, 1\n",
      "Inner Loop 1\n",
      "Inner Loop 2\n",
      "Outer Loop, 2\n",
      "Inner Loop 1\n",
      "Inner Loop 2\n",
      "Rest of the Code.\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 3):\n",
    "    print(\"Outer Loop,\", i)\n",
    "    for j in range(1, 3):\n",
    "        print(\"Inner Loop\", j)\n",
    "print(\"Rest of the Code.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Red Apple\n",
      "Red Cheery\n",
      "Red Strabery\n",
      "Big Apple\n",
      "Big Cheery\n",
      "Big Strabery\n",
      "Tasty Apple\n",
      "Tasty Cheery\n",
      "Tasty Strabery\n"
     ]
    }
   ],
   "source": [
    "#Print adjecent for for every fruit name:\n",
    "adj = [\"Red\", \"Big\", \"Tasty\"]\n",
    "fruit_names = [\"Apple\", \"Cheery\", \"Strabery\"]\n",
    "\n",
    "for x in adj:\n",
    "    for y in fruit_names:\n",
    "        print (x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "#### A 'function' is a block of a code which only runs when it calls.\n",
    "Function help to reduce the line of code and break into small code section, basically Function use for program and code in organsed and manageable. \n",
    "#### We can pass the data, known as parameters, into a function.\n",
    "### Types of Fucntion \n",
    "    There are two type of function\n",
    "        1. Buitl-in Function\n",
    "        2. User-defined Function \n",
    "\n",
    "### Built-in Function(68)\n",
    "    Built-in function built in within the Python also they are called Pre-defined function. For example: print(), len(), index(), range(), etc\n",
    "    \n",
    "### User-define Function\n",
    "    User define function is made by user as there requirement"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Creating A Function:\n",
    "In Python a function is defined using 'def' keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function():\n",
    "    print (\"Hello! From a Function...\")    #we will not get any output because we have'nt mentioned calling function"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Calling A Function:\n",
    "To call a function, use the function name followed by parathensis brackets.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello! From a Function...\n"
     ]
    }
   ],
   "source": [
    "my_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# how to define a simple string function \n",
    "def string_function():\n",
    "    print (\"Python is a very simple and esiest language!\")\n",
    "string_function()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Parameters or Aruguments\n",
    "Information can also be passed to functions as a parameters.\n",
    "Parameters are specified after the function's name, inside the parenthesis. We can add as many parameters as we want, just seperate them with a comma.\n",
    "\n",
    "def function_name(parament/argument)\n",
    "\"This function is in argument\"\n",
    "print (\"Helo,\" +name+ \" Welcome to Python\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nasir Ali\n",
      "Yasir Ali\n",
      "Qasir Ali\n"
     ]
    }
   ],
   "source": [
    "# The following example has a function with one paramet (f_name), when the function is called, we can pass along a first-name, which is used inside the function to print the full-name...\n",
    "def my_function(f_name):\n",
    "    print (f_name + \"Ali\")    # 'Ali' will work as a parameter\n",
    "my_function (\"Nasir \")\n",
    "my_function (\"Yasir \")\n",
    "my_function (\"Qasir \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Helo,Nasir Welcome to Python\n"
     ]
    }
   ],
   "source": [
    "def my_function(name):\n",
    "    print (\"Helo,\" + name +\" Welcome to Python\")\n",
    "my_function('Nasir')"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Default Parameter Value:\n",
    "It will call the function without parameter, it uses the default values:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am from Norway\n",
      "I am from Sweden\n",
      "I am from Turkey\n",
      "I am from Pakistan\n"
     ]
    }
   ],
   "source": [
    "#The following example shows how to use a default parameter value:\n",
    "def my_function (country = \"Pakistan\"):\n",
    "    print (\"I am from \" + country )\n",
    "\n",
    "my_function(\"Norway\")\n",
    "my_function(\"Sweden\")\n",
    "my_function(\"Turkey\")\n",
    "my_function()    # here it will work as default parameter\n",
    "\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Return Statement:\n",
    "The return statement is used to exit a function and go back to the place from where it was called/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "def my_function (x):\n",
    "    return 5 * x              # Table of 5 \n",
    "print (my_function(1))\n",
    "print (my_function(2))\n",
    "print (my_function(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Array\n",
    "#### Note: Python does not have built-in support for Array, but Python list can be use instead.\n",
    "### Array are used to store the multiple values in one single variable.\n",
    "\n",
    "### or\n",
    "\n",
    "### Array is a special variable, which can hold more than one value at a time. \n",
    "    Group of students, Group of Employees, Group of Cats are the example of an Array.\n",
    "    Group of Intgers, Group of Floats, Group of strings.\n",
    "    Datatype will be same in Array, otherwise it will gives an error. \n",
    "\n",
    "### Some Important Point:\n",
    "#### 1. Array can store only one type of data.\n",
    "#### 2. The size of array is not fixed, it can increase or decrease their size dynamically.\n",
    "#### 3. Array and List are not same like in Array we cannot store the different type of data but in List we can store the different type of data.   Another reason is that, Array uses less memory than List.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Why We Need An Array?\n",
    "Lists and arrays both are used in Python to store data(any data type- strings, integers etc), both can be indexed and iterated also. ... If you want to store a large amount of data, then you should consider arrays because they can store data very compactly and efficiently.\n",
    "\n",
    "    For example: if someone want to store roll number of students, you need to print their roll number one-by-one but by using print () fucntion but what if the there are thousand of student, at that time we will use an Array, we can perform the same result just through small number of instructions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Types of Array\n",
    "###    There are two type of an Array\n",
    "####    1. One-Dimentional Array/One D-Array\n",
    "        Single Row Multiple Columns like [1,2,3,4,5]\n",
    "####    2. Multi-Dimentional Array/Multi D-Array\n",
    "        Multiple Row Multiple Columns like \n",
    "            Student1 Marks[40,60,80,100,120]\n",
    "            Student2 Marks[60,80,100,120,140]\n",
    "        \n",
    "####    Note: Python does not support Multi-Dimentional Array but we can create Multi-D Array using third party packages like 'Numpy'."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Create an Array containing car names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "car_names = [\"Honda\", \"Chrola\", \"Suzuki\", \"Mistbushi\", \"Audi\"]"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "If we have a list of items (a list of car names, for example) storing the cars in single variable can look like this:\n",
    "\n",
    "        car1 = \"Honda\";\n",
    "        car2 = \"Chrola\";\n",
    "        car3  = \"Suzuki\";\n",
    "However, what if we want to loop through the cars and find a specific one?\n",
    "And what if we had not 3 cars, but 300 or 3000?\n",
    "Then we will use an Array that can hold more than one item at a same time ad you can get an access the values by referring to an 'index' number. "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Access the elements of an Array\n",
    "We refer to an Array's elements by referring to the 'index' number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Honda\n",
      "Chrola\n",
      "Suzuki\n",
      "Mistbushi\n",
      "Audi\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print (car_names[0])\n",
    "\n",
    "print (car_names[1])\n",
    "\n",
    "print (car_names[2])\n",
    "\n",
    "print (car_names[3])\n",
    "\n",
    "print (car_names[4])"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Looping Array Elements\n",
    "We can use the for-loop to through the elements of an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Honda\n",
      "Chrola\n",
      "Suzuki\n",
      "Mistbushi\n",
      "Audi\n"
     ]
    }
   ],
   "source": [
    "#print each itmes in the car array\n",
    "for x in car_names:\n",
    "    print (x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "stu1_roll= 1\n",
    "stu2_roll= 2\n",
    "stu3_roll= 3\n",
    "stu4_roll= 4\n",
    "stu5_roll= 5          \n",
    "\n",
    "print (stu1_roll)\n",
    "print (stu2_roll)\n",
    "print (stu3_roll)\n",
    "print (stu4_roll)      \n",
    "print (stu5_roll)      # What if these student become thousand, at that time we will use an Array \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'array' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-33-aa91c621d5ba>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;31m#\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mstu_roll\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'i'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\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      6\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mstu_roll\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'array' is not defined"
     ]
    }
   ],
   "source": [
    "stu_roll = [1,2,3,4,5]\n",
    "print (stu_roll)\n",
    "#\n",
    "\n",
    "stu_roll = array('i',[1,2,3,4,5])\n",
    "for x in stu_roll:\n",
    "    print(x)\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Removing Array\n",
    "We can use the pop() method to remove an element from the Array.\n",
    "\n",
    "we can also remove a specified element by using remove () method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Chrola', 'Suzuki', 'Mistbushi', 'Audi']\n"
     ]
    }
   ],
   "source": [
    "#pop() method\n",
    "car_names = [\"Honda\", \"Chrola\", \"Suzuki\", \"Mistbushi\", \"Audi\"]\n",
    "car_names.pop(0)\n",
    "print (car_names)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Chrola', 'Suzuki', 'Mistbushi', 'Audi']\n"
     ]
    }
   ],
   "source": [
    "#remove() method\n",
    "car_names = [\"Honda\", \"Chrola\", \"Suzuki\", \"Mistbushi\", \"Audi\"]\n",
    "car_names.remove(\"Honda\")\n",
    "print (car_names)  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Chrola', 'Suzuki', 'Mistbushi', 'Audi', 'Marzadies']\n"
     ]
    }
   ],
   "source": [
    "#append() method\n",
    "car_names.append(\"Marzadies\")\n",
    "print (car_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. One Dimentional Array\n",
    "         Single Row, Multi Columns\n",
    "\n",
    "## Creating & Initializing One-D Array\n",
    "\n",
    "#### Note: We must initialize a 'Array Module# in Pychon, because Pythone does not initialize array without import Array Module!!!\n",
    "\n",
    "### Import Array Module(Set of code that you can use in Python): \n",
    "    If we want to use an Array in Pythone then we need to import Array Module.\n",
    "    \n",
    "    There are two way to import array module:-\n",
    "        import array - This will import the entire array module.\n",
    "        \n",
    "        from array import - This will import all class, objects, variable, etc from array module. \n",
    "        Here * mean All\n",
    "\n",
    "### Syntax:\n",
    "    1.Method-1\n",
    "     import array\n",
    "     array_name = array. array('type_code',[elements])      \n",
    "     # Array before . is a Module Name & Array after . is a Class Name\n",
    "     # array_name = Object of Array Class\n",
    "     \n",
    "    2. Mehod-2\n",
    "     from array import*\n",
    "     array_name = array('type_code',[elements])      \n",
    "     # in this method you won't need to use module name in this method\n",
    "     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to take input from an Array in One-D\n",
    "### By Creating Empty One-D Array\n",
    "       We can take input from One-D Array from user\n",
    "       \n",
    "### Syntax:\n",
    "     from array import*\n",
    "     array_name = array ('type_code',[])    \n",
    "     \n",
    "     # Type Code: There are number of type of type_code which is use to initialize as integer or float in Array \n",
    "     'i' type_code use for integer in an array\n",
    "     'f' type_code use for float in an array\n",
    " \n",
    "### Index: An index represents the position number of an array's elements.  \n",
    "    Python interpreter allocatred number of block of memory and stores the elements. \n",
    "    Index alway start with 0. \n",
    "     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing One-D Array Elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For indsex elements\n",
      "50\n",
      "51\n",
      "52\n",
      "53\n",
      "54\n",
      " \n",
      "array('i', [50, 51, 52, 53, 54])\n"
     ]
    }
   ],
   "source": [
    "# Create An Array Example#1 using method 1\n",
    "import array\n",
    "stu_roll = array.array ('i', [50,51,52,53,54])\n",
    "\n",
    "print (\"For indsex elements\")    # for index elements\n",
    "print (stu_roll[0])\n",
    "print (stu_roll[1])\n",
    "print (stu_roll[2])\n",
    "print (stu_roll[3])\n",
    "print (stu_roll[4])\n",
    "\n",
    "#We can also refer our array from 'import array' or we can change our module-name\n",
    "print (\" \")\n",
    "import array as ar\n",
    "stu_roll = ar.array ('i', [50,51,52,53,54])\n",
    "print (stu_roll)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array('i', [50, 51, 52, 53, 54])\n",
      "For indsex elements\n",
      "50\n",
      "51\n",
      "52\n",
      "53\n",
      "54\n"
     ]
    }
   ],
   "source": [
    "# Create An Array Example#1 using method 2\n",
    "from array import*\n",
    "stu_roll = array('i', [50,51,52,53,54])\n",
    "print (stu_roll) # it will give complete array\n",
    "\n",
    "print (\"For indsex elements\")    # for index elements\n",
    "print (stu_roll[0])\n",
    "print (stu_roll[1])\n",
    "print (stu_roll[2])\n",
    "print (stu_roll[3])\n",
    "print (stu_roll[4])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing Array using for-loop\n",
    "\n",
    "    from array import*\n",
    "    stu_roll = array ('i', [50,51,52,53,54]\n",
    "\n",
    "\n",
    "    Without Index:                      With Index:\n",
    "     for i in stu_roll:                  n = len(stu_roll)\n",
    "         print(i)                        for i in range(n):    \n",
    "                                           print (stu_roll[i])\n",
    "\n",
    "                                      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "51\n",
      "52\n",
      "53\n",
      "54\n"
     ]
    }
   ],
   "source": [
    "#Creating array by using for-loop or while loop but at the moment we are going to use for-loop\n",
    "from array import*\n",
    "stu_roll = array('i', [50,51,52,53,54])\n",
    "for i in stu_roll:                   # what if we take thousand of student's roll-number, on that stage we will use for=loop\n",
    "    print(i)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of an Array: 5\n",
      "index 0 = 50\n",
      "index 1 = 51\n",
      "index 2 = 52\n",
      "index 3 = 53\n",
      "index 4 = 54\n"
     ]
    }
   ],
   "source": [
    "# Some thime this method wont work when we want to call our index number\n",
    "from array import*\n",
    "stu_roll = array('i', [50,51,52,53,54])\n",
    "\n",
    "# if we want to print index number then we need to find lenght of array by using len() method.\n",
    "\n",
    "n = len(stu_roll)  \n",
    "print (\"Length of an Array:\",n)\n",
    "# elements position starts from 0 and we can get these number fro range() function\n",
    "for i in range(n):\n",
    "    print(\"index\", i, \"=\", stu_roll[i])\n",
    "    \n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "How to take input from an Array:\n",
    "    Before taking input from an Array using for-loop and while-loop\n",
    "        1. How to make empty array\n",
    "        2. how's input function work\n",
    "        3. how's range function work\n",
    "        4. how's len() method work\n",
    "        6. how'sappend method work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of Element: 3\n",
      "Enter Element: 15\n",
      "Enter Element: 20\n",
      "Enter Element: 25\n",
      "15\n",
      "20\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "# Getting input from user using for loop\n",
    "from array import*\n",
    "stu_roll = array('i', [])\n",
    "n = int(input(\"Enter Number of Element: \"))\n",
    "\n",
    "# give index to given number of element, we will use \n",
    "for i in range(n):\n",
    "    stu_roll.append(int(input(\"Enter Element: \")))\n",
    "\n",
    "# for print we need to use another for-loop\n",
    "for i in range(len(stu_roll)):\n",
    "    print(stu_roll[i])\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number of Element: 2\n",
      "Enter Element:112\n",
      "Enter Element:123\n",
      "112\n",
      "123\n"
     ]
    }
   ],
   "source": [
    "# Getting input from user using while-loop\n",
    "from array import*\n",
    "stu_roll = array('i', [])\n",
    "n = int(input(\"Enter Number of Element: \"))\n",
    "\n",
    "i=0\n",
    "j=0\n",
    "while i<n:\n",
    "    stu_roll.append(int(input(\"Enter Element:\")))\n",
    "    i+=1\n",
    "    \n",
    "while (j<len(stu_roll)):\n",
    "    print (stu_roll[j])\n",
    "    j+=1\n",
    "\n",
    "# give index to given number of element, we will use \n",
    "for i in range(n):\n",
    "    stu_roll.append(int(input(\"Enter Element: \")))\n",
    "\n",
    "# for print we need to use another for-loop\n",
    "for i in range(len(stu_roll)):\n",
    "    print(stu_roll[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "51\n",
      "52\n",
      "53\n",
      "54\n",
      "Array After Append:\n",
      "50\n",
      "51\n",
      "52\n",
      "53\n",
      "54\n",
      "55\n",
      "56\n"
     ]
    }
   ],
   "source": [
    "#append() method\n",
    "from array import*\n",
    "stu_roll = array ('i', [50,51,52,53,54])\n",
    "n = len(stu_roll)\n",
    "i=0\n",
    "while i<n:\n",
    "    print (stu_roll[i])\n",
    "    i+=1\n",
    "\n",
    "print(\"Array After Append:\")\n",
    "stu_roll.append(55)\n",
    "stu_roll.append(56)\n",
    "n = len(stu_roll)\n",
    "i = 0 # for while loop\n",
    "while(i<n):\n",
    "    print(stu_roll[i])\n",
    "    i+=1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "51\n",
      "52\n",
      "53\n",
      "54\n",
      "Array After Inser:\n",
      "50\n",
      "100\n",
      "51\n",
      "200\n",
      "52\n",
      "53\n",
      "54\n"
     ]
    }
   ],
   "source": [
    "#insert() method\n",
    "from array import*\n",
    "stu_roll = array ('i', [50,51,52,53,54])\n",
    "n = len(stu_roll)\n",
    "i=0\n",
    "while i<n:\n",
    "    print (stu_roll[i])\n",
    "    i+=1\n",
    "\n",
    "print(\"Array After Inser:\")\n",
    "stu_roll.insert(1,100)\n",
    "stu_roll.insert(3,200)\n",
    "n = len(stu_roll)\n",
    "i = 0 # for while loop\n",
    "while(i<n):\n",
    "    print(stu_roll[i])\n",
    "    i+=1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "51\n",
      "52\n",
      "53\n",
      "54\n",
      "Array After Pop:\n",
      "51\n",
      "52\n",
      "53\n",
      "54\n"
     ]
    }
   ],
   "source": [
    "#remove() method\n",
    "from array import*\n",
    "stu_roll = array ('i', [50,51,52,53,54])\n",
    "n = len(stu_roll)\n",
    "i=0\n",
    "while i<n:\n",
    "    print (stu_roll[i])\n",
    "    i+=1\n",
    "\n",
    "print(\"Array After Pop:\")         # pop () method will delete the last index from the array\n",
    "stu_roll.remove(50)\n",
    "n = len(stu_roll)\n",
    "i = 0 # for while loop\n",
    "while(i<n):\n",
    "    print(stu_roll[i])\n",
    "    i+=1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "51\n",
      "52\n",
      "53\n",
      "54\n",
      "Array After Pop:\n",
      "50\n",
      "51\n",
      "52\n",
      "53\n"
     ]
    }
   ],
   "source": [
    "#pop() method\n",
    "from array import*\n",
    "stu_roll = array ('i', [50,51,52,53,54])\n",
    "n = len(stu_roll)\n",
    "i=0\n",
    "while i<n:\n",
    "    print (stu_roll[i])\n",
    "    i+=1\n",
    "\n",
    "print(\"Array After Pop:\")         # pop () method will delete the last index from the array\n",
    "stu_roll.pop()\n",
    "n = len(stu_roll)\n",
    "i = 0 # for while loop\n",
    "while(i<n):\n",
    "    print(stu_roll[i])\n",
    "    i+=1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "#index() method\n",
    "from array import*\n",
    "stu1_roll = array ('i', [50,51,52,53,54])\n",
    "print (stu1_roll.index(54))   # index method shows the position number of given element like 54 placed on 4th index\n",
    "\n",
    "stu2_roll = array ('i', [50,51,50,53,54])\n",
    "print (stu2_roll.index(50))   # if there are mulitple same number then it will give first preference to first number that occur in an array\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "51\n",
      "52\n",
      "53\n",
      "54\n",
      "Array After Reverse:\n",
      "54\n",
      "53\n",
      "52\n",
      "51\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "#reverse() method\n",
    "from array import*\n",
    "stu_roll = array ('i', [50,51,52,53,54])\n",
    "n = len(stu_roll)\n",
    "i=0\n",
    "while i<n:\n",
    "    print (stu_roll[i])\n",
    "    i+=1\n",
    "\n",
    "print(\"Array After Reverse:\")         # pop () method will delete the last index from the array\n",
    "stu_roll.reverse()\n",
    "n = len(stu_roll)\n",
    "i = 0 # for while loop\n",
    "while(i<n):\n",
    "    print(stu_roll[i])\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "51\n",
      "52\n",
      "53\n",
      "54\n",
      "Array After Reverse:\n",
      "50\n",
      "51\n",
      "52\n",
      "53\n",
      "54\n",
      "55\n",
      "56\n",
      "57\n",
      "58\n",
      "59\n",
      "60\n"
     ]
    }
   ],
   "source": [
    "#extend() method\n",
    "from array import*\n",
    "stu_roll = array ('i', [50,51,52,53,54])\n",
    "another_stu_roll = array ('i', [55,56,57,58,59, 60])\n",
    "n = len(stu_roll)\n",
    "i=0\n",
    "while i<n:\n",
    "    print (stu_roll[i])\n",
    "    i+=1\n",
    "\n",
    "print(\"Array After Reverse:\")         # pop () method will delete the last index from the array\n",
    "stu_roll.extend(another_stu_roll)\n",
    "n = len(stu_roll)\n",
    "i = 0 # for while loop\n",
    "while(i<n):\n",
    "    print(stu_roll[i])\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing on Arrays\n",
    "##### Slicing is use to retieve a range of elements.\n",
    "#### Syntax:\n",
    "        new_array_name = array_name[start:stop:stepsize]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Array\n",
      "0 = 50\n",
      "1 = 51\n",
      "2 = 52\n",
      "3 = 53\n",
      "4 = 54\n",
      "5 = 55\n",
      "***************\n",
      "51\n",
      "52\n",
      "***************\n",
      "50\n",
      "51\n",
      "52\n",
      "***************\n",
      "53\n",
      "54\n",
      "55\n",
      "***************\n",
      "50\n",
      "52\n"
     ]
    }
   ],
   "source": [
    "from array import*\n",
    "stu_roll = array ('i', [50,51,52,53,54,55])\n",
    "print(\"Original Array\")\n",
    "n = len (stu_roll)\n",
    "for i in range(n):\n",
    "    print (i, \"=\", stu_roll[i])\n",
    "\n",
    "print(\"***************\")\n",
    "a = stu_roll[1:3]\n",
    "for i in a:\n",
    "    print(i)\n",
    "\n",
    "# Start is 0\n",
    "print(\"***************\")\n",
    "a = stu_roll[:3]     # it will take 0 by default or we cal also write stu_roll[0:3]\n",
    "for i in a:\n",
    "    print(i)\n",
    "    /\n",
    "print(\"***************\")\n",
    "a = stu_roll[3:]     # it will take 0 by default or we cal also write stu_roll[0:3]\n",
    "for i in a:\n",
    "    print(i)\n",
    "    \n",
    "# step size\n",
    "print(\"***************\")\n",
    "a = stu_roll[0:4:2]   # it will take 0 by default or we cal also write stu_roll[0:3]\n",
    "for i in a:\n",
    "    print(i)\n",
    "# we can also take -ve value in slicing method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Methods: Python has a set of built-in method that you can use!\n",
    "    append():  Add an element at the end of the array     array_name.append(new_element)\n",
    "    insert():  Add an element at the specified position   array_name.insert(pos_no,new_element)\n",
    "    remove():  Remove the specified element               array_name.remove(element)\n",
    "    pop():     Remove the at the end of element in array  array_name.pop()\n",
    "    index():   Return the position number of given elem.  array_name.index(element)\n",
    "    reverse(): Reverse the the whole array                array_name.reverse()\n",
    "    extend():  It append another array at end_of_array    array_name.extend(another_array)\n",
    "    slicing:   It is use to slice the                     array_name[start:stop,step]\n",
    "    sort ():   Sort the array\n",
    "    copy():    Returns a copy of the array\n",
    "    count():   Returns the number of elements with the specified value\n"
   ]
  }
 ],
 "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": 4
}