intro_to_python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyPHBiByilYVuOEX5clTzzoL",
      "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/aseddin/F23_ECE4715/blob/main/intro_to_python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Introduction to Python\n",
        "\n",
        "**Objective:** To introduce Python, its syntax, basic data types, and control structures.\n",
        "\n",
        "**IDEs**\n",
        "   - [Colab](https://colab.google/)  \n",
        "   - [Jupyter](https://jupyter.org/)\n",
        "   - [Visual Studio Code](https://code.visualstudio.com/). You might want to install the Jupyter plugin\n",
        "   - [PyCharm](https://www.jetbrains.com/community/education/#students)\n"
      ],
      "metadata": {
        "id": "MH4eteTVsISw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Python Basics"
      ],
      "metadata": {
        "id": "2GuzMG7huHMv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Printing \"Hello, World!\"\n",
        "print(\"Hello, World!\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cGjE7mXguirM",
        "outputId": "ae202607-b6a6-4694-c319-398e26cf802b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, World!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        " **Indentation and whitespace significance**\n",
        "\n",
        " Python uses indentation (usually four spaces) to indicate code blocks. In C/C++, you typically use curly braces `{}` to define code blocks. In Python, consistent indentation is crucial for code readability and structure. Incorrect indentation can result in syntax errors."
      ],
      "metadata": {
        "id": "7o19XV0FvPqT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "if True:\n",
        "    print(\"This is indented.\")\n",
        "    print(\"Python uses indentation to define code blocks.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9bwDxEj6uwau",
        "outputId": "e6657eb6-3b51-4193-e33f-66099334df33"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "This is indented.\n",
            "Python uses indentation to define code blocks.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Variables and dynamic typing**\n",
        "\n",
        "Python uses dynamic typing, which means you don't have to declare a variable's type explicitly. The type is determined at runtime based on the value you assign to it. This flexibility can make code shorter and more readable compared to statically-typed languages like C/C++."
      ],
      "metadata": {
        "id": "SxG69_yqvl91"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Variables and dynamic typing\n",
        "x = 10  # x is an integer\n",
        "y = 3.14  # y is a float\n",
        "name = \"Alice\"  # name is a string\n",
        "is_student = True  # is_student is a boolean\n",
        "\n",
        "# Reassigning a variable\n",
        "print(type(x))\n",
        "x = \"Hello\"  # Now x is a string\n",
        "print(type(x))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GpLhW4T0vwW-",
        "outputId": "11c50e74-62e6-4738-f49e-8386667a7aca"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'int'>\n",
            "<class 'str'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Basic Data Types: int, float, string, boolean**\n",
        "\n",
        "Python supports various basic data types, including:\n",
        "\n",
        "* `int`: Integer data type for whole numbers.\n",
        "* `float`: Floating-point data type for decimal numbers.\n",
        "* `str`: String data type for text.\n",
        "* `bool`: Boolean data type for true or false values.\n",
        "\n",
        "If necessary, you can perform type conversions easily using functions like `str()`, `int()`, and `float()` to change data types as needed."
      ],
      "metadata": {
        "id": "QkVl3FkEwQan"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Basic data types\n",
        "integer_num = 42\n",
        "floating_num = 3.14\n",
        "text = \"Python is great!\"\n",
        "is_python_fun = True\n",
        "\n",
        "# Type conversion\n",
        "num_as_string = str(integer_num)\n",
        "float_as_int = int(floating_num)\n",
        "\n",
        "print(\"integer_num is of type:\", type(integer_num))\n",
        "print(\"num_as_string is of type:\", type(num_as_string))\n",
        "print(\"float_as_int is of type:\", type(float_as_int))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "14M5K_Bkwy2N",
        "outputId": "8338f1da-70ed-4cd1-828d-8ef2dc789c24"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "integer_num is of type: <class 'int'>\n",
            "num_as_string is of type: <class 'str'>\n",
            "float_as_int is of type: <class 'int'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Control Structures"
      ],
      "metadata": {
        "id": "b19vpiMaxZDn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Conditional Statements:\n",
        "\n",
        "`if`, `elif`, `else` work as you would expect.\n",
        "\n",
        "Relational operators | Meaning\n",
        "- | -\n",
        "== | equal\n",
        "!= | not equal\n",
        "< | less than\n",
        "<= | less or euqal\n",
        "> | greater than\n",
        ">= | greater or equal than\n",
        "\n",
        "------------------------------\n",
        "\n",
        "\n",
        "Boolean logic operators | Meaning\n",
        "- | -\n",
        "and | logic and\n",
        "or | logic or\n",
        "not | logic not"
      ],
      "metadata": {
        "id": "CpiZz6yfxht-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Conditional statements\n",
        "age = 25\n",
        "\n",
        "if age < 18:\n",
        "    print(\"You are a minor.\")\n",
        "elif age >= 18 and age < 65:\n",
        "    print(\"You are an adult.\")\n",
        "else:\n",
        "    print(\"You are a senior citizen.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CaQVLk08ySzq",
        "outputId": "a3c70f6c-69d5-4eb3-844c-7974b64d4f10"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "You are an adult.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can test conditional statements"
      ],
      "metadata": {
        "id": "z8VNzJDdy-e_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 5"
      ],
      "metadata": {
        "id": "pWwaQ_9Fy9sy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x == 5"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rXXe6dK3zFfW",
        "outputId": "624b6d37-5b03-44b0-e134-e72be5bc67ee"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x != 8"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kxTyNv_FzH43",
        "outputId": "594b4edc-9982-4625-bc1d-54fb97ae0ff0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "(x > 3) and (x < 10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AeMMa0Y3zH_w",
        "outputId": "9c3f577a-a42d-48b4-e492-f5b8df3615a4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Loops\n",
        "\n",
        "`for`, `while`, `break`, `continue` operate as you would expect"
      ],
      "metadata": {
        "id": "oZugedfwzVCI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l = [2, 4, 5, 6]\n",
        "for i in l:\n",
        "  print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KfQC0Y_bzuBw",
        "outputId": "74740eb8-2b96-493f-aa73-600697d33441"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "4\n",
            "5\n",
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(10):\n",
        "  print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dw5I6SjIzxNY",
        "outputId": "c48e36a6-ce79-4e19-c16a-561194892950"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# For loop to iterate through a list\n",
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "\n",
        "for fruit in fruits:\n",
        "    print(fruit)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FqVT99hhzIF2",
        "outputId": "75fe85e7-f1dd-43de-e427-ab23e1e19be5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# While loop to count from 1 to 5\n",
        "count = 1\n",
        "\n",
        "while count <= 5:\n",
        "    print(count)\n",
        "    count += 1\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EbGtRc4Tz0Y3",
        "outputId": "3090a741-5795-4e9b-9780-8ef8e14f4f33"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Containers"
      ],
      "metadata": {
        "id": "of7yj_CH0cls"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Lists\n",
        "\n",
        "Lists are one of the most commonly used data structures in Python. They can hold a collection of items and are mutable, meaning you can change their contents after creation."
      ],
      "metadata": {
        "id": "UEIwh2eI0oKt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a list\n",
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "\n",
        "print(fruits)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SdZ4m-1b0wp6",
        "outputId": "d2efa882-a846-44d8-c190-ec7cf685ffd0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Adding elements to a list\n",
        "fruits.append(\"orange\")\n",
        "\n",
        "print(fruits)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pqLe9VaQ04N9",
        "outputId": "3f3c782b-02cf-4fff-dcdf-d7b2726fdb9d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry', 'orange']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Another way to add is to use +\n",
        "fruits += ['melon']\n",
        "\n",
        "print(fruits)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n5kL0SOq1vAP",
        "outputId": "99ae30da-fafd-41cd-bab7-9315416be017"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'banana', 'cherry', 'orange', 'melon']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Accessing elements by index\n",
        "print(fruits[0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gVfUMWPd1EsE",
        "outputId": "7046b43a-f38a-4da2-d366-4d3e4ce107a1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifying Elemnts\n",
        "fruits[1] = \"kiwi\"\n",
        "\n",
        "print(fruits)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XK7vWQhi1eiS",
        "outputId": "151a950b-86cd-4695-b654-48c1744e3fda"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple', 'kiwi', 'cherry', 'orange', 'melon']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Slicing\n",
        "\n",
        "List slicing is a powerful feature in Python that allows you to extract specific portions or segments of a list. It is done by specifying a start index, an end index, and an optional step value within square brackets `[start:end:step]`. Here's a breakdown of how list slicing works:\n",
        "\n",
        "1. **Start Index**: This is the index of the element where the slice begins. The element at this index is included in the slice. If you omit the start index, it defaults to 0 (the beginning of the list).\n",
        "\n",
        "2. **End Index**: This is the index of the element where the slice ends. The element at this index is not included in the slice. If you omit the end index, it goes up to the end of the list.\n",
        "\n",
        "3. **Step Value**: This is an optional parameter that specifies the step or interval between elements to include in the slice. It can be used to skip elements in the list. If you omit the step value, it defaults to 1 (every element is included).\n",
        "\n",
        "\n",
        "Some important points to note:\n",
        "\n",
        "- List slicing returns a new list containing the selected elements; it doesn't modify the original list.\n",
        "- If the start index is greater than or equal to the end index, an empty list is returned.\n",
        "- Slicing with a negative step can be used to reverse a list or extract elements in reverse order.\n",
        "\n",
        "Here are some examples to illustrate list slicing:\n"
      ],
      "metadata": {
        "id": "f77EQzqm2FQv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
        "\n",
        "# Slicing from index 2 to 5 (exclusive), step by 1\n",
        "slice1 = my_list[2:5]\n",
        "print(\"slice1:\", slice1)\n",
        "\n",
        "# Slicing from index 1 to the end\n",
        "slice2 = my_list[1:]\n",
        "print(\"slice2:\", slice2)\n",
        "\n",
        "# Slicing from the beginning to index 7 (exclusive), step by 2\n",
        "slice3 = my_list[:7:2]\n",
        "print(\"slice3:\", slice3)\n",
        "\n",
        "# Reverse the list using a negative step\n",
        "slice4 = my_list[::-1]\n",
        "print(\"slice4:\", slice4)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fit4cUFi2e7w",
        "outputId": "062c983e-9779-4d31-d2da-8c4cf8fba0db"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "slice1: [2, 3, 4]\n",
            "slice2: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
            "slice3: [0, 2, 4, 6]\n",
            "slice4: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Hetrogenious Lists\n",
        "\n",
        "Lists are  heterogeneous, which means they can contain elements of different data types within the same list.\n"
      ],
      "metadata": {
        "id": "5nAJMbJg3E7w"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mixed_list = [1, 2.5, \"Hello\", True, [10, 20, 30]]\n",
        "\n",
        "print(mixed_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FNGDR3Dq3_cP",
        "outputId": "c2720c17-547b-4069-c147-89cbfc25c9cf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2.5, 'Hello', True, [10, 20, 30]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# List items can be other lists as well\n",
        "list_of_lists = [[1, 2, 3], [40, 50, 60]]\n",
        "list_of_lists"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O-Zpy47I4FfK",
        "outputId": "b5d0d852-57f0-40a8-8f65-314d4ea59dd1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[1, 2, 3], [40, 50, 60]]"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# The lists within a list need not be of the same length\n",
        "list_of_lists = [[1, 2, 3], [5, 6]]\n",
        "print(list_of_lists)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ik_uzC8t4HJ3",
        "outputId": "4cd4e013-de7c-4edb-aaba-f80bdb3c4f0d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1, 2, 3], [5, 6]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "len(list_of_lists)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WV5RWu9p4NZj",
        "outputId": "4f5461b8-4157-4c22-ed20-2501776823d4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### List Comprenesions\n",
        "\n",
        "List comprehensions in Python offer a succinct and efficient means of generating lists by applying an expression to each element within an iterable (e.g., a list, tuple, or range).\n",
        "\n",
        "The basic syntax of a list comprehension consists of square brackets `[]`, an expression to evaluate for each element, and a `for` loop to iterate over the elements.\n"
      ],
      "metadata": {
        "id": "GZn5QJohB-JE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Using a for loop to create a list of squares\n",
        "squares = []\n",
        "for x in range(1, 6):\n",
        "    squares.append(x**2)\n",
        "\n",
        "# Using a list comprehension for the same task\n",
        "squares_comprehension = [x**2 for x in range(1, 6)]\n",
        "\n",
        "print(squares)                # [1, 4, 9, 16, 25]\n",
        "print(squares_comprehension)  # [1, 4, 9, 16, 25]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IWa6b3AzEFqh",
        "outputId": "b0077d5b-cbf0-448c-b82b-514f368680c8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 4, 9, 16, 25]\n",
            "[1, 4, 9, 16, 25]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**List comprehensions with conditional statements**"
      ],
      "metadata": {
        "id": "mFqt36p3ETZb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Using a for loop to filter odd numbers\n",
        "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
        "odd_numbers = []\n",
        "for num in numbers:\n",
        "    if num % 2 != 0:\n",
        "        odd_numbers.append(num)\n",
        "\n",
        "# Using a list comprehension for the same task\n",
        "odd_numbers_comprehension = [num for num in numbers if num % 2 != 0]\n",
        "\n",
        "print(odd_numbers)               # [1, 3, 5, 7, 9]\n",
        "print(odd_numbers_comprehension) # [1, 3, 5, 7, 9]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NuoBXrXGEYiV",
        "outputId": "8868d54a-bd9a-4029-fd80-7f0bed02e61e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 3, 5, 7, 9]\n",
            "[1, 3, 5, 7, 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Nested List Comprehensions**"
      ],
      "metadata": {
        "id": "C8oVP0jCE4uZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "matrix = [\n",
        "    [1, 2, 3],\n",
        "    [4, 5, 6],\n",
        "    [7, 8, 9]\n",
        "]\n",
        "\n",
        "# Using nested list comprehensions to transpose the matrix\n",
        "transpose = [[row[i] for row in matrix] for i in range(len(matrix[0]))]\n",
        "\n",
        "for row in transpose:\n",
        "    print(row)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MTrfjb3pFu2U",
        "outputId": "42404329-9460-49f1-ac74-dfac8a181a3a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 4, 7]\n",
            "[2, 5, 8]\n",
            "[3, 6, 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Tuples\n",
        "\n",
        "Tuples are similar to lists, but they are immutable, which means you cannot change their content once defined. Tuples are created using parentheses `()`.\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "suzWfvMi4Xwi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dimensions = (10, 20, 30)\n",
        "\n",
        "print(dimensions)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WazhWbyq4fhN",
        "outputId": "943fe0af-22dc-429c-ae22-ecb655df4fad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(10, 20, 30)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# The try except below so we can run all cells in the notebook without issues\n",
        "try:\n",
        "  dimensions.append(5)\n",
        "except Exception as e:\n",
        "  print(e)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KArA0vGo4ksL",
        "outputId": "5dd3d475-75e5-45cf-b506-cc7890db7266"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "'tuple' object has no attribute 'append'\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "  dimensions[1] = 0\n",
        "except Exception as e:\n",
        "  print(e)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eEGm13CN4qO6",
        "outputId": "f56d1b5d-68e3-4333-815c-2afd8ff4069d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "'tuple' object does not support item assignment\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Elements can be accessed in the same way as lists (including slicing)\n",
        "length = dimensions[0]  # Accesses the first item (index 0)\n",
        "print(length)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BO9HBEwk4yWe",
        "outputId": "aec6825a-5894-40f1-f818-b77eee3d00c2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a, b = dimensions[1:3] # useful for functions returning multiple values\n",
        "print(\"a=\", a)\n",
        "print(\"b=\", b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "40qboBrE5Awl",
        "outputId": "2f1a1112-8880-4136-d996-9d483d5ac48a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a= 20\n",
            "b= 30\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Dictionaries\n",
        "\n",
        "Python dictionaries are another versatile data structure that allows you to store and organize data in a flexible and efficient manner. Unlike lists, which use sequential indices to access elements, dictionaries use key-value pairs, offering a more associative and unordered way to store data.\n",
        "\n",
        "**Key-Value Pairs**: A dictionary is a collection of key-value pairs. Each key is unique within a dictionary, and it is used to access its associated value. Keys are typically strings or numbers, while values can be of any data type, including other dictionaries."
      ],
      "metadata": {
        "id": "vJR1tVKx5SV9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a Dictionary\n",
        "student = {\n",
        "    \"name\": \"Alice\",\n",
        "    \"age\": 20,\n",
        "    \"courses\": [\"Math\", \"History\", \"Physics\"]\n",
        "}\n",
        "\n",
        "print(student)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S3HBI3lt568M",
        "outputId": "15140207-8e25-4c49-ea2b-fbc5df1a0fa4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'name': 'Alice', 'age': 20, 'courses': ['Math', 'History', 'Physics']}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Accessing Values\n",
        "student_name = student[\"name\"]\n",
        "\n",
        "print(student_name)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R0gnjU-46Mgl",
        "outputId": "18803f27-193e-482a-897d-08ae48f17874"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Alice\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifying Values\n",
        "student[\"age\"] = 31\n",
        "\n",
        "print(student)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hwWyYBG56YnM",
        "outputId": "009d9378-f3d8-46f3-bc34-3743c28eab4c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'name': 'Alice', 'age': 31, 'courses': ['Math', 'History', 'Physics']}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Adding new key-value pair\n",
        "student[\"grade\"] = \"A\"\n",
        "\n",
        "print(student)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tqn1QiCZ6n-K",
        "outputId": "f3385525-ce08-4d91-b8a6-a6f96274e39b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'name': 'Alice', 'age': 31, 'courses': ['Math', 'History', 'Physics'], 'grade': 'A'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Checking for key existence\n",
        "if \"age\" in student:\n",
        "    print(\"key exist\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ot5itZga6y50",
        "outputId": "a30697ef-a1d0-47cb-e3c6-f3fc694447e5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "key exist\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Iterating over a dictionary\n",
        "for key in student:\n",
        "    print(key, \":\", student[key])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U3lS7FKN7Cs1",
        "outputId": "89fcefc5-d336-4fbd-aed3-646e2b08cb63"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "name : Alice\n",
            "age : 31\n",
            "courses : ['Math', 'History', 'Physics']\n",
            "grade : A\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Dictionary Methods**: Python provides various methods for dictionaries, such as `keys()`, `values()`, and `items()`, which allow you to work with keys, values, and key-value pairs, respectively."
      ],
      "metadata": {
        "id": "llrUtZG37P98"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "keys = student.keys()\n",
        "print(keys)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fjmxwoNm7PSN",
        "outputId": "b1060088-f5d5-4768-a140-e233f84ae1e0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dict_keys(['name', 'age', 'courses', 'grade'])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "values = student.values()\n",
        "print(values)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c0izLgzx7Y12",
        "outputId": "13010b61-0605-4257-c4a1-74828b2f9217"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dict_values(['Alice', 31, ['Math', 'History', 'Physics'], 'A'])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "key_value_pairs = student.items()\n",
        "print(key_value_pairs)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qELb5ieV7Y4X",
        "outputId": "5f810d18-4a32-4520-af6e-df8f01613399"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dict_items([('name', 'Alice'), ('age', 31), ('courses', ['Math', 'History', 'Physics']), ('grade', 'A')])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Operators\n",
        "\n",
        "The basic arithmetic operators are\n",
        "\n",
        "Operator | Meaning |\n",
        "---------|---------|\n",
        "+ | addition\n",
        "- | subtraction\n",
        "* | multiplication\n",
        "\\ | division\n",
        "\\\\\\ | int division\n",
        "% | modulo\n",
        "** | power"
      ],
      "metadata": {
        "id": "jBGfcXAk7olW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "2 ** 3 # int"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SA8itM20703w",
        "outputId": "6a3140b2-bb7a-4142-a04d-7b90949835ed"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "2. ** 3 # float"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R2KVkRad76FG",
        "outputId": "eed1b5dd-5237-4dc5-d963-3c51ce781fc3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8.0"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Some operators work with `strings` and `lists`\n"
      ],
      "metadata": {
        "id": "wtIUhMEJ796I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'hello ' * 3"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "6W_w4jLa8CxD",
        "outputId": "7f793f50-a06d-466b-95a3-27e128814689"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'hello hello hello '"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'hello' + ' ' + 'world!'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "wLSwihqs8GBB",
        "outputId": "a5cfea96-2791-4102-bcd7-e98dff42e137"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'hello world!'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "[1, 2 ,3] * 3"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fHm4GaMH8Ih0",
        "outputId": "5464aea4-d0e7-4358-c506-bb1dd2856cc0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 1, 2, 3, 1, 2, 3]"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "[1, 2, 3] + [30, 40, 50]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_fCCfhb68KPi",
        "outputId": "6cfc773c-0d3e-45bb-b87b-6ce60b86c5a9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 30, 40, 50]"
            ]
          },
          "metadata": {},
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Strings\n",
        "\n",
        "Here's a quick overview of strings in Python:"
      ],
      "metadata": {
        "id": "t-GruHZ08uQv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating strings\n",
        "single_quoted = 'This is a string.'\n",
        "double_quoted = \"This is another string.\"\n",
        "triple_quoted = '''This is a multi-line\n",
        "string.'''\n"
      ],
      "metadata": {
        "id": "J03g9t3H88cP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# String indexing\n",
        "text = \"Python\"\n",
        "print(text[0])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nb22rBwg9EO5",
        "outputId": "af2ae444-0777-4bde-bc93-78f3d7957a87"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "P\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# String slicing\n",
        "text = \"Python\"\n",
        "print(text[0:3])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VVS-_rGr9KVu",
        "outputId": "10cb5ffb-d7cb-4cdb-a2db-e2f2605f446c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Pyt\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Concatenation\n",
        "first_name = \"John\"\n",
        "last_name = \"Doe\"\n",
        "full_name = first_name + \" \" + last_name\n",
        "\n",
        "print(full_name)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w4MhNX169Smk",
        "outputId": "cc3b59c9-cd68-4bd5-f8cd-b5af48cc8dc6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "John Doe\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**String methods**\n",
        "\n",
        "Python provides many of built-in methods for string manipulation. Some common methods include `upper()`, `lower()`, `title()`, `strip()`, `split()`, `replace()`, `find()`, and `count()`."
      ],
      "metadata": {
        "id": "zV7CGXEr9sqi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"this is a test string\"\n",
        "print(text.upper())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xRQ8EfhS92hg",
        "outputId": "08c70dfa-cd8d-4e11-9bb4-aadd1fbd2b8f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "THIS IS A TEST STRING\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(text.title())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gbPSeHtk-ioF",
        "outputId": "0712f4a6-3f8a-4b3b-fe2a-a8d408ddaa81"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "This Is A Test String\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "words = text.split(' ')\n",
        "print(words)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qqdg6fOc-AcF",
        "outputId": "26294756-2550-4112-a6a7-a7acf29c39d1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['this', 'is', 'a', 'test', 'string']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "new_text = \"_\".join(text.split(\" \"))\n",
        "print(new_text)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hJiDP0st-uip",
        "outputId": "a1e2012a-7cd2-4614-ab88-0d9cb1ff9a46"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "this_is_a_test_string\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**String Formatting**\n",
        "\n",
        "Python offers various ways to format strings, such as using f-strings (formatted string literals), the `%` operator, or the `str.format()` method."
      ],
      "metadata": {
        "id": "rH0iXvTQ_ERf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "name = \"Alice\"\n",
        "age = 30"
      ],
      "metadata": {
        "id": "ghQYTBTz_PVy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**F-Strings (formatted string literals) - Python 3.6 and newer:**\n",
        "\n",
        "\n",
        "F-strings are the recommended way to format strings in modern Python. You can embed expressions inside curly braces {} within a string, and these expressions will be evaluated and replaced with their values when the string is created."
      ],
      "metadata": {
        "id": "d1HJznZPAUJC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "formatted_string = f\"My name is {name} and I am {age} years old.\"\n",
        "print(formatted_string)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WDahurlD_YuT",
        "outputId": "643f5ecc-9469-40c1-bbea-6a1971410f92"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "My name is Alice and I am 30 years old.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**str.format() method - Python 2.7 and 3.x:**\n",
        "\n",
        "The str.format() method allows you to create formatted strings by specifying placeholders within a string and then providing values to replace these placeholders using the .format() method."
      ],
      "metadata": {
        "id": "XYCeeESAAivJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "formatted_string = \"My name is {} and I am {} years old.\".format(name, age)\n",
        "print(formatted_string)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pFIregFz_Ywh",
        "outputId": "246a38fc-6c56-4e90-b10e-1ade3f46fdae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "My name is Alice and I am 30 years old.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**%-formatting - Older Python 2.x:**\n",
        "\n",
        "This method uses the % operator to format strings. It's considered less readable and less flexible than the other two methods and is not recommended for new code."
      ],
      "metadata": {
        "id": "KfA1wA-DAqKc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "formatted_string = \"My name is %s and I am %d years old.\" %(name, age)\n",
        "print(formatted_string)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-N3wXKmR_YzP",
        "outputId": "06804442-744a-4eeb-bda8-763e2857287d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "My name is Alice and I am 30 years old.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Functions\n",
        "\n",
        "Functions are blocks of reusable code that can be defined and called to perform specific tasks."
      ],
      "metadata": {
        "id": "xAk5E7l5ATVI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Defining and calling functions\n",
        "\n",
        "# Define a simple function\n",
        "def double(x):\n",
        "  return x * 2\n",
        "\n",
        "# Call the function\n",
        "result = double(3)\n",
        "print(result)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lEWxxezuAgwO",
        "outputId": "5e048f87-c8ae-43d5-e204-7e5531a20385"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# the parameter's data type is not specific\n",
        "double([1, 2, 3])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JK16M4LcBcHI",
        "outputId": "1a6307ba-a530-4862-aa77-15b6911634db"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 1, 2, 3]"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Functions in Python can accept multiple arguments. These arguments can have default values, making them optional when calling the function."
      ],
      "metadata": {
        "id": "rtkLF41OA8Wh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add_numbers(x, y=0):\n",
        "    return x + y"
      ],
      "metadata": {
        "id": "vQOyle_BA_y4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "result = add_numbers(5, 3)\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r1_D8c2dBDX0",
        "outputId": "2bbc1bbe-db83-49c1-e065-2f7dd48cea20"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "result = add_numbers(5)\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o3QdSzvcBIXh",
        "outputId": "57af7a5c-24d3-4320-eb1a-05bf7a4034db"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Functions can return multiple values\n"
      ],
      "metadata": {
        "id": "gnKvojE7BL_i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# return 2 objects\n",
        "\n",
        "def double_triple(x):\n",
        "  return (x * 2, x * 3)"
      ],
      "metadata": {
        "id": "2Zf3x4DEBth8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a, b = double_triple(3)\n",
        "print(a)\n",
        "print(b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jXeRNb4sBvnW",
        "outputId": "22463cac-b06f-4c96-931e-7cb9811cc134"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6\n",
            "9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Object-Oriented Programming (OOP) in Python\n",
        "\n",
        "Object-Oriented Programming (OOP) is a programming paradigm that is based on the concept of objects. It is a way of organizing and structuring your code to make it more modular, reusable, and easier to understand."
      ],
      "metadata": {
        "id": "q0cYDE6b-2cS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Classes\n",
        "**Classes and Objects**\n",
        "\n",
        "- **Classes**: In Python, a class is a blueprint or template for creating objects. It defines the attributes (variables) and methods (functions) that an object of that class will have. Classes are like a blueprint for creating objects.\n",
        "\n",
        "- **Objects**: An object is an instance of a class. It is a concrete realization of the class blueprint, with its own unique data (attributes) and behavior (methods).\n",
        "\n",
        "**Attributes and Methods**\n",
        "\n",
        "- **Attributes**: Attributes are variables that belong to a class and describe the characteristics of objects created from that class. For example, if we have a class called `Car`, attributes could include `color`, `make`, and `model`.\n",
        "\n",
        "- **Methods**: Methods are functions that are defined inside a class and can operate on the attributes of that class. They define the behavior of objects created from the class. For instance, a `Car` class might have methods like `start_engine()` and `stop_engine()`."
      ],
      "metadata": {
        "id": "QjQAYhoqAlsO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define a simple class called 'Person'\n",
        "class Person:\n",
        "    def __init__(self, name, age):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "\n",
        "    def greet(self):\n",
        "        print(f\"Hello, my name is {self.name} and I am {self.age} years old.\")\n",
        "\n",
        "# Create an instance of the 'Person' class\n",
        "person1 = Person(\"Alice\", 30)\n",
        "\n",
        "# Accessing attributes and calling methods\n",
        "print(person1.name)\n",
        "print(person1.age)\n",
        "person1.greet()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gUDobQ76_4lQ",
        "outputId": "1920c120-7ec4-4a3c-d8f6-c3f57311b2a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Alice\n",
            "30\n",
            "Hello, my name is Alice and I am 30 years old.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Inheritance\n",
        "\n",
        "Inheritance is a key concept in OOP that allows you to create a new class based on an existing class. The new class inherits the attributes and methods of the existing class, which promotes code reuse and organization.\n"
      ],
      "metadata": {
        "id": "WzDhI736_25N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define a base class 'Animal'\n",
        "class Animal:\n",
        "    def __init__(self, name):\n",
        "        self.name = name\n",
        "\n",
        "    def speak(self):\n",
        "        pass  # Placeholder method\n",
        "\n",
        "# Define a derived class 'Dog' inheriting from 'Animal'\n",
        "class Dog(Animal):\n",
        "    def speak(self):\n",
        "        return f\"{self.name} says Woof!\"\n",
        "\n",
        "# Create instances of 'Dog'\n",
        "dog1 = Dog(\"Buddy\")\n",
        "dog2 = Dog(\"Max\")\n",
        "\n",
        "# Call the 'speak' method on 'Dog' instances\n",
        "print(dog1.speak())\n",
        "print(dog2.speak())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SQG3wlRCBKrT",
        "outputId": "14b206d0-5576-4056-b036-e950768d4805"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Buddy says Woof!\n",
            "Max says Woof!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Modules\n",
        "\n",
        "In Python, a module is a file containing Python definitions and statements. It's essentially a code library that you can use in your programs. Modules help you organize your code into separate files, making it more manageable and reusable.\n",
        "\n",
        "Python comes with a rich standard library and a vast ecosystem of third-party libraries. To use these libraries in your code, you need to import them using the `import` statement.\n"
      ],
      "metadata": {
        "id": "-qlbilywE0i-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Importing Modules"
      ],
      "metadata": {
        "id": "ZPdDxAjIGsBd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Basic import**"
      ],
      "metadata": {
        "id": "mvruoEQvFo8s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import the 'math' module to use mathematical functions\n",
        "import math\n",
        "\n",
        "# Calculate the square root using 'math.sqrt'\n",
        "result = math.sqrt(16)\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5hZAKTyQFSns",
        "outputId": "dcb6957d-2723-4dab-a74a-953539064265"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Import Specific Functions or Variables**"
      ],
      "metadata": {
        "id": "_Xf8-FgOFw7O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import only the 'sqrt' function from 'math'\n",
        "from math import sqrt\n",
        "\n",
        "# Use the 'sqrt' function directly\n",
        "result = sqrt(25)\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ew2eqG61Fzcv",
        "outputId": "9528cd93-c753-4983-e50b-c473ab4e3b2e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Renaming Imported Modules**"
      ],
      "metadata": {
        "id": "mvX5h6XRF5r5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import the 'math' module and give it an alias 'm'\n",
        "import math as m\n",
        "\n",
        "# Use the 'm' alias to call functions from 'math'\n",
        "result = m.sqrt(25)\n",
        "print(result)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gG4efrsZGH2I",
        "outputId": "a4b446fd-8160-4421-c3e0-71701a682916"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Importing All with `*` (not recommended)**\n",
        "\n",
        "You can use the `from module_name import *` syntax to import all functions and variables from a module. However, this is generally discouraged as it can lead to namespace pollution and make it unclear where certain names come from."
      ],
      "metadata": {
        "id": "luqizMMwGVvp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import all functions and variables from 'math' (not recommended)\n",
        "from math import *\n",
        "\n",
        "# Now you can use all 'math' functions directly\n",
        "result = sqrt(36)\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XtUzvf-xGVTN",
        "outputId": "4220c686-da59-4b3f-aa2e-f137e54619f1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating and Using Your Own Modules"
      ],
      "metadata": {
        "id": "In44ANvnGoQe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile my_module.py\n",
        "\n",
        "# my_module.py\n",
        "\n",
        "def greet(name):\n",
        "    return f\"Hello, {name}!\""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y7hvhjCZF_EZ",
        "outputId": "bea85741-52b3-4068-fe16-53cb4e77e739"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting my_module.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Import 'greet' function from 'my_module'\n",
        "from my_module import greet\n",
        "\n",
        "# Use the 'greet' function\n",
        "message = greet(\"Alice\")\n",
        "print(message)"
      ],
      "metadata": {
        "id": "w2U9KTXlHvzr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c297ca97-6118-4df6-ca7d-b91de4a87c36"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Alice!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Python Standard Library\n",
        "\n",
        "Python's Standard Library contains a wide range of modules that provide functionality for various tasks. The following are a few examples"
      ],
      "metadata": {
        "id": "GEiPo8nLAqBT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "\n",
        "# Generate a random integer between 1 and 10\n",
        "random_number = random.randint(1, 10)\n",
        "print(f\"Random number: {random_number}\")\n",
        "\n",
        "# Generate a random choice from a list\n",
        "my_list = [1, 2, 3, 4, 5]\n",
        "random_choice = random.choice(my_list)\n",
        "print(f\"Random choice: {random_choice}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "glg2nZdcA1yz",
        "outputId": "f99d870a-b607-401d-cec7-969f64ba9f37"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Random number: 7\n",
            "Random choice: 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import datetime\n",
        "\n",
        "# Get the current date and time\n",
        "current_datetime = datetime.datetime.now()\n",
        "print(f\"Current datetime: {current_datetime}\")\n",
        "\n",
        "# Format a datetime object as a string\n",
        "formatted_date = current_datetime.strftime(\"%Y-%m-%d %H:%M:%S\")\n",
        "print(f\"Formatted datetime: {formatted_date}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YSpfoN1FA_8z",
        "outputId": "9fdbf048-ec5f-42f5-8b62-f975aae527d0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Current datetime: 2023-09-06 06:14:31.083446\n",
            "Formatted datetime: 2023-09-06 06:14:31\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "# Get the current working directory\n",
        "current_directory = os.getcwd()\n",
        "print(f\"Current directory: {current_directory}\")\n",
        "\n",
        "# List files in a directory\n",
        "files_in_directory = os.listdir(current_directory)\n",
        "print(f\"Files in directory: {files_in_directory}\")\n",
        "\n",
        "# Check if a file or directory exists\n",
        "file_exists = os.path.exists(\"my_file.txt\")\n",
        "print(f\"File exists: {file_exists}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XHOrtgbRBX0u",
        "outputId": "337446d2-6ac8-464d-9d84-5b31519244b0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Current directory: /content\n",
            "Files in directory: ['.config', 'my_module.py', '__pycache__', 'sample_data']\n",
            "File exists: False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Exercises"
      ],
      "metadata": {
        "id": "j9qrTXoCCjJR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "## **1. Movie Ratings Analyzer**\n",
        "\n",
        "You are tasked with building a simple movie ratings analyzer program. The program will read user input to store and analyze movie ratings. It should provide options to:\n",
        "\n",
        "1. Add a new movie rating.\n",
        "2. View the average rating for all movies.\n",
        "3. Display the highest-rated movie.\n",
        "4. Exit the program.\n",
        "\n",
        "\n",
        "\n",
        "Below is a starter code. Your task is to complete the `add_rating`, `calculate_average_rating`, and `find_highest_rated_movie` functions."
      ],
      "metadata": {
        "id": "4hNRHdCHCyuv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create an empty dictionary to store movie ratings.\n",
        "movie_ratings = {}\n",
        "\n",
        "def add_rating(movie, rating):\n",
        "    # TODO: Implement the function to add a movie rating to the dictionary.\n",
        "    pass\n",
        "\n",
        "def calculate_average_rating(ratings):\n",
        "    # TODO: Implement the function to calculate and return the average rating.\n",
        "    pass\n",
        "\n",
        "def find_highest_rated_movie(ratings):\n",
        "    # TODO: Implement the function to find and return the highest-rated movie.\n",
        "    pass\n",
        "\n",
        "# Main program loop\n",
        "while True:\n",
        "    print(\"\\nOptions:\")\n",
        "    print(\"1. Add a new movie rating\")\n",
        "    print(\"2. View the average rating for all movies\")\n",
        "    print(\"3. Display the highest-rated movie\")\n",
        "    print(\"4. Exit\")\n",
        "\n",
        "    choice = input(\"Enter your choice: \")\n",
        "\n",
        "    if choice == \"1\":\n",
        "        movie = input(\"Enter the movie name: \")\n",
        "        rating = float(input(\"Enter the movie rating (0-10): \"))\n",
        "        add_rating(movie, rating)\n",
        "\n",
        "    elif choice == \"2\":\n",
        "        average = calculate_average_rating(movie_ratings)\n",
        "        print(f\"The average rating for all movies is: {average:.2f}\")\n",
        "\n",
        "    elif choice == \"3\":\n",
        "        highest_rated_movie = find_highest_rated_movie(movie_ratings)\n",
        "        print(f\"The highest-rated movie is: {highest_rated_movie}\")\n",
        "\n",
        "    elif choice == \"4\":\n",
        "        print(\"Exiting the program.\")\n",
        "        break\n",
        "\n",
        "    else:\n",
        "        print(\"Invalid choice. Please enter a valid option.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZAEYT3Z8CkWL",
        "outputId": "5f75c841-662c-40df-866e-d38cad5460da"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Options:\n",
            "1. Add a new movie rating\n",
            "2. View the average rating for all movies\n",
            "3. Display the highest-rated movie\n",
            "4. Exit\n",
            "Enter your choice: 4\n",
            "Exiting the program.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **2. Password Strength Checker**\n",
        "\n",
        "You are tasked with building a program that checks the strength of a user-provided password. The program should evaluate the password based on certain criteria and provide feedback on its strength. Users can enter passwords, and the program should provide options to:\n",
        "\n",
        "1. Check the strength of a password.\n",
        "2. Exit the program.\n",
        "\n",
        "\n",
        "Below is a starter code. Your task is to complete the `check_password_strength` function. This function should take a password input and assess its strength based on criteria like length, use of uppercase and lowercase characters, numbers, and special characters. You can define your own criteria for password strength.\n",
        "\n",
        "For example, you might consider a strong password to have a length of at least 8 characters, a mix of uppercase and lowercase letters, at least one number, and at least one special character."
      ],
      "metadata": {
        "id": "gXWdRvLrEFyJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# TODO: Create a function to check the strength of a password.\n",
        "def check_password_strength(password):\n",
        "    pass\n",
        "\n",
        "# Main program loop\n",
        "while True:\n",
        "    print(\"\\nOptions:\")\n",
        "    print(\"1. Check the strength of a password\")\n",
        "    print(\"2. Exit\")\n",
        "\n",
        "    choice = input(\"Enter your choice: \")\n",
        "\n",
        "    if choice == \"1\":\n",
        "        password = input(\"Enter a password: \")\n",
        "        strength = check_password_strength(password)\n",
        "        print(f\"Password strength: {strength}\")\n",
        "\n",
        "    elif choice == \"2\":\n",
        "        print(\"Exiting the program.\")\n",
        "        break\n",
        "\n",
        "    else:\n",
        "        print(\"Invalid choice. Please enter a valid option.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vC8VMkjvC3MR",
        "outputId": "c1a9ba01-52f2-4c81-cbe5-51e68750192f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Options:\n",
            "1. Check the strength of a password\n",
            "2. Exit\n",
            "Enter your choice: 2\n",
            "Exiting the program.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **3. Shopping List Manager**\n",
        "\n",
        "You are tasked with building a simple shopping list manager program. The program should allow users to add, view, and manage items on their shopping list. Users can also check off items when they've purchased them. The program should provide options to:\n",
        "\n",
        "1. Add an item to the shopping list. (include the name of the item and its purchased status - i.e. \"purchased\" or \"not purchased\")\n",
        "2. View the current shopping list.\n",
        "3. Check off an item (mark it as purchased).\n",
        "4. Remove an item from the shopping list.\n",
        "5. Exit the program.\n",
        "\n",
        "\n",
        "Below is a starter code.Your task is to complete the `add_item`, `check_off_item`, and `remove_item` functions. The `add_item` function should add an item to the `shopping_list`, the `check_off_item` function should mark an item as purchased, and the `remove_item` function should remove an item from the list."
      ],
      "metadata": {
        "id": "I6uXJrcQEuYS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a list to store shopping list items.\n",
        "shopping_list = []\n",
        "\n",
        "def add_item(item):\n",
        "    # TODO: Implement the function to add an item to the shopping list.\n",
        "    pass\n",
        "\n",
        "def check_off_item(item):\n",
        "    # TODO: Implement the function to check off an item (mark it as purchased).\n",
        "    pass\n",
        "\n",
        "def remove_item(item):\n",
        "    # TODO: Implement the function to remove an item from the shopping list.\n",
        "    pass\n",
        "\n",
        "# Main program loop\n",
        "while True:\n",
        "    print(\"\\nOptions:\")\n",
        "    print(\"1. Add an item to the shopping list\")\n",
        "    print(\"2. View the current shopping list\")\n",
        "    print(\"3. Check off an item\")\n",
        "    print(\"4. Remove an item from the shopping list\")\n",
        "    print(\"5. Exit\")\n",
        "\n",
        "    choice = input(\"Enter your choice: \")\n",
        "\n",
        "    if choice == \"1\":\n",
        "        item = input(\"Enter the item to add: \")\n",
        "        add_item(item)\n",
        "        print(f\"'{item}' has been added to the shopping list.\")\n",
        "\n",
        "    elif choice == \"2\":\n",
        "        print(\"\\nShopping List:\")\n",
        "        for i, item in enumerate(shopping_list, start=1):\n",
        "            print(f\"{i}. {item}\")\n",
        "\n",
        "    elif choice == \"3\":\n",
        "        item = input(\"Enter the item to check off: \")\n",
        "        check_off_item(item)\n",
        "        print(f\"'{item}' has been checked off.\")\n",
        "\n",
        "    elif choice == \"4\":\n",
        "        item = input(\"Enter the item to remove: \")\n",
        "        remove_item(item)\n",
        "        print(f\"'{item}' has been removed from the shopping list.\")\n",
        "\n",
        "    elif choice == \"5\":\n",
        "        print(\"Exiting the program.\")\n",
        "        break\n",
        "\n",
        "    else:\n",
        "        print(\"Invalid choice. Please enter a valid option.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dhVjbYAuEb1R",
        "outputId": "b15cb2a6-c4a9-4075-b1d2-4a651ba259e6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Options:\n",
            "1. Add an item to the shopping list\n",
            "2. View the current shopping list\n",
            "3. Check off an item\n",
            "4. Remove an item from the shopping list\n",
            "5. Exit\n",
            "Enter your choice: 5\n",
            "Exiting the program.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **4. Creating a Dice Rolling Simulator**\n",
        "\n",
        "Create a Python class called `Dice` that represents a standard six-sided die. The `Dice` class should have the following attributes and methods:\n",
        "\n",
        "- `sides` (integer): The number of sides on the die (always 6 for a standard die).\n",
        "- `roll()`: A method that simulates rolling the die and returns a random number between 1 and 6.\n",
        "\n",
        "Next, create a class called `DiceGame` that simulates a simple dice game. The `DiceGame` class should have the following methods:\n",
        "\n",
        "- `__init__(self)`: Initializes the game with two dice objects.\n",
        "- `play(self)`: Simulates a round of the game by rolling both dice and determining the winner based on the highest roll.\n",
        "- `display_winner(self)`: Displays the winner of the game.\n",
        "\n",
        "Below is a starter code. Your task is to complete the `Dice` and `DiceGame` classes, implement the missing methods, and create a simple dice rolling game. The game should roll two dice, compare the results, and declare a winner based on the highest roll."
      ],
      "metadata": {
        "id": "jlEzKeFsHTvz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "\n",
        "class Dice:\n",
        "    def __init__(self, sides=6):\n",
        "        # Initialize the number of sides\n",
        "        pass\n",
        "\n",
        "    def roll(self):\n",
        "        # Simulate rolling the die and return the result\n",
        "        pass\n",
        "\n",
        "class DiceGame:\n",
        "    def __init__(self):\n",
        "        # Initialize the game with two Dice objects\n",
        "        pass\n",
        "\n",
        "    def play(self):\n",
        "        # Simulate a round of the game and determine the winner\n",
        "        pass\n",
        "\n",
        "    def display_winner(self):\n",
        "        # Display the winner of the game\n",
        "        pass\n",
        "\n",
        "# Example usage:\n",
        "if __name__ == \"__main__\":\n",
        "    game = DiceGame()\n",
        "    game.play()\n",
        "    game.display_winner()"
      ],
      "metadata": {
        "id": "w34qunFqHugb"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}