Python_loop_and_function_&_class_in_details_.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python loop and function & class  in details .ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyNQLupEkDAu/U7tyFMudYrY",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/satyambhatt5/Python-source-code-/blob/main/Python_loop_and_function_%26_class_in_details_.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hlGlY1WqKW7-"
      },
      "source": [
        "#Let’s use a for loop to print out each name in a list of magicians:\r\n",
        "\r\n",
        "\r\n",
        "magicians = ['alice', 'david', 'carolina'] \r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UmwBCgGNi00L"
      },
      "source": [
        "for magician in magicians:\r\n",
        "  print(magician)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Zs8eMznjBfo"
      },
      "source": [
        "for magician in magicians:\r\n",
        "  print(f'{magician.title()},That was great trick!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6JI8QwNOkiPo"
      },
      "source": [
        "for magician in magicians:\r\n",
        "  print(f'{magician.title()},That was great trick!')\r\n",
        "  print(f\"I can't wait to see your next trick, {magician.title()}.\\n\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PesxBZnbk-PU"
      },
      "source": [
        " for magician in magicians:\r\n",
        "  print(f'{magician.title()},That was great trick!')\r\n",
        "  print(f\"I can't wait to see your next trick, {magician.title()}.\\n\")\r\n",
        " \r\n",
        " print(\"Thank you, everyone. That was a great magic show!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kb_NLxePlLoW"
      },
      "source": [
        "\r\n",
        "#LIST\r\n",
        "\r\n",
        "#Example :\r\n",
        "\r\n",
        "pizza=  ['pizza1','pizza2','pizza3']\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_Ls0AOL-milY"
      },
      "source": [
        "for pizzas in pizza:\r\n",
        "  print(f\"{pizzas.title()},I like pepperonipizza!\")\r\n",
        "  print(f'What kind of the pizza u like,{pizzas.title()}.')\r\n",
        "  \r\n",
        "print(\"i love the pizza.........\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DDECpE9NnbbT"
      },
      "source": [
        "#for the value or integer \r\n",
        "\r\n",
        "#using the range function \r\n",
        "\r\n",
        "for i in range(1,5):\r\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f7s1_8ulo1Of"
      },
      "source": [
        "#Using range() to Make a List of Numbers\r\n",
        "#normal\r\n",
        "num=list(range(0,5))\r\n",
        "print(num)\r\n",
        "\r\n",
        "#for the even number \r\n",
        "num=list(range(0,5,2))\r\n",
        "print(num)\r\n",
        "\r\n",
        "\r\n",
        "#for the odd number \r\n",
        "num=list(range(0,5,1))\r\n",
        "print(num)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "knpgttTkpTOT"
      },
      "source": [
        "#square method \r\n",
        "\r\n",
        "squares=[]\r\n",
        "\r\n",
        "for i in range(1,5):\r\n",
        "  square= i**2\r\n",
        "  squares.append(square)\r\n",
        "  \r\n",
        "print(squares)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b2Y3OPyQqfR-"
      },
      "source": [
        "#we can write same code in this ways \r\n",
        "\r\n",
        "squares = []\r\n",
        "\r\n",
        "for i in range(1,11):\r\n",
        "  squares.append(i**2)\r\n",
        "\r\n",
        "print(squares)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tkuo-B4VrjGR"
      },
      "source": [
        "\r\n",
        "#list of the number \r\n",
        "digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]\r\n",
        "\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JgBJTPiOr3PI"
      },
      "source": [
        "print(max(digits))\r\n",
        "\r\n",
        "print(min(digits))\r\n",
        "\r\n",
        "\r\n",
        "sum(digits)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8XDXm-jhsT6H"
      },
      "source": [
        "#The approach described earlier for generating the list squares consisted ofusing three or four lines of code.\r\n",
        "\r\n",
        " #A list comprehension allows you to generate this same list in just one line of code. \r\n",
        "\r\n",
        "A list comprehension combines the for loop and the creation of new elements into one line, and automatically\r\n",
        "appends each new element. \r\n",
        "\r\n",
        "List comprehensions are not always presented to beginners, but I have included them here because you’ll most likely see them as soon as you start looking at other people’s code."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IJ-BEMyQsBjI"
      },
      "source": [
        "#List Comprehensions\r\n",
        "squares = [i**2 for i in range(1, 11)]\r\n",
        "print(squares)\r\n",
        "\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e-4UpRO1s3Ah"
      },
      "source": [
        "# Q1=Counting to Twenty: Use a for loop to print the numbers from 1 to 20,\r\n",
        "\r\n",
        "# Q2=One Million: Make a list of the numbers from one to one million, and then use a for loop to print the numbers. (If the output is taking too long, stop it by\r\n",
        "#pressing ctrl-C or by closing the output window.)\r\n",
        "\r\n",
        "#Q3=Make a list of the numbers from one to one million,and then use min() and max() to make sure your list actually starts at one and\r\n",
        "#ends at one million. Also, use the sum() function to see how quickly Python canadd a million numbers.\r\n",
        "\r\n",
        "#Q4:Use the third argument of the range() function to make a list of the odd numbers from 1 to 20. Use a for loop to print each number.\r\n",
        "\r\n",
        "#Q5:Make a list of the multiples of 3 from 3 to 30. Use a for loop to print the numbers in your list.\r\n",
        "\r\n",
        "#Q6:A number raised to the third power is called a cube. For example,\r\n",
        "#the cube of 2 is written as 2**3 in Python. Make a list of the first 10 cubes (that is, the cube of each integer from 1 through 10), and use a for loop to print outthe value of each cube.\r\n",
        "\r\n",
        "#Q6:Use a list comprehension to generate a list of the first 10 cubes."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vBfElHQ6uRcd"
      },
      "source": [
        "#Q1 \r\n",
        "\r\n",
        "for i in range(1,20):\r\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O4CCStw-um8m"
      },
      "source": [
        "\r\n",
        "\r\n",
        "#for i in range(1,1000000):\r\n",
        "  #print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QCVV5FYCu6yv"
      },
      "source": [
        "#q5\r\n",
        "num=[]\r\n",
        "\r\n",
        "for i in range(0,11):\r\n",
        "  number=  i**3\r\n",
        "  num.append(number)\r\n",
        "print(num)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sRegQZ9vwOLI"
      },
      "source": [
        "#q6 comprensive list \r\n",
        "\r\n",
        "cube= [i**3 for i in range(0,10)]\r\n",
        "print(cube)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-g4kQh7bxfeV"
      },
      "source": [
        "#Looping Through a Slice\r\n",
        "\r\n",
        "players = ['charles', 'martina', 'michael', 'florence', 'eli'] "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CgUiQcJEx8OJ"
      },
      "source": [
        "print(\"Here the list of the player\")\r\n",
        "for player in players[:4]:\r\n",
        "  print(player.title())\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TOoyJM2qyjZK"
      },
      "source": [
        "#Copying a List:you’ll want to start with an existing list and make an entirely new list  based on the first one\r\n",
        "my_foods = ['pizza', 'falafel', 'carrot cake']\r\n",
        "friend_food=my_foods[:]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TFaPnPMEzrH-"
      },
      "source": [
        "print(\"My favorite food are :\")\r\n",
        "print(my_foods)\r\n",
        "\r\n",
        "\r\n",
        "print(\"My friend favorite food are:\")\r\n",
        "print(friend_food)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6ssfrdLL2X22"
      },
      "source": [
        "#add the new string \r\n",
        "\r\n",
        "my_foods.append(\"mango\")\r\n",
        "\r\n",
        "\r\n",
        "friend_food.append(\"ice cream\")\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ad2YRrz33Czq"
      },
      "source": [
        "print(\"My favorite food are :\")\r\n",
        "print(my_foods)\r\n",
        "\r\n",
        "\r\n",
        "print(\"My friend favorite food are:\")\r\n",
        "print(friend_food)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8mlK1xnc3Tsw"
      },
      "source": [
        "#if -else case \r\n",
        "\r\n",
        "cars = ['audi', 'bmw', 'subaru', 'toyota']\r\n",
        "for car in cars:\r\n",
        " if car == 'bmw':\r\n",
        "  print(car.upper())\r\n",
        " else:\r\n",
        "  print(car.title())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JWMJ-Ts76Hqb"
      },
      "source": [
        "#checking the iniquality \r\n",
        "requested_topping = 'mushrooms'\r\n",
        "\r\n",
        "\r\n",
        "if requested_topping != 'anchovies':\r\n",
        "  print(\"Hold the anchovies!\")\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wp3uPom3XBx9"
      },
      "source": [
        "ans =17\r\n",
        "\r\n",
        "if ans !=20:\r\n",
        "  print(\"That is not correct. Please try again later\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Of2maborXqSq"
      },
      "source": [
        "a =22\r\n",
        "b=18\r\n",
        "\r\n",
        "print(a>=21 and b>=21)\r\n",
        "print(a>=21 or b>=21)\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qjyut_bIZOTF"
      },
      "source": [
        "list = ['mushrooms', 'onions', 'pineapple']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DqBNxqPPaZTh"
      },
      "source": [
        "'mushrooms' in list "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DGxj_hFna5_K"
      },
      "source": [
        "'satyam' in  list "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d60ukml-a9se"
      },
      "source": [
        "#using the banned list of the customer \r\n",
        "\r\n",
        "blist = ['Dinesh','Sarvesh','Suraj']\r\n",
        "user='Satyam'\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3TXxv2PRbcGs"
      },
      "source": [
        "if user not in  blist:\r\n",
        "  print(f\"{user.title()}, you can post a response if you wish.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K2YoqyRwtRRI"
      },
      "source": [
        "requested_toppings = ['mushrooms', 'green peppers', 'extra cheese']\r\n",
        "\r\n",
        "\r\n",
        "for requested_topping in requested_toppings:\r\n",
        "  \r\n",
        " print(f\"Adding {requested_topping}.\")\r\n",
        "print(\"\\nFinished making your pizza!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c6rrxzLNuPbh"
      },
      "source": [
        "for requested_topping in requested_toppings:\r\n",
        " if requested_topping == 'green peppers':\r\n",
        "  print(\"Sorry, we are out of green peppers right now.\")\r\n",
        "else:\r\n",
        " print(f\"Adding {requested_topping}.\")\r\n",
        "print(\"\\nFinished making your pizza!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HDOAMJlvuoE-"
      },
      "source": [
        "#Checking That a List Is Not Empty\r\n",
        "\r\n",
        "requested_toppings = []"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VVF_I-PnvRTb"
      },
      "source": [
        "if requested_toppings:\r\n",
        " for requested_topping in requested_toppings:\r\n",
        "  print(f\"Adding {requested_topping}.\")\r\n",
        "  print(\"\\nFinished making your pizza!\")\r\n",
        "else:\r\n",
        " print(\"Are you sure you want a plain pizza?\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kfuBC3AYva3D"
      },
      "source": [
        "#multiple list \r\n",
        "\r\n",
        "available_toppings = ['mushrooms', 'olives', 'green peppers','pepperoni', 'pineapple', 'extra cheese']\r\n",
        "requested_toppings = ['mushrooms', 'french fries', 'extra cheese']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dni9lv6XvqlL"
      },
      "source": [
        "for requested_topping in requested_toppings:\r\n",
        "  if requested_topping in available_toppings:\r\n",
        "    print(f\"adding {requested_topping}.\")\r\n",
        "  else:\r\n",
        "    print(f\"Sorry,we dont have {requested_topping}.\")\r\n",
        "print(\"Finish making pizza \")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mZAaGzN-xkb_"
      },
      "source": [
        "#dictionary \r\n",
        "\r\n",
        "#key and value \r\n",
        "\r\n",
        "\r\n",
        "favorite_languages = {'jen': 'python','sarah': 'c','edward': 'ruby','phil': 'python'}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LMS6AQupy9k_"
      },
      "source": [
        "for key, value in favorite_languages.items():\r\n",
        " print(f\"\\nKey: {key}\")\r\n",
        " print(f\"Value: {value}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P732tEeP0AV9"
      },
      "source": [
        "for name, language in favorite_languages.items():\r\n",
        " print(f\"{name.title()}'s favorite language is {language.title()}.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BtRe1sV30xkp"
      },
      "source": [
        "#Looping Through All the Keys in a Dictionary\r\n",
        "\r\n",
        "for name in favorite_languages.keys():\r\n",
        "  print(name.title())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wrqCkIng1dc2"
      },
      "source": [
        "#all the value in dictonary \r\n",
        "for language in favorite_languages.values():\r\n",
        "  print(language.title())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uHcy-NCw11uE"
      },
      "source": [
        " friends = ['phil', 'sarah']\r\n",
        "for name in favorite_languages.keys():\r\n",
        "  print(name.title())\r\n",
        "\r\n",
        " if name in friends:\r\n",
        "  language = favorite_languages[name].title()\r\n",
        "  print(f\"\\t{name.title()}, I see you love {language}!\")\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ud8kMPv2u6L"
      },
      "source": [
        "if 'erin' not in favorite_languages:\r\n",
        "  print(\"Erin, Please take our poll\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wm7F37l03gBN"
      },
      "source": [
        "#Looping Through a Dictionary’s Keys in a Particular Order\r\n",
        "\r\n",
        "favorite_languages"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5HtSshvA3sU5"
      },
      "source": [
        "for name in sorted(favorite_languages.keys()):\r\n",
        "  print(f'{name.title()},Thank you for the taking poll.')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zAWPlgr34TMB"
      },
      "source": [
        "#Nesting: we can do for all list and tuple and dictionary \r\n",
        "\r\n",
        "alien_0 = {'color': 'green', 'points': 5}\r\n",
        "alien_1 = {'color': 'yellow', 'points': 10}\r\n",
        "alien_2 = {'color': 'red', 'points': 15}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jiGySuf88FpX"
      },
      "source": [
        "#merge all list \r\n",
        "\r\n",
        "aliens = [alien_0, alien_1, alien_2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AJsYeUau8Mdb"
      },
      "source": [
        "for alien in aliens:\r\n",
        " print(alien)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jhZfm7H_8T6i"
      },
      "source": [
        "#use range() to create a fleet of 30 aliens\r\n",
        "\r\n",
        "\r\n",
        "\r\n",
        "# Make an empty list for storing aliens.\r\n",
        "\r\n",
        "\r\n",
        "aliens = []\r\n",
        "\r\n",
        "# Make 30 green aliens.\r\n",
        "for alien_number in range(30):\r\n",
        "  new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}\r\n",
        "  aliens.append(new_alien)\r\n",
        "\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o0ThOmH_WhO5"
      },
      "source": [
        "# Show the first 5 aliens.\r\n",
        "for alien in aliens[:5]:\r\n",
        " print(alien)\r\n",
        "print(\"...\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lqsZvQFbWvA9"
      },
      "source": [
        "# Show how many aliens have been created.\r\n",
        "print(f\"Total number of aliens: {len(aliens)}\")\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YHr1YOvLXFKr"
      },
      "source": [
        "for alien in aliens[:3]:\r\n",
        " if alien['color'] == 'green':\r\n",
        "  alien['color'] = 'yellow'\r\n",
        "  alien['speed'] = 'medium'\r\n",
        "  alien['points'] = 10\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DoYeEXDqYkTA"
      },
      "source": [
        "These aliens all have the same characteristics, but Python considers each one a separate object, which allows us to modify each alien\r\n",
        "individually.\r\n",
        "How might you work with a group of aliens like this? Imagine that one\r\n",
        "aspect of a game has some aliens changing color and moving faster as the\r\n",
        "game progresses. When it’s time to change colors, we can use a for loop and\r\n",
        "an if statement to change the color of aliens. For example, to change the\r\n",
        "first three aliens to yellow, medium-speed aliens worth 10 points each, we\r\n",
        "could do this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QPx79VJWX3sI"
      },
      "source": [
        "# Show the first 5 aliens.\r\n",
        "for alien in aliens[:5]:\r\n",
        " print(alien)\r\n",
        "print(\"...\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fcRQjRvsY0U2"
      },
      "source": [
        "You could expand this loop by adding an elif block that turns yellow\r\n",
        "aliens into red, fast-moving ones worth 15 points each. Without showing the\r\n",
        "entire program again, that loop would look like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o8jpIxeyYC4Z"
      },
      "source": [
        "\r\n",
        "for alien in aliens[0:3]:\r\n",
        " if alien['color'] == 'green':\r\n",
        "  alien['color'] = 'yellow'\r\n",
        "  alien['speed'] = 'medium'\r\n",
        "  alien['points'] = 10\r\n",
        " elif alien['color'] == 'yellow':\r\n",
        "  alien['color'] = 'red'\r\n",
        "  alien['speed'] = 'fast'\r\n",
        "  alien['points'] = 15"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QCOC8aYdY7Nw"
      },
      "source": [
        "for alien in aliens[:5]:\r\n",
        " print(alien)\r\n",
        "print(\"...\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UgWOzAM0ZObG"
      },
      "source": [
        "#A List in a Dictionary\r\n",
        "## Store information about a pizza being ordered.\r\n",
        "pizza = {'crust': 'thick','toppings': ['mushrooms', 'extra cheese']}\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x5sB1_lYZraU"
      },
      "source": [
        "Rather than putting a dictionary inside a list, it’s sometimes useful to put\r\n",
        "a list inside a dictionary. For example, consider how you might describe a\r\n",
        "pizza that someone is ordering. If you were to use only a list, all you could\r\n",
        "really store is a list of the pizza’s toppings. With a dictionary, a list of toppings can be just one aspect of the pizza you’re describing.\r\n",
        "In the following example, two kinds of information are stored for each\r\n",
        "pizza: a type of crust and a list of toppings. The list of toppings is a value\r\n",
        "associated with the key 'toppings'. To use the items in the list, we give the\r\n",
        "name of the dictionary and the key 'toppings', as we would any value in the\r\n",
        "dictionary. Instead of returning a single value, we get a list of toppings:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P1-Mgs3iZsUp"
      },
      "source": [
        "# Summarize the order.\r\n",
        "print(f\"You ordered a {pizza['crust']}-crust pizza \"\r\n",
        " \"with the following toppings:\")\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ObpQ_RwyZ9MT"
      },
      "source": [
        "for topping in pizza['toppings']:\r\n",
        " print(\"\\t\" + topping)\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ABp95SQxaBjO"
      },
      "source": [
        "\r\n",
        "\r\n",
        "\r\n",
        "users = {'aeinstein': {'first': 'albert','last': 'einstein','location': 'princeton',},'mcurie': {'first': 'marie','last': 'curie','location': 'paris',}}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HQBW0YmDbrg7"
      },
      "source": [
        "We first define a dictionary called users with two keys: one each for the\r\n",
        "usernames 'aeinstein' and 'mcurie'. The value associated with each key is a\r\n",
        "dictionary that includes each user’s first name, last name, and location. At u\r\n",
        "we loop through the users dictionary. Python assigns each key to the variable\r\n",
        "username, and the dictionary associated with each username is assigned to the\r\n",
        "variable user_info. Once inside the main dictionary loop, we print the username at v.\r\n",
        "At w we start accessing the inner dictionary. The variable user_info,\r\n",
        "which contains the dictionary of user information, has three keys: 'first',\r\n",
        "'last', and 'location'. We use each key to generate a neatly formatted full\r\n",
        "name and location for each person, and then print a summary of what we\r\n",
        "know about each user x:\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eBzGYcJVazs5"
      },
      "source": [
        "for username, user_info in users.items():\r\n",
        "  print(f\"\\nUsername: {username}\")\r\n",
        "  full_name = f\"{user_info['first']} {user_info['last']}\"\r\n",
        "  location = user_info['location']\r\n",
        "  print(f\"\\tFull name: {full_name.title()}\")\r\n",
        "  print(f\"\\tLocation: {location.title()}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D6nDrvaCgTNF"
      },
      "source": [
        "#WHILE LOOP \r\n",
        "#Input"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lgXoIKMda-7D"
      },
      "source": [
        "#How the input() Function Works\r\n",
        "message = input(\"Tell me something, and I will repeat it back to you: \")\r\n",
        "print(message)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-QfCy681fYIi"
      },
      "source": [
        "name = input(\"Please enter your name: \")\r\n",
        "print(f\"\\nHello, {name}!\")\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qAreg2RSgO4C"
      },
      "source": [
        "age = input(\"how old you are :\")\r\n",
        "print(\"age : \",age)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HsjWvqg-haLj"
      },
      "source": [
        "height=input(\"What is your hight ?\")\r\n",
        "height=int(height)\r\n",
        "\r\n",
        "\r\n",
        "print(\"\\n Height :\",height)\r\n",
        "if height>48:\r\n",
        "  print(\"\\n You are tall enough to ride.\")\r\n",
        "else:\r\n",
        "  print(\"\\n You will able to ride when you will be little older\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tROaw9mTjDvb"
      },
      "source": [
        "#The Modulo Operator\r\n",
        "\r\n",
        "4 % 3,5 % 3,6 % 3,7 % 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ux3Fqy2mjt3z"
      },
      "source": [
        "number = input(\"Enter a number, and I'll tell you if it's even or odd: \")\r\n",
        "number = int(number)\r\n",
        "if number % 2 == 0:\r\n",
        " print(f\"\\nThe number {number} is even.\")\r\n",
        "else:\r\n",
        " print(f\"\\nThe number {number} is odd.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sAvnKvjllP5h"
      },
      "source": [
        "7-1. Rental Car: Write a program that asks the user what kind of rental car they\r\n",
        "would like. Print a message about that car, such as “Let me see if I can find you a Subaru.”\r\n",
        "\r\n",
        "7-2. Restaurant Seating: Write a program that asks the user how many people\r\n",
        "are in their dinner group. If the answer is more than eight, print a message saying they’ll have to wait for a table. Otherwise, report that their table is ready.\r\n",
        "\r\n",
        "\r\n",
        "7-3. Multiples of Ten: Ask the user for a number, and then report whether the\r\n",
        "number is a multiple of 10 or not."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ULedpmpKlPWt"
      },
      "source": [
        "people =input(\"How many people are in Dinner Group\")\r\n",
        "people=int(people)\r\n",
        "\r\n",
        "if people>8:\r\n",
        "  print(\"\\n Please wait for the table Otherwise.\\nreport that their table is ready.\")\r\n",
        "else:\r\n",
        "  print(\"\\nPlease take Tabel.\\nTable is Ready for the Dinner.\")\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dA-8nLu3pU7h"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ne9x_cwkpRlD"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9g_eVu8fpWRv"
      },
      "source": [
        "#while\r\n",
        "The for loop takes a collection of items and executes a block of code once\r\n",
        "for each item in the collection. In contrast, the while loop runs as long as,\r\n",
        "or while, a certain condition is true. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-WPl8HVSpSyS"
      },
      "source": [
        "#You can use a while loop to count up through a series of numbers. For example, the following while loop counts from 1 to 5:\r\n",
        "current_number = 0\r\n",
        "while current_number <= 5:\r\n",
        " print(\"current num =\",current_number*5)\r\n",
        " current_number += 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DU52W5uLvyMj"
      },
      "source": [
        "#Letting the User Choose When to Quit"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vUZja9biuG66"
      },
      "source": [
        "prompt = \"\\nTell me something, and I will repeat it back to you:\"\r\n",
        "prompt += \"\\nEnter 'quit' to end the program. \""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZPh-7dg3vuh2"
      },
      "source": [
        "message = \"\"\r\n",
        "while message != 'quit':\r\n",
        " message = input(prompt)\r\n",
        " print(message)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rSsHWqWGv8IR"
      },
      "source": [
        "prompt = \"\\nTell me something, and I will repeat it back to you:\"\r\n",
        "prompt += \"\\nEnter 'quit' to end the program. \"\r\n",
        "\r\n",
        "message = \"\"\r\n",
        "while message != 'quit':\r\n",
        " message = input(prompt)\r\n",
        "\r\n",
        " if message != 'quit':\r\n",
        "  print(message)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qQvXMQnpwojm"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AbyXbygkx6cs"
      },
      "source": [
        "#Using a Flag\r\n",
        "In the previous example, we had the program perform certain tasks while\r\n",
        "a given condition was true. But what about more complicated programs in\r\n",
        "which many different events could cause the program to stop running?\r\n",
        "For example, in a game, several different events can end the game.\r\n",
        "When the player runs out of ships, their time runs out, or the cities they\r\n",
        "were supposed to protect are all destroyed, the game should end. It needs\r\n",
        "to end if any one of these events happens. If many possible events might\r\n",
        "occur to stop the program, trying to test all these conditions in one while\r\n",
        "statement becomes complicated and difficult.\r\n",
        "For a program that should run only as long as many conditions are true,\r\n",
        "you can define one variable that determines whether or not the entire program is active. This variable, called a flag, acts as a signal to the program. We\r\n",
        "can write our programs so they run while the flag is set to True and stop running when any of several events sets the value of the flag to False. As a result,\r\n",
        "our overall while statement needs to check only one condition: whether or\r\n",
        "not the flag is currently True. Then, all our other tests (to see if an event has\r\n",
        "occurred that should set the flag to False) can be neatly organized in the rest\r\n",
        "of the program.\r\n",
        "Let’s add a flag to parrot.py from the previous section. This flag, which\r\n",
        "we’ll call active (though you can call it anything), will monitor whether or\r\n",
        "not the program should continue running:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BoLtXzIFx9KU"
      },
      "source": [
        "prompt = \"\\nTell me something, and I will repeat it back to you:\"\r\n",
        "prompt += \"\\nEnter 'quit' to end the program. \""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3PlG-NwWyHak"
      },
      "source": [
        "#flag\r\n",
        "\r\n",
        "active=True\r\n",
        "while active:\r\n",
        "  message=input(prompt)\r\n",
        "  if message =='quit':\r\n",
        "    active=False\r\n",
        "  else:\r\n",
        "    print(message)\r\n",
        "\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pSDpZ_6mzA6W"
      },
      "source": [
        "#Using break to Exit a Loop\r\n",
        "\r\n",
        "prompt=\"\\n Please Enter The City You Visited\"\r\n",
        "prompt+=\"\\n(Enter 'quit' when you are finished.) \"\r\n",
        "\r\n",
        "while True:\r\n",
        "  city=input(prompt)\r\n",
        "  if city == 'quit':\r\n",
        "    break\r\n",
        "  else:\r\n",
        "    print(f\"I'd love to go to {city.title()}!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R_IkhsrhzvWY"
      },
      "source": [
        "#Using continue in a Loop\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "earzAVzg12fE"
      },
      "source": [
        "Rather than breaking out of a loop entirely without executing the rest of its\r\n",
        "code, you can use the continue statement to return to the beginning of the\r\n",
        "loop based on the result of a conditional test. For example, consider a loop\r\n",
        "that counts from 1 to 10 but prints only the odd numbers in that range:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YmQ9ZKkd13bw"
      },
      "source": [
        "#if i need to print only the odd number \r\n",
        "\r\n",
        "current_number =0\r\n",
        "while current_number<10:\r\n",
        "  current_number +=1\r\n",
        "  if current_number % 2==0:\r\n",
        "    continue\r\n",
        "  print(current_number)\r\n",
        " \r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qq4ysCP-36zK"
      },
      "source": [
        "Movie Tickets: A movie theater charges different ticket prices depending on\r\n",
        "a person’s age. If a person is under the age of 3, the ticket is free; if they are\r\n",
        "\r\n",
        "between 3 and 12, the ticket is $10; and if they are over age 12, the ticket is\r\n",
        "$15. Write a loop in which you ask users their age, and then tell them the cost\r\n",
        "of their movie ticket."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WN_azsEm2szb"
      },
      "source": [
        "\r\n",
        "age =input(\"Please Enter the age of the Person\")\r\n",
        "age=int(age)\r\n",
        "\r\n",
        "if age<3 :\r\n",
        "  print(\"The Ticket is free!\")\r\n",
        "\r\n",
        "elif age <=12:\r\n",
        "  print(\"The Ticket price is : $10\")\r\n",
        "\r\n",
        "elif age>12:\r\n",
        "  print('The ticket Price is : $15')\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ozZZ7vQwF55T"
      },
      "source": [
        "#Using a while Loop with Lists and Dictionaries\r\n",
        "\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eriV-MpsJ_-p"
      },
      "source": [
        "So far, we’ve worked with only one piece of user information at a time. We\r\n",
        "received the user’s input and then printed the input or a response to it.\r\n",
        "The next time through the while loop, we’d receive another input value\r\n",
        "and respond to that. But to keep track of many users and pieces of information, we’ll need to use lists and dictionaries with our while loops.\r\n",
        "A for loop is effective for looping through a list, but you shouldn’t modify\r\n",
        "a list inside a for loop because Python will have trouble keeping track of the\r\n",
        "items in the list. To modify a list as you work through it, use a while loop.\r\n",
        "Using while loops with lists and dictionaries allows you to collect, store, and\r\n",
        "organize lots of input to examine and report on later. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gBb-6IqKKAzy"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BQ31j3bKKOQh"
      },
      "source": [
        "#Moving Items from One List to Another\r\n",
        "Consider a list of newly registered but unverified users of a website. After\r\n",
        "we verify these users, how can we move them to a separate list of confirmed\r\n",
        "users? One way would be to use a while loop to pull users from the list of\r\n",
        "unconfirmed users as we verify them and then add them to a separate list of\r\n",
        "confirmed users. Here’s what that code might look like:\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ocfhcp5IKQKO"
      },
      "source": [
        "# Start with users that need to be verified,\r\n",
        "#users.py # and an empty list to hold confirmed users.\r\n",
        "unconfirmed_users = ['alice', 'brian', 'candace']\r\n",
        "confirmed_users = []\r\n",
        "\r\n",
        "#verify the user until the unconfirmed user no more \r\n",
        "\r\n",
        "#Move the verify user the to the confirmed_user list \r\n",
        "\r\n",
        "while unconfirmed_users:\r\n",
        "  current_user=unconfirmed_users.pop()\r\n",
        "\r\n",
        "  print(f\"Verifying User :{current_user.title()}\")\r\n",
        "  confirmed_users.append(current_user)\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g2AGyfC9K6HM"
      },
      "source": [
        "# Display all confirmed users.\r\n",
        "print(\"\\nThe following users have been confirmed:\")\r\n",
        "for confirmed_user in confirmed_users:\r\n",
        " print(confirmed_user.title())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bauq4oAdM1gZ"
      },
      "source": [
        "#@Removing All Instances of Specific Values from a List\r\n",
        "\r\n",
        "pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']\r\n",
        "\r\n",
        "print(pets)\r\n",
        "\r\n",
        "while 'cat' in pets:\r\n",
        " pets.remove('cat')\r\n",
        "\r\n",
        "print(pets)\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4sMwBxipNR7t"
      },
      "source": [
        "responses = {}\r\n",
        "\r\n",
        "\r\n",
        "# Set a flag to indicate that polling is active.\r\n",
        "polling_active = True\r\n",
        "\r\n",
        "while polling_active:\r\n",
        " # Prompt for the person's name and response.\r\n",
        " name = input(\"\\nWhat is your name? \")\r\n",
        " response = input(\"Which mountain would you like to climb someday? \")\r\n",
        "\r\n",
        "\r\n",
        " #Store the response in the dictionary.\r\n",
        " responses[name] = response\r\n",
        "\r\n",
        " # Find out if anyone else is going to take the poll.\r\n",
        " repeat = input(\"Would you like to let another person respond? (yes/ no / Yes / No) \")\r\n",
        " if repeat == 'no' or \"No\":\r\n",
        "  polling_active = False\r\n",
        "\r\n",
        "\r\n",
        "\r\n",
        "# Polling is complete. Show the results.\r\n",
        "print(\"\\n--- Poll Results ---\")\r\n",
        "\r\n",
        "for name, response in responses.items():\r\n",
        " print(f\"{name} would like to climb {response}.\")\r\n",
        "\r\n",
        " "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X-DX-NzcNsnW"
      },
      "source": [
        " "
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}