Untitled7.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyM66XDTTOZ2c2dwtZ0TFt5R",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/RkBeau/FMBlog/blob/main/Untitled7.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Defining Essential Python DataTypes\n"
      ],
      "metadata": {
        "id": "LDuvWRzSgnRp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Putting information into variables"
      ],
      "metadata": {
        "id": "PfddOa3zg7pT"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hw8-BCS6gUzn",
        "outputId": "75c2eaae-717f-48e8-fd84-d0a69c403739"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ],
      "source": [
        "# variables are assigned with value with the\"=\" assignment operator\n",
        "myVar = 5\n",
        "print(myVar)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Understanding the Numeric Data Types"
      ],
      "metadata": {
        "id": "2gXKM9MaiRLf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Integers\n",
        "\n",
        "Integers are, put plainly, whole, real, numbers.  This includes \"-\" negative integers.\n"
      ],
      "metadata": {
        "id": "vT1218eFiec0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "AhWHIQgLieaa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Test = 0b100\n",
        "print(\"100 binary: \", Test)\n",
        "\n",
        "Test = 0o100\n",
        "print(\"100 octal: \", Test)\n",
        "\n",
        "Test = 0x100\n",
        "print(\"100 hexadecimal: \", Test)\n",
        "\n",
        "print(bin(Test))\n",
        "print(oct(Test))\n",
        "print(hex(Test))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_VQ5hzv2ipAa",
        "outputId": "f4521d3f-7296-40bd-ccb6-ce38affeb92a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "100 binary:  4\n",
            "100 octal:  64\n",
            "100 hexadecimal:  256\n",
            "0b100000000\n",
            "0o400\n",
            "0x100\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Floating Point Types"
      ],
      "metadata": {
        "id": "sdNNoI4NuznF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Test = 255.0\n",
        "print(\"Direct Assignment: \", Test)\n",
        "\n",
        "Test = float(255)\n",
        "print(\"Type Casting: \", Test)\n",
        "\n",
        "Test = 2.55e2\n",
        "print(\"Scientific Notation: \", Test)\n",
        "\n",
        "Test = 2.55e-2\n",
        "print(\"Negative Exponent:\", Test)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aZPh-ry-4PcO",
        "outputId": "d48fd210-a6fa-400c-9bec-c673f00996ad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Direct Assignment:  255.0\n",
            "Type Casting:  255.0\n",
            "Scientific Notation:  255.0\n",
            "Negative Exponent: 0.0255\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Complex numbers"
      ],
      "metadata": {
        "id": "o6vUZMkY5Hqe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "myComplex = 3 + 4j\n",
        "print(myComplex.real)\n",
        "print(myComplex.imag)\n",
        "print(myComplex.conjugate())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z0d1Faoq5YBi",
        "outputId": "b5916d5e-d256-49b7-d508-8f24359df4fe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3.0\n",
            "4.0\n",
            "(3-4j)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Understanding Boolean Values"
      ],
      "metadata": {
        "id": "CEPJ6Utg56iY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# A Boolean can only contain one of two values\n",
        "# true or false, 0 or 1, open or closed.\n",
        "myBool = 1 > 2\n",
        "print(myBool) #or\n",
        "myBool = 2 > 1\n",
        "print(myBool)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EHKcW-y66OWA",
        "outputId": "61936295-9397-47fa-ad89-99a9b021d039"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Understanding Strings\n",
        "\n",
        "\n",
        "---\n",
        "Strings are simply a series of characters contained within doublequotes.  They can be any character on the keyboard in any order.  Strings can be made of numeric characters.  Sometimes these have to be converted to their numeric data types like so:\n"
      ],
      "metadata": {
        "id": "N-q9wuJ_7SUN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# To better understand the concept of strings consider that each character is\n",
        "# represented in the machine by an ascii code. We can see this value by using\n",
        "# the ord() function.\n",
        "print(ord('A'))\n",
        "print(ord('a'))\n",
        "print(ord('0'))\n",
        "# note that the 'A' and 'a' characters value is 32 places difference.  this\n",
        "# is because ascii lists all lowercase then all uppercase letters.\n",
        "'''\n",
        "    sometimes it is neccesary to convert a string to a number\n",
        "    we do so with the int() function and the float() function\n",
        "'''\n",
        "myInt = int('123')\n",
        "print(myInt)\n",
        "myFloat = float('123.45')\n",
        "print(type(myFloat))\n",
        "print(type(myInt))\n",
        "'''\n",
        "    we can also convert a number to a string with the str() function\n",
        "'''\n",
        "myString = str(123)\n",
        "print(type(myString))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Um8HMrmR7Wsg",
        "outputId": "b452f859-5dcb-4412-a4aa-9dee50b1bdb2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "65\n",
            "97\n",
            "48\n",
            "123\n",
            "<class 'float'>\n",
            "<class 'int'>\n",
            "<class 'str'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Managing Information"
      ],
      "metadata": {
        "id": "_eTIuc_T_DAB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Creating and Using Functions\n"
      ],
      "metadata": {
        "id": "rGfrFBXBJzrs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Defining a function"
      ],
      "metadata": {
        "id": "kkK0DIrdJ-Gn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# @title\n",
        "'''\n",
        "    To define a function we use the keyword \"def\" followed\n",
        "    by the function name and parenthesis ending with a colon\n",
        "'''\n",
        "def myFunction():\n",
        "    print(\"Hello World\")\n",
        "\n",
        "# Make sure to run this cell first to define the function %% [markdown] ##\n",
        "# Accessing functions a function is accessed by calling or invoking it. This is\n",
        "# done simply by entering the function name. %%"
      ],
      "metadata": {
        "id": "szjG9HeSewBK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Accessing functions\n",
        "\n",
        "a function is accessed by calling or invoking it.  This is done simply by entering the function name."
      ],
      "metadata": {
        "id": "UKk1FUd-LpW5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "myFunction()  # Now you can call the function"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 147
        },
        "id": "_sWHN3bGMESP",
        "outputId": "02027842-eb31-4b81-e0de-2835750b56d9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "name 'myFunction' is not defined",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-1-28fc209470a8>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmyFunction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# Now you can call the function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'myFunction' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Understanding arguments\n",
        "\n",
        "    Arguments are data you supply the function with.  these may be litorals or variable names.  "
      ],
      "metadata": {
        "id": "6x4xc4ZiMoY-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def AddIt(value1, value2):\n",
        "    print(value1, \" + \", value2, \" = \", (value1 + value2))\n",
        "3\n",
        "AddIt(1, 2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qyhan9KvNBQA",
        "outputId": "d7e35cb8-f5d0-4a6c-bd81-f5abec205b66"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1  +  2  =  3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### default values\n",
        "    to create a default value simply follow the argument name with an assignment operator and the value."
      ],
      "metadata": {
        "id": "WhWajYX2Nw0d"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def Hello(Greeting = \"No Value Supplied\"):\n",
        "    print(Greeting)\n",
        "\n",
        "Hello()\n",
        "Hello(\"hello world\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gWB6qVhhOHVu",
        "outputId": "db64d289-7f32-4b5d-b2e1-a520c8526777"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "No Value Supplied\n",
            "hello world\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Creating functions with a variable number of arguments"
      ],
      "metadata": {
        "id": "p2CEyAHkPJ-6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "    To create a function that can accept a variable number of arguments\n",
        "    create a variable preceded by an asterisk and the name of the variable like so:\n",
        "'''\n",
        "def Hello4(ArgCount, *varArgs):\n",
        "    print(\"You passed \", ArgCount, \" arguments.\")\n",
        "    for Arg in varArgs:\n",
        "        print(Arg)\n",
        "\n",
        "Hello4(1, \"Hello\")\n",
        "Hello4(2, \"Hello\", \"World\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "64AAdLWyuB2i",
        "outputId": "5714df90-bfb3-4bfc-8150-e308fcf5e6d0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "You passed  1  arguments.\n",
            "Hello\n",
            "You passed  2  arguments.\n",
            "Hello\n",
            "World\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def Hello4(ArgCount, *varArgs):\n",
        "    print(\"You passed \", ArgCount, \" arguments.\")\n",
        "    for Arg in varArgs:\n",
        "        print(Arg)\n",
        "Hello4(1, \"A test string.\")\n",
        "Hello4(3, \"one\", \"two\", \"three\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_quMYGlCPhG8",
        "outputId": "b9d1dbfd-4413-4fef-b7bd-0fca4acad4a5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "You passed  1  arguments.\n",
            "A test string.\n",
            "You passed  3  arguments.\n",
            "one\n",
            "two\n",
            "three\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Returning Information From Functions\n",
        "    To return data to a caller, a function needs to include the keyword \"return\", followed by the data to be returned.  Some data types commonly returned are:\n",
        "        *Values*: Any value is acceptable.  Numbers, strings, Booleans.\n",
        "       * Variables*: The content of any variable works just as well as a direct value.  The caller recieves what is stored in the variable.\n",
        "       * Expression*s: You can simply return a + b rather than perform the calculation.  Place the result in a variable, and then return the variable.  Faster.\n",
        "       * Results from other functions*:  May call the data from another funtion as part of the return.*italicized text*\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "1sijJ6rCQZmt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def DoAdd(Value1, Value2):\n",
        "    return Value1 + Value2\n",
        "\n",
        "Result = DoAdd(1, 2)\n",
        "print(Result)\n",
        "\n",
        "DoAdd(5, 7)\n",
        "print('The result of 5 plus 7 is', DoAdd(5, 7))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4o4WrJbdSSBV",
        "outputId": "7e6a9f94-3045-487a-c82c-1fc0503d517c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "The result of 5 plus 7 is 12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Comparing function output"
      ],
      "metadata": {
        "id": "1hQv0qybS-IE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "DoAdd(2, 2) == DoAdd(1, 3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-ggtM2pyTHyw",
        "outputId": "519948a8-df2a-4de6-a323-6848c086e3e1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Getting User Input\n",
        "    Most functions require input from a user or a data file.  For this we use the input() funtion.\n",
        "\n",
        "    Input() always outputs a string.  Even if a user types a number the output is a string.  If you are needing a number you must convert it to the appropriate numeric data type after recieving the input.  "
      ],
      "metadata": {
        "id": "mHY32uHHThmQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Name = input(\"What is your name? \")\n",
        "print(\"Hello\", Name)\n",
        "\n",
        "#conversion to other data types.\n",
        "ANumber = float(input(\"Type a number: \"))\n",
        "print(\"You entered\" , ANumber)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2n6x8UxYUQ5L",
        "outputId": "fb19df7e-4c45-434a-99de-72444df764e7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "What is your name? kyle\n",
            "Hello kyle\n",
            "Type a number: 43\n",
            "You entered 43.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Making Decisions\n",
        "Making decisions is a critical part of work.  The ability to make a decision and take one path or another is the basis of logical processes and alogorithms.  Computers often perform the following decision making processes:\n",
        "*Obtain the actual or current value of something.*\n",
        "*Compare the actual or current value with a desired value*\n",
        "*Perform an action that corresponds to the desired outcome of the comparison*"
      ],
      "metadata": {
        "id": "uEJKnR_nV_eC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Understanding if statements\n",
        "    The if statement is the easiest method for decision making in Python.  Simply states, \"if condition, then do this code\".  \n",
        "    The syntax is as follows:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "# This is formatted as code\n",
        "```if (someCondition == true):\n",
        "        do someCode```\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "trev-1FmXTRV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "TestMe = 5\n",
        "if TestMe == 5:\n",
        "    print(\"TestMe is equal to 5\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vvk-BVN9YgLn",
        "outputId": "44a2533f-55c6-40c9-8268-14aa86099be9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "TestMe is equal to 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "M2c34UE5Y9kz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Using the if statement in an application\n",
        "\n",
        "There are three common ways to use if in an application:\n",
        " >>use a single condition to exercute a single statement when      \n",
        "      the condition is true.\n",
        ">>use a single condition to execute multiple statements when the\n",
        "     condition is true.\n",
        ">>Combine multiple conditions into a single decision and execute one or more statements when combined conditions are true"
      ],
      "metadata": {
        "id": "gULqehR_Y1ao"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### working with relational operators\n",
        "\n",
        "    A relational operator determines how a value on the left side of an expression compares to the value on the right side of the expression.  After determination, it outputs a value of true or false.  This reflects the truth value of the expression."
      ],
      "metadata": {
        "id": "o34qddMqaBFR"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "UmDplM9Ca8-o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# assign variable values\n",
        "TestMe = 6\n",
        "if (TestMe == 5):\n",
        "    #this creates the if statement\n",
        "    print(\"TestMe is equal to 5\")\n",
        "if (TestMe == 6):\n",
        "    print(\"TestMe is equal to 6\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N4PhWQ3YbBno",
        "outputId": "df471de8-26f4-4721-c1fc-6506b6a8f047"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "TestMe is equal to 6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## performing multiple tasks\n",
        "    Sometimes it is neccesary to perform more than one task after making a decision.  Python relies on indentation to determine when to stop executing tasks as part of an if statement.\n",
        "    "
      ],
      "metadata": {
        "id": "uOJYDaMeb0bj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "TestMe = 6\n",
        "if (\"TestMe\"== 6):\n",
        "    print(\"TestMe is equal to 6\")"
      ],
      "metadata": {
        "id": "Dk6B4t5FfyhN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## making multiple comparisons by using logical operators\n",
        "    To make multiple comparisons, you create multiple conditions by using relational operators and combine them using logical operators. A *logical operator* describes how conditions combine.  For example,\n",
        "      "
      ],
      "metadata": {
        "id": "R4FV4nRUgs-h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "X==6 and y==7\n",
        "\n",
        "'''\n",
        "    The *and* keyword is a logical operator that states both conditions must be true for the statement to be true.\n",
        "'''\n",
        "\n"
      ],
      "metadata": {
        "id": "dCBphv1ciFvs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Choosing Alternatives by Using the If ...Else Statement"
      ],
      "metadata": {
        "id": "m84LGbStjfZw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Understanding the if ... else statement\n",
        "    With python, you choose one of two alternatives by using the else clause of the if statement.  A clause is an addition to a code block that modifies the way that it works.  Most code blocks support multiple clauses.  "
      ],
      "metadata": {
        "id": "O3flYlCzj39U"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Using the if/else statement in an application"
      ],
      "metadata": {
        "id": "ynOqvQlukcO2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Value = int(input(\"Type a number between 1 and 10: \"))\n",
        "if (Value > 0 ) and (Value <= 10):\n",
        "    print(\"You typed: \", Value)\n",
        "else:\n",
        "    print(\"The value you typed is incorrect.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dyLMQIZbkopo",
        "outputId": "26396108-349e-4225-c845-5dcf3109a724"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Type a number between 1 and 10: 11\n",
            "The value you typed is incorrect.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Using the if/elif statement in an application\n",
        "    Use if/elif if there are more than two options but a separate statement is not needful."
      ],
      "metadata": {
        "id": "-QG_aXLSldhk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"1. Red\")\n",
        "print(\"2. Orange\")\n",
        "print(\"3. Yellow\")\n",
        "print(\"4. Green\")\n",
        "print(\"5. Blue\")\n",
        "print(\"6. Purple\")\n",
        "Choice = int(input(\"select your favorite color: \"))\n",
        "if (Choice == 1):\n",
        "    print(\"You chose Red\")\n",
        "elif (Choice == 2):\n",
        "    print(\"You chose Orange\")\n",
        "elif (Choice == 3):\n",
        "    print(\"You chose Yellow\")\n",
        "elif (Choice == 4):\n",
        "    print(\"You chose Green\")\n",
        "elif (Choice == 5):\n",
        "    print(\"You chose Blue\")\n",
        "elif (Choice == 6):\n",
        "    print(\"You chose Purple\")\n",
        "else:\n",
        "    print(\"You made an invalid choice\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N0hHJB2Bl1MD",
        "outputId": "eb4fca39-f1b7-41a2-c392-b16e541bfcbe"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1. Red\n",
            "2. Orange\n",
            "3. Yellow\n",
            "4. Green\n",
            "5. Blue\n",
            "6. Purple\n",
            "select your favorite color: 8\n",
            "You made an invalid choice\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Using Nested Decision Statements\n",
        "    The process of making decisions in levels, with each level dependent on the previous level is called nesting"
      ],
      "metadata": {
        "id": "-Kc_TJaimriI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Using multiple if or if else statements\n",
        "    The most commonly used multi selection technique is a combination of if and if...else statements.  The form of selection is often called a selection tree because of its resemblance to the branches of a tree."
      ],
      "metadata": {
        "id": "M4f3psMsnAsk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "One = int(input(\"Type a number between 1 and 10: \"))\n",
        "Two = int(input(\"Type a number between 1 and 10: \"))\n",
        "if (One >= 1) and (One <= 10):\n",
        "    if (Two >= 1) and (Two <= 10):\n",
        "        print(\"your secret number is:  \", One * Two)\n",
        "    else:\n",
        "        print(\"Incorrect second value!\")\n",
        "else:\n",
        "    print(\"Incorrect first value!\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h2mF3v3-nalK",
        "outputId": "fea1f547-26ef-4aeb-9b3b-806d62478565"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Type a number between 1 and 10: 5\n",
            "Type a number between 1 and 10: 8\n",
            "your secret number is:   40\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Combining other types of decisions\n",
        "    Any combination of if, if...else, and if...elif statements may be used to provide a desired outcome. The blocks may be nested as many levels deep as needed to perform the required checks.  "
      ],
      "metadata": {
        "id": "Kc36xs_9ohgV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"1. Eggs\")\n",
        "print(\"2. Pancakes\")\n",
        "print(\"3. Waffles\")\n",
        "print(\"4. Oatmeal\")\n",
        "MainChoice = int(input(\"Choose a breakfast item: \"))\n",
        "\n",
        "if MainChoice == 1:\n",
        "    Meal = \"Eggs\"\n",
        "    print(\"1. Wheat Toast\")\n",
        "    print(\"2. Sourdough\")\n",
        "    print(\"3. Rye\")\n",
        "    BreadChoice = int(input(\"Choose a type of bread: \"))\n",
        "    if BreadChoice == 1:\n",
        "        Bread = \"Wheat\"\n",
        "    elif BreadChoice == 2:\n",
        "        Bread = \"Sourdough\"\n",
        "    elif BreadChoice == 3:\n",
        "        Bread = \"Rye\"\n",
        "    else:\n",
        "        print(\"You chose an invalid bread choice.\")\n",
        "        Bread = None\n",
        "    if Bread:\n",
        "        print(f\"You chose {Meal} with {Bread} bread.\")\n",
        "elif MainChoice in [2, 3]:\n",
        "    Meal = \"Pancakes\" if MainChoice == 2 else \"Waffles\"\n",
        "    print(\"1. Syrup\")\n",
        "    print(\"2. Strawberries\")\n",
        "    print(\"3. Powdered Sugar\")\n",
        "    ToppingChoice = int(input(\"Choose a topping: \"))\n",
        "    if ToppingChoice == 1:\n",
        "        Topping = \"Syrup\"\n",
        "    elif ToppingChoice == 2:\n",
        "        Topping = \"Strawberries\"\n",
        "    elif ToppingChoice == 3:\n",
        "        Topping = \"Powdered Sugar\"\n",
        "    else:\n",
        "        print(\"You chose an invalid topping.\")\n",
        "        Topping = None\n",
        "    if Topping:\n",
        "        print(f\"You chose {Meal} with {Topping}.\")\n",
        "elif MainChoice == 4:\n",
        "    Meal = \"Oatmeal\"\n",
        "    print(f\"You chose {Meal}.\")\n",
        "else:\n",
        "    print(\"You chose an invalid breakfast item.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l9O9I6KTyWOM",
        "outputId": "bbc9d26b-8020-43c7-88bc-cae6ac5fcedf"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1. Eggs\n",
            "2. Pancakes\n",
            "3. Waffles\n",
            "4. Oatmeal\n",
            "Choose a breakfast item: 1\n",
            "1. Wheat Toast\n",
            "2. Sourdough\n",
            "3. Rye\n",
            "Choose a type of bread: 1\n",
            "You chose Eggs with Wheat bread.\n"
          ]
        }
      ]
    }
  ]
}