Loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Created by Berkay Alan**\n",
    "\n",
    "**Loops**\n",
    "\n",
    "**15 of November, 2020**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Content\n",
    "\n",
    "- range()\n",
    "- In Operator\n",
    "- For Loop\n",
    "- Iterating in Strings\n",
    "- Iterating in two(2) dimensional Lists\n",
    "- continue\n",
    "- break\n",
    "- zip()\n",
    "- Iteration in a Dictionary\n",
    "- Iterating pair values\n",
    "- While Loop\n",
    "- While True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## range()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 20)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(0,20) #It creates a range between 0 and 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19\n"
     ]
    }
   ],
   "source": [
    "print(*range(0,20)) # You can print with *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_list = list(range(0,20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 6 7 8 9 10 11\n"
     ]
    }
   ],
   "source": [
    "print(*range(5,12))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14\n"
     ]
    }
   ],
   "source": [
    "print(*range(15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 2 4 6 8 10 12 14 16 18\n"
     ]
    }
   ],
   "source": [
    "print(*range(0,20,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1\n"
     ]
    }
   ],
   "source": [
    "print(*range(20,0,-1)) #Reverse the numbers with -1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## In Operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"a\" in \"hello\" # a is not in hello"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"i\" in \"time\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 in [1,2,3,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 in range(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 in (1,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2000, 4000, 7000, 5000]\n"
     ]
    }
   ],
   "source": [
    "incomes = [2000,4000,7000,5000]\n",
    "print(incomes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4000"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "incomes[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(incomes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2000\n",
      "4000\n",
      "7000\n",
      "5000\n"
     ]
    }
   ],
   "source": [
    "for i in incomes: # i is a temporary value\n",
    "    print(i) # It prints every element in incomes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Josh', 'Katy', 'Hurry']\n"
     ]
    }
   ],
   "source": [
    "names = [\"Josh\",\"Katy\",\"Hurry\"]\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Josh\n",
      "Katy\n",
      "Hurry\n"
     ]
    }
   ],
   "source": [
    "for name in names:\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Josh\n",
      "Katy\n",
      "Hurry\n"
     ]
    }
   ],
   "source": [
    "for name in range(len(names)):\n",
    "    print(names[name])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades = [50,70,90,45]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "total = 0\n",
    "\n",
    "for i in range(len(grades)):\n",
    "    total = total+grades[i] #or total+=grades[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "255"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average is 63.75\n"
     ]
    }
   ],
   "source": [
    "avg = total / len(grades)\n",
    "print(\"Average is\", avg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[50, 70, 90, 45]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(grades)):\n",
    "    grades[i]-=5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[45, 65, 85, 40]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "new_list = [1,2,3,4,5,6,7,8,9] # Print all even elements\n",
    "\n",
    "for element in new_list:\n",
    "    if element % 2 == 0:\n",
    "        print(element)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n",
      "* * * * * * \n",
      "* * * * * * * \n",
      "* * * * * * * * \n",
      "* * * * * * * * * \n",
      "* * * * * * * * * * \n",
      "* * * * * * * * * * * \n",
      "* * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * * \n",
      "* * * * * * * * * * * * * * * * * * * \n"
     ]
    }
   ],
   "source": [
    "for sayı in range(1,20): # for and range\n",
    "    print(\"* \" * sayı)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating in Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "py = \"Python\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "for i in py:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PPP\n",
      "yyy\n",
      "ttt\n",
      "hhh\n",
      "ooo\n",
      "nnn\n"
     ]
    }
   ],
   "source": [
    "for ch in py:\n",
    "    print(ch*3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating in two(2) dimensional Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2], [3, 4], [5, 6], [7, 8]]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list = [[1,2],[3,4],[5,6],[7,8]]\n",
    "new_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2]\n",
      "[3, 4]\n",
      "[5, 6]\n",
      "[7, 8]\n"
     ]
    }
   ],
   "source": [
    "for e in new_list:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Continue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i: 1\n",
      "i: 2\n",
      "i: 4\n",
      "i: 6\n",
      "i: 7\n",
      "i: 8\n",
      "i: 9\n"
     ]
    }
   ],
   "source": [
    "new_list = [1,2,3,4,5,6,7,8,9] # continue will pass 3 and 5.\n",
    "\n",
    "\n",
    "for i in new_list:\n",
    "    if (i == 3 or i == 5):\n",
    "        continue\n",
    "    print(\"i:\",i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7000, 8000, 5000, 9000]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "incomes = [7000,8000,5000,9000] \n",
    "incomes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We want to make a salary increase if income is lower than 8000\n",
    "\n",
    "for i in range(len(incomes)):\n",
    "    if incomes[i]>=8000:\n",
    "        continue\n",
    "    else:\n",
    "        incomes[i]+=1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8000, 8000, 6000, 9000]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "incomes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 6, 21, 4, 100, 35, 2, 1, 2, 43, 2, 2]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num = [1,4,6,21,4,100,35,2,1,2,43,2,2]\n",
    "num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "6\n",
      "21\n",
      "4\n",
      "100\n",
      "Highest Number!\n"
     ]
    }
   ],
   "source": [
    "for i in num: # Break when found 100\n",
    "    print(i)\n",
    "    if i==100:\n",
    "        print(\"Highest Number!\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7000, 8000, 5000, 9000]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "incomes = [7000,8000,5000,9000] \n",
    "incomes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5000, 7000, 8000, 9000]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "incomes.sort()\n",
    "incomes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5000\n",
      "7000\n",
      "8000\n",
      "8000 is border!\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(incomes)):\n",
    "    print(incomes[i])\n",
    "    if incomes[i]>=8000:\n",
    "        print(\"8000 is border!\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## zip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "jobs = [\"ML Engineer\",\"Data Scientist\",\"Researcher\",\"Deep Learning Specialist\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "incomes = [7000,11000,6000,9000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "zipped = zip(jobs,incomes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('ML Engineer', 7000),\n",
       " ('Data Scientist', 11000),\n",
       " ('Researcher', 6000),\n",
       " ('Deep Learning Specialist', 9000)]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zipped)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ML Engineer 7000\n",
      "Data Scientist 11000\n",
      "Researcher 6000\n",
      "Deep Learning Specialist 9000\n"
     ]
    }
   ],
   "source": [
    "for j,i in zip(jobs,incomes):\n",
    "    print(j,i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteration in a Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "dic = {\"Apartment1\": {\"persons\": [\"Josh\",\"Katy\"]},\"Apartment2\": {\"persons\": [\"Mike\",\"Hate\"]}, \n",
    "       \"Apartment3\": {\"persons\": [\"Michael\",\"Jone\"]}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Apartment1': {'persons': ['Josh', 'Katy']},\n",
       " 'Apartment2': {'persons': ['Mike', 'Hate']},\n",
       " 'Apartment3': {'persons': ['Michael', 'Jone']}}"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Apartment1\n",
      "Apartment2\n",
      "Apartment3\n"
     ]
    }
   ],
   "source": [
    "for i in dic:\n",
    "    print(i) # It just prints keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Apartment1 {'persons': ['Josh', 'Katy']}\n",
      "Apartment2 {'persons': ['Mike', 'Hate']}\n",
      "Apartment3 {'persons': ['Michael', 'Jone']}\n"
     ]
    }
   ],
   "source": [
    "for i in dic:\n",
    "    j = dic[i]\n",
    "    print(i,j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Apartment1 {'persons': ['Josh', 'Katy']}\n",
      "Apartment2 {'persons': ['Mike', 'Hate']}\n",
      "Apartment3 {'persons': ['Michael', 'Jone']}\n"
     ]
    }
   ],
   "source": [
    "for i,j in dic.items():\n",
    "    print(i,j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'persons': ['Josh', 'Katy']},\n",
       " {'persons': ['Mike', 'Hate']},\n",
       " {'persons': ['Michael', 'Jone']}]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(dic.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Apartment1', 'Apartment2', 'Apartment3']"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(dic.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "# assigning multiple variables at the same time\n",
    "x, y = (5,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 6\n"
     ]
    }
   ],
   "source": [
    "print(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating pair values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = [\"Josh\",\"Kate\",\"Hurry\",\"Bradson\"]\n",
    "ages = [32,23,56,35]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Josh - Age: 32\n",
      "Name: Kate - Age: 23\n",
      "Name: Hurry - Age: 56\n",
      "Name: Bradson - Age: 35\n"
     ]
    }
   ],
   "source": [
    "for n,a in zip(names,ages):\n",
    "    print(\"Name: {0} - Age: {1}\".format(n,a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value of i:  0\n",
      "Value of i:  1\n",
      "Value of i:  2\n",
      "Value of i:  3\n",
      "Value of i:  4\n",
      "Value of i:  5\n",
      "Value of i:  6\n",
      "Value of i:  7\n",
      "Value of i:  8\n",
      "Value of i:  9\n"
     ]
    }
   ],
   "source": [
    "i = 0 \n",
    "\n",
    "while (i < 10):\n",
    "    print(\"Value of i: \",i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Odd number is  1\n",
      "Odd number is  3\n",
      "Odd number is  5\n",
      "Odd number is  7\n",
      "Odd number is  9\n"
     ]
    }
   ],
   "source": [
    "num = 0\n",
    "\n",
    "while num < 10:\n",
    "    num += 1\n",
    "    if num % 2 == 0:\n",
    "        \n",
    "        continue\n",
    "    \n",
    "    print(\"Odd number is \",num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Give me a number: 98\n",
      "Can not divide to 3\n",
      "Give me a number: 9\n",
      "Can divide to 3\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    num = int(input(\"Give me a number: \"))\n",
    "    if num == 0:\n",
    "        continue\n",
    "    else:\n",
    "        if num % 3 ==0:\n",
    "            print(\"Can divide to 3\")\n",
    "            break\n",
    "        else:\n",
    "            print(\"Can not divide to 3\")"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}