Python1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python1.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyPUiuDqPGAbbfi/AIMVNhEk",
      "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/Fatema110/Python1/blob/master/Python1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x00XxB2q7hfh",
        "colab_type": "text"
      },
      "source": [
        "*#Hello World*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G4bY-tC_7qZo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "74ed6b2a-f0a8-4080-c5e7-2ee10681b066"
      },
      "source": [
        "print(\"Hello world\")"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello world\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "is4-CkgtPkhV",
        "colab_type": "text"
      },
      "source": [
        "# Python Excercise from Kaggle"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "59e0ftGfPqxU",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "bc90769d-86c6-4b60-b0b9-67dbca2ca3af"
      },
      "source": [
        "spam_amount=0\n",
        "print(spam_amount)\n",
        "\n",
        "spam_amount=spam_amount+4\n",
        "print(spam_amount)\n",
        "\n",
        "if spam_amount>0:\n",
        "  print(\"I dont want any span!!\")\n",
        "\n",
        "viking_song=\"spam\"*spam_amount\n",
        "print(viking_song)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "4\n",
            "I dont want any span!!\n",
            "spamspamspamspam\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5yK7pI0PS4yd",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "1aa58d34-458a-424b-cc82-9f83971299e2"
      },
      "source": [
        "hat_height_cm = 25\n",
        "my_height_cm = 190\n",
        "# How tall am I, in meters, when wearing my hat?\n",
        "total_height_meters = hat_height_cm + my_height_cm / 100\n",
        "print(\"Height in meters =\", total_height_meters, \"?\")\n",
        "\n",
        "\n",
        "# Importance of Parenthesis\n",
        "total_height_meters = (hat_height_cm + my_height_cm) / 100\n",
        "print(\"Height in meters =\", total_height_meters)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Height in meters = 26.9 ?\n",
            "Height in meters = 2.15\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yfsBN4Z3ThU4",
        "colab_type": "text"
      },
      "source": [
        "**Buildin Function**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "09bg5_4bTNMK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "7437623b-8e36-4888-af90-1ca99d08eaa2"
      },
      "source": [
        "print(min(1,4,5))\n",
        "print(max(6,7,3))\n",
        "\n",
        "print(abs(32))\n",
        "print(abs(-67))"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "7\n",
            "32\n",
            "67\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PSfYYu3nTo_H",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "f81b1f67-1a9f-4ca0-da17-6282cf23e651"
      },
      "source": [
        "print(float(10))\n",
        "print(int(3.33))\n",
        "# They can even be called on strings!\n",
        "print(int('807') + 1)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10.0\n",
            "3\n",
            "808\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TqA_11lOZA1I",
        "colab_type": "text"
      },
      "source": [
        "Area and Diameter"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rdo4b7kDY--r",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "c18967ab-634e-4a0f-cfc0-10cc1e97d852"
      },
      "source": [
        "pi = 3.14159 # approximate\n",
        "diameter = 3\n",
        "\n",
        "# Create a variable called 'radius' equal to half the diameter\n",
        "radius=(1/2*diameter)\n",
        "print(radius)\n",
        "# Create a variable called 'area', using the formula for the area of a circle: pi times the radius squared\n",
        "area=pi*radius**2\n",
        "print(area)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1.5\n",
            "7.0685775\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3ekjHwpMZPDQ",
        "colab_type": "text"
      },
      "source": [
        "**Swapping List**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "37iHYds0ZYFm",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "43be749a-a152-4f8e-94a6-7a755e8a5f7d"
      },
      "source": [
        "a = [1, 2, 3]\n",
        "b = [3, 2, 1]\n",
        "a,b=b,a\n",
        "print(a)\n",
        "print(b)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3, 2, 1]\n",
            "[1, 2, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p-i0OdNnas91",
        "colab_type": "text"
      },
      "source": [
        "Alice, Bob and Carol have agreed to pool their Halloween candy and split it evenly among themselves. For the sake of their friendship, any candies left over will be smashed. For example, if they collectively bring home 91 candies, they'll take 30 each and smash 1.\n",
        "Write an arithmetic expression below to calculate how many candies they must smash for a given haul."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SWixoQwHa0mD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f1200661-7be5-4c36-8225-fdec2a287504"
      },
      "source": [
        "# Variables representing the number of candies collected by alice, bob, and carol\n",
        "alice_candies = 121\n",
        "bob_candies = 77\n",
        "carol_candies = 109\n",
        "\n",
        "# Your code goes here! Replace the right-hand side of this assignment with an expression\n",
        "# involving alice_candies, bob_candies, and carol_candies\n",
        "to_smash = -1\n",
        "smash_candy=(alice_candies + bob_candies + carol_candies) % 3\n",
        "print(smash_candy)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ir1ZZ9jccKxE",
        "colab_type": "text"
      },
      "source": [
        "**Functions**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g9M5zOEvZGnL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def least_difference(a, b, c):\n",
        "    diff1 = abs(a - b)\n",
        "    diff2 = abs(b - c)\n",
        "    diff3 = abs(a - c)\n",
        "    return min(diff1, diff2, diff3)\n",
        "\n",
        "    "
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SMJfmlwWcRcV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5ab3734a-15ef-41ea-c177-d9b9eea81d20"
      },
      "source": [
        "print(\n",
        "    least_difference(1, 10, 100),\n",
        "    least_difference(1, 10, 10),\n",
        "    least_difference(5, 6, 7), # Python allows trailing commas in argument lists. How nice is that?\n",
        ")"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "9 0 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_GFNYN_2izHz",
        "colab_type": "text"
      },
      "source": [
        "**Function that don't return**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xitlXpmcitlL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "cb55fdc0-d666-4d65-95b7-d05677f51f3e"
      },
      "source": [
        "def least_difference(a, b, c):\n",
        "    \"\"\"Return the smallest difference between any two numbers\n",
        "    among a, b and c.\n",
        "    \"\"\"\n",
        "    diff1 = abs(a - b)\n",
        "    diff2 = abs(b - c)\n",
        "    diff3 = abs(a - c)\n",
        "    min(diff1, diff2, diff3)\n",
        "    \n",
        "print(\n",
        "    least_difference(1, 10, 100),\n",
        "    least_difference(1, 10, 10),\n",
        "    least_difference(5, 6, 7),\n",
        ")"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "None None None\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mURB_SiMjcNx",
        "colab_type": "text"
      },
      "source": [
        "**Default Argument**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hHDwbiB9jhRU",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5caeecfd-fce7-4c80-8438-48e4467ae507"
      },
      "source": [
        "print(1, 2, 3, sep=' < ')"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 < 2 < 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2wy2e-hgjo5j",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5180016b-819d-448e-b16f-048b92a1eec5"
      },
      "source": [
        "print(1,2,3,4)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 2 3 4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P9-yAXBwjsqm",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "346a5ecc-a2cf-4e81-ee20-07c075595d51"
      },
      "source": [
        "def greet(who=\"Colin\"):\n",
        "    print(\"Hello,\", who)\n",
        "    \n",
        "greet()\n",
        "greet(who=\"Kaggle\")\n",
        "# (In this case, we don't need to specify the name of the argument, because it's unambiguous.)\n",
        "greet(\"world\")"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, Colin\n",
            "Hello, Kaggle\n",
            "Hello, world\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SflKZv7uj_g4",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "26aaf575-6d99-4ab3-ee87-99365daa2c60"
      },
      "source": [
        "def greet(name):\n",
        "  print(\"Hello\",name+\"!!\")\n",
        "\n",
        "greet(\"Mark\")\n"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello Mark!!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J6WNxjK1kyWg",
        "colab_type": "text"
      },
      "source": [
        "**Function Applied to Function**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hJRhbM44k5Pp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "5b4542b8-521d-4921-cdb2-0bcf9b5a8cdc"
      },
      "source": [
        "def mult_by_five(x):\n",
        "    return 5 * x\n",
        "\n",
        "def call(fn, arg):\n",
        "    \"\"\"Call fn on arg\"\"\"\n",
        "    return fn(arg)\n",
        "\n",
        "def squared_call(fn, arg):\n",
        "    \"\"\"Call fn on the result of calling fn on arg\"\"\"\n",
        "    return fn(fn(arg))\n",
        "\n",
        "print(\n",
        "    call(mult_by_five, 1),\n",
        "    squared_call(mult_by_five, 1), \n",
        "    sep='\\n', # '\\n' is the newline character - it starts a new line\n",
        ")"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5\n",
            "25\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kwIR-d5-lU2T",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "058a4016-160b-4fd9-91c0-f72bc71ff1a0"
      },
      "source": [
        "def mod_5(x):\n",
        "    \"\"\"Return the remainder of x after dividing by 5\"\"\"\n",
        "    return x % 5\n",
        "\n",
        "print(\n",
        "    'Which number is biggest?',\n",
        "    max(100, 51, 14),\n",
        "    'Which number is the biggest modulo 5?',\n",
        "    max(100, 51, 14, key=mod_5),\n",
        "    sep='\\n',\n",
        ")"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Which number is biggest?\n",
            "100\n",
            "Which number is the biggest modulo 5?\n",
            "14\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G4FwzL5xo_3h",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "7cb199a5-fce6-42fc-a2b3-498986b3effc"
      },
      "source": [
        "#Round off\n",
        "def round_to_two_places(num):\n",
        "    return round(num,2)\n",
        "round_to_two_places(31.456)\n"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "31.46"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L139NiqgpTym",
        "colab_type": "text"
      },
      "source": [
        "For the sake of their friendship, any candies left over would be smashed. For example, if they collectively bring home 91 candies, they'll take 30 each and smash 1.\n",
        "\n",
        "Below is a simple function that will calculate the number of candies to smash for any number of total candies.\n",
        "\n",
        "Modify it so that it optionally takes a second argument representing the number of friends the candies are being split between. If no second argument is provided, it should assume 3 friends, as before.\n",
        "\n",
        "Update the docstring to reflect this new behaviour."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "93Br49V5pLqT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "375f8404-d0fd-495b-9b34-2b41f6328302"
      },
      "source": [
        "def to_smash(total_candies,friends=3):\n",
        "    \"\"\"Return the number of leftover candies that must be smashed after distributing\n",
        "    the given number of candies evenly between 3 friends.\n",
        "    \n",
        "    >>> to_smash(91)\n",
        "    1\n",
        "    \"\"\"\n",
        "    return total_candies % friends\n",
        "to_smash(91,3)"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "27sELpo6tt5g",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "4f2e9463-7222-4837-fc9a-85232a97a3c6"
      },
      "source": [
        "#PRESIDENT PROBLEM\n",
        "def can_run_for_president(age):\n",
        "    \"\"\"Can someone of the given age run for president in the US?\"\"\"\n",
        "    # The US Constitution says you must be at least 35 years old\n",
        "    return age >= 35\n",
        "\n",
        "print(\"Can a 19-year-old run for president?\", can_run_for_president(19))\n",
        "print(\"Can a 45-year-old run for president?\", can_run_for_president(45))\n"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Can a 19-year-old run for president? False\n",
            "Can a 45-year-old run for president? True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rz9TvFppt5Iz",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "d0ed141b-4c6b-4876-8d92-b2ec3acdd67b"
      },
      "source": [
        "#ODD EVEN \n",
        "def is_odd(n):\n",
        "    return (n % 2) == 1\n",
        "\n",
        "print(\"Is 100 odd?\", is_odd(100))\n",
        "print(\"Is -1 odd?\", is_odd(-1))"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Is 100 odd? False\n",
            "Is -1 odd? True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GAOOTnePuR4Q",
        "colab_type": "text"
      },
      "source": [
        "**Combing Boolean Values**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FFcDUn3uuP6v",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "c3747883-6eaf-4820-d8bd-2b330fe2e07b"
      },
      "source": [
        "def can_run_for_president(age, is_natural_born_citizen):\n",
        "    \"\"\"Can someone of the given age and citizenship status run for president in the US?\"\"\"\n",
        "    # The US Constitution says you must be a natural born citizen *and* at least 35 years old\n",
        "    return is_natural_born_citizen and (age >= 35)\n",
        "\n",
        "print(can_run_for_president(19, True))\n",
        "print(can_run_for_president(55, False))\n",
        "print(can_run_for_president(55, True))"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n",
            "False\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1yau3DSauv8H",
        "colab_type": "text"
      },
      "source": [
        "**PRECEDENCE**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jCEqkmzju3kV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "52d573b3-6f51-4267-8706-f1e1a4641bb6"
      },
      "source": [
        "True or True and False\n",
        "\n",
        "\n",
        "\"\"\"For example, and is evaluated before or. That's why the first expression above is True.\n",
        " If we evaluated it from left to right, we would have calculated True or True first (which is True), \n",
        " and then taken the and of that result with False, giving a final value of False.\"\"\""
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vzniGG4Nvihf",
        "colab_type": "text"
      },
      "source": [
        "**POSITIVE AND NEGATIVE NUMBERS**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_uI5tnHTvZ9L",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "3ed54a56-946a-4021-8a95-0b14e8d48ede"
      },
      "source": [
        "#POSITIVE AND NEGATIVE NUMBERS\n",
        "def inspect(x):\n",
        "    if x == 0:\n",
        "        print(x, \"is zero\")\n",
        "    elif x > 0:\n",
        "        print(x, \"is positive\")\n",
        "    elif x < 0:\n",
        "        print(x, \"is negative\")\n",
        "    else:\n",
        "        print(x, \"is unlike anything I've ever seen...\")\n",
        "\n",
        "inspect(0)\n",
        "inspect(-15)"
      ],
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 is zero\n",
            "-15 is negative\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YjKVFw5nvzgM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "d471048e-631d-41b2-be83-e13a4530bba3"
      },
      "source": [
        "def f(x):\n",
        "    if x > 0:\n",
        "        print(\"Only printed when x is positive; x =\", x)\n",
        "        print(\"Also only printed when x is positive; x =\", x)\n",
        "    print(\"Always printed, regardless of x's value; x =\", x)\n",
        "\n",
        "f(1)\n",
        "f(0)"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Only printed when x is positive; x = 1\n",
            "Also only printed when x is positive; x = 1\n",
            "Always printed, regardless of x's value; x = 1\n",
            "Always printed, regardless of x's value; x = 0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8j2_0o7-wr4N",
        "colab_type": "text"
      },
      "source": [
        "**BOOLEAN**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sWsf2v0zwp50",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "6b3cd06c-49d6-4e3c-8d53-ab580fd1b76c"
      },
      "source": [
        "print(bool(1)) # all numbers are treated as true, except 0\n",
        "print(bool(0))\n",
        "print(bool(\"asf\")) # all strings are treated as true, except the empty string \"\"\n",
        "print(bool(\"\"))\n",
        "# Generally empty sequences (strings, lists, and other types we've yet to see like lists and tuples)\n",
        "# are \"falsey\" and the rest are \"truthy\""
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n",
            "True\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nb6cyKMxw3Kb",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "703efb28-d627-4290-a4d3-e5b2ed993b39"
      },
      "source": [
        "if 0:\n",
        "    print(0)\n",
        "elif \"spam\":\n",
        "    print(\"spam\")"
      ],
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "spam\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}