OCT 8 - Python Crash Course .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "06a382ec",
   "metadata": {},
   "source": [
    "# Essence of Python "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be929467",
   "metadata": {},
   "source": [
    "## 1.  What is  Python ?\n",
    "**Python is an interpreted ,Object Oriented, high-level programming langauge with dynamic semantics.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9401a356",
   "metadata": {},
   "source": [
    "## 2.  History of Python \n",
    "\n",
    "1. **1980s**: Guido van Rossum started working on Python, inspired by the ABC language.\n",
    "2. **1989**: Python development began as a hobby project.\n",
    "3. **1991**: First Python release (**Python 0.9.0**) with classes and functions.\n",
    "4. **1994**: Python **1.0** was released, introducing lambda functions.\n",
    "5. **2000**: Python **2.0** added list comprehensions; Python Software Foundation (PSF) was formed.\n",
    "6. **2008**: Python **3.0** released, introducing breaking changes and improved syntax.\n",
    "7. **2020**: Python **2.x** officially retired.\n",
    "8. **2023**: Python became dominant in AI, data science, and web development.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef969cb5",
   "metadata": {},
   "source": [
    "## 3. Key features of Python:\n",
    "\n",
    "1. **Easy to Learn and Use**: Python has simple syntax and is highly readable, making it beginner-friendly.\n",
    "   \n",
    "2. **Interpreted Language**: Python is executed line by line, allowing for easy debugging and testing.\n",
    "\n",
    "3. **Dynamically Typed**: You don't need to declare the type of variables; Python determines it during runtime.\n",
    "\n",
    "4. **High-Level Language**: Python handles memory management, allowing developers to focus on logic instead of hardware details.\n",
    "\n",
    "5. **Cross-Platform**: Python works on various operating systems like Windows, macOS, and Linux.\n",
    "\n",
    "6. **Extensive Standard Library**: Python provides a vast collection of modules and libraries for various tasks (e.g., web development, data science, machine learning).\n",
    "\n",
    "7. **Open Source**: Python is free to use and distribute, with a large supportive community for contributions.\n",
    "\n",
    "8. **Object-Oriented**: Python supports object-oriented programming, offering features like inheritance, polymorphism, and encapsulation.\n",
    "\n",
    "9. **Support for Multiple Paradigms**: Python supports procedural, object-oriented, and functional programming.\n",
    "\n",
    "10. **Integration Capabilities**: Python integrates easily with other languages like C, C++, and Java, and can be extended using APIs.\n",
    "\n",
    "11. **Garbage Collection**: Python has built-in garbage collection to manage memory automatically.\n",
    "\n",
    "12. **Vast Ecosystem**: Python has rich libraries and frameworks (e.g., Django, Flask, NumPy, TensorFlow) for web development, data analysis, AI, and more."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba311c6a",
   "metadata": {},
   "source": [
    "### 4. Key applications of Python:\n",
    "\n",
    "1. **Web Development**: Frameworks like Django and Flask are used to build websites and web apps.\n",
    "2. **Data Science**: Python is popular for data analysis, visualization, and statistical modeling (libraries: Pandas, NumPy, Matplotlib).\n",
    "3. **Machine Learning/AI**: Python is widely used in AI and ML with libraries like TensorFlow, Keras, and Scikit-learn.\n",
    "4. **Automation/Scripting**: Python automates repetitive tasks and processes.\n",
    "5. **Game Development**: Libraries like Pygame help in building simple games.\n",
    "6. **Software Development**: Python is used for building desktop apps, GUIs, and prototyping.\n",
    "7. **Networking**: Python is used for network programming and socket programming.\n",
    "8. **Scientific Computing**: Python is used for scientific research and numerical computations.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc70fad8",
   "metadata": {},
   "source": [
    "## 5. Application of Python\n",
    "### **Famous People/Founders**\n",
    "1. **Guido van Rossum** – Creator of Python\n",
    "   - Although not a business founder, Guido van Rossum created Python, which has become one of the most popular programming languages globally and is used by countless companies.\n",
    "\n",
    "2. **Mark Zuckerberg** – Founder of Facebook (Meta)\n",
    "   - Facebook’s backend(First used PHP) has extensive use of Python, especially for production engineering and in many machine learning applications. Python is also used in Facebook’s AI Research (FAIR).\n",
    "\n",
    "3. **Elon Musk** – Founder of SpaceX, Tesla\n",
    "   - Python plays a role in SpaceX’s rocket design and testing automation systems, as well as in Tesla for vehicle automation systems, machine learning models, and analytics tools.\n",
    "\n",
    "4. **Travis Kalanick and Garrett Camp** – Founders of Uber\n",
    "   - Uber heavily uses Python for building its backend systems and handling real-time ride requests, data processing, and AI-based route optimization.\n",
    "\n",
    "5. **Reid Hoffman** – Co-Founder of LinkedIn\n",
    "   - LinkedIn uses Python for backend services, including data analysis, machine learning algorithms, and many internal tools.\n",
    "\n",
    "6. **Jack Dorsey** – Co-Founder of Twitter\n",
    "   - Twitter originally built part of its platform in Python. Even though much of it was later rewritten in Java and Scala for performance reasons, Python is still used for various internal services and data analysis.\n",
    "\n",
    "7. **Aaron Swartz** – Co-Founder of Reddit\n",
    "   - Reddit was originally built with Python, and the platform still heavily uses Python for its backend, including handling user data, APIs, and community moderation systems.\n",
    "\n",
    "### **Companies Built Using Python**\n",
    "\n",
    "1. **Google**\n",
    "   - Python is one of Google’s official programming languages. It's widely used for system building, scripting, and machine learning. Google’s AI libraries, including TensorFlow, are also Python-compatible.\n",
    "\n",
    "2. **Instagram**\n",
    "   - Instagram was originally built using Django, a Python web framework, and continues to rely on Python for scaling their massive platform, handling millions of users and images.\n",
    "\n",
    "3. **Dropbox**\n",
    "   - Dropbox was originally built with Python by co-founder **Drew Houston**. Today, Dropbox continues to use Python in its desktop client applications and backend systems.\n",
    "\n",
    "4. **Spotify**\n",
    "   - Spotify uses Python for data analysis and backend services. It is responsible for recommendation systems, data pipelines, and machine learning models used for personalized playlists.\n",
    "\n",
    "5. **Quora**\n",
    "   - Quora, a Q&A platform, was developed using Python. It uses Python for its core functionality, handling queries and answers, user management, and data analytics.\n",
    "\n",
    "6. **Pinterest**\n",
    "   - Pinterest uses Python for web scraping, backend development, and data analysis. Its recommendation engines and machine learning algorithms also run on Python.\n",
    "\n",
    "7. **YouTube**\n",
    "   - YouTube, now part of Google, was initially built with Python. It uses Python for server-side operations, managing millions of video uploads and views daily.\n",
    "\n",
    "8. **NASA**\n",
    "   - NASA uses Python for scientific computing, automation, and in various software used for mission-critical applications, including space exploration tools.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c100ec6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "490c6031",
   "metadata": {},
   "source": [
    "## 6.Variables in python \n",
    "<h4>A variable in programming, including Python, is a symbolic name that refers to or stores data that can be manipulated or accessed during the execution of a program. Think of a variable as a container for holding information that can change or vary as the program runs.</h4>\n",
    "\n",
    "1. **No Declaration Needed**: Variables are created when you assign a value, no need to declare the type.\n",
    "   ```python\n",
    "   x = 5\n",
    "   name = \"Alice\"\n",
    "   ```\n",
    "\n",
    "2. **Dynamic Typing**: Python automatically infers the variable type based on the value.\n",
    "   ```python\n",
    "   x = 10     # Integer\n",
    "   y = 10.5   # Float\n",
    "   name = \"John\"  # String\n",
    "   ```\n",
    "\n",
    "3. **Variable Naming Rules**:\n",
    "   - Must start with a letter or underscore (`_`).\n",
    "   - Can contain letters, numbers, and underscores but cannot start with a number.\n",
    "   - Python is case-sensitive (`name` and `Name` are different).\n",
    "\n",
    "4. **Reassigning Variables**: You can change the value and type of a variable anytime.\n",
    "   ```python\n",
    "   x = 10\n",
    "   x = \"Hello\"  # Now x is a string\n",
    "   ```\n",
    "\n",
    "5. **Multiple Assignments**: You can assign multiple variables at once.\n",
    "   ```python\n",
    "   a, b, c = 1, 2, 3\n",
    "   ```\n",
    "\n",
    "6. **Global and Local Variables**:\n",
    "   - Variables declared inside a function are **local** and accessible only within that function.\n",
    "   - Variables declared outside any function are **global** and accessible throughout the program.\n",
    "\n",
    "7. **Global Keyword**: Use `global` to modify a global variable inside a function.\n",
    "   ```python\n",
    "   x = 10\n",
    "   def modify_var():\n",
    "       global x\n",
    "       x = 20\n",
    "   ```\n",
    "\n",
    "8. **Constants**: While Python doesn’t have built-in constant variables, it’s a convention to use uppercase for variables that shouldn’t change.\n",
    "   ```python\n",
    "   PI = 3.14159\n",
    "   ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ee39947",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9c2cae3d",
   "metadata": {},
   "source": [
    "## 7.Strings\n",
    "In Python, a **string** is a sequence of characters enclosed within single quotes (`'`), double quotes (`\"`), or triple quotes (`'''` or `\"\"\"`). Strings are used to represent text-based data and are one of the most commonly used data types in programming.\n",
    "\n",
    "### Key Features of Strings:\n",
    "\n",
    "1. **Creation**:\n",
    "   - Strings can be created using single, double, or triple quotes.\n",
    "   ```python\n",
    "   single_quote = 'Hello'\n",
    "   double_quote = \"World\"\n",
    "   triple_quote = '''This is a \n",
    "   multi-line string.'''\n",
    "   ```\n",
    "\n",
    "2. **Immutability**: \n",
    "   - Strings in Python are immutable, meaning once created, their values cannot be changed. However, you can create new strings based on existing ones.\n",
    "   ```python\n",
    "   original = \"Hello\"\n",
    "   new_string = original + \" World\"  # 'original' remains \"Hello\"\n",
    "   ```\n",
    "\n",
    "3. **String Concatenation**: \n",
    "   - You can concatenate (join) two or more strings using the `+` operator.\n",
    "   ```python\n",
    "   greeting = \"Hello\" + \" \" + \"World\"  # Result: \"Hello World\"\n",
    "   ```\n",
    "\n",
    "4. **String Multiplication**: \n",
    "   - You can repeat a string multiple times using the `*` operator.\n",
    "   ```python\n",
    "   repeated = \"Hi! \" * 3  # Result: \"Hi! Hi! Hi! \"\n",
    "   ```\n",
    "\n",
    "5. **Accessing Characters**: \n",
    "   - You can access individual characters in a string using indexing. Python uses zero-based indexing.\n",
    "   ```python\n",
    "   s = \"Python\"\n",
    "   first_char = s[0]  # 'P'\n",
    "   last_char = s[-1]  # 'n'\n",
    "   ```\n",
    "\n",
    "6. **Slicing**: \n",
    "   - You can extract a substring using slicing.\n",
    "   ```python\n",
    "   s = \"Hello, World!\"\n",
    "   substring = s[7:12]  # 'World'\n",
    "   ```\n",
    "\n",
    "7. **String Methods**: \n",
    "   - Python provides many built-in methods for string manipulation, such as:\n",
    "   ```python\n",
    "   s = \"hello\"\n",
    "   capitalized = s.capitalize()  # 'Hello'\n",
    "   upper = s.upper()              # 'HELLO'\n",
    "   lower = s.lower()              # 'hello'\n",
    "   split_string = s.split(\",\")    # Splits string into a list\n",
    "   ```\n",
    "\n",
    "8. **String Formatting**: \n",
    "   - You can format strings using f-strings (Python 3.6+), `str.format()`, or the `%` operator.\n",
    "   ```python\n",
    "   name = \"Alice\"\n",
    "   age = 25\n",
    "   formatted = f\"{name} is {age} years old.\"  # Using f-strings\n",
    "   ```\n",
    "\n",
    "9. **Escape Characters**: \n",
    "   - Special characters can be included in strings using escape sequences (e.g., `\\'`, `\\\"`, `\\\\`, `\\n`, `\\t`).\n",
    "   ```python\n",
    "   escaped_string = \"He said, \\\"Hello!\\\"\\nNew line here.\"\n",
    "   ```\n",
    "\n",
    "### Example:\n",
    "Here’s a simple example demonstrating some of these features:\n",
    "```python\n",
    "# Creating strings\n",
    "greeting = \"Hello, World!\"\n",
    "\n",
    "# Accessing characters\n",
    "first_letter = greeting[0]  # 'H'\n",
    "last_letter = greeting[-1]   # '!'\n",
    "\n",
    "# String methods\n",
    "upper_case = greeting.upper()  # 'HELLO, WORLD!'\n",
    "lower_case = greeting.lower()  # 'hello, world!'\n",
    "\n",
    "# String concatenation\n",
    "full_greeting = greeting + \" How are you?\"\n",
    "\n",
    "# Slicing\n",
    "sub_string = greeting[7:12]   # 'World'\n",
    "\n",
    "print(full_greeting)  # Output: Hello, World! How are you?\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64a4cb4f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c5973353",
   "metadata": {},
   "source": [
    "## 8. Operators\n",
    "### 1. Arithmetic Operators\n",
    "- **`+`**: Addition  \n",
    "- **`-`**: Subtraction  \n",
    "- **`*`**: Multiplication  \n",
    "- **`/`**: Division  \n",
    "- **`//`**: Floor Division  \n",
    "- **`%`**: Modulus  \n",
    "- **`**`**: Exponentiation  \n",
    "\n",
    "### 2. Comparison Operators\n",
    "- **`==`**: Equal  \n",
    "- **`!=`**: Not Equal  \n",
    "- **`>`**: Greater Than  \n",
    "- **`<`**: Less Than  \n",
    "- **`>=`**: Greater Than or Equal To  \n",
    "- **`<=`**: Less Than or Equal To  \n",
    "\n",
    "### 3. Logical Operators\n",
    "- **`and`**: True if both are true  \n",
    "- **`or`**: True if at least one is true  \n",
    "- **`not`**: Reverses the logical state  \n",
    "\n",
    "### 4. Assignment Operators\n",
    "- **`=`**: Assign  \n",
    "- **`+=`**: Add and Assign  \n",
    "- **`-=`**: Subtract and Assign  \n",
    "- **`*=`**: Multiply and Assign  \n",
    "- **`/=`**: Divide and Assign  \n",
    "\n",
    "### 5. Bitwise Operators\n",
    "- **`&`**: Bitwise AND  \n",
    "- **`|`**: Bitwise OR  \n",
    "- **`^`**: Bitwise XOR  \n",
    "- **`~`**: Bitwise NOT  \n",
    "- **`<<`**: Left Shift  \n",
    "- **`>>`**: Right Shift  \n",
    "\n",
    "### 6. Identity Operators\n",
    "- **`is`**: Checks if two variables point to the same object  \n",
    "- **`is not`**: Checks if they do not point to the same object  \n",
    "\n",
    "### 7. Membership Operators\n",
    "- **`in`**: Checks if a value exists in a sequence  \n",
    "- **`not in`**: Checks if a value does not exist in a sequence  \n",
    "\n",
    "This summarizes the key operators in Python!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a8baf29c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A (Binary)</th>\n",
       "      <th>B (Binary)</th>\n",
       "      <th>A &amp; B (AND)</th>\n",
       "      <th>A | B (OR)</th>\n",
       "      <th>A ^ B (XOR)</th>\n",
       "      <th>~A (NOT A)</th>\n",
       "      <th>A &lt;&lt; 1 (Left Shift)</th>\n",
       "      <th>A &gt;&gt; 1 (Right Shift)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   A (Binary)  B (Binary)  A & B (AND)  A | B (OR)  A ^ B (XOR)  ~A (NOT A)  \\\n",
       "0           0           0            0           0            0           3   \n",
       "1           0           1            0           1            1           2   \n",
       "2           1           0            0           1            1           3   \n",
       "3           1           1            1           1            0           2   \n",
       "\n",
       "   A << 1 (Left Shift)  A >> 1 (Right Shift)  \n",
       "0                    0                     0  \n",
       "1                    2                     0  \n",
       "2                    0                     0  \n",
       "3                    2                     0  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "data = {\n",
    "    'A (Binary)': [0, 0, 1, 1],\n",
    "    'B (Binary)': [0, 1, 0, 1],\n",
    "    'A & B (AND)': [0 & 0, 0 & 1, 1 & 0, 1 & 1],\n",
    "    'A | B (OR)': [0 | 0, 0 | 1, 1 | 0, 1 | 1],\n",
    "    'A ^ B (XOR)': [0 ^ 0, 0 ^ 1, 1 ^ 0, 1 ^ 1],\n",
    "    '~A (NOT A)': [~0 & 0b11, ~1 & 0b11, ~0 & 0b11, ~1 & 0b11],  # To display last 2 bits\n",
    "    'A << 1 (Left Shift)': [0 << 1, 1 << 1, 0 << 1, 1 << 1],\n",
    "    'A >> 1 (Right Shift)': [0 >> 1, 1 >> 1, 0 >> 1, 1 >> 1]\n",
    "}\n",
    "bitwise_table = pd.DataFrame(data)\n",
    "bitwise_table\n",
    "# Ignore the code looks at truth table to understand the working mechanism of bitwise operator "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "67dde498",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b1010'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(10)\n",
    "# Here  1010 is the Binary conversion and 0b is type \n",
    "# We can do this for all types of number system "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc6eee14",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "fb4ff622",
   "metadata": {},
   "source": [
    "## 9. Data Types \n",
    "Categorization of Python data types into **mutable** and **immutable**:\n",
    "\n",
    "### **Mutable (Changeable) Types**  \n",
    "These data types can be modified after they are created.\n",
    "\n",
    "- **List**: e.g., `[1, 2, 3]`\n",
    "- **Dictionary (dict)**: e.g., `{\"name\": \"Alice\", \"age\": 25}`\n",
    "- **Set**: e.g., `{1, 2, 3}`\n",
    "- **Bytearray**: e.g., `bytearray(b'hello')`\n",
    "\n",
    "### **Immutable (Unchangeable) Types**  \n",
    "These data types cannot be modified after they are created.\n",
    "\n",
    "- **Integer (int)**: e.g., `10`\n",
    "- **Float (float)**: e.g., `3.14`\n",
    "- **String (str)**: e.g., `\"hello\"`\n",
    "- **Tuple**: e.g., `(1, 2, 3)`\n",
    "- **Boolean (bool)**: e.g., `True`, `False`\n",
    "- **Set (frozenset)**: e.g., `frozenset({1, 2, 3})`\n",
    "- **Bytes**: e.g., `b'hello'`\n",
    "- **Complex**: e.g., `2+3j`\n",
    "- **NoneType**: e.g., `None`\n",
    "\n",
    "This classification separates data types based on whether their values can be altered after initialization!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a6e3adf8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3+5j)\n"
     ]
    }
   ],
   "source": [
    "# Define a complex number\n",
    "complex_num = 3 + 5j\n",
    "\n",
    "# Print the complex number\n",
    "print(complex_num)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "927cbaad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(complex_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f551939c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "53773372",
   "metadata": {},
   "source": [
    "## 10. Type casting \n",
    "**Type casting** (or type conversion) in Python is the process of converting a value from one data type to another. This is useful when you want to perform operations that require data to be in a specific type, like converting a string input to an integer for mathematical operations.\n",
    "\n",
    "### Types of Type Casting:\n",
    "\n",
    "1. **Implicit Type Casting**: Python automatically converts one data type to another when needed.\n",
    "   - Example: Converting an integer to a float during division.\n",
    "   ```python\n",
    "   result = 5 / 2  # The result is automatically converted to float: 2.5\n",
    "   ```\n",
    "\n",
    "2. **Explicit Type Casting**: The user manually converts a value from one type to another using type casting functions.\n",
    "   - Common type casting functions:\n",
    "     - **`int()`**: Converts a value to an integer.\n",
    "     - **`float()`**: Converts a value to a floating-point number.\n",
    "     - **`str()`**: Converts a value to a string.\n",
    "     - **`list()`**: Converts a value to a list.\n",
    "     - **`eval()`**: Evaluates a string as a Python expression.\n",
    "\n",
    "### Example of Explicit Type Casting:\n",
    "```python\n",
    "# Convert string to integer\n",
    "num = int(\"10\")\n",
    "print(num + 5)  # Output: 15\n",
    "\n",
    "# Convert integer to float\n",
    "num_float = float(10)\n",
    "print(num_float)  # Output: 10.0\n",
    "```\n",
    "\n",
    "### Why Use Type Casting?\n",
    "- To ensure data is in the correct format for operations (e.g., summing two numbers).\n",
    "- To convert user input (which is always a string) into other types like integers or floats for calculations.\n",
    "\n",
    "\n",
    "Here are some common type casting functions used with **user input** in Python:\n",
    "\n",
    "1. **`int()`**  \n",
    "   Converts the input to an integer.\n",
    "   ```python\n",
    "   user_input = int(input(\"Enter an integer: \"))\n",
    "   ```\n",
    "\n",
    "2. **`float()`**  \n",
    "   Converts the input to a floating-point number.\n",
    "   ```python\n",
    "   user_input = float(input(\"Enter a float: \"))\n",
    "   ```\n",
    "\n",
    "3. **`str()`**  \n",
    "   Ensures the input is treated as a string (though `input()` already returns a string).\n",
    "   ```python\n",
    "   user_input = str(input(\"Enter a string: \"))\n",
    "   ```\n",
    "\n",
    "4. **`eval()`**  \n",
    "   Evaluates the input as a Python expression, automatically interpreting it as an integer, float, list, etc.\n",
    "   ```python\n",
    "   user_input = eval(input(\"Enter an expression (e.g., 1+2, [1, 2]): \"))\n",
    "\n",
    "   ```\n",
    "\n",
    "5. **`list()`**  \n",
    "   Converts the input to a list (useful with `split()`).\n",
    "   ```python\n",
    "   user_input = input(\"Enter space-separated values: \").split()\n",
    "   user_list = list(user_input)\n",
    "   ```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "bfc5f825",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval('10+0b1010')\n",
    "# bin 10 = 0b1010 , eval us converting 10 into bin and adding "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "881fa0ff",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f144aa13",
   "metadata": {},
   "source": [
    "### 11. Conditionals\n",
    "In Python, **conditionals** are used to execute different blocks of code based on certain conditions. The primary conditional statements are **`if`**, **`elif`**, and **`else`**.\n",
    "\n",
    "### Basic Syntax\n",
    "\n",
    "1. **`if` statement**:\n",
    "   - Executes a block of code if the condition is true.\n",
    "   ```python\n",
    "   if condition:\n",
    "       # Code to execute if condition is true\n",
    "   ```\n",
    "\n",
    "2. **`elif` (else if) statement**:\n",
    "   - Allows checking multiple conditions. If the previous conditions are false, it checks this condition.\n",
    "   ```python\n",
    "   if condition1:\n",
    "       # Code for condition1\n",
    "   elif condition2:\n",
    "       # Code for condition2\n",
    "   ```\n",
    "\n",
    "3. **`else` statement**:\n",
    "   - Executes a block of code if none of the previous conditions are true.\n",
    "   ```python\n",
    "   if condition:\n",
    "       # Code if condition is true\n",
    "   else:\n",
    "       # Code if condition is false\n",
    "   ```\n",
    "\n",
    "### Example of Conditionals\n",
    "```python\n",
    "age = int(input(\"Enter your age: \"))\n",
    "\n",
    "if age < 18:\n",
    "    print(\"You are a minor.\")\n",
    "elif age < 65:\n",
    "    print(\"You are an adult.\")\n",
    "else:\n",
    "    print(\"You are a senior.\")\n",
    "```\n",
    "\n",
    "### Nested Conditionals\n",
    "You can also nest conditionals within each other to create more complex logic.\n",
    "```python\n",
    "number = int(input(\"Enter a number: \"))\n",
    "\n",
    "if number > 0:\n",
    "    print(\"The number is positive.\")\n",
    "    if number % 2 == 0:\n",
    "        print(\"It's an even number.\")\n",
    "    else:\n",
    "        print(\"It's an odd number.\")\n",
    "elif number < 0:\n",
    "    print(\"The number is negative.\")\n",
    "else:\n",
    "    print(\"The number is zero.\")\n",
    "```\n",
    "\n",
    "### Ternary Conditional Operator\n",
    "Python also has a shorthand way to write conditionals using the ternary operator.\n",
    "```python\n",
    "# Ternary conditional\n",
    "result = \"Even\" if number % 2 == 0 else \"Odd\"\n",
    "print(result)\n",
    "```\n",
    "\n",
    "### Important Notes\n",
    "- Indentation is crucial in Python. The code blocks under each conditional must be indented consistently.\n",
    "- Conditions can use comparison operators (`==`, `!=`, `<`, `>`, `<=`, `>=`) and logical operators (`and`, `or`, `not`) to combine multiple conditions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f42fafa6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "da19a365",
   "metadata": {},
   "source": [
    "## 12. Loops\n",
    "Loops in Python are used to execute a block of code repeatedly based on a specified condition. They allow for the efficient processing of collections, performing actions multiple times, or iterating through a sequence of values. There are primarily two types of loops in Python: **`for`** loops and **`while`** loops.\n",
    "\n",
    "### 1. **`for` Loop**\n",
    "\n",
    "The `for` loop is used to iterate over a sequence (such as a list, tuple, dictionary, set, or string) or to perform a certain number of iterations using the `range()` function.\n",
    "\n",
    "#### Syntax:\n",
    "```python\n",
    "for variable in sequence:\n",
    "    # Code block to execute\n",
    "```\n",
    "\n",
    "#### Example of Iterating Over a List:\n",
    "```python\n",
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for fruit in fruits:\n",
    "    print(fruit)\n",
    "```\n",
    "**Output:**\n",
    "```\n",
    "apple\n",
    "banana\n",
    "cherry\n",
    "```\n",
    "\n",
    "#### Example Using `range()`:\n",
    "The `range()` function generates a sequence of numbers. You can specify the start, stop, and step values.\n",
    "\n",
    "```python\n",
    "for i in range(5):  # 0 to 4\n",
    "    print(i)\n",
    "```\n",
    "**Output:**\n",
    "```\n",
    "0\n",
    "1\n",
    "2\n",
    "3\n",
    "4\n",
    "```\n",
    "\n",
    "#### Example with Start and Step:\n",
    "```python\n",
    "for i in range(1, 10, 2):  # Start at 1, end before 10, increment by 2\n",
    "    print(i)\n",
    "```\n",
    "**Output:**\n",
    "```\n",
    "1\n",
    "3\n",
    "5\n",
    "7\n",
    "9\n",
    "```\n",
    "\n",
    "#### Using `for` Loop with Dictionaries:\n",
    "You can iterate over keys and values of a dictionary.\n",
    "\n",
    "```python\n",
    "person = {\"name\": \"Alice\", \"age\": 25}\n",
    "\n",
    "for key, value in person.items():\n",
    "    print(f\"{key}: {value}\")\n",
    "```\n",
    "**Output:**\n",
    "```\n",
    "name: Alice\n",
    "age: 25\n",
    "```\n",
    "\n",
    "### 2. **`while` Loop**\n",
    "\n",
    "The `while` loop repeatedly executes a block of code as long as a specified condition is true. It's useful when the number of iterations is not known beforehand.\n",
    "\n",
    "#### Syntax:\n",
    "```python\n",
    "while condition:\n",
    "    # Code block to execute\n",
    "```\n",
    "\n",
    "#### Example:\n",
    "```python\n",
    "count = 0\n",
    "while count < 5:\n",
    "    print(count)\n",
    "    count += 1  # Increment the count to avoid an infinite loop\n",
    "```\n",
    "**Output:**\n",
    "```\n",
    "0\n",
    "1\n",
    "2\n",
    "3\n",
    "4\n",
    "```\n",
    "\n",
    "#### Using `while` Loop with User Input:\n",
    "You can use a `while` loop to continue asking for input until a specific condition is met.\n",
    "\n",
    "```python\n",
    "number = 0\n",
    "while number != -1:\n",
    "    number = int(input(\"Enter a number (-1 to stop): \"))\n",
    "    print(f\"You entered: {number}\")\n",
    "```\n",
    "\n",
    "### 3. **Loop Control Statements**\n",
    "\n",
    "Control statements can alter the flow of loops. The most common control statements are **`break`**, **`continue`**, and **`pass`**.\n",
    "\n",
    "#### a. **`break` Statement**\n",
    "The `break` statement is used to exit a loop prematurely.\n",
    "\n",
    "```python\n",
    "for i in range(10):\n",
    "    if i == 5:\n",
    "        break  # Exit the loop when i is 5\n",
    "    print(i)\n",
    "```\n",
    "**Output:**\n",
    "```\n",
    "0\n",
    "1\n",
    "2\n",
    "3\n",
    "4\n",
    "```\n",
    "\n",
    "#### b. **`continue` Statement**\n",
    "The `continue` statement skips the current iteration and proceeds to the next iteration.\n",
    "\n",
    "```python\n",
    "for i in range(5):\n",
    "    if i == 2:\n",
    "        continue  # Skip when i is 2\n",
    "    print(i)\n",
    "```\n",
    "**Output:**\n",
    "```\n",
    "0\n",
    "1\n",
    "3\n",
    "4\n",
    "```\n",
    "\n",
    "#### c. **`pass` Statement**\n",
    "The `pass` statement is a placeholder that does nothing. It can be useful when a loop is required syntactically but no action is needed.\n",
    "\n",
    "```python\n",
    "for i in range(5):\n",
    "    if i == 2:\n",
    "        pass  # Do nothing when i is 2\n",
    "    print(i)\n",
    "```\n",
    "**Output:**\n",
    "```\n",
    "0\n",
    "1\n",
    "2\n",
    "3\n",
    "4\n",
    "```\n",
    "\n",
    "### 4. **Nested Loops**\n",
    "\n",
    "You can nest loops within each other. For example, a `for` loop inside a `while` loop or vice versa.\n",
    "\n",
    "#### Example of Nested Loops:\n",
    "```python\n",
    "for i in range(3):  # Outer loop\n",
    "    for j in range(2):  # Inner loop\n",
    "        print(f\"i = {i}, j = {j}\")\n",
    "```\n",
    "**Output:**\n",
    "```\n",
    "i = 0, j = 0\n",
    "i = 0, j = 1\n",
    "i = 1, j = 0\n",
    "i = 1, j = 1\n",
    "i = 2, j = 0\n",
    "i = 2, j = 1\n",
    "```\n",
    "\n",
    "### Summary of Loops in Python\n",
    "\n",
    "- **`for` Loop**: Used for iterating over a sequence (like lists or ranges).\n",
    "- **`while` Loop**: Used for repeating code as long as a condition is true.\n",
    "- **Control Statements**:\n",
    "  - **`break`**: Exit the loop immediately.\n",
    "  - **`continue`**: Skip to the next iteration.\n",
    "  - **`pass`**: Placeholder that does nothing.\n",
    "- **Nested Loops**: You can place one loop inside another for more complex scenarios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09079ab4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "44fd80e8",
   "metadata": {},
   "source": [
    "## 13. String\n",
    "---\n",
    "\n",
    "### **1. String Basics**\n",
    "\n",
    "Strings in Python are sequences of characters enclosed in single, double, or triple quotes.\n",
    "\n",
    "```python\n",
    "my_string = \"Hello, World!\"\n",
    "```\n",
    "\n",
    "### **2. Indexing in Strings**\n",
    "\n",
    "#### **Accessing characters by index:**\n",
    "\n",
    "```python\n",
    "my_string = \"Python\"\n",
    "print(my_string[0])   # Output: P\n",
    "print(my_string[-1])  # Output: n\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### **3. Slicing Strings**\n",
    "\n",
    "#### **Syntax**: `string[start:end:step]`\n",
    "\n",
    "```python\n",
    "my_string = \"Python Programming\"\n",
    "print(my_string[0:6])   # Output: Python\n",
    "print(my_string[::-1])  # Output: gnimmargorP nohtyP\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### **4. String Functions**\n",
    "\n",
    "#### **a. `len()`** – Find the length of a string:\n",
    "\n",
    "```python\n",
    "len(\"Python\")  # Output: 6\n",
    "```\n",
    "\n",
    "#### **b. `lower()` and `upper()`** – Convert to lowercase/uppercase:\n",
    "\n",
    "```python\n",
    "\"Python\".lower()  # Output: python\n",
    "```\n",
    "\n",
    "#### **c. `strip()`, `lstrip()`, `rstrip()`** – Remove whitespace:\n",
    "\n",
    "```python\n",
    "\"  Hello  \".strip()  # Output: \"Hello\"\n",
    "```\n",
    "\n",
    "#### **d. `replace()`** – Replace a part of the string:\n",
    "\n",
    "```python\n",
    "\"Hello World\".replace(\"World\", \"Python\")  # Output: Hello Python\n",
    "```\n",
    "\n",
    "#### **e. `split()` and `join()`** – Splitting and joining strings:\n",
    "\n",
    "```python\n",
    "\"apple,banana,cherry\".split(\",\")    # Output: ['apple', 'banana', 'cherry']\n",
    "\"-\".join(['apple', 'banana'])       # Output: apple-banana\n",
    "```\n",
    "\n",
    "#### **f. `find()` and `index()`** – Locate a substring:\n",
    "\n",
    "```python\n",
    "\"Hello World\".find(\"World\")   # Output: 6\n",
    "```\n",
    "\n",
    "#### **g. `startswith()` and `endswith()`** – Check string start/end:\n",
    "\n",
    "```python\n",
    "\"Python\".startswith(\"Py\")  # Output: True\n",
    "```\n",
    "\n",
    "#### **h. `count()`** – Count occurrences of a substring:\n",
    "\n",
    "```python\n",
    "\"banana\".count(\"a\")  # Output: 3\n",
    "```\n",
    "\n",
    "#### **i. `isalnum()`, `isalpha()`, `isdigit()`** – Check character types:\n",
    "\n",
    "```python\n",
    "\"Python3\".isalnum()  # Output: True\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### **5. String Formatting**\n",
    "\n",
    "#### **a. Using `+` operator (Concatenation):**\n",
    "\n",
    "```python\n",
    "name = \"Alice\"\n",
    "age = 25\n",
    "message = \"My name is \" + name + \" and I am \" + str(age) + \" years old.\"\n",
    "```\n",
    "\n",
    "#### **b. Using `format()` function:**\n",
    "\n",
    "```python\n",
    "message = \"My name is {} and I am {} years old.\".format(name, age)\n",
    "```\n",
    "\n",
    "#### **c. Using `f-strings` (Python 3.6+):**\n",
    "\n",
    "```python\n",
    "message = f\"My name is {name} and I am {age} years old.\"\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### **6. String Immutability**\n",
    "\n",
    "Strings are immutable; once created, they cannot be modified.\n",
    "\n",
    "```python\n",
    "my_string = \"Python\"\n",
    "my_string[0] = \"J\"  # This raises an error\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### **7. Escape Characters**\n",
    "\n",
    "#### Examples:\n",
    "- `\\'` for single quote\n",
    "- `\\n` for newline\n",
    "- `\\t` for tab\n",
    "\n",
    "```python\n",
    "message = \"He said, \\\"Hello!\\\"\"\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### **8. Multiline Strings**\n",
    "\n",
    "You can create multiline strings using triple quotes:\n",
    "\n",
    "```python\n",
    "multiline_string = \"\"\"This is\n",
    "a multiline\n",
    "string.\"\"\"\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### **9. Raw Strings**\n",
    "\n",
    "#### **Raw strings** treat backslashes (`\\`) literally.\n",
    "\n",
    "```python\n",
    "raw_string = r\"C:\\Users\\Alice\\Documents\"\n",
    "```\n",
    "---\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9042890a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4894de22",
   "metadata": {},
   "source": [
    "\n",
    "---\n",
    "## 14. List \n",
    "### Beginner Level:\n",
    "\n",
    "a list is a built-in data structure that allows you to store a collection of items. \n",
    "1. **Creating Lists**: A list is created using square brackets `[]`, and it can hold elements of any type.\n",
    "   ```python\n",
    "   my_list = [1, 2, 3, 4, 5]\n",
    "   fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "   ```\n",
    "\n",
    "2. **Accessing List Elements**: You can access elements using their index, starting from `0`.\n",
    "   ```python\n",
    "   print(fruits[0])  # Output: apple\n",
    "   ```\n",
    "\n",
    "3. **Modifying List Elements**: Lists are mutable, so you can change their elements.\n",
    "   ```python\n",
    "   fruits[1] = \"orange\"\n",
    "   ```\n",
    "\n",
    "4. **Appending Elements**: Use `append()` to add a single element to the end of the list.\n",
    "   ```python\n",
    "   fruits.append(\"grape\")\n",
    "   ```\n",
    "\n",
    "5. **Removing Elements**: Use `remove()` to delete a specific element.\n",
    "   ```python\n",
    "   fruits.remove(\"cherry\")\n",
    "   ```\n",
    "\n",
    "6. **List Length**: Use `len()` to get the number of elements in a list.\n",
    "   ```python\n",
    "   len(fruits)  # Output: 3\n",
    "   ```\n",
    "\n",
    "---\n",
    "\n",
    "### **Intermediate Level:**\n",
    "\n",
    "7. **Slicing Lists**: Extract a portion of a list using slicing (`start:end:step`).\n",
    "   ```python\n",
    "   my_list[1:4]  # Output: [2, 3, 4]\n",
    "   ```\n",
    "\n",
    "8. **Inserting Elements**: Use `insert()` to insert an element at a specific position.\n",
    "   ```python\n",
    "   fruits.insert(1, \"mango\")\n",
    "   ```\n",
    "\n",
    "9. **Extending Lists**: Use `extend()` to add all elements from another list.\n",
    "   ```python\n",
    "   more_fruits = [\"pineapple\", \"melon\"]\n",
    "   fruits.extend(more_fruits)\n",
    "   ```\n",
    "\n",
    "10. **Pop Elements**: Use `pop()` to remove and return the last element (or the element at a specific index).\n",
    "   ```python\n",
    "   fruits.pop()  # Removes and returns the last item\n",
    "   ```\n",
    "\n",
    "11. **Reversing a List**: Use `reverse()` to reverse the order of elements.\n",
    "   ```python\n",
    "   fruits.reverse()\n",
    "   ```\n",
    "\n",
    "12. **Sorting Lists**: Use `sort()` to sort the list in ascending order (by default).\n",
    "   ```python\n",
    "   my_list.sort()\n",
    "   ```\n",
    "\n",
    "---\n",
    "\n",
    "### **Advanced Level:**\n",
    "\n",
    "13. **List Comprehensions**: Create new lists using a concise syntax.\n",
    "   ```python\n",
    "   squares = [x**2 for x in range(5)]  # Output: [0, 1, 4, 9, 16]\n",
    "   ```\n",
    "\n",
    "14. **Nested Lists**: Lists can contain other lists (multidimensional lists).\n",
    "   ```python\n",
    "   matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "   ```\n",
    "\n",
    "15. **Copying Lists**: Use `copy()` to create a copy of a list.\n",
    "   ```python\n",
    "   new_list = fruits.copy()\n",
    "   ```\n",
    "\n",
    "16. **List `count()`**: Counts how many times a value appears in the list.\n",
    "   ```python\n",
    "   my_list.count(2)  # Output: 1\n",
    "   ```\n",
    "\n",
    "17. **List `index()`**: Find the index of the first occurrence of a value.\n",
    "   ```python\n",
    "   my_list.index(3)  # Output: 2\n",
    "   ```\n",
    "\n",
    "18. **Using `zip()` with Lists**: Combine elements of multiple lists into tuples.\n",
    "   ```python\n",
    "   list1 = [1, 2, 3]\n",
    "   list2 = ['a', 'b', 'c']\n",
    "   combined = list(zip(list1, list2))  # Output: [(1, 'a'), (2, 'b'), (3, 'c')]\n",
    "   ```\n",
    "\n",
    "19. **Unpacking Lists**: Assign list elements to variables directly.\n",
    "   ```python\n",
    "   a, b, c = [1, 2, 3]\n",
    "   ```\n",
    "\n",
    "---\n",
    "> NOTE : Array is collection of similar element where List is collection of elements, list elements can be different "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0a3e9e7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1e4b7226",
   "metadata": {},
   "source": [
    "### **15. Dictionaries:**\n",
    "A **dictionary** in Python is a collection of **key-value pairs** where each key is unique, and it is used to store data values like a map. Unlike lists or tuples, dictionaries are **unordered** and **mutable**. Dictionaries are defined using curly braces `{}` and each key is mapped to a value using a colon `:`.\n",
    "\n",
    "---\n",
    "\n",
    "### **Beginner Level:**\n",
    "\n",
    "1. **Creating a Dictionary**: \n",
    "   A dictionary is created using curly braces `{}`, with key-value pairs inside. The **keys** must be unique and immutable (like strings or numbers), while **values** can be of any data type.\n",
    "\n",
    "   ```python\n",
    "   my_dict = {\n",
    "       \"name\": \"Alice\",\n",
    "       \"age\": 25,\n",
    "       \"city\": \"New York\"\n",
    "   }\n",
    "   ```\n",
    "\n",
    "2. **Accessing Values by Key**: \n",
    "   You can retrieve a value by referring to its key.\n",
    "   ```python\n",
    "   print(my_dict[\"name\"])  # Output: Alice\n",
    "   ```\n",
    "\n",
    "3. **Modifying Values**: \n",
    "   Dictionaries are mutable, so you can update the value of any key.\n",
    "   ```python\n",
    "   my_dict[\"age\"] = 26\n",
    "   ```\n",
    "\n",
    "4. **Adding a New Key-Value Pair**: \n",
    "   Simply assign a value to a new key.\n",
    "   ```python\n",
    "   my_dict[\"profession\"] = \"Engineer\"\n",
    "   ```\n",
    "\n",
    "5. **Removing Key-Value Pairs**: \n",
    "   Use `del` or `pop()` to remove specific pairs.\n",
    "   ```python\n",
    "   del my_dict[\"city\"]  # Removes the 'city' key\n",
    "   my_dict.pop(\"age\")   # Removes the 'age' key\n",
    "   ```\n",
    "\n",
    "6. **Dictionary Length**: \n",
    "   Use `len()` to count the number of key-value pairs.\n",
    "   ```python\n",
    "   len(my_dict)  # Output: 2 (if 'city' and 'age' are removed)\n",
    "   ```\n",
    "\n",
    "---\n",
    "\n",
    "### **Intermediate Level:**\n",
    "\n",
    "7. **Dictionary Methods**: \n",
    "   Some commonly used methods are:\n",
    "   \n",
    "   - **`keys()`**: Returns all keys.\n",
    "     ```python\n",
    "     my_dict.keys()  # Output: dict_keys(['name', 'profession'])\n",
    "     ```\n",
    "   \n",
    "   - **`values()`**: Returns all values.\n",
    "     ```python\n",
    "     my_dict.values()  # Output: dict_values(['Alice', 'Engineer'])\n",
    "     ```\n",
    "\n",
    "   - **`items()`**: Returns all key-value pairs as tuples.\n",
    "     ```python\n",
    "     my_dict.items()  # Output: dict_items([('name', 'Alice'), ('profession', 'Engineer')])\n",
    "     ```\n",
    "\n",
    "   - **`get()`**: Retrieves a value for a given key, with an optional default if the key doesn't exist.\n",
    "     ```python\n",
    "     my_dict.get(\"age\", \"Not Available\")  # Output: \"Not Available\"\n",
    "     ```\n",
    "\n",
    "8. **Updating Dictionaries**: \n",
    "   Use `update()` to merge one dictionary into another.\n",
    "   ```python\n",
    "   new_data = {\"age\": 26, \"city\": \"Boston\"}\n",
    "   my_dict.update(new_data)\n",
    "   ```\n",
    "\n",
    "9. **Checking for a Key**: \n",
    "   Use the `in` keyword to check if a key exists in a dictionary.\n",
    "   ```python\n",
    "   \"name\" in my_dict  # Output: True\n",
    "   ```\n",
    "\n",
    "---\n",
    "\n",
    "### **Advanced Level:**\n",
    "\n",
    "10. **Dictionary Comprehensions**: \n",
    "    Just like list comprehensions, Python allows dictionary comprehensions to create dictionaries from iterables.\n",
    "    ```python\n",
    "    squares = {x: x*x for x in range(6)}\n",
    "    # Output: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}\n",
    "    ```\n",
    "\n",
    "11. **Nested Dictionaries**: \n",
    "    Dictionaries can contain other dictionaries, creating complex nested data structures.\n",
    "    ```python\n",
    "    student = {\n",
    "        \"name\": \"John\",\n",
    "        \"grades\": {\"math\": 95, \"science\": 88}\n",
    "    }\n",
    "    print(student[\"grades\"][\"math\"])  # Output: 95\n",
    "    ```\n",
    "\n",
    "12. **Copying Dictionaries**: \n",
    "    Use `copy()` to create a shallow copy of a dictionary (to avoid modifying the original dictionary).\n",
    "    ```python\n",
    "    new_dict = my_dict.copy()\n",
    "    ```\n",
    "\n",
    "13. **Dictionary `popitem()`**: \n",
    "    Removes and returns the last inserted key-value pair.\n",
    "    ```python\n",
    "    my_dict.popitem()  # Removes the last key-value pair\n",
    "    ```\n",
    "\n",
    "14. **Handling Missing Keys with `setdefault()`**: \n",
    "    Returns the value of a key, and if the key doesn’t exist, it inserts the key with a default value.\n",
    "    ```python\n",
    "    my_dict.setdefault(\"age\", 30)  # Adds 'age': 30 if not already present\n",
    "    ```\n",
    "\n",
    "---\n",
    "\n",
    "### **Example: Full Dictionary Usage**\n",
    "```python\n",
    "person = {\n",
    "    \"name\": \"Alice\",\n",
    "    \"age\": 30,\n",
    "    \"city\": \"London\"\n",
    "}\n",
    "\n",
    "# Add or update a key-value pair\n",
    "person[\"job\"] = \"Engineer\"\n",
    "\n",
    "# Access a value\n",
    "print(person[\"name\"])  # Output: Alice\n",
    "\n",
    "# Loop through keys\n",
    "for key in person:\n",
    "    print(key, person[key])\n",
    "\n",
    "# Get all values\n",
    "print(person.values())  # Output: dict_values(['Alice', 30, 'London', 'Engineer'])\n",
    "\n",
    "# Check if a key exists\n",
    "if \"age\" in person:\n",
    "    print(\"Age is:\", person[\"age\"])  # Output: Age is: 30\n",
    "```\n",
    "\n",
    "---\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e50736ba",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f6f9cde9",
   "metadata": {},
   "source": [
    "### **17. Tuples**\n",
    "\n",
    "A **tuple** in Python is a collection of **ordered** elements, similar to a list. However, unlike lists, **tuples are immutable**, meaning that once created, the elements within them cannot be changed, added, or removed. Tuples are often used to store **related data** that should not be modified during the program’s execution. Tuples are created using parentheses `()`.\n",
    "\n",
    "---\n",
    "\n",
    "### **Beginner Level:**\n",
    "\n",
    "1. **Creating a Tuple**:\n",
    "   Tuples can store mixed data types, including strings, numbers, and even other tuples.\n",
    "   ```python\n",
    "   my_tuple = (1, 2, 3)\n",
    "   fruits = (\"apple\", \"banana\", \"cherry\")\n",
    "   mixed_tuple = (1, \"apple\", 3.14)\n",
    "   ```\n",
    "\n",
    "2. **Accessing Tuple Elements**: \n",
    "   Access elements using an index, similar to lists, starting from `0`.\n",
    "   ```python\n",
    "   print(fruits[0])  # Output: apple\n",
    "   ```\n",
    "\n",
    "3. **Tuple Length**: \n",
    "   Use `len()` to find the number of elements in a tuple.\n",
    "   ```python\n",
    "   len(fruits)  # Output: 3\n",
    "   ```\n",
    "\n",
    "4. **Tuple with One Element**: \n",
    "   A tuple with one element needs a comma to differentiate it from a regular value inside parentheses.\n",
    "   ```python\n",
    "   single_element_tuple = (5,)\n",
    "   ```\n",
    "\n",
    "---\n",
    "\n",
    "### **Intermediate Level:**\n",
    "\n",
    "5. **Tuple Slicing**: \n",
    "   Tuples support slicing to extract a subset of elements.\n",
    "   ```python\n",
    "   my_tuple = (0, 1, 2, 3, 4, 5)\n",
    "   print(my_tuple[1:4])  # Output: (1, 2, 3)\n",
    "   ```\n",
    "\n",
    "6. **Concatenating Tuples**: \n",
    "   Tuples can be concatenated using the `+` operator.\n",
    "   ```python\n",
    "   new_tuple = (1, 2) + (3, 4)\n",
    "   # Output: (1, 2, 3, 4)\n",
    "   ```\n",
    "\n",
    "7. **Repeating Tuples**: \n",
    "   Use the `*` operator to repeat a tuple a certain number of times.\n",
    "   ```python\n",
    "   repeated_tuple = (\"Hi\",) * 3\n",
    "   # Output: ('Hi', 'Hi', 'Hi')\n",
    "   ```\n",
    "\n",
    "8. **Nested Tuples**: \n",
    "   Tuples can contain other tuples as elements.\n",
    "   ```python\n",
    "   nested_tuple = (1, (2, 3), 4)\n",
    "   ```\n",
    "\n",
    "9. **Tuple Unpacking**: \n",
    "   You can assign the elements of a tuple to variables directly.\n",
    "   ```python\n",
    "   my_tuple = (1, 2, 3)\n",
    "   a, b, c = my_tuple\n",
    "   print(a, b, c)  # Output: 1 2 3\n",
    "   ```\n",
    "\n",
    "---\n",
    "\n",
    "### **Advanced Level:**\n",
    "\n",
    "10. **Checking if an Element Exists**: \n",
    "    Use the `in` keyword to check if an element is present in a tuple.\n",
    "    ```python\n",
    "    my_tuple = (1, 2, 3)\n",
    "    print(2 in my_tuple)  # Output: True\n",
    "    ```\n",
    "\n",
    "11. **Finding Index of an Element**: \n",
    "    Use `index()` to find the position of an element.\n",
    "    ```python\n",
    "    my_tuple = (1, 2, 3, 2)\n",
    "    print(my_tuple.index(2))  # Output: 1 (first occurrence)\n",
    "    ```\n",
    "\n",
    "12. **Counting Elements in a Tuple**: \n",
    "    Use `count()` to count how many times an element appears in a tuple.\n",
    "    ```python\n",
    "    my_tuple = (1, 2, 3, 2)\n",
    "    print(my_tuple.count(2))  # Output: 2\n",
    "    ```\n",
    "\n",
    "13. **Tuple Functions**:\n",
    "    - **`min()`**: Returns the smallest element in the tuple.\n",
    "    - **`max()`**: Returns the largest element in the tuple.\n",
    "    - **`sum()`**: Returns the sum of all numeric elements.\n",
    "    ```python\n",
    "    numbers = (1, 2, 3, 4)\n",
    "    print(min(numbers))  # Output: 1\n",
    "    print(max(numbers))  # Output: 4\n",
    "    print(sum(numbers))  # Output: 10\n",
    "    ```\n",
    "\n",
    "14. **Converting List to Tuple**: \n",
    "    Use `tuple()` to convert a list to a tuple.\n",
    "    ```python\n",
    "    my_list = [1, 2, 3]\n",
    "    my_tuple = tuple(my_list)\n",
    "    ```\n",
    "\n",
    "15. **Immutability**: \n",
    "    While you can’t modify tuple elements, you can create a new tuple by concatenating.\n",
    "    ```python\n",
    "    my_tuple = (1, 2, 3)\n",
    "    new_tuple = my_tuple + (4, 5)\n",
    "    # Output: (1, 2, 3, 4, 5)\n",
    "    ```\n",
    "\n",
    "---\n",
    "\n",
    "### **Example: Full Tuple Usage**\n",
    "\n",
    "```python\n",
    "# Creating a tuple\n",
    "person_info = (\"Alice\", 30, \"Engineer\")\n",
    "\n",
    "# Accessing elements\n",
    "name = person_info[0]  # Output: Alice\n",
    "\n",
    "# Unpacking tuple\n",
    "name, age, profession = person_info\n",
    "print(age)  # Output: 30\n",
    "\n",
    "# Slicing\n",
    "print(person_info[1:])  # Output: (30, \"Engineer\")\n",
    "\n",
    "# Checking if an element exists\n",
    "print(\"Alice\" in person_info)  # Output: True\n",
    "\n",
    "# Counting elements\n",
    "print(person_info.count(\"Engineer\"))  # Output: 1\n",
    "```\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39ea4993",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "78827924",
   "metadata": {},
   "source": [
    "### **18. Sets:**\n",
    "A **set** is a built-in data type in Python that represents an unordered collection of unique elements. Sets are useful for storing distinct items and performing operations like unions, intersections, and differences. Since they are unordered, sets do not support indexing or slicing, which distinguishes them from lists and tuples.\n",
    "\n",
    "### **Creating a Set:**\n",
    "You can create a set using curly braces `{}` or the `set()` function.\n",
    "\n",
    "```python\n",
    "my_set = {1, 2, 3, \"apple\", \"banana\"}\n",
    "another_set = set([1, 2, 2, 3, 4])  # Duplicates will be removed\n",
    "```\n",
    "\n",
    "### **Basic Operations with Sets:**\n",
    "1. **Accessing Elements**: Since sets are unordered, you cannot access elements by index, but you can check for membership using the `in` keyword.\n",
    "   ```python\n",
    "   if \"apple\" in my_set:\n",
    "       print(\"Apple is in the set\")  # Output: Apple is in the set\n",
    "   ```\n",
    "\n",
    "2. **Adding Elements**: Use `add()` to include a new element in the set.\n",
    "   ```python\n",
    "   my_set.add(\"orange\")\n",
    "   ```\n",
    "\n",
    "3. **Removing Elements**: You can remove elements using `remove()` (raises an error if the element is not found) or `discard()` (does not raise an error).\n",
    "   ```python\n",
    "   my_set.remove(\"banana\")  # Raises KeyError if \"banana\" is not present\n",
    "   my_set.discard(\"banana\")  # No error if \"banana\" is not present\n",
    "   ```\n",
    "\n",
    "4. **Set Length**: Use `len()` to find the number of unique elements in a set.\n",
    "   ```python\n",
    "   print(len(my_set))  # Output: 5 (if no duplicates)\n",
    "   ```\n",
    "\n",
    "5. **Clearing a Set**: Use `clear()` to remove all elements from the set.\n",
    "   ```python\n",
    "   my_set.clear()\n",
    "   ```\n",
    "\n",
    "### **Set Operations:**\n",
    "1. **Union**: Combines elements from two sets.\n",
    "   ```python\n",
    "   set1 = {1, 2, 3}\n",
    "   set2 = {3, 4, 5}\n",
    "   union_set = set1 | set2  # Output: {1, 2, 3, 4, 5}\n",
    "   ```\n",
    "\n",
    "2. **Intersection**: Gets common elements between sets.\n",
    "   ```python\n",
    "   intersection_set = set1 & set2  # Output: {3}\n",
    "   ```\n",
    "\n",
    "3. **Difference**: Gets elements that are in one set but not in the other.\n",
    "   ```python\n",
    "   difference_set = set1 - set2  # Output: {1, 2}\n",
    "   ```\n",
    "\n",
    "4. **Symmetric Difference**: Gets elements that are in either of the sets but not in both.\n",
    "   ```python\n",
    "   symmetric_difference_set = set1 ^ set2  # Output: {1, 2, 4, 5}\n",
    "   ```\n",
    "\n",
    "### **Example of a Set:**\n",
    "```python\n",
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "fruits.add(\"orange\")  # Adds 'orange' to the set\n",
    "fruits.discard(\"banana\")  # Removes 'banana' if present\n",
    "print(fruits)  # Output: {'apple', 'cherry', 'orange'} (order may vary)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36b87620",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c5bf40ae",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "### **19.Functions:**\n",
    "A **function** is a reusable block of code that performs a specific task. Functions help in organizing code, reducing redundancy, and improving maintainability. In Python, functions can take inputs (known as parameters), perform operations, and return outputs.\n",
    "\n",
    "### **Key Characteristics of Functions:**\n",
    "- **Reusability**: Functions allow you to write code once and reuse it multiple times.\n",
    "- **Parameters**: Functions can accept inputs, making them flexible and versatile.\n",
    "- **Return Values**: Functions can return results back to the caller.\n",
    "\n",
    "### **Creating a Function:**\n",
    "To define a function in Python, you use the `def` keyword followed by the function name and parentheses `()`.\n",
    "\n",
    "```python\n",
    "def my_function():\n",
    "    print(\"Hello, World!\")\n",
    "```\n",
    "\n",
    "### **Basic Function Operations:**\n",
    "1. **Calling a Function**: You invoke a function by using its name followed by parentheses.\n",
    "   ```python\n",
    "   my_function()  # Output: Hello, World!\n",
    "   ```\n",
    "\n",
    "2. **Function with Parameters**: Functions can accept parameters to perform operations using inputs.\n",
    "   ```python\n",
    "   def greet(name):\n",
    "       print(f\"Hello, {name}!\")\n",
    "   \n",
    "   greet(\"Alice\")  # Output: Hello, Alice!\n",
    "   ```\n",
    "\n",
    "3. **Return Statement**: Functions can return values using the `return` keyword.\n",
    "   ```python\n",
    "   def add(a, b):\n",
    "       return a + b\n",
    "\n",
    "   result = add(3, 5)\n",
    "   print(result)  # Output: 8\n",
    "   ```\n",
    "\n",
    "4. **Default Parameters**: You can set default values for parameters in functions.\n",
    "   ```python\n",
    "   def multiply(a, b=2):\n",
    "       return a * b\n",
    "   \n",
    "   print(multiply(3))  # Output: 6 (uses default value of b)\n",
    "   ```\n",
    "\n",
    "### **Intermediate Function Concepts:**\n",
    "5. **Variable Scope**: Variables defined inside a function are local to that function and cannot be accessed outside it.\n",
    "   ```python\n",
    "   def my_function():\n",
    "       local_var = 10\n",
    "       return local_var\n",
    "   \n",
    "   print(my_function())  # Output: 10\n",
    "   # print(local_var)  # Error: NameError\n",
    "   ```\n",
    "\n",
    "6. **Lambda Functions**: These are small anonymous functions defined with the `lambda` keyword.\n",
    "   ```python\n",
    "   square = lambda x: x * x\n",
    "   print(square(5))  # Output: 25\n",
    "   ```\n",
    "\n",
    "7. **Higher-Order Functions**: Functions that take other functions as arguments or return them as results.\n",
    "   ```python\n",
    "   def apply_function(func, value):\n",
    "       return func(value)\n",
    "\n",
    "   print(apply_function(square, 4))  # Output: 16\n",
    "   ```\n",
    "\n",
    "### **Advanced Function Concepts:**\n",
    "8. **Variable-Length Arguments**: You can allow a function to accept an arbitrary number of arguments using `*args` and `**kwargs`.\n",
    "   ```python\n",
    "   def variable_args(*args):\n",
    "       for arg in args:\n",
    "           print(arg)\n",
    "   \n",
    "   variable_args(1, 2, 3)  # Output: 1 2 3\n",
    "\n",
    "   def keyword_args(**kwargs):\n",
    "       for key, value in kwargs.items():\n",
    "           print(f\"{key}: {value}\")\n",
    "\n",
    "   keyword_args(name=\"Alice\", age=25)  # Output: name: Alice, age: 25\n",
    "   ```\n",
    "\n",
    "9. **Docstrings**: You can provide documentation for functions using docstrings, which describe what the function does.\n",
    "   ```python\n",
    "   def subtract(a, b):\n",
    "       \"\"\"Returns the difference between a and b.\"\"\"\n",
    "       return a - b\n",
    "\n",
    "   print(subtract.__doc__)  # Output: Returns the difference between a and b.\n",
    "   ```\n",
    "\n",
    "10. **Function Annotations**: You can add optional type hints to function parameters and return values.\n",
    "    ```python\n",
    "    def divide(a: int, b: int) -> float:\n",
    "        return a / b\n",
    "\n",
    "    print(divide(10, 2))  # Output: 5.0\n",
    "    ```\n",
    "\n",
    "### **Example of a Function:**\n",
    "```python\n",
    "def calculate_area(radius):\n",
    "    \"\"\"Calculates the area of a circle given its radius.\"\"\"\n",
    "    pi = 3.14159\n",
    "    return pi * (radius ** 2)\n",
    "\n",
    "# Calling the function\n",
    "area = calculate_area(5)\n",
    "print(f\"The area of the circle is: {area}\")  # Output: The area of the circle is: 78.53975\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57a9885b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1b6e2714",
   "metadata": {},
   "source": [
    "### **20 Modules:**\n",
    "A **module** in Python is a file containing Python code that defines functions, classes, variables, and runnable code. Modules allow you to organize your code into manageable sections and reuse code across different projects. By breaking your code into modules, you can enhance its readability, maintainability, and scalability.\n",
    "\n",
    "### **Creating a Module:**\n",
    "To create a module, simply save a Python file with a `.py` extension. For example, if you create a file named `mymodule.py`, it can contain the following code:\n",
    "\n",
    "```python\n",
    "# mymodule.py\n",
    "def greet(name):\n",
    "    return f\"Hello, {name}!\"\n",
    "\n",
    "PI = 3.14159\n",
    "```\n",
    "\n",
    "### **Using Modules:**\n",
    "1. **Importing a Module**: You can import a module using the `import` statement.\n",
    "   ```python\n",
    "   import mymodule\n",
    "\n",
    "   print(mymodule.greet(\"Alice\"))  # Output: Hello, Alice!\n",
    "   print(mymodule.PI)               # Output: 3.14159\n",
    "   ```\n",
    "\n",
    "2. **Importing Specific Functions or Variables**: You can import specific items from a module using the `from` keyword.\n",
    "   ```python\n",
    "   from mymodule import greet, PI\n",
    "\n",
    "   print(greet(\"Bob\"))  # Output: Hello, Bob!\n",
    "   print(PI)            # Output: 3.14159\n",
    "   ```\n",
    "\n",
    "3. **Importing All Contents**: You can import everything from a module using `*`, but it's generally not recommended due to potential name conflicts.\n",
    "   ```python\n",
    "   from mymodule import *\n",
    "\n",
    "   print(greet(\"Charlie\"))  # Output: Hello, Charlie!\n",
    "   ```\n",
    "\n",
    "### **Intermediate Module Concepts:**\n",
    "4. **Module Search Path**: Python searches for modules in the directories listed in `sys.path`. You can add directories to this list.\n",
    "   ```python\n",
    "   import sys\n",
    "   print(sys.path)  # Displays the module search path\n",
    "   ```\n",
    "\n",
    "5. **Built-in Modules**: Python comes with many built-in modules, such as `math`, `random`, `os`, and `datetime`, which provide a wide range of functionalities.\n",
    "   ```python\n",
    "   import math\n",
    "\n",
    "   print(math.sqrt(16))  # Output: 4.0\n",
    "   ```\n",
    "\n",
    "6. **Creating Packages**: A package is a collection of related modules. To create a package, organize your modules into a directory and include an `__init__.py` file (which can be empty).\n",
    "   ```\n",
    "   mypackage/\n",
    "   ├── __init__.py\n",
    "   ├── module1.py\n",
    "   └── module2.py\n",
    "   ```\n",
    "\n",
    "7. **Importing from Packages**: You can import modules from a package using dot notation.\n",
    "   ```python\n",
    "   from mypackage import module1\n",
    "   ```\n",
    "\n",
    "### **Advanced Module Concepts:**\n",
    "8. **Reloading Modules**: If you modify a module, you can reload it without restarting the Python interpreter using the `importlib` module.\n",
    "   ```python\n",
    "   import importlib\n",
    "   import mymodule\n",
    "\n",
    "   importlib.reload(mymodule)\n",
    "   ```\n",
    "\n",
    "9. **Module Attributes**: Every module has a built-in attribute `__name__` that indicates its name. You can use this to determine if a module is being run directly or imported.\n",
    "   ```python\n",
    "   if __name__ == \"__main__\":\n",
    "       print(\"Module is being run directly\")\n",
    "   else:\n",
    "       print(\"Module has been imported\")\n",
    "   ```\n",
    "\n",
    "10. **Namespace Management**: Modules provide a way to organize your code into separate namespaces, which helps prevent naming collisions between variables and functions.\n",
    "    ```python\n",
    "    def example_function():\n",
    "        pass\n",
    "    ```\n",
    "\n",
    "### **Example of a Module:**\n",
    "Here's a simple module named `calculator.py`:\n",
    "\n",
    "```python\n",
    "# calculator.py\n",
    "\n",
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "def subtract(a, b):\n",
    "    return a - b\n",
    "\n",
    "def multiply(a, b):\n",
    "    return a * b\n",
    "\n",
    "def divide(a, b):\n",
    "    if b == 0:\n",
    "        return \"Cannot divide by zero!\"\n",
    "    return a / b\n",
    "```\n",
    "\n",
    "You can use this module in another script as follows:\n",
    "\n",
    "```python\n",
    "# main.py\n",
    "import calculator\n",
    "\n",
    "result_add = calculator.add(5, 3)\n",
    "result_subtract = calculator.subtract(10, 4)\n",
    "\n",
    "print(f\"Addition: {result_add}\")      # Output: Addition: 8\n",
    "print(f\"Subtraction: {result_subtract}\")  # Output: Subtraction: 6\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7cc50082",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "55db1c8f",
   "metadata": {},
   "source": [
    "## ** 21. Object-Oriented Programming (OOP) **\n",
    "\n",
    "### **Introduction to OOP**\n",
    "**Object-Oriented Programming (OOP)** is a programming paradigm that organizes software design around data, or objects, rather than functions and logic. An object can be defined as a collection of properties (attributes) and behaviors (methods). OOP enables developers to create modular, reusable, and maintainable code.\n",
    "\n",
    "### **Core Concepts of OOP**\n",
    "\n",
    "1. **Classes and Objects**:\n",
    "   - **Class**: A class is a blueprint for creating objects. It encapsulates data for the object and defines behaviors through methods.\n",
    "   - **Object**: An object is an instance of a class. When you create an object, you allocate memory for it and define its state and behavior based on the class.\n",
    "\n",
    "   **Example**:\n",
    "   ```python\n",
    "   class Dog:\n",
    "       def __init__(self, name, age):\n",
    "           self.name = name  # Attribute\n",
    "           self.age = age    # Attribute\n",
    "\n",
    "       def bark(self):      # Method\n",
    "           return \"Woof!\"\n",
    "   \n",
    "   my_dog = Dog(\"Buddy\", 3)  # Creating an object of the Dog class\n",
    "   print(my_dog.name)  # Output: Buddy\n",
    "   print(my_dog.bark())  # Output: Woof!\n",
    "   ```\n",
    "\n",
    "2. **Attributes and Methods**:\n",
    "   - **Attributes**: Attributes are variables that hold data associated with a class or object. They represent the state or properties of an object.\n",
    "   - **Methods**: Methods are functions defined inside a class that operate on the class's attributes. They define the behaviors of the object.\n",
    "\n",
    "   **Example**:\n",
    "   ```python\n",
    "   class Car:\n",
    "       def __init__(self, brand, model):\n",
    "           self.brand = brand  # Attribute\n",
    "           self.model = model  # Attribute\n",
    "\n",
    "       def display_info(self):  # Method\n",
    "           return f\"{self.brand} {self.model}\"\n",
    "\n",
    "   my_car = Car(\"Toyota\", \"Corolla\")\n",
    "   print(my_car.display_info())  # Output: Toyota Corolla\n",
    "   ```\n",
    "\n",
    "### **Intermediate OOP Concepts**\n",
    "\n",
    "3. **Inheritance**:\n",
    "   - **Inheritance** allows one class (child or subclass) to inherit the attributes and methods of another class (parent or superclass). This promotes code reuse and establishes a hierarchical relationship between classes.\n",
    "\n",
    "   **Example**:\n",
    "   ```python\n",
    "   class Animal:\n",
    "       def speak(self):\n",
    "           return \"Animal speaks\"\n",
    "\n",
    "   class Dog(Animal):  # Dog inherits from Animal\n",
    "       def bark(self):\n",
    "           return \"Woof!\"\n",
    "\n",
    "   my_dog = Dog()\n",
    "   print(my_dog.speak())  # Output: Animal speaks\n",
    "   print(my_dog.bark())   # Output: Woof!\n",
    "   ```\n",
    "\n",
    "4. **Method Overriding**:\n",
    "   - **Method Overriding** occurs when a child class provides a specific implementation of a method that is already defined in its parent class. This allows the child class to customize or extend the behavior of the parent class.\n",
    "\n",
    "   **Example**:\n",
    "   ```python\n",
    "   class Animal:\n",
    "       def speak(self):\n",
    "           return \"Animal speaks\"\n",
    "\n",
    "   class Cat(Animal):\n",
    "       def speak(self):  # Overriding the speak method\n",
    "           return \"Meow!\"\n",
    "\n",
    "   my_cat = Cat()\n",
    "   print(my_cat.speak())  # Output: Meow!\n",
    "   ```\n",
    "\n",
    "### **Advanced OOP Concepts**\n",
    "\n",
    "5. **Polymorphism**:\n",
    "   - **Polymorphism** allows methods to do different things based on the object that calls them. It enables a single interface to represent different underlying forms (data types). This can be achieved through method overriding or by using the same method name across different classes.\n",
    "\n",
    "   **Example**:\n",
    "   ```python\n",
    "   def animal_sound(animal):\n",
    "       print(animal.speak())\n",
    "\n",
    "   class Dog(Animal):\n",
    "       def speak(self):\n",
    "           return \"Woof!\"\n",
    "\n",
    "   class Cat(Animal):\n",
    "       def speak(self):\n",
    "           return \"Meow!\"\n",
    "\n",
    "   dog = Dog()\n",
    "   cat = Cat()\n",
    "   animal_sound(dog)  # Output: Woof!\n",
    "   animal_sound(cat)  # Output: Meow!\n",
    "   ```\n",
    "\n",
    "6. **Encapsulation**:\n",
    "   - **Encapsulation** is the practice of restricting access to certain attributes and methods to protect the integrity of the object's data. In Python, you can achieve encapsulation using private attributes (by prefixing them with double underscores) and providing public methods to access or modify them.\n",
    "\n",
    "   **Example**:\n",
    "   ```python\n",
    "   class BankAccount:\n",
    "       def __init__(self, balance):\n",
    "           self.__balance = balance  # Private attribute\n",
    "\n",
    "       def deposit(self, amount):\n",
    "           self.__balance += amount\n",
    "\n",
    "       def get_balance(self):  # Public method to access the private attribute\n",
    "           return self.__balance\n",
    "\n",
    "   account = BankAccount(1000)\n",
    "   account.deposit(500)\n",
    "   print(account.get_balance())  # Output: 1500\n",
    "   # print(account.__balance)  # Raises AttributeError\n",
    "   ```\n",
    "\n",
    "7. **Class and Static Methods**:\n",
    "   - **Class Methods**: Defined with `@classmethod`, they take `cls` as the first parameter and can access class attributes and methods.\n",
    "   - **Static Methods**: Defined with `@staticmethod`, they do not take any special first parameter and cannot access instance or class attributes.\n",
    "\n",
    "   **Example**:\n",
    "   ```python\n",
    "   class MyClass:\n",
    "       count = 0\n",
    "\n",
    "       def __init__(self):\n",
    "           MyClass.count += 1\n",
    "\n",
    "       @classmethod\n",
    "       def get_count(cls):\n",
    "           return cls.count\n",
    "\n",
    "       @staticmethod\n",
    "       def info():\n",
    "           return \"This is a static method.\"\n",
    "\n",
    "   print(MyClass.get_count())  # Output: 0\n",
    "   obj1 = MyClass()\n",
    "   print(MyClass.get_count())  # Output: 1\n",
    "   print(MyClass.info())       # Output: This is a static method.\n",
    "   ```\n",
    "\n",
    "8. **Abstract Classes and Interfaces**:\n",
    "   - **Abstract Classes** are classes that cannot be instantiated and may contain abstract methods (methods without implementation). They are designed to be subclasses for other classes. You can define an abstract class using the `abc` module.\n",
    "\n",
    "   **Example**:\n",
    "   ```python\n",
    "   from abc import ABC, abstractmethod\n",
    "\n",
    "   class Shape(ABC):\n",
    "       @abstractmethod\n",
    "       def area(self):\n",
    "           pass\n",
    "\n",
    "   class Rectangle(Shape):\n",
    "       def __init__(self, width, height):\n",
    "           self.width = width\n",
    "           self.height = height\n",
    "\n",
    "       def area(self):\n",
    "           return self.width * self.height\n",
    "\n",
    "   my_rectangle = Rectangle(5, 10)\n",
    "   print(my_rectangle.area())  # Output: 50\n",
    "   ```\n",
    "\n",
    "### **Conclusion**\n",
    "Object-Oriented Programming in Python is a powerful paradigm that promotes code organization, reusability, and maintainability. Understanding the core principles of classes, objects, inheritance, polymorphism, encapsulation, and abstraction allows developers to write more efficient and scalable code. As you gain proficiency with these concepts, you'll be better equipped to tackle complex programming challenges and create modular applications that are easier to understand and maintain."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "044c345f",
   "metadata": {},
   "source": [
    "## **List of Python Projects**\n",
    "\n",
    "1. **Simple Calculator**\n",
    "2. **Number Guessing Game**\n",
    "3. **Personal Address Book**\n",
    "4. **To-Do List Application**\n",
    "5. **Weather Application**\n",
    "6. **Library Management System**\n",
    "7. **Expense Tracker**\n",
    "8. **Quiz Application**\n",
    "9. **Flashcard App for Learning**\n",
    "10. **Web Scraper for News Articles**\n",
    "11. **Chatbot using Natural Language Processing**\n",
    "12. **Portfolio Website**\n",
    "13. **Markdown to HTML Converter**\n",
    "14. **Simple Blog Platform**\n",
    "15. **File Organizer Script**\n",
    "16. **Password Manager**\n",
    "17. **Movie Recommendation System**\n",
    "18. **Image Gallery Application**\n",
    "19. **Simple E-commerce Website**\n",
    "20. **Habit Tracker**\n",
    "21. **Pomodoro Timer**\n",
    "22. **Travel Planner**\n",
    "23. **Currency Converter**\n",
    "24. **Data Visualization Dashboard**\n",
    "25. **Sudoku Solver**\n",
    "26. **Real-time Chat Application**\n",
    "27. **Online Voting System**\n",
    "28. **Basic Game (like Tic-Tac-Toe or Snake)**\n",
    "29. **Music Player Application**\n",
    "30. **Digital Clock with GUI**\n",
    "31. **Fitness Tracker**\n",
    "32. **Personal Finance Management Tool**\n",
    "33. **Event Reminder Application**\n",
    "34. **Recipe App**\n",
    "35. **News Aggregator**\n",
    "36. **Web-based Note-taking App**\n",
    "37. **Budget Calculator**\n",
    "38. **Email Automation Script**\n",
    "39. **File Compression Tool**\n",
    "40. **Website Status Checker**\n",
    "\n",
    "---\n",
    "\n",
    "This list provides a diverse range of projects that cater to various interests and skill levels in Python programming. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f80348be",
   "metadata": {},
   "source": [
    "## Thank You Note\n",
    "<i>\n",
    "Thank you for taking the time to explore this document. Your interest in Python programming and its applications is greatly appreciated. I hope this resource serves as a valuable guide on your journey to mastering Python. Should you have any questions or require further assistance, please feel free to reach out. Happy coding!</i>\n",
    "\n",
    "**— <i>Unique Shrestha</i>**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73d8b600",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}