Python II.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python II"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lesson, we will cover about other python data types such as \n",
    "- lists \n",
    "- disctionaries \n",
    "- tuples \n",
    "- statements\n",
    "\n",
    "Python has the following data types built-in by default, in these categories:"
   ]
  },
  {
   "attachments": {
    "download.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![download.png](attachment:download.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List in python is created by using []. It is more flexible and iterable and unlike strings, it is mutable.\n",
    "mylist1 = [1, 2, 3]\n",
    "mylist1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'orange', 'banana']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist2 = ['apple', 'orange', 'banana']\n",
    "mylist2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have just created two lists of integers and strings, but lists can actually hold different object types. For example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 99, 50.22, 'o']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = ['apple',99,50.22,'o']\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will use print() and len() functions on lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 99, 50.22, 'o']\n"
     ]
    }
   ],
   "source": [
    "print (my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 1.1 Indexing and Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing and slicing work just like in strings. Let's make a new list to remind ourselves of how this works:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Lets grab an element at index 0\n",
    "mylist1 = [1,2,3]\n",
    "mylist1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get sll elements after index 2\n",
    "mylist1[2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get all before index 3\n",
    "mylist1[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 1, 2, 3]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can also make the list double\n",
    "mylist1 * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are familiar with another programming language, you might start to draw parallels between arrays in another language and lists in Python. Lists in Python however, tend to be more flexible than arrays in other languages for a two good reasons: they have no fixed size (meaning we don't have to specify how big a list will be), and they have no fixed type constraint (like we've seen above)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 1.2 In built Properties or Methods for Lists in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are certain methods which are built in such as:\n",
    "1. Append()\n",
    "2. Clear()\n",
    "3. Copy()\n",
    "4. Count()\n",
    "5. Extend()\n",
    "6. Index\n",
    "7. Insert\n",
    "8. Pop\n",
    "9. Remove\n",
    "10. Reverse\n",
    "11. Sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 'attache me please!']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  Append is used to add elements in the list \n",
    "mylist1.append('attache me please!')\n",
    "mylist1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please try all methods one by one on mylist list and check what are their functions. Send it back, it is homework!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 1.3 Nesting Lists\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A great feature of of Python data structures is that they support nesting. This means we can have data structures within data structures. For example: A list inside a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1=[1,2,3]\n",
    "list2=[4,5,6]\n",
    "list3=[7,8,9]\n",
    "# create a list of lists to form a matrix\n",
    "matrix = [list1, list2, list3]\n",
    "matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can again use indexing to grab elements, but now there are two levels for the index. The\n",
    "items in the matrix object, and then the items inside that list!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Grab first item\n",
    "matrix[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Grab second item of the first item\n",
    "matrix[0][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 1.4 List Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has an advanced feature called list comprehensions. They allow for quick construction of lists. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 7]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use a list comprehension here to grab the first element of every row in the matrix object.\n",
    "first_element = [i[0] for i in matrix]\n",
    "first_element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionary is about mapping in python which means it is used to store data values in key:value pairs. A dictionary is a collection which is ordered*, changeable and does not allow duplicates. It is constructed by using {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperatue = {\"lahore\":40, \"islamaabd\": 23, \"karachi\":60}\n",
    "# temperatue['islamaabd']\n",
    "temperatue['atari'] = 1200\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'lahore': 40, 'islamaabd': 23, 'karachi': 60, 'atari': 1200}\n"
     ]
    }
   ],
   "source": [
    "print(temperatue)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a dictionary with {} and : to signify a key and a value\n",
    "my_dict = {'key1':'value1','key2':'value2'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key1': 'value1', 'key2': 'value2'}\n"
     ]
    }
   ],
   "source": [
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'value2'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Call values by their key\n",
    "my_dict['key2']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 123, 'key2': [22, 99, 52], 'key3': ['apple', 'Canada', 'cake']}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dictionaries are very flexible in the data types they can hold. For example:\n",
    "mydict = {'key1':123,'key2':[22,99,52],'key3':['apple','Canada','cake']}\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'Canada', 'cake']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict['key3']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Canada'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict['key3'][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also create keys by assignment. For instance if we started off with an empty dictionary, we could continually add to it:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'fruit': 'apple', 'integer': 99}"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict1 = {}\n",
    "# Create a new key through assignment\n",
    "dict1['fruit'] = 'apple'\n",
    "dict1['integer'] = 99\n",
    "dict1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2.1 Methods for values in dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Apple'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict['key3'][0].capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explore all other methods by pressing tab key after [0]. in the above code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2.2 Methods for Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are certain methods which are built in and can be applied on dictionary such as:\n",
    "1.  clear()\n",
    "2.  copy()\n",
    "3.  fromkeys()\n",
    "4.  get()\n",
    "5.  items()\n",
    "6.  keys()\n",
    "7.  pop()\n",
    "8.  popitem()\n",
    "9.  setdefault()\t\n",
    "10. update()\n",
    "11. values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets try some methods here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a typical dictionary\n",
    "d = {'key1':1,'key2':2,'key3':3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['key1', 'key2', 'key3'])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Method to return a list of all keys \n",
    "d.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([1, 2, 3])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Method to grab all values\n",
    "d.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('key1', 1), ('key2', 2), ('key3', 3)])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Method to return tuples of all items (we'll learn about tuples soon)\n",
    "d.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2.3 Nesting with Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dictionary nested inside a dictionary nested inside a dictionary\n",
    "t = {'key1':{'nestkey':{'subnestkey':'value'}}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'value'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Keep calling the keys\n",
    "t['key1']['nestkey']['subnestkey']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python tuples are very similar to lists, however, unlike lists they are immutable meaning they can not be changed. The construction of a tuples use () with elements separated by commas. For example: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 5, 6)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a tuple\n",
    "t = (4,5,6)\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Can also mix object types\n",
    "t = ('one',2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'one'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use indexing just like we did in lists\n",
    "t[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing just like a list\n",
    "t[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 3.1 Basic Tuple Methods\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use .index to enter a value and return the index\n",
    "t.index('one')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.count('count')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above are the only two methods applied to tuples. With only few mwthods tuples are not used as often as lists in programming, but are used when immutability is necessary. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Python Statement (if, else, elif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if Statements in Python allows us to tell the computer to perform alternative actions based on a certain set of results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It was true!\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    " print('It was true!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I will be printed in any case where x is not true\n"
     ]
    }
   ],
   "source": [
    "x = False\n",
    "if x == True:\n",
    " print('x was True!')\n",
    "else:\n",
    " print('I will be printed in any case where x is not true')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to the School!\n"
     ]
    }
   ],
   "source": [
    "location = 'School'\n",
    "if location == 'Cafe':\n",
    " print('Welcome to the Cafe!')\n",
    "elif location == 'School':\n",
    " print('Welcome to the School!')\n",
    "else:\n",
    " print('Where are you?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome George!\n"
     ]
    }
   ],
   "source": [
    "person = 'George'\n",
    "if person == 'Sammy':\n",
    " print('Welcome Sammy!')\n",
    "elif person =='George':\n",
    " print('Welcome George!')\n",
    "else:\n",
    " print(\"Welcome, what's your name?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Loops in Python (For and While)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.1 For Loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A for loop acts as an iterator in Python; it goes through items that are in a sequence or any other iterable item."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "mylist = [1,2,3,4,5,6,7,8,9,10]\n",
    "for num in mylist:\n",
    " print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for num in mylist:\n",
    " if num % 2 == 0:\n",
    "     print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Odd number\n",
      "2\n",
      "Odd number\n",
      "4\n",
      "Odd number\n",
      "6\n",
      "Odd number\n",
      "8\n",
      "Odd number\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# for loop with if else statament\n",
    "for num in mylist:\n",
    " if num % 2 == 0:\n",
    "     print(num)\n",
    " else:\n",
    "     print('Odd number')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i\n",
      " \n",
      "e\n",
      "n\n",
      "j\n",
      "o\n",
      "y\n",
      " \n",
      "c\n",
      "o\n",
      "d\n",
      "i\n",
      "n\n",
      "g\n"
     ]
    }
   ],
   "source": [
    "# iterate through characters of a string \n",
    "string = \"i enjoy coding\"\n",
    "for letter in string:\n",
    " print(letter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# for loop on a tupple\n",
    "tup = (1,2,3,4,5)\n",
    "for t in tup:\n",
    " print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 4)\n",
      "(6, 8)\n",
      "(10, 12)\n"
     ]
    }
   ],
   "source": [
    "# tupple unpacking through for loop\n",
    "list100 = [(2,4),(6,8),(10,12)]\n",
    "for t in list100:\n",
    "    print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "6\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for (t1,t2) in list100:\n",
    " print(t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k1\n",
      "k2\n",
      "k3\n"
     ]
    }
   ],
   "source": [
    "# for loop on adictionary\n",
    "d = {'k1':1,'k2':2,'k3':3}\n",
    "for i in d:\n",
    " print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k1\n",
      "1\n",
      "k2\n",
      "2\n",
      "k3\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# dictionary unpacking\n",
    "for key,value in d.items():\n",
    " print(k)\n",
    " print(v) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'lahore': 40, 'islamaabd': 23, 'karachi': 60, 'atari': 1200}"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temperatue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n",
      "23\n",
      "60\n",
      "1200\n"
     ]
    }
   ],
   "source": [
    "for i in temperatue.values():\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "for i in l:\n",
    "    if i == 2:\n",
    "        print(i)\n",
    "        continue\n",
    "        print('hello')\n",
    "        print('world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "4\n",
      "6\n",
      "7\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "numbs = [1,3,4,5,6,7,8]\n",
    "for i in numbs:\n",
    "    if i == 5:\n",
    "        continue\n",
    "    else:\n",
    "        print(i)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.2 While Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i <= 5:\n",
    "    print(i)\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The while statement in Python is one of most general ways to perform iteration. A while statement will repeatedly execute a single statement or group of statements as long as the condition is true. The reason it is called a 'loop' is because the code statements are looped through over and over again until the condition is no longer met."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y is currently:  0\n",
      " y is still less than 10, adding 1 to y\n",
      "y is currently:  1\n",
      " y is still less than 10, adding 1 to y\n",
      "y is currently:  2\n",
      " y is still less than 10, adding 1 to y\n",
      "y is currently:  3\n",
      " y is still less than 10, adding 1 to y\n",
      "y is currently:  4\n",
      " y is still less than 10, adding 1 to y\n",
      "y is currently:  5\n",
      " y is still less than 10, adding 1 to y\n",
      "y is currently:  6\n",
      " y is still less than 10, adding 1 to y\n",
      "y is currently:  7\n",
      " y is still less than 10, adding 1 to y\n",
      "y is currently:  8\n",
      " y is still less than 10, adding 1 to y\n",
      "y is currently:  9\n",
      " y is still less than 10, adding 1 to y\n"
     ]
    }
   ],
   "source": [
    "y = 0\n",
    "while y < 10:\n",
    "    print('y is currently: ',y)\n",
    "    print(' y is still less than 10, adding 1 to y')\n",
    "    y+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z is currently:  0\n",
      " z is still less than 10, adding 1 to z\n",
      "z is currently:  1\n",
      " z is still less than 10, adding 1 to z\n",
      "z is currently:  2\n",
      " z is still less than 10, adding 1 to z\n",
      "z is currently:  3\n",
      " z is still less than 10, adding 1 to z\n",
      "z is currently:  4\n",
      " z is still less than 10, adding 1 to z\n",
      "z is currently:  5\n",
      " z is still less than 10, adding 1 to z\n",
      "z is currently:  6\n",
      " z is still less than 10, adding 1 to z\n",
      "z is currently:  7\n",
      " z is still less than 10, adding 1 to z\n",
      "z is currently:  8\n",
      " z is still less than 10, adding 1 to z\n",
      "z is currently:  9\n",
      " z is still less than 10, adding 1 to z\n",
      "All Good!\n"
     ]
    }
   ],
   "source": [
    "z = 0\n",
    "while z < 10:\n",
    " print('z is currently: ',z)\n",
    " print(' z is still less than 10, adding 1 to z')\n",
    " z+=1\n",
    " \n",
    "else:\n",
    " print('All Good!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#####  5.2.1 Break, Continue, Pass\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is currently:  0\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  1\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  2\n",
      " x is still less than 10, adding 1 to x\n",
      "x==3\n",
      "x is currently:  3\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  4\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  5\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  6\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  7\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  8\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  9\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x < 10:\n",
    " print('x is currently: ',x)\n",
    " print(' x is still less than 10, adding 1 to x')\n",
    " x+=1\n",
    " if x==3:\n",
    "     print('x==3')\n",
    " else:\n",
    "     print('continuing...')\n",
    " continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how we have a printed statement when x==3, and a continue being printed out as we continue through the outer while loop. Let's put in a break once x ==3 and see if the result makes sense:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is currently:  0\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  1\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  2\n",
      " x is still less than 10, adding 1 to x\n",
      "Breaking because x==3\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x < 10:\n",
    " print('x is currently: ',x)\n",
    " print(' x is still less than 10, adding 1 to x')\n",
    " x+=1\n",
    " if x==3:\n",
    "     print('Breaking because x==3')\n",
    "     break\n",
    " else:\n",
    "     print('continuing...')\n",
    " continue\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Comparison Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Equal\n",
    "2 == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Not equal\n",
    "100 != 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Greater than\n",
    "5 > 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Less than\n",
    "2 < 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Greater Than or Equal to\n",
    "2 >= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Less than or Equal to\n",
    "5 <= 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## task"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to make a program that allows the users to enter a fruit name. Based on the input name, we’ll search for it from the basket list and show its quantity if the fruit is on the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "basket = [{'fruit':\"apple\",\"qty\":20},\n",
    "         {'fruit':\"mango\", \"qty\":30}]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'fruit': 'apple', 'qty': 20}, {'fruit': 'mango', 'qty': 30}]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "basket"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = (\"apple\",\"mango\",\"banana\",\"graps\",\"cherry\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('apple', 'mango', 'banana', 'graps', 'cherry')"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "first,second, *second = fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['banana', 'graps', 'cherry']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "second"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'mango'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "second"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "second=fruits[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'mango'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "second"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mulple assigment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1 = 2\n",
    "num2 = 3\n",
    "num3 = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1, num2, *num = 2,3,4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit = input(\"enter your favrt fruits:\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(\"apple has 20 qty\")\n",
    "qty = input(\"enter your qty\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qtsy = input(\"enter your qty\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}