Python_Theories.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/SouvikChakraborty472/Python/blob/main/Python_Theories.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oOPcjbtvZEcy"
      },
      "source": [
        "**Python Theories**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8tX8JAFiaNkq"
      },
      "source": [
        "**Introduction**\n",
        "\n",
        "Python was created in the late 1980s by Guido van Rossum, a Dutch programmer. It was first released in 1991 as Python 0.9.0. Python's design philosophy emphasizes readability and simplicity, with a clear and intuitive syntax. Over the years, Python gained popularity due to its versatility and an active open-source community.\n",
        "\n",
        "Major milestones include Python 2.0 (2000) with garbage collection and Unicode support, and Python 3.0 (2008), which introduced backward-incompatible changes for a cleaner language. Despite initial resistance to migrating from Python 2 to 3, the transition was successful, and Python 3 is now the dominant version. Python is widely used in web development, data science, machine learning, and automation.\n",
        "\n",
        "Python is a versatile, high-level programming language known for its simplicity and readability. It emphasizes clean, concise code and has a vast ecosystem of libraries and frameworks. Python is used in web development, data analysis, machine learning, automation, and more, making it a popular choice for developers."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "72nRHZWzbC2c"
      },
      "source": [
        "**Features**\n",
        "\n",
        "1. **Readable and Understandable**: Python emphasizes code readability with a clean and easy-to-follow syntax. This reduces the cost of program maintenance and encourages collaboration among developers.\n",
        "\n",
        "2. **Interpreted Language**: Python is an interpreted language, meaning that code can be executed line by line, making it suitable for rapid development and debugging.\n",
        "\n",
        "3. **Cross-Platform Compatibility**: Python is available on multiple platforms, including Windows, macOS, and Linux. This cross-platform compatibility ensures that code can run on different operating systems without modification.\n",
        "\n",
        "4. **Dynamic Typing**: Python uses dynamic typing, allowing variables to change types during runtime. This flexibility simplifies code development and makes it more concise.\n",
        "\n",
        "5. **High-Level Language**: Python provides high-level abstractions, simplifying complex tasks such as memory management and low-level operations. This allows developers to focus on problem-solving rather than dealing with low-level details.\n",
        "\n",
        "6. **Large Standard Library**: Python includes a comprehensive standard library with modules for tasks like file I/O, regular expressions, networking, and more. This library reduces the need for external dependencies and accelerates development."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QuwQw4wtha37"
      },
      "source": [
        "**Application**\n",
        "\n",
        "1. **Web Development**:\n",
        "   Python is widely used for building web applications and websites. Frameworks like Django and Flask make it easy to create scalable and secure web applications. Python's simplicity and readability, along with its extensive libraries, make it a preferred choice for web developers.\n",
        "\n",
        "2. **Data Science and Machine Learning**:\n",
        "   Python is a go-to language for data scientists and machine learning engineers. Libraries like NumPy, pandas, Matplotlib, and scikit-learn provide powerful tools for data analysis, manipulation, visualization, and machine learning. Frameworks like TensorFlow and PyTorch are widely used for deep learning and neural network development.\n",
        "\n",
        "3. **Scientific Computing**:\n",
        "   Python is popular in the scientific community for its ability to handle complex mathematical and scientific computations. Libraries like SciPy, SymPy, and specialized tools such as Jupyter Notebooks make it a valuable tool for scientific research, simulations, and data analysis.\n",
        "\n",
        "4. **Automation and Scripting**:\n",
        "   Python is an excellent choice for automation and scripting tasks. Its clean and readable syntax, along with modules like os and shutil, allows developers to automate repetitive tasks, manage files, and interact with the operating system. It's commonly used in system administration and DevOps.\n",
        "\n",
        "5. **Game Development and Graphics**:\n",
        "   Python can be used for developing games and graphical applications. Libraries like Pygame provide game development capabilities, while libraries like PyOpenGL allow for 3D graphics programming. Python's ease of use makes it a suitable choice for game prototyping and development."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hbuT9ebvqhqw"
      },
      "source": [
        "**IDE (Intregrated Development Environment)**\n",
        "\n",
        "An Integrated Development Environment (IDE) in Python is a software tool that provides a comprehensive environment for coding, testing, and debugging Python programs. It typically includes features like code editors, syntax highlighting, debugging tools, and integrated documentation, streamlining the development process for Python software and applications."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-jqiqyKArVC2"
      },
      "source": [
        "**First Program in Python**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BClKU_-rsd_D",
        "outputId": "1e0440dd-5752-4d84-cffc-eea36b779ad3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hello, World!\n"
          ]
        }
      ],
      "source": [
        "# This is a comment in Python. Comments are for documentation and are not executed by the program.\n",
        "\n",
        "# The following line is a Python statement that prints the text \"Hello, World!\" to the console.\n",
        "print(\"Hello, World!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-AuSg2qls0wP"
      },
      "source": [
        "Now, let's break down the code:\n",
        "\n",
        "1. `# This is a comment in Python.`: Comments in Python start with a `#` symbol. They are ignored by the Python interpreter and are used for adding explanations and documentation to the code. Comments are not executed.\n",
        "\n",
        "2. `print(\"Hello, World!\")`: This is the actual Python code that performs an action. In this case, it uses the `print` function to output the text \"Hello, World!\" to the console. The `print` function is built into Python and is used for displaying information to the user.\n",
        "\n",
        "When you run this program, it will execute the `print` statement, and you will see \"Hello, World!\" printed to the console."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cX2AXhlf3_Zm"
      },
      "source": [
        "**Literals in Python**\n",
        "\n",
        "In Python, a literal is a notation that represents a specific value within your source code. Literals are used to express values of various data types directly in your code. Here are some common types of literals in Python along with examples and explanations:\n",
        "\n",
        "1. **Integer Literals:**\n",
        "   Integer literals are used to represent whole numbers without a decimal point. They can be written in decimal (base 10), binary (base 2), octal (base 8), or hexadecimal (base 16) format.\n",
        "\n",
        "   Examples:\n",
        "\n",
        "   - Decimal integer: `42`\n",
        "   - Binary integer: `0b1010` (10 in binary)\n",
        "   - Octal integer: `0o52` (42 in octal)\n",
        "   - Hexadecimal integer: `0x2A` (42 in hexadecimal)\n",
        "\n",
        "2. **Floating-Point Literals:**\n",
        "   Floating-point literals are used to represent real numbers with a decimal point.\n",
        "\n",
        "   Example:\n",
        "\n",
        "   - Floating-point number: `3.14`\n",
        "\n",
        "3. **String Literals:**\n",
        "   String literals are used to represent sequences of characters enclosed in single (' ') or double (\" \") quotes.\n",
        "\n",
        "   Examples:\n",
        "\n",
        "   - Single-quoted string: `'Hello, World!'`\n",
        "   - Double-quoted string: `\"Python is awesome!\"`\n",
        "\n",
        "4. **Boolean Literals:**\n",
        "   Boolean literals represent one of two values: `True` or `False`.\n",
        "\n",
        "   Examples:\n",
        "\n",
        "   - `True`\n",
        "   - `False`\n",
        "\n",
        "5. **None Literal:**\n",
        "   The `None` literal represents the absence of a value. It is often used to indicate that a variable has no value assigned to it.\n",
        "\n",
        "   Example:\n",
        "\n",
        "   - `None`\n",
        "\n",
        "6. **List Literals:**\n",
        "   List literals are used to represent ordered collections of values enclosed in square brackets `[]`.\n",
        "\n",
        "   Example:\n",
        "\n",
        "   - List of integers: `[1, 2, 3, 4]`\n",
        "\n",
        "7. **Tuple Literals:**\n",
        "   Tuple literals represent ordered collections of values enclosed in parentheses `()`.\n",
        "\n",
        "   Example:\n",
        "\n",
        "   - Tuple of mixed data types: `(\"apple\", 3.14, True)`\n",
        "\n",
        "8. **Dictionary Literals:**\n",
        "   Dictionary literals are used to represent key-value pairs enclosed in curly braces `{}`.\n",
        "\n",
        "   Example:\n",
        "\n",
        "   - Dictionary of person's information: `{\"name\": \"Alice\", \"age\": 30, \"city\": \"New York\"}`\n",
        "\n",
        "9. **Set Literals:**\n",
        "   Set literals represent an unordered collection of unique values enclosed in curly braces `{}`. Introduced in Python 3.0.\n",
        "   \n",
        "   Example:\n",
        "\n",
        "   - Set of integers: `{1, 2, 3, 4, 5}`\n",
        "\n",
        "10. **Complex Literals:**\n",
        "    Complex literals are used to represent complex numbers in the form `real + imagj`, where `real` and `imag` are floating-point values.\n",
        "\n",
        "    Example:\n",
        "\n",
        "    - Complex number: `3 + 2j`\n",
        "\n",
        "These literals play a fundamental role in Python programming as they allow you to directly specify values for various data types, making your code more readable and expressive."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hTY84auMvl3e"
      },
      "source": [
        "**Data Types in Python**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "igK8ZJKnvtyV"
      },
      "source": [
        "Python is a dynamically typed language, which means that you don't need to declare the data type of a variable explicitly; Python will determine the data type for you. Here are some of the most common data types in Python:\n",
        "\n",
        "1. **Integers (int):** Integers are whole numbers, both positive and negative, without a decimal point. They can be represented using the `int` data type. For example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fwC5jPyNv7EL"
      },
      "outputs": [],
      "source": [
        "x = 5\n",
        "y = -10"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qiP5s5mHwBk2"
      },
      "source": [
        "2. **Floating-Point Numbers (float):** Floating-point numbers, or floats, are numbers with decimal points or in scientific notation. They are represented using the `float` data type. For example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tavqv4SVwPBl"
      },
      "outputs": [],
      "source": [
        "pi = 3.14159\n",
        "e = 2.71828"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wsYZr2obwUse"
      },
      "source": [
        "3. **Strings (str):** Strings are sequences of characters and are enclosed in either single (' ') or double (\" \") quotes. For example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LnYfSh0kwdfP"
      },
      "outputs": [],
      "source": [
        "name = \"Alice\"\n",
        "sentence = 'Hello, World!'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fCeqxe-8weTM"
      },
      "source": [
        "4. **Booleans (bool):** Booleans represent binary values, either `True` or `False`. They are often used for conditional statements and comparisons. For example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pKSczHpOwnuq"
      },
      "outputs": [],
      "source": [
        "is_true = True\n",
        "is_false = False"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lKH6UkC7woWL"
      },
      "source": [
        "5. **Lists:** Lists are ordered collections of elements that can contain items of different data types. They are represented using square brackets `[]`. For example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "m9gB8eWIwy2D"
      },
      "outputs": [],
      "source": [
        "fruits = ['apple', 'banana', 'cherry']\n",
        "numbers = [1, 2, 3, 4, 5]\n",
        "mixed_list = [1, 'apple', True, 3.14]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uJjK9engwzPN"
      },
      "source": [
        "6. **Tuples:** Tuples are similar to lists, but they are immutable, which means you can't change their elements after creation. They are represented using parentheses `()`. For example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Rxq8iGbsxFna"
      },
      "outputs": [],
      "source": [
        "coordinates = (3, 4)\n",
        "colors = ('red', 'green', 'blue')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2snBeyuHxYBO"
      },
      "source": [
        "7. Dictionaries (dict): Dictionaries are collections of key-value pairs. They are unordered and use curly braces {}. For example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eZgDhFGexdpy"
      },
      "outputs": [],
      "source": [
        "person = {'name': 'John', 'age': 30, 'city': 'New York'}\n",
        "car = {'brand': 'Ford', 'model': 'Mustang', 'year': 2022}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0er4BW-txh0u"
      },
      "source": [
        "8. Sets: Sets are unordered collections of unique elements. They are represented using curly braces {} or with the set() constructor. For example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SZGEepH_xnOl"
      },
      "outputs": [],
      "source": [
        "unique_numbers = {1, 2, 3, 4, 5}\n",
        "letters = set('abcdefg')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GOGBLGK1xq1T"
      },
      "source": [
        "9. NoneType (None): None is a special data type in Python that represents the absence of a value. It's often used to initialize variables or indicate that a function does not return a value."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9x1ZYnISxwbA"
      },
      "outputs": [],
      "source": [
        "result = None"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NxBE-k3yyXD7"
      },
      "source": [
        "In Python, type conversion allows you to convert one data type to another. Type conversions can be categorized into two main types: implicit (automatic) type conversion and explicit (manual) type conversion.\n",
        "\n",
        "1. Implicit (Automatic) Type Conversion:\n",
        "Implicit type conversion occurs automatically when Python converts one data type to another without the programmer's intervention. This happens when an operation between two different data types is performed, and Python converts one of the operands to a more \"complex\" data type to perform the operation. The goal is to avoid data loss.\n",
        "\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oQwzq5tdyZ9O",
        "outputId": "4763547f-6992-401e-c5df-b9af921f1a5c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "7.5"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = 5  # Integer\n",
        "y = 2.5  # Float\n",
        "result = x + y  # The addition requires implicit conversion of 'x' to float\n",
        "result"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SdmsHW46yeLL"
      },
      "source": [
        "In this example, Python automatically converts the integer x to a float before performing the addition, resulting in a float value in the result.\n",
        "\n",
        "2. Explicit (Manual) Type Conversion:\n",
        "Explicit type conversion, also known as casting, occurs when the programmer explicitly instructs Python to convert a value from one data type to another using functions like int(), float(), str(), and others.\n",
        "\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jaJf_uanykOl"
      },
      "outputs": [],
      "source": [
        "x = \"42\"  # String\n",
        "y = int(x)  # Explicitly convert 'x' to an integer using int()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m8EBS25OyqIF"
      },
      "source": [
        "In this example, the int() function is used to explicitly convert the string \"42\" to an integer, and the result is stored in y. Without this explicit conversion, x would have remained a string.\n",
        "\n",
        "Here are some examples of explicit type conversion functions:\n",
        "\n",
        "int(): Converts to an integer.\n",
        "\n",
        "float(): Converts to a floating-point number.\n",
        "\n",
        "str(): Converts to a string.\n",
        "\n",
        "list(): Converts to a list.\n",
        "\n",
        "tuple(): Converts to a tuple.\n",
        "\n",
        "bool(): Converts to a boolean."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tjDMIuWnywZf"
      },
      "source": [
        "**Variable in Python**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XVYhDco801Mo"
      },
      "source": [
        "In Python, variables are used to store and manage data. A variable is a name that refers to a value, allowing you to work with and manipulate that value in your code. Here's an explanation and some examples of variables in Python:\n",
        "\n",
        "1. **Variable Naming Rules:**\n",
        "    \n",
        "    Variable names must start with a letter (a-z, A-Z) or an underscore (_).\n",
        "\n",
        "    Variable names can contain letters, numbers (0-9), and underscores.\n",
        "    \n",
        "    Variable names are case-sensitive, meaning \"myVar\" and \"myvar\" are considered different variables.\n",
        "    \n",
        "    Python reserves certain keywords that cannot be used as variable names (e.g., if, while, for, print, etc.).\n",
        "\n",
        "2. **Variable Assignment:**\n",
        "You can assign a value to a variable using the assignment operator =.\n",
        "\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zmrXelZ_024Q"
      },
      "outputs": [],
      "source": [
        "x = 10  # Assign the value 10 to the variable 'x'\n",
        "name = \"Alice\"  # Assign the string \"Alice\" to the variable 'name'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LeSRbm_x1f9a"
      },
      "source": [
        "3. **Variable Data Types:**\n",
        "In Python, variables are dynamically typed, meaning their data type is determined by the value they reference. You don't need to specify the data type explicitly.\n",
        "\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JrR5ODuQ2KfB"
      },
      "outputs": [],
      "source": [
        "a = 5        # 'a' is an integer\n",
        "b = 3.14     # 'b' is a float\n",
        "c = \"Hello\"  # 'c' is a string"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9NLGfifM2OXa"
      },
      "source": [
        "4. **Variable Reassignment:**\n",
        "You can change the value of a variable by simply assigning a new value to it.\n",
        "\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "O-jvVd342VU0"
      },
      "outputs": [],
      "source": [
        "x = 5\n",
        "x = x + 1  # Reassign 'x' with a new value (6)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1XUAGakB2Y7d"
      },
      "source": [
        "5. **Multiple Assignments:**\n",
        "Python allows you to assign multiple variables in a single line.\n",
        "\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5Ad9SLCt2e8j"
      },
      "outputs": [],
      "source": [
        "a, b, c = 1, 2, 3"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2llwwRbM2jEa"
      },
      "source": [
        "6. **Variable Scope:**\n",
        "Variables can have local or global scope. A local variable is defined within a specific block of code, like a function, and is only accessible within that block. A global variable is defined outside any specific block and can be accessed from anywhere in the code.\n",
        "\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f3Mkbb6F2qWC",
        "outputId": "6ae888f7-6575-46ed-df2a-2377c00bc5cc"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10\n"
          ]
        }
      ],
      "source": [
        "global_var = 10  # Global variable\n",
        "\n",
        "def my_function():\n",
        "    local_var = 5  # Local variable\n",
        "    print(global_var)  # Access global variable\n",
        "\n",
        "my_function()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u-6ygrhV2uaV"
      },
      "source": [
        "In this example, global_var is a global variable, and local_var is a local variable within the my_function scope."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yyk8X2Ya0N_X"
      },
      "source": [
        "**Operators in Python**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wtA6xpGT1RFW"
      },
      "source": [
        "In Python, operators are special symbols or keywords used to perform operations on operands. Operands can be variables, values, or expressions. Python supports a wide range of operators, which can be categorized into several types. Here, I'll explain some of the most common operators with examples:\n",
        "\n",
        "1. Arithmetic Operators: Used for mathematical calculations.Examples:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cFPO2bvL1vHI"
      },
      "outputs": [],
      "source": [
        "a = 10\n",
        "b = 5\n",
        "\n",
        "addition = a + b  # 15\n",
        "subtraction = a - b  # 5\n",
        "multiplication = a * b  # 50\n",
        "division = a / b  # 2.0\n",
        "modulus = a % b  # 0\n",
        "exponentiation = a ** b  # 100000\n",
        "floor_division = a // b  # 2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nKnIqYQj2UhE"
      },
      "source": [
        "The BODMAS rule, also known as the PEMDAS rule in some regions, is a set of rules used in mathematics to determine the order of operations in an arithmetic expression. BODMAS stands for:\n",
        "\n",
        "1. **B**rackets: Operations within parentheses or brackets are performed first.\n",
        "2. **O**rders (Exponents and Roots): Exponentiation (raising a number to a power) and root operations are performed next.\n",
        "3. **D**ivision and **M**ultiplication: Division and multiplication operations are performed from left to right.\n",
        "4. **A**ddition and **S**ubtraction: Finally, addition and subtraction operations are performed from left to right.\n",
        "\n",
        "In Python, the order of operations follows the BODMAS rule, which is the same as the PEMDAS rule. You can use parentheses to control the order of operations. Here are some examples:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Puxu9cnp2nDh"
      },
      "outputs": [],
      "source": [
        "result = 3 + 4 * 2  # First multiplication, then addition: 11\n",
        "result = (3 + 4) * 2  # First addition within parentheses, then multiplication: 14\n",
        "result = 3 + 4 ** 2  # First exponentiation, then addition: 19 (4 squared is 16)\n",
        "result = (3 + 4) / 2  # First addition within parentheses, then division: 3.5"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cJcta0Wc3Puh"
      },
      "source": [
        "2. Comparison Operators: Used to compare values and return Boolean results (True or False).\n",
        "Examples:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6s7D8EPr3VtA"
      },
      "outputs": [],
      "source": [
        "x = 10\n",
        "y = 5\n",
        "\n",
        "equal = x == y  # False\n",
        "not_equal = x != y  # True\n",
        "greater_than = x > y  # True\n",
        "less_than = x < y  # False\n",
        "greater_equal = x >= y  # True\n",
        "less_equal = x <= y  # False"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8b1Bbg923e2i"
      },
      "source": [
        "3. Logical Operators: Used for combining conditional statements.\n",
        "Examples:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-CDcaFme3rdz"
      },
      "outputs": [],
      "source": [
        "p = True # 1\n",
        "q = False # 0\n",
        "\n",
        "and_operator = p and q  # False\n",
        "or_operator = p or q  # True\n",
        "not_operator = not p  # False"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fybqEs-r4EWh"
      },
      "source": [
        "4. Assignment Operators: Used to assign values to variables.\n",
        "Examples:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qkfMwg1R4MkV"
      },
      "outputs": [],
      "source": [
        "x = 10\n",
        "y = 5\n",
        "\n",
        "x += y  # Equivalent to x = x + y, x is now 15\n",
        "y -= 3  # Equivalent to y = y - 3, y is now 2\n",
        "x *= y  # Equivalent to x = x * y, x is now 30\n",
        "x /= y # Equivalent to x = x / y, x is now 15"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WApWXbGi5p1B"
      },
      "source": [
        "5. Bitwise Operators: Used for binary bitwise operations.\n",
        "Examples:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gJ_f5OMn5vlm"
      },
      "outputs": [],
      "source": [
        "a = 5  # 101 in binary\n",
        "b = 3  # 011 in binary\n",
        "\n",
        "bitwise_and = a & b  # 1 (001 in binary)\n",
        "bitwise_or = a | b  # 7 (111 in binary)\n",
        "bitwise_xor = a ^ b  # 6 (110 in binary)\n",
        "bitwise_not_a = ~a  # -6 (in two's complement form)\n",
        "left_shift = a << 2  # 20 (10100 in binary)\n",
        "right_shift = a >> 1  # 2 (10 in binary)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jc_g44GU5-NW"
      },
      "source": [
        "6. Membership Operators: Used to test if a value is present in a sequence (like a list, tuple, or string).\n",
        "Examples:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hWzd5z9B6GcE"
      },
      "outputs": [],
      "source": [
        "my_list = [1, 2, 3, 4]\n",
        "\n",
        "in_operator = 2 in my_list  # True\n",
        "not_in_operator = 5 not in my_list  # True"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "21z8rG9b6cjV"
      },
      "source": [
        "7. Identity Operators: Used to compare the memory locations of two objects.\n",
        "Examples:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oDTa-FkX6gFW"
      },
      "outputs": [],
      "source": [
        "x = [1, 2, 3]\n",
        "y = x  # y references the same list as x\n",
        "\n",
        "is_operator = x is y  # True\n",
        "is_not_operator = x is not y  # False"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GricIoud6j5b"
      },
      "source": [
        "8. Ternary Operator (Conditional Expression): A concise way to write if-else statements.\n",
        "Example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NTGwjUQE6sRi"
      },
      "outputs": [],
      "source": [
        "age = 20\n",
        "is_adult = True if age >= 18 else False"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lR9rcZ2IWIsA"
      },
      "source": [
        "**Indexing & Slicing in Python**\n",
        "\n",
        "In Python, indexing and slicing are fundamental concepts for working with sequences, such as strings, lists, and tuples. Indexing allows you to access individual elements within a sequence, while slicing allows you to extract a portion (subsequence) of the sequence. Here, I'll explain both concepts with examples.\n",
        "\n",
        "1. Indexing:\n",
        "\n",
        "    Indexing refers to accessing a specific element within a sequence by specifying its position (index). In Python, indexing is zero-based, which means the first element has an index of 0, the second has an index of 1, and so on.\n",
        "\n",
        "    Example with a string:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W38x0Mf1Wfd1",
        "outputId": "8997f470-2d3c-4d51-e3bb-df561f452a69"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "W\n"
          ]
        }
      ],
      "source": [
        "text = \"Hello, World\"\n",
        "char = text[7]  # Accessing the character 'W' at index 7\n",
        "print(char)  # Output: 'W'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ECJCiqJXWk12"
      },
      "source": [
        "Example with a list:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "snatQH50WpGs",
        "outputId": "f56d9a6c-613d-49ac-c1e7-d5e14ec4d5e3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3\n"
          ]
        }
      ],
      "source": [
        "numbers = [1, 2, 3, 4, 5]\n",
        "value = numbers[2]  # Accessing the value 3 at index 2\n",
        "print(value)  # Output: 3"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "udNps3W1WuMa"
      },
      "source": [
        "2. Slicing:\n",
        "\n",
        "    Slicing allows you to extract a portion of a sequence by specifying a range of indices. The slicing syntax is as follows: sequence[start:stop:step]. The start index is inclusive, and the stop index is exclusive, meaning that the slice includes elements from the start index up to, but not including, the stop index. The step parameter determines the increment when selecting elements.\n",
        "\n",
        "    Example with a string:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Sk0xs6n1W1f0"
      },
      "outputs": [],
      "source": [
        "text = \"Hello, World\"\n",
        "substring = text[0:5]  # Slicing from index 0 to 4 (inclusive)\n",
        "print(substring)  # Output: 'Hello'\n",
        "\n",
        "substring2 = text[7:]  # Slicing from index 7 to the end\n",
        "print(substring2)  # Output: 'World'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MJ3cz88sW5LK"
      },
      "source": [
        "Example with a list:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gGdSy9H2W8Vk"
      },
      "outputs": [],
      "source": [
        "numbers = [1, 2, 3, 4, 5]\n",
        "subset = numbers[1:4]  # Slicing from index 1 to 3 (inclusive)\n",
        "print(subset)  # Output: [2, 3]\n",
        "\n",
        "subset2 = numbers[2:]  # Slicing from index 2 to the end\n",
        "print(subset2)  # Output: [3, 4, 5]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GYb1G2N4XOZ7"
      },
      "source": [
        "Slicing can also be used with a step parameter to skip elements:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aKHPGu1qXRRk"
      },
      "outputs": [],
      "source": [
        "numbers = [1, 2, 3, 4, 5]\n",
        "subset = numbers[0:5:2]  # Slicing with a step of 2\n",
        "print(subset)  # Output: [1, 3, 5]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EttAXoEFX_tK"
      },
      "source": [
        "**Functions & Methods in Python**\n",
        "\n",
        "In Python, functions and methods are both used to define reusable blocks of code, but they are used in slightly different contexts.\n",
        "\n",
        "Functions:\n",
        "A function is a block of organized, reusable code that performs a specific task. Functions are defined using the **def** keyword, followed by the function name, parameters (if any), and a colon. The function body is indented and contains the code to execute. Functions are typically defined outside of classes and can be called from anywhere in your code.\n",
        "\n",
        "Here's an example of a simple function that adds two numbers and returns the result:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ipvhXgz2YjgL",
        "outputId": "cb078815-702c-47a5-a869-8ee54a87ac44"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "8\n"
          ]
        }
      ],
      "source": [
        "def add_numbers(a, b):\n",
        "    result = a + b\n",
        "    return result\n",
        "\n",
        "# Calling the function\n",
        "sum_result = add_numbers(5, 3)\n",
        "print(sum_result)  # Output: 8"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2QzNLDNpYo5V"
      },
      "source": [
        "In this example, add_numbers is a function that takes two parameters, a and b, and returns their sum.\n",
        "\n",
        "Methods:\n",
        "A method is similar to a function but is associated with an object or class. Methods are defined within a class and are used to perform operations on that class's data. Methods are called using the dot notation (**object.method()**). Methods can access and modify the object's attributes.\n",
        "\n",
        "Here's an example of a simple class with a method:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZYYlVB1PYuqH"
      },
      "outputs": [],
      "source": [
        "class Dog:\n",
        "    def __init__(self, name):\n",
        "        self.name = name\n",
        "\n",
        "    def bark(self):\n",
        "        return f\"{self.name} says woof!\"\n",
        "\n",
        "# Creating an instance of the class\n",
        "dog1 = Dog(\"Buddy\")\n",
        "\n",
        "# Calling the method\n",
        "bark_result = dog1.bark()\n",
        "print(bark_result)  # Output: Buddy says woof!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PLvPskgfY6DW"
      },
      "source": [
        "In this example, we define a class **Dog** with an **__init__** method (constructor) to initialize the **name** attribute, and a **bark** method to return a message specific to the dog instance.\n",
        "\n",
        "In summary, functions are standalone blocks of code that can be called from anywhere in your program, while methods are functions associated with an object or class, allowing you to operate on that object's data. Both functions and methods are essential tools for organizing and reusing code in Python."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wFiyKaRIjQs3"
      },
      "source": [
        "**Function & Methods used with String**\n",
        "\n",
        "Python provides a variety of built-in string functions (methods) that allow you to manipulate and work with strings. Here are some commonly used string functions with explanations and examples:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sO7EOGKeji1-"
      },
      "outputs": [],
      "source": [
        "text = \"Hello, World!\"\n",
        "length = len(text)\n",
        "print(length)  # Output: 13\n",
        "\n",
        "text = \"Hello, World!\"\n",
        "uppercase_text = text.upper()\n",
        "print(uppercase_text)  # Output: \"HELLO, WORLD!\"\n",
        "\n",
        "text = \"Hello, World!\"\n",
        "lowercase_text = text.lower()\n",
        "print(lowercase_text)  # Output: \"hello, world!\"\n",
        "\n",
        "text = \"   Python   \"\n",
        "stripped_text = text.strip()\n",
        "print(stripped_text)  # Output: \"Python\"\n",
        "\n",
        "text = \"apple,banana,cherry\"\n",
        "fruits = text.split(\",\")\n",
        "print(fruits)  # Output: ['apple', 'banana', 'cherry']\n",
        "\n",
        "text = \"Hello, World!\"\n",
        "new_text = text.replace(\"Hello\", \"Hi\")\n",
        "print(new_text)  # Output: \"Hi, World!\"\n",
        "\n",
        "text = \"Hello, World!\"\n",
        "position = text.find(\"World\")\n",
        "print(position)  # Output: 7\n",
        "\n",
        "text = \"Hello, World!\"\n",
        "starts_with_hello = text.startswith(\"Hello\")\n",
        "ends_with_exclamation = text.endswith(\"!\")\n",
        "print(starts_with_hello)  # Output: True\n",
        "print(ends_with_exclamation)  # Output: True"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jyMP4hbOnGq7"
      },
      "source": [
        "**Function & Methods used with List**\n",
        "\n",
        "There are numerous built-in functions and methods that can be used with lists in Python to manipulate and work with them. Here is a list of some commonly used functions and methods for lists:\n",
        "\n",
        "**Common Functions:**\n",
        "\n",
        "1. `len(list)`: Returns the number of elements in the list.\n",
        "2. `max(list)`: Returns the maximum element in the list.\n",
        "3. `min(list)`: Returns the minimum element in the list.\n",
        "4. `sum(list)`: Returns the sum of all elements in the list.\n",
        "5. `sorted(list)`: Returns a new sorted list.\n",
        "6. `any(iterable)`: Returns `True` if at least one element in the iterable is `True`.\n",
        "7. `all(iterable)`: Returns `True` if all elements in the iterable are `True`.\n",
        "\n",
        "**List Methods:**\n",
        "\n",
        "1. `append(item)`: Adds an item to the end of the list.\n",
        "2. `extend(iterable)`: Appends elements from an iterable to the end of the list.\n",
        "3. `insert(index, item)`: Inserts an item at a specific index.\n",
        "4. `remove(item)`: Removes the first occurrence of the item from the list.\n",
        "5. `pop([index])`: Removes and returns the element at the specified index. If no index is provided, it removes and returns the last element.\n",
        "6. `clear()`: Removes all items from the list.\n",
        "7. `count(item)`: Returns the number of occurrences of the item in the list.\n",
        "8. `index(item)`: Returns the index of the first occurrence of the item.\n",
        "9. `reverse()`: Reverses the order of the elements in the list in place.\n",
        "10. `copy()`: Returns a shallow copy of the list.\n",
        "11. `sort()`: Sorts the list in ascending order.\n",
        "12. `sort(reverse=True)`: Sorts the list in descending order.\n",
        "13. `sort(key=function)`: Sorts the list using a custom key function.\n",
        "14. `clear()`: Removes all items from the list."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aadj8KG-oynM"
      },
      "source": [
        "**Function & Method used with Dictionary**\n",
        "\n",
        "Dictionaries in Python are a versatile data structure that allows you to store key-value pairs. They come with various built-in functions and methods for manipulating and working with the data stored in dictionaries. Here's a list of some commonly used functions and methods associated with dictionaries in Python:\n",
        "\n",
        "**Functions:**\n",
        "\n",
        "1. `len(dict)`: Returns the number of key-value pairs in the dictionary.\n",
        "\n",
        "2. `str(dict)`: Returns a string representation of the dictionary.\n",
        "\n",
        "3. `dict(keys, values)`: Creates a new dictionary with the given keys and values, typically used with two lists.\n",
        "\n",
        "**Methods:**\n",
        "\n",
        "1. `clear()`: Removes all key-value pairs from the dictionary.\n",
        "\n",
        "2. `copy()`: Returns a shallow copy of the dictionary.\n",
        "\n",
        "3. `fromkeys(keys, value)`: Creates a new dictionary with the specified keys and an optional default value.\n",
        "\n",
        "4. `get(key, default)`: Returns the value associated with the key if it exists, or a default value if the key is not found.\n",
        "\n",
        "5. `items()`: Returns a view of all key-value pairs in the dictionary.\n",
        "\n",
        "6. `keys()`: Returns a view of all keys in the dictionary.\n",
        "\n",
        "7. `values()`: Returns a view of all values in the dictionary.\n",
        "\n",
        "8. `pop(key, default)`: Removes and returns the value associated with the key if it exists, or a default value if the key is not found.\n",
        "\n",
        "9. `popitem()`: Removes and returns an arbitrary key-value pair from the dictionary.\n",
        "\n",
        "10. `setdefault(key, default)`: Returns the value associated with the key if it exists, or sets the key to the default value if it doesn't.\n",
        "\n",
        "11. `update(dict2)`: Merges the dictionary with another dictionary or iterable of key-value pairs.\n",
        "\n",
        "12. `items()`: Returns a view of all key-value pairs in the dictionary.\n",
        "\n",
        "13. `keys()`: Returns a view of all keys in the dictionary.\n",
        "\n",
        "14. `values()`: Returns a view of all values in the dictionary.\n",
        "\n",
        "15. `pop(key, default)`: Removes and returns the value associated with the key if it exists, or a default value if the key is not found.\n",
        "\n",
        "16. `popitem()`: Removes and returns an arbitrary key-value pair from the dictionary.\n",
        "\n",
        "17. `setdefault(key, default)`: Returns the value associated with the key if it exists, or sets the key to the default value if it doesn't.\n",
        "\n",
        "18. `update(dict2)`: Merges the dictionary with another dictionary or iterable of key-value pairs.\n",
        "\n",
        "These functions and methods are essential for creating, updating, and retrieving data from dictionaries. They provide the tools to work with key-value pairs effectively, making dictionaries a valuable data structure in Python."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XKP_xlB7qqtw"
      },
      "source": [
        "**Function & Method used with Tuple**\n",
        "\n",
        "Tuples are similar to lists in Python, but they are immutable, meaning their elements cannot be changed after creation. Here is a list of some common functions and methods used with tuples in Python:\n",
        "\n",
        "**1. Creating Tuples:**\n",
        "   - `my_tuple = (1, 2, 3)`: Creates a tuple with the specified values.\n",
        "   - `empty_tuple = ()`: Creates an empty tuple.\n",
        "\n",
        "**2. Accessing Elements:**\n",
        "   - `element = my_tuple[index]`: Access an element by its index.\n",
        "   - `slice = my_tuple[start:stop:step]`: Slice the tuple to extract a portion.\n",
        "   - `len(my_tuple)`: Get the length of the tuple.\n",
        "\n",
        "**3. Concatenation:**\n",
        "   - `new_tuple = tuple1 + tuple2`: Concatenate two tuples.\n",
        "\n",
        "**4. Count and Index:**\n",
        "   - `count = my_tuple.count(value)`: Count the number of occurrences of a value.\n",
        "   - `index = my_tuple.index(value)`: Find the index of the first occurrence of a value.\n",
        "\n",
        "**5. Tuple Packing and Unpacking:**\n",
        "   - You can pack multiple values into a tuple and unpack them into separate variables in a single statement.\n",
        "   - Example:\n",
        "     ```python\n",
        "     coordinates = (3, 4)\n",
        "     x, y = coordinates  # Unpacking into x and y\n",
        "     ```\n",
        "\n",
        "**6. Membership Testing:**\n",
        "   - `element_in_tuple = value in my_tuple`: Check if a value is present in the tuple.\n",
        "\n",
        "**7. Built-in Functions:**\n",
        "   - `min(my_tuple)`: Find the minimum value in the tuple.\n",
        "   - `max(my_tuple)`: Find the maximum value in the tuple.\n",
        "   - `sum(my_tuple)`: Calculate the sum of all elements in the tuple.\n",
        "\n",
        "**8. Immutable Nature:**\n",
        "   - Tuples are immutable, so there are no methods for adding, changing, or removing elements like lists have.\n",
        "\n",
        "Tuples are often used when you want to ensure that the data remains unchanged once it's defined. They are efficient for situations where data should not be modified, such as coordinates or records. While tuples have limited built-in methods compared to lists, their immutability makes them suitable for specific use cases."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "upozSHPrrFJd"
      },
      "source": [
        "**Functions & Methods used with Set**\n",
        "\n",
        "Sets in Python have several built-in functions and methods that allow you to perform various operations on sets. Here is a list of commonly used functions and methods associated with sets:\n",
        "\n",
        "**Set Functions:**\n",
        "\n",
        "1. `len(set)`: Returns the number of elements in the set.\n",
        "\n",
        "2. `max(set)`: Returns the maximum element in the set.\n",
        "\n",
        "3. `min(set)`: Returns the minimum element in the set.\n",
        "\n",
        "4. `sum(set)`: Returns the sum of all elements in the set.\n",
        "\n",
        "**Set Methods:**\n",
        "\n",
        "1. `add(element)`: Adds an element to the set. If the element is already present, it does nothing.\n",
        "\n",
        "2. `remove(element)`: Removes an element from the set. Raises a `KeyError` if the element is not found.\n",
        "\n",
        "3. `discard(element)`: Removes an element from the set if it exists. It does not raise an error if the element is not found.\n",
        "\n",
        "4. `pop()`: Removes and returns an arbitrary element from the set. Raises a `KeyError` if the set is empty.\n",
        "\n",
        "5. `clear()`: Removes all elements from the set, making it an empty set.\n",
        "\n",
        "6. `union(other_set)`: Returns a new set that is the union of the current set and the provided set.\n",
        "\n",
        "7. `intersection(other_set)`: Returns a new set containing the elements that are present in both the current set and the provided set.\n",
        "\n",
        "8. `difference(other_set)`: Returns a new set containing the elements that are in the current set but not in the provided set.\n",
        "\n",
        "9. `symmetric_difference(other_set)`: Returns a new set containing elements that are in either of the sets but not in both.\n",
        "\n",
        "10. `issubset(other_set)`: Checks if the current set is a subset of the provided set and returns `True` or `False`.\n",
        "\n",
        "11. `issuperset(other_set)`: Checks if the current set is a superset of the provided set and returns `True` or `False`.\n",
        "\n",
        "12. `copy()`: Returns a shallow copy of the set.\n",
        "\n",
        "These are some of the key functions and methods used with sets in Python. Sets are particularly useful for storing collections of unique elements and performing operations like intersection, union, and difference between sets."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F-q0tLRR2ycP"
      },
      "source": [
        "**Indentation in Python**\n",
        "\n",
        "\n",
        "In Python, indentation refers to the use of whitespace (usually spaces or tabs) at the beginning of a line to indicate the structure and nesting of code. Python uses indentation to define code blocks and scope, such as loops, conditionals, functions, classes, and more. Indentation is not just for visual clarity but is a crucial part of the Python syntax.\n",
        "\n",
        "1. **Indentation Rules:**\n",
        "\n",
        "    Indentation is used to define a code block.\n",
        "\n",
        "    The indented lines belong to the block.\n",
        "\n",
        "    Blocks of code are usually defined after a colon (:), as seen in loops, conditionals, functions, and class definitions.\n",
        "\n",
        "    All lines in the same block must have the same level of indentation.\n",
        "\n",
        "    Subsequent nested blocks are indented further."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6DOw2Ab2sgIq"
      },
      "source": [
        "**If-Else Statement in Python**\n",
        "\n",
        "In Python, the `if` and `else` statements are used to create conditional branching in your code. They allow you to execute different blocks of code based on whether a specified condition is `True` or `False`. Here's an explanation with an example of how the `if` and `else` statements work:\n",
        "\n",
        "**if Statement:**\n",
        "\n",
        "The `if` statement is used to test a condition. If the condition is true, the code inside the `if` block is executed. If the condition is false, the `if` block is skipped."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "M5xjhocMs4rE"
      },
      "outputs": [],
      "source": [
        "x = 10\n",
        "if x > 5:\n",
        "    print(\"x is greater than 5\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8lmBDI_0s9b6"
      },
      "source": [
        "In this example, the code inside the `if` block is executed because the condition `x > 5` is true.\n",
        "\n",
        "**if-else Statement:**\n",
        "\n",
        "The `if-else` statement allows you to specify two blocks of code. If the condition is true, the code inside the `if` block is executed; if the condition is false, the code inside the `else` block is executed."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GvNahzW0tLG7"
      },
      "outputs": [],
      "source": [
        "x = 3\n",
        "if x > 5:\n",
        "    print(\"x is greater than 5\")\n",
        "else:\n",
        "    print(\"x is not greater than 5\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4WiP9hhrtPI6"
      },
      "source": [
        "In this example, since the condition `x > 5` is false, the code inside the `else` block is executed, and it prints \"x is not greater than 5.\"\n",
        "\n",
        "**if-elif-else Statement:**\n",
        "\n",
        "You can use multiple `elif` (short for \"else if\") statements to create more complex conditional logic."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f5_ImKUPtZBQ"
      },
      "outputs": [],
      "source": [
        "x = 7\n",
        "if x > 10:\n",
        "    print(\"x is greater than 10\")\n",
        "elif x > 5:\n",
        "    print(\"x is greater than 5 but not greater than 10\")\n",
        "else:\n",
        "    print(\"x is 5 or less\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BBmiXVi-tenK"
      },
      "source": [
        "In this example, the first condition is false, so it moves to the `elif` condition, which is true. Therefore, the code inside the second block is executed, and it prints \"x is greater than 5 but not greater than 10.\"\n",
        "\n",
        "The `if`, `elif`, and `else` statements are powerful tools for controlling the flow of your code based on conditions. They allow you to make decisions and execute specific blocks of code accordingly, which is fundamental for building complex and responsive programs."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uJEEItcx_61Q"
      },
      "source": [
        "**For Loop in Python**\n",
        "\n",
        "In Python, for loops are used to iterate over a sequence, such as a list, tuple, string, or range. The for loop repeats a block of code for each element in the sequence. Here's an explanation with examples of different for loop variations in Python:\n",
        "\n",
        "1. Iterating over a List:\n",
        "You can use a for loop to iterate over the elements of a list."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gA8FvUOF_6Nn"
      },
      "outputs": [],
      "source": [
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "for fruit in fruits:\n",
        "    print(fruit)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ryby5x-iAQy_"
      },
      "source": [
        "This loop iterates through the fruits list and prints each fruit one by one.\n",
        "\n",
        "2. Iterating over a Range:\n",
        "The range() function generates a sequence of numbers, and you can iterate over it."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JpW0c8V4AWwC"
      },
      "outputs": [],
      "source": [
        "for number in range(1, 6):  # Numbers from 1 to 5\n",
        "    print(number)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UwgIKAfWAbHk"
      },
      "source": [
        "This loop iterates through the numbers 1 to 5 and prints each number.\n",
        "\n",
        "3. Iterating over a String:\n",
        "You can loop through each character in a string."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "D6DOsdkJAarc"
      },
      "outputs": [],
      "source": [
        "word = \"Python\"\n",
        "for char in word:\n",
        "    print(char)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "86QkjKfNBDUP"
      },
      "source": [
        "This loop iterates through the characters in the string \"Python\" and prints each character.\n",
        "\n",
        "4. Iterating with Index:\n",
        "You can use the enumerate() function to loop through a sequence and get both the index and the value."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mHIosrOVBHf6"
      },
      "outputs": [],
      "source": [
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "for index, fruit in enumerate(fruits):\n",
        "    print(f\"Index {index}: {fruit}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TQNqgfvtBLDf"
      },
      "source": [
        "This loop iterates through the fruits list, providing both the index and the value in each iteration.\n",
        "\n",
        "5. Nested Loops:\n",
        "You can nest for loops to iterate through multiple sequences."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mqG51g4wBPm6"
      },
      "outputs": [],
      "source": [
        "colors = [\"red\", \"green\", \"blue\"]\n",
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "for color in colors:\n",
        "    for fruit in fruits:\n",
        "        print(f\"{color} {fruit}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bfm7G4B5BV5o"
      },
      "source": [
        "This loop nests two for loops to create combinations of colors and fruits.\n",
        "\n",
        "6. Iterating through a Dictionary:\n",
        "You can loop through the keys, values, or key-value pairs in a dictionary."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fZscLLyXBZ7r"
      },
      "outputs": [],
      "source": [
        "person = {\"name\": \"Alice\", \"age\": 30, \"city\": \"New York\"}\n",
        "for key in person:\n",
        "    print(f\"Key: {key}, Value: {person[key]}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mo5oleCSBfFt"
      },
      "source": [
        "This loop iterates through the keys in the person dictionary and prints each key and its corresponding value.\n",
        "\n",
        "In Python, for loops are versatile and can be used in various situations to iterate over different types of sequences, making them a fundamental tool for repetitive tasks and data processing."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E1H6aduCBgk1"
      },
      "source": [
        "**While loop in Python**\n",
        "\n",
        "In Python, the while loop is used to repeatedly execute a block of code as long as a specified condition is True. It's a control flow structure that allows you to create loops that continue until the condition becomes False. Here's an explanation with an example of a while loop in Python:\n",
        "\n",
        "Syntax:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q0pBVeFCCYiQ"
      },
      "outputs": [],
      "source": [
        "#while condition:\n",
        "    # Code to execute while the condition is True"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZzQkIoK6CiRL"
      },
      "source": [
        "Example - Using a while Loop:\n",
        "\n",
        "In this example, we'll use a while loop to print numbers from 1 to 5. The loop will continue executing as long as a counter variable is less than or equal to 5."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y7v5f7VtClvx",
        "outputId": "fff44d23-bdea-42a7-a6bf-a7ee5ca5481f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ],
      "source": [
        "counter = 1\n",
        "\n",
        "while counter <= 5:\n",
        "    print(counter)\n",
        "    counter += 1  # Increment the counter by 1 in each iteration"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GA7CCDXHCn1Z"
      },
      "source": [
        "In this example:\n",
        "\n",
        "1. We start with a counter variable initialized to 1.\n",
        "\n",
        "2. The while loop checks the condition counter <= 5. As long as this condition is True, the code inside the loop is executed.\n",
        "\n",
        "3. Inside the loop, we print the current value of counter and then increment it by 1 using counter += 1.\n",
        "\n",
        "4. The loop continues to execute until the condition becomes False. Once counter reaches 6, the condition is no longer met, and the loop terminates.\n",
        "\n",
        "Infinite Loop:\n",
        "\n",
        "Be careful when using while loops, as an incorrect condition or code can lead to an infinite loop, which will execute indefinitely. For example, the following code creates an infinite loop because the condition is always True:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eOd29ieJDBZl"
      },
      "outputs": [],
      "source": [
        "while True:\n",
        "    print(\"This is an infinite loop!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wSPokiZrDDcG"
      },
      "source": [
        "You can exit an infinite loop by manually stopping the program or by including a condition inside the loop that will eventually become False.\n",
        "\n",
        "**Using break and continue:**\n",
        "\n",
        "You can use the break statement to exit a while loop prematurely if a certain condition is met, and the continue statement to skip the rest of the current iteration and move to the next iteration.\n",
        "\n",
        "Here's an example using break to exit the loop:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BZRoVHMSDHlc"
      },
      "outputs": [],
      "source": [
        "counter = 1\n",
        "\n",
        "while True:\n",
        "    print(counter)\n",
        "    counter += 1\n",
        "    if counter > 5:\n",
        "        break  # Exit the loop when counter is greater than 5"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ExmcDhFEDQtP"
      },
      "source": [
        "This code will produce the same output as the previous example but uses a break statement to control the loop's termination.\n",
        "\n",
        "The while loop is a valuable tool for repetitive tasks where the number of iterations is not known in advance or when you want to loop until a specific condition is met. Be cautious with the loop condition to avoid infinite loops and use break and continue when necessary to control the loop's behavior."
      ]
    }
  ],
  "metadata": {
    "colab": {
      "authorship_tag": "ABX9TyPVPkSy0lo7Yy8hSxeRT0T7",
      "include_colab_link": true,
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}