List in Python for Beginners.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "67dc2fa9",
   "metadata": {
    "papermill": {
     "duration": 0.020818,
     "end_time": "2023-10-22T03:21:01.696149",
     "exception": false,
     "start_time": "2023-10-22T03:21:01.675331",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **List in Python**\n",
    "\n",
    "In Python, a list is a fundamental and versatile data structure that allows you to store and manipulate collections of items. Lists are ordered, mutable (meaning you can change their contents), and can contain elements of different data types, including numbers, strings, or even other lists. Lists are defined using square brackets [] and can hold zero or more items.\n",
    "\n",
    "You should use lists when you need to work with a group of related items or data that you want to keep together. Lists are commonly used for tasks such as storing a list of numbers, managing a collection of user names, or organizing data in a tabular format. Lists provide flexibility and ease of use, making them a go-to choice for organizing and processing data in Python programs.\n",
    "\n",
    "To use lists effectively, you can create them by specifying the elements enclosed in square brackets, access elements by their index (starting from 0), modify elements using assignment, and take advantage of built-in list methods for operations like adding, removing, and sorting elements. Lists are versatile and find applications in various programming scenarios, from simple data storage to complex data processing tasks. Understanding how to work with lists is essential for any Python programmer."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf7223e9",
   "metadata": {
    "papermill": {
     "duration": 0.020319,
     "end_time": "2023-10-22T03:21:01.737868",
     "exception": false,
     "start_time": "2023-10-22T03:21:01.717549",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Basics of List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b97f92a2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:01.780104Z",
     "iopub.status.busy": "2023-10-22T03:21:01.779714Z",
     "iopub.status.idle": "2023-10-22T03:21:01.794184Z",
     "shell.execute_reply": "2023-10-22T03:21:01.793021Z"
    },
    "papermill": {
     "duration": 0.038602,
     "end_time": "2023-10-22T03:21:01.796678",
     "exception": false,
     "start_time": "2023-10-22T03:21:01.758076",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type([]) # Using the type() function to determine the data type of an object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab19f213",
   "metadata": {
    "papermill": {
     "duration": 0.020074,
     "end_time": "2023-10-22T03:21:01.837295",
     "exception": false,
     "start_time": "2023-10-22T03:21:01.817221",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Empty List** is a list which does not have any elements means it uis empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c01382cd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:01.882090Z",
     "iopub.status.busy": "2023-10-22T03:21:01.881723Z",
     "iopub.status.idle": "2023-10-22T03:21:01.888607Z",
     "shell.execute_reply": "2023-10-22T03:21:01.887022Z"
    },
    "papermill": {
     "duration": 0.034508,
     "end_time": "2023-10-22T03:21:01.892216",
     "exception": false,
     "start_time": "2023-10-22T03:21:01.857708",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "empty_list = []\n",
    "\n",
    "# Printing the type of the list\n",
    "# The type() function returns the class type of the argument(object) passed as parameter.\n",
    "# Since we passed a list, it will return <class 'list'>.\n",
    "\n",
    "print(type(empty_list)) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2366bf47",
   "metadata": {
    "papermill": {
     "duration": 0.020248,
     "end_time": "2023-10-22T03:21:01.933513",
     "exception": false,
     "start_time": "2023-10-22T03:21:01.913265",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**List Constructor** : The list() constructor creates a new list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "67471753",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:01.976628Z",
     "iopub.status.busy": "2023-10-22T03:21:01.976226Z",
     "iopub.status.idle": "2023-10-22T03:21:01.981824Z",
     "shell.execute_reply": "2023-10-22T03:21:01.980708Z"
    },
    "papermill": {
     "duration": 0.030202,
     "end_time": "2023-10-22T03:21:01.984158",
     "exception": false,
     "start_time": "2023-10-22T03:21:01.953956",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "lst = list()  # An empty list is created and assigned to the variable 'lst'\n",
    "\n",
    "# Printing the newly created list to verify its content and type\n",
    "print(lst)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0b5bad19",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:02.028735Z",
     "iopub.status.busy": "2023-10-22T03:21:02.028375Z",
     "iopub.status.idle": "2023-10-22T03:21:02.035083Z",
     "shell.execute_reply": "2023-10-22T03:21:02.034071Z"
    },
    "papermill": {
     "duration": 0.032014,
     "end_time": "2023-10-22T03:21:02.037628",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.005614",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2299df06",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:02.081960Z",
     "iopub.status.busy": "2023-10-22T03:21:02.081578Z",
     "iopub.status.idle": "2023-10-22T03:21:02.086893Z",
     "shell.execute_reply": "2023-10-22T03:21:02.085732Z"
    },
    "papermill": {
     "duration": 0.030246,
     "end_time": "2023-10-22T03:21:02.089321",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.059075",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Creating a list of numbers\n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Accessing elements by index (zero-based)\n",
    "first_element = my_list[0]  # Accessing the first element\n",
    "second_element = my_list[1]  # Accessing the second element"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a12d637c",
   "metadata": {
    "papermill": {
     "duration": 0.020704,
     "end_time": "2023-10-22T03:21:02.130978",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.110274",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Modifying Elements in List**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "df42d091",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:02.174372Z",
     "iopub.status.busy": "2023-10-22T03:21:02.173936Z",
     "iopub.status.idle": "2023-10-22T03:21:02.181393Z",
     "shell.execute_reply": "2023-10-22T03:21:02.180323Z"
    },
    "papermill": {
     "duration": 0.031863,
     "end_time": "2023-10-22T03:21:02.183686",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.151823",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 6, 4, 5]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Modifying elements in the list\n",
    "my_list[2] = 6  # Changing the third element to 6\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "514f8218",
   "metadata": {
    "papermill": {
     "duration": 0.020426,
     "end_time": "2023-10-22T03:21:02.282018",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.261592",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Length of List**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2c344552",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:02.325526Z",
     "iopub.status.busy": "2023-10-22T03:21:02.325128Z",
     "iopub.status.idle": "2023-10-22T03:21:02.330984Z",
     "shell.execute_reply": "2023-10-22T03:21:02.329843Z"
    },
    "papermill": {
     "duration": 0.030515,
     "end_time": "2023-10-22T03:21:02.333304",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.302789",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The length of My List is: 5, means it has 5 elements in it.\n"
     ]
    }
   ],
   "source": [
    "# Finding the length of the list\n",
    "length = len(my_list)  # Getting the number of elements in the list\n",
    "\n",
    "print(f\"The length of My List is: {length}, means it has {length} elements in it.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f69ed52d",
   "metadata": {
    "papermill": {
     "duration": 0.02094,
     "end_time": "2023-10-22T03:21:02.375368",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.354428",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Iteration of List**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e1dedcd8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:02.419890Z",
     "iopub.status.busy": "2023-10-22T03:21:02.419520Z",
     "iopub.status.idle": "2023-10-22T03:21:02.424905Z",
     "shell.execute_reply": "2023-10-22T03:21:02.423685Z"
    },
    "papermill": {
     "duration": 0.030681,
     "end_time": "2023-10-22T03:21:02.427515",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.396834",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "6\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# Iterating through the elements of the list\n",
    "for item in my_list:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a45082eb",
   "metadata": {
    "papermill": {
     "duration": 0.020981,
     "end_time": "2023-10-22T03:21:02.469833",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.448852",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Creating a list with city names**\n",
    "- A new list named 'lst' is created with strings as its elements. \n",
    "- Each string represents a city name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "16248ba2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:02.515416Z",
     "iopub.status.busy": "2023-10-22T03:21:02.514955Z",
     "iopub.status.idle": "2023-10-22T03:21:02.521184Z",
     "shell.execute_reply": "2023-10-22T03:21:02.519933Z"
    },
    "papermill": {
     "duration": 0.03348,
     "end_time": "2023-10-22T03:21:02.524700",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.491220",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Suwon', 'Dague', 'Daejeon']\n"
     ]
    }
   ],
   "source": [
    "lst = ['Suwon', 'Dague', 'Daejeon']  # The list contains three city names.\n",
    "\n",
    "# Printing the list to verify its content.\n",
    "print(lst) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "288d66e4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:02.576798Z",
     "iopub.status.busy": "2023-10-22T03:21:02.576333Z",
     "iopub.status.idle": "2023-10-22T03:21:02.583062Z",
     "shell.execute_reply": "2023-10-22T03:21:02.581776Z"
    },
    "papermill": {
     "duration": 0.035069,
     "end_time": "2023-10-22T03:21:02.586000",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.550931",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# The len() function returns the number of items in an object.\n",
    "# When used with a list, it returns the number of elements in the list.\n",
    "length_of_lst = len(lst)\n",
    "print(length_of_lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6558602f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:02.635390Z",
     "iopub.status.busy": "2023-10-22T03:21:02.634815Z",
     "iopub.status.idle": "2023-10-22T03:21:02.643941Z",
     "shell.execute_reply": "2023-10-22T03:21:02.642704Z"
    },
    "papermill": {
     "duration": 0.037497,
     "end_time": "2023-10-22T03:21:02.646713",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.609216",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fec6e263",
   "metadata": {
    "papermill": {
     "duration": 0.02251,
     "end_time": "2023-10-22T03:21:02.691373",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.668863",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Adding multiple elements to a list using '+' operator**\n",
    "* Each step of the operation is thoroughly explained.\n",
    "* The role of the '+' operator in concatenating lists is clarified, helping to understand how multiple elements are added to the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0a2b97a9",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:02.736023Z",
     "iopub.status.busy": "2023-10-22T03:21:02.735658Z",
     "iopub.status.idle": "2023-10-22T03:21:02.741763Z",
     "shell.execute_reply": "2023-10-22T03:21:02.740657Z"
    },
    "papermill": {
     "duration": 0.03132,
     "end_time": "2023-10-22T03:21:02.744130",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.712810",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "# Creating an initial list named 'my_list' containing three integer elements\n",
    "my_list = [1, 2, 3]\n",
    "\n",
    "# Adding multiple elements (4, 5, 6) to 'my_list' using the '+' operator\n",
    "# The '+' operator concatenates the lists, creating a new list\n",
    "my_list = my_list + [4, 5, 6]\n",
    "\n",
    "# Printing the updated list to verify that the new elements have been added successfully\n",
    "print(my_list)   # Output: [1, 2, 3, 4, 5, 6]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46b039f0",
   "metadata": {
    "papermill": {
     "duration": 0.021979,
     "end_time": "2023-10-22T03:21:02.788072",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.766093",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Adding Multiple Element using extend() method**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "492030bb",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:02.833689Z",
     "iopub.status.busy": "2023-10-22T03:21:02.833311Z",
     "iopub.status.idle": "2023-10-22T03:21:02.839579Z",
     "shell.execute_reply": "2023-10-22T03:21:02.838458Z"
    },
    "papermill": {
     "duration": 0.032271,
     "end_time": "2023-10-22T03:21:02.842034",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.809763",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# Creating an initial list named 'my_list' containing three integer elements\n",
    "my_list = [1, 2, 3]\n",
    "\n",
    "# Using the extend() method to add multiple elements (4, 5, 6, 7, 8, 9) to 'my_list'\n",
    "# The extend() method modifies the list in-place by appending elements from an iterable\n",
    "my_list.extend([4, 5, 6, 7, 8, 9])\n",
    "\n",
    "# Printing the updated list to verify that the new elements have been added successfully\n",
    "print(my_list)   "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18285259",
   "metadata": {
    "papermill": {
     "duration": 0.022434,
     "end_time": "2023-10-22T03:21:02.886300",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.863866",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Indexing in List**\n",
    "Indexing in a list refers to the process of accessing individual elements or items within the list by their position or index. In Python, list indexing is zero-based, which means the first element has an index of 0, the second element has an index of 1, and so on.\n",
    "\n",
    "Here are some examples of how list indexing works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f9b4f5aa",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:02.932174Z",
     "iopub.status.busy": "2023-10-22T03:21:02.931805Z",
     "iopub.status.idle": "2023-10-22T03:21:02.938810Z",
     "shell.execute_reply": "2023-10-22T03:21:02.937626Z"
    },
    "papermill": {
     "duration": 0.033819,
     "end_time": "2023-10-22T03:21:02.941688",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.907869",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First fruit: Apple\n",
      "Second fruit: Banana\n",
      "Third fruit: Cherry\n",
      "Fourth fruit: Elderberry\n",
      "Final Sliced List: ['Banana', 'Cherry', 'Date']\n"
     ]
    }
   ],
   "source": [
    "# Creating a list\n",
    "my_list = [\"Apple\", \"Banana\", \"Cherry\", \"Date\", \"Elderberry\"]\n",
    "\n",
    "# Accessing individual elements by index\n",
    "first_fruit = my_list[0]       # \"apple\"\n",
    "second_fruit = my_list[1]      # \"banana\"\n",
    "third_fruit = my_list[2]       # \"cherry\"\n",
    "last_fruit = my_list[-1]       # \"elderberry\" (negative index counts from the end)\n",
    "\n",
    "# Slicing to access a range of elements\n",
    "sliced_list = my_list[1:4]    \n",
    "\n",
    "print(f\"First fruit: {first_fruit}\")\n",
    "print(f\"Second fruit: {second_fruit}\")\n",
    "print(f\"Third fruit: {third_fruit}\")\n",
    "print(f\"Fourth fruit: {last_fruit}\")\n",
    "print(f\"Final Sliced List: {sliced_list}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80ed617c",
   "metadata": {
    "papermill": {
     "duration": 0.021735,
     "end_time": "2023-10-22T03:21:02.985594",
     "exception": false,
     "start_time": "2023-10-22T03:21:02.963859",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Common List Methods**\n",
    "\n",
    "### Insert\n",
    "The insert() method in Python is used to insert an element at a specified index in a list. It allows you to add an item to a specific position within the list, shifting the existing elements to make room for the new element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "291858ec",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:03.031407Z",
     "iopub.status.busy": "2023-10-22T03:21:03.030967Z",
     "iopub.status.idle": "2023-10-22T03:21:03.037671Z",
     "shell.execute_reply": "2023-10-22T03:21:03.036654Z"
    },
    "papermill": {
     "duration": 0.033048,
     "end_time": "2023-10-22T03:21:03.040866",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.007818",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial list: ['apple', 'banana', 'cherry']\n",
      "List after insertion: ['apple', 'date', 'banana', 'cherry']\n"
     ]
    }
   ],
   "source": [
    "# Creating a list of fruits\n",
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "\n",
    "# Printing the initial list\n",
    "print(\"Initial list:\", fruits)  # Output: ['apple', 'banana', 'cherry']\n",
    "\n",
    "# Using insert() to add \"date\" at index 1 (second position)\n",
    "fruits.insert(1, \"date\")\n",
    "\n",
    "# Printing the updated list to verify the insertion\n",
    "print(\"List after insertion:\", fruits)  # Output: ['apple', 'date', 'banana', 'cherry']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d1b4ec9",
   "metadata": {
    "papermill": {
     "duration": 0.022382,
     "end_time": "2023-10-22T03:21:03.086860",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.064478",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### Extend Method\n",
    "The extend() method in Python is used to append elements from an iterable (e.g., a list, tuple, or another iterable) to the end of an existing list. It allows you to add multiple elements to a list in a single operation, effectively extending the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "01c4e8ff",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:03.134067Z",
     "iopub.status.busy": "2023-10-22T03:21:03.133065Z",
     "iopub.status.idle": "2023-10-22T03:21:03.140356Z",
     "shell.execute_reply": "2023-10-22T03:21:03.139281Z"
    },
    "papermill": {
     "duration": 0.033672,
     "end_time": "2023-10-22T03:21:03.143366",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.109694",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial list: ['apple', 'banana', 'cherry']\n",
      "List after extension: ['apple', 'banana', 'cherry', 'date', 'elderberry']\n"
     ]
    }
   ],
   "source": [
    "# Creating an initial list of fruits\n",
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "\n",
    "# Printing the initial list\n",
    "print(\"Initial list:\", fruits)  # Output: ['apple', 'banana', 'cherry']\n",
    "\n",
    "# Creating another list with additional fruits\n",
    "additional_fruits = [\"date\", \"elderberry\"]\n",
    "\n",
    "# Using extend() to add elements from 'additional_fruits' to 'fruits'\n",
    "fruits.extend(additional_fruits)\n",
    "\n",
    "# Printing the updated list to verify the extension\n",
    "print(\"List after extension:\", fruits)  # Output: ['apple', 'banana', 'cherry', 'date', 'elderberry']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40debfc0",
   "metadata": {
    "papermill": {
     "duration": 0.02148,
     "end_time": "2023-10-22T03:21:03.187225",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.165745",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### Append\n",
    "The append() method in Python is used to add a single element to the end of a list. It's a commonly used method when you want to add elements one at a time to the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "7bbe8d05",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:03.232742Z",
     "iopub.status.busy": "2023-10-22T03:21:03.232358Z",
     "iopub.status.idle": "2023-10-22T03:21:03.238792Z",
     "shell.execute_reply": "2023-10-22T03:21:03.237588Z"
    },
    "papermill": {
     "duration": 0.032639,
     "end_time": "2023-10-22T03:21:03.241934",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.209295",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial list: ['apple', 'banana', 'cherry']\n",
      "List after appending: ['apple', 'banana', 'cherry', 'date']\n"
     ]
    }
   ],
   "source": [
    "# Creating an initial list of fruits\n",
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "\n",
    "# Printing the initial list\n",
    "print(\"Initial list:\", fruits)  # Output: ['apple', 'banana', 'cherry']\n",
    "\n",
    "# Using append() to add a new fruit \"date\" to the end of the list\n",
    "fruits.append(\"date\")\n",
    "\n",
    "# Printing the updated list to verify the addition\n",
    "print(\"List after appending:\", fruits)  # Output: ['apple', 'banana', 'cherry', 'date']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b102c249",
   "metadata": {
    "papermill": {
     "duration": 0.021667,
     "end_time": "2023-10-22T03:21:03.286791",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.265124",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### Remove\n",
    "The remove() method in Python is used to remove the first occurrence of a specified element from a list. It allows you to target and eliminate a specific value within the list, and it modifies the list in-place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f3401f8c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:03.332364Z",
     "iopub.status.busy": "2023-10-22T03:21:03.331964Z",
     "iopub.status.idle": "2023-10-22T03:21:03.338138Z",
     "shell.execute_reply": "2023-10-22T03:21:03.337095Z"
    },
    "papermill": {
     "duration": 0.032734,
     "end_time": "2023-10-22T03:21:03.341489",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.308755",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial list: ['apple', 'banana', 'cherry', 'date', 'cherry']\n",
      "List after removal: ['apple', 'banana', 'date', 'cherry']\n"
     ]
    }
   ],
   "source": [
    "# Creating a list of fruits\n",
    "fruits = [\"apple\", \"banana\", \"cherry\", \"date\", \"cherry\"]\n",
    "\n",
    "# Printing the initial list\n",
    "print(\"Initial list:\", fruits)  # Output: ['apple', 'banana', 'cherry', 'date', 'cherry']\n",
    "\n",
    "# Using remove() to eliminate the first occurrence of \"cherry\"\n",
    "fruits.remove(\"cherry\")\n",
    "\n",
    "# Printing the updated list to verify the removal\n",
    "print(\"List after removal:\", fruits)  # Output: ['apple', 'banana', 'date', 'cherry']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09265968",
   "metadata": {
    "papermill": {
     "duration": 0.021731,
     "end_time": "2023-10-22T03:21:03.386592",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.364861",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### Pop\n",
    "The pop() method in Python is used to remove and return the element at a specified index from a list. It allows you to target and extract an element from the list based on its position, and it modifies the list in-place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "245b9f11",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:03.432098Z",
     "iopub.status.busy": "2023-10-22T03:21:03.431732Z",
     "iopub.status.idle": "2023-10-22T03:21:03.438124Z",
     "shell.execute_reply": "2023-10-22T03:21:03.437035Z"
    },
    "papermill": {
     "duration": 0.032463,
     "end_time": "2023-10-22T03:21:03.440986",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.408523",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial list: ['apple', 'banana', 'cherry', 'date']\n",
      "List after popping: ['apple', 'cherry', 'date']\n",
      "Removed fruit: banana\n"
     ]
    }
   ],
   "source": [
    "# Creating a list of fruits\n",
    "fruits = [\"apple\", \"banana\", \"cherry\", \"date\"]\n",
    "\n",
    "# Printing the initial list\n",
    "print(\"Initial list:\", fruits)  # Output: ['apple', 'banana', 'cherry', 'date']\n",
    "\n",
    "# Using pop() to remove and return the element at index 1 (second element)\n",
    "removed_fruit = fruits.pop(1)\n",
    "\n",
    "# Printing the updated list and the removed element\n",
    "print(\"List after popping:\", fruits)  # Output: ['apple', 'cherry', 'date']\n",
    "print(\"Removed fruit:\", removed_fruit)  # Output: 'banana'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6b8525a",
   "metadata": {
    "papermill": {
     "duration": 0.021815,
     "end_time": "2023-10-22T03:21:03.484754",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.462939",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### Sorting\n",
    "The sort() method in Python is used to sort the elements of a list in ascending order by default. It modifies the list in-place, meaning it doesn't return a new sorted list but instead rearranges the elements of the original list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "4c7390ac",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:03.530449Z",
     "iopub.status.busy": "2023-10-22T03:21:03.530045Z",
     "iopub.status.idle": "2023-10-22T03:21:03.536269Z",
     "shell.execute_reply": "2023-10-22T03:21:03.535199Z"
    },
    "papermill": {
     "duration": 0.031995,
     "end_time": "2023-10-22T03:21:03.538779",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.506784",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial list: [4, 2, 7, 1, 9, 3]\n",
      "List after sorting: [1, 2, 3, 4, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "# Creating an initial list of numbers\n",
    "numbers = [4, 2, 7, 1, 9, 3]\n",
    "\n",
    "# Printing the initial list\n",
    "print(\"Initial list:\", numbers)  # Output: [4, 2, 7, 1, 9, 3]\n",
    "\n",
    "# Using sort() to sort the elements in ascending order\n",
    "numbers.sort()\n",
    "\n",
    "# Printing the updated list after sorting\n",
    "print(\"List after sorting:\", numbers)  # Output: [1, 2, 3, 4, 7, 9]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ea5c7f5",
   "metadata": {
    "papermill": {
     "duration": 0.021925,
     "end_time": "2023-10-22T03:21:03.583410",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.561485",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### Reverse\n",
    "The reverse() method in Python is used to reverse the order of elements in a list. It modifies the list in-place, meaning it doesn't return a new reversed list but instead reverses the elements within the original list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "48ee83bb",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:03.629464Z",
     "iopub.status.busy": "2023-10-22T03:21:03.629035Z",
     "iopub.status.idle": "2023-10-22T03:21:03.634815Z",
     "shell.execute_reply": "2023-10-22T03:21:03.633756Z"
    },
    "papermill": {
     "duration": 0.032015,
     "end_time": "2023-10-22T03:21:03.637616",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.605601",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial list: [1, 2, 3, 4, 7, 9]\n",
      "List after reversing: [9, 7, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "# Printing the initial list\n",
    "print(\"Initial list:\", numbers)  # Output: [1, 2, 3, 4, 5]\n",
    "\n",
    "# Using reverse() to reverse the order of elements\n",
    "numbers.reverse()\n",
    "\n",
    "# Printing the updated list after reversing\n",
    "print(\"List after reversing:\", numbers)  # Output: [5, 4, 3, 2, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10b2c9fe",
   "metadata": {
    "papermill": {
     "duration": 0.022034,
     "end_time": "2023-10-22T03:21:03.681973",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.659939",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### Count\n",
    "The count() method in Python is used to count the number of occurrences of a specific element or value in a list. It allows you to find out how many times a particular element appears within the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "e33bf1c1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:03.728014Z",
     "iopub.status.busy": "2023-10-22T03:21:03.727661Z",
     "iopub.status.idle": "2023-10-22T03:21:03.733423Z",
     "shell.execute_reply": "2023-10-22T03:21:03.732675Z"
    },
    "papermill": {
     "duration": 0.032524,
     "end_time": "2023-10-22T03:21:03.736594",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.704070",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial list: ['red', 'blue', 'green', 'blue', 'yellow', 'blue']\n",
      "Count of 'blue': 3\n"
     ]
    }
   ],
   "source": [
    "# Creating a list of colors\n",
    "colors = [\"red\", \"blue\", \"green\", \"blue\", \"yellow\", \"blue\"]\n",
    "\n",
    "# Printing the initial list\n",
    "print(\"Initial list:\", colors)  # Output: ['red', 'blue', 'green', 'blue', 'yellow', 'blue']\n",
    "\n",
    "# Using count() to count the occurrences of \"blue\" in the list\n",
    "blue_count = colors.count(\"blue\")\n",
    "\n",
    "# Printing the count of \"blue\"\n",
    "print(\"Count of 'blue':\", blue_count)  # Output: Count of 'blue': 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57b5316f",
   "metadata": {
    "papermill": {
     "duration": 0.022233,
     "end_time": "2023-10-22T03:21:03.783067",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.760834",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### Max & Min\n",
    "The max() and min() functions in Python are used to find the maximum and minimum values, respectively, within a sequence, including lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "bb92a2c3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:03.830029Z",
     "iopub.status.busy": "2023-10-22T03:21:03.829637Z",
     "iopub.status.idle": "2023-10-22T03:21:03.836699Z",
     "shell.execute_reply": "2023-10-22T03:21:03.835590Z"
    },
    "papermill": {
     "duration": 0.034726,
     "end_time": "2023-10-22T03:21:03.840329",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.805603",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial list: [4, 2, 7, 1, 9, 3]\n",
      "Maximum value: 9\n",
      "Minimum value: 1\n"
     ]
    }
   ],
   "source": [
    "# Creating a list of numbers\n",
    "numbers = [4, 2, 7, 1, 9, 3]\n",
    "\n",
    "# Printing the initial list\n",
    "print(\"Initial list:\", numbers)  # Output: [4, 2, 7, 1, 9, 3]\n",
    "\n",
    "# Using max() to find the maximum value in the list\n",
    "maximum_value = max(numbers)\n",
    "\n",
    "# Using min() to find the minimum value in the list\n",
    "minimum_value = min(numbers)\n",
    "\n",
    "# Printing the maximum and minimum values\n",
    "print(\"Maximum value:\", maximum_value)  # Output: Maximum value: 9\n",
    "print(\"Minimum value:\", minimum_value)  # Output: Minimum value: 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45898eea",
   "metadata": {
    "papermill": {
     "duration": 0.023085,
     "end_time": "2023-10-22T03:21:03.887682",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.864597",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Multiplying a List**\n",
    "Multiplying a list in Python means creating a new list by repeating the elements of the original list a specified number of times. You can achieve this by using the multiplication operator (*) with a list and an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "93df700d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:03.936679Z",
     "iopub.status.busy": "2023-10-22T03:21:03.936293Z",
     "iopub.status.idle": "2023-10-22T03:21:03.942766Z",
     "shell.execute_reply": "2023-10-22T03:21:03.941598Z"
    },
    "papermill": {
     "duration": 0.033773,
     "end_time": "2023-10-22T03:21:03.945185",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.911412",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial list: [1, 2, 3]\n",
      "Multiplied list: [1, 2, 3, 1, 2, 3, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "# Creating an initial list of elements\n",
    "original_list = [1, 2, 3]\n",
    "\n",
    "# Printing the initial list\n",
    "print(\"Initial list:\", original_list)  # Output: Initial list: [1, 2, 3]\n",
    "\n",
    "# Multiplying the list to create a new list with repeated elements\n",
    "multiplied_list = original_list * 3  # This repeats the elements 3 times\n",
    "\n",
    "# Printing the multiplied list\n",
    "print(\"Multiplied list:\", multiplied_list)  # Output: Multiplied list: [1, 2, 3, 1, 2, 3, 1, 2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4f96236",
   "metadata": {
    "papermill": {
     "duration": 0.022212,
     "end_time": "2023-10-22T03:21:03.990212",
     "exception": false,
     "start_time": "2023-10-22T03:21:03.968000",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Nested List**\n",
    "A nested list in Python is a list that contains other lists as its elements. In other words, it's a list of lists. This allows you to create a multi-dimensional data structure where each element can be a list itself. You can have lists within lists to represent more complex data structures like matrices, tables, or hierarchical data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "49b8aef7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:04.036953Z",
     "iopub.status.busy": "2023-10-22T03:21:04.036565Z",
     "iopub.status.idle": "2023-10-22T03:21:04.043315Z",
     "shell.execute_reply": "2023-10-22T03:21:04.042228Z"
    },
    "papermill": {
     "duration": 0.032835,
     "end_time": "2023-10-22T03:21:04.045661",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.012826",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nested list (matrix): [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "Accessed element: 6\n"
     ]
    }
   ],
   "source": [
    "# A nested list representing a matrix\n",
    "matrix = [\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 8, 9]\n",
    "]\n",
    "\n",
    "# Printing the nested list\n",
    "print(\"Nested list (matrix):\", matrix)\n",
    "\n",
    "# Accessing an element within the nested list\n",
    "element = matrix[1][2]  # Accessing the element in the second row and third column\n",
    "\n",
    "# Printing the accessed element\n",
    "print(\"Accessed element:\", element)  # Output: Accessed element: 6"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e50491f",
   "metadata": {
    "papermill": {
     "duration": 0.022537,
     "end_time": "2023-10-22T03:21:04.091166",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.068629",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### **More examples of Nested List**\n",
    "**Example 1: A List of Lists of Names and Ages**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "34e1b346",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:04.139821Z",
     "iopub.status.busy": "2023-10-22T03:21:04.139451Z",
     "iopub.status.idle": "2023-10-22T03:21:04.146902Z",
     "shell.execute_reply": "2023-10-22T03:21:04.145793Z"
    },
    "papermill": {
     "duration": 0.034395,
     "end_time": "2023-10-22T03:21:04.149670",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.115275",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "People Info: [['Alice', 28], ['Bob', 32], ['Charlie', 45], ['David', 22]]\n",
      "Name: Alice\n",
      "Age: 32\n"
     ]
    }
   ],
   "source": [
    "# Creating a nested list of names and ages\n",
    "people_info = [\n",
    "    [\"Alice\", 28],\n",
    "    [\"Bob\", 32],\n",
    "    [\"Charlie\", 45],\n",
    "    [\"David\", 22]\n",
    "]\n",
    "\n",
    "# Printing the nested list\n",
    "print(\"People Info:\", people_info)\n",
    "\n",
    "# Accessing elements within the nested list\n",
    "name = people_info[0][0]  # Accessing the first person's name\n",
    "age = people_info[1][1]   # Accessing the second person's age\n",
    "\n",
    "# Printing the accessed elements\n",
    "print(\"Name:\", name)  # Output: Name: Alice\n",
    "print(\"Age:\", age)    # Output: Age: 32"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cbffc9a",
   "metadata": {
    "papermill": {
     "duration": 0.023292,
     "end_time": "2023-10-22T03:21:04.196181",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.172889",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 2: A List of Lists for a To-Do List**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "9d37db46",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:04.244602Z",
     "iopub.status.busy": "2023-10-22T03:21:04.244150Z",
     "iopub.status.idle": "2023-10-22T03:21:04.251461Z",
     "shell.execute_reply": "2023-10-22T03:21:04.250288Z"
    },
    "papermill": {
     "duration": 0.034753,
     "end_time": "2023-10-22T03:21:04.254302",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.219549",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To-Do List: [['Buy groceries', '2023-10-25'], ['Finish project', '2023-10-30'], ['Call dentist', '2023-11-05']]\n",
      "Task: Buy groceries\n",
      "Due Date: 2023-10-30\n"
     ]
    }
   ],
   "source": [
    "# Creating a nested list for a to-do list\n",
    "todo_list = [\n",
    "    [\"Buy groceries\", \"2023-10-25\"],\n",
    "    [\"Finish project\", \"2023-10-30\"],\n",
    "    [\"Call dentist\", \"2023-11-05\"]\n",
    "]\n",
    "\n",
    "# Printing the nested list\n",
    "print(\"To-Do List:\", todo_list)\n",
    "\n",
    "# Accessing elements within the nested list\n",
    "task = todo_list[0][0]    # Accessing the first task\n",
    "due_date = todo_list[1][1]  # Accessing the due date of the second task\n",
    "\n",
    "# Printing the accessed elements\n",
    "print(\"Task:\", task)       # Output: Task: Buy groceries\n",
    "print(\"Due Date:\", due_date)  # Output: Due Date: 2023-10-30"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "676827df",
   "metadata": {
    "papermill": {
     "duration": 0.023019,
     "end_time": "2023-10-22T03:21:04.300693",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.277674",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Example 3: A List of Lists Representing a 2D Grid**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b5c1f651",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:04.348685Z",
     "iopub.status.busy": "2023-10-22T03:21:04.348298Z",
     "iopub.status.idle": "2023-10-22T03:21:04.354906Z",
     "shell.execute_reply": "2023-10-22T03:21:04.353648Z"
    },
    "papermill": {
     "duration": 0.034298,
     "end_time": "2023-10-22T03:21:04.358074",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.323776",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grid: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "Value: 6\n"
     ]
    }
   ],
   "source": [
    "# Creating a nested list representing a 2D grid\n",
    "grid = [\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 8, 9]\n",
    "]\n",
    "\n",
    "# Printing the nested list\n",
    "print(\"Grid:\", grid)\n",
    "\n",
    "# Accessing elements within the nested list\n",
    "value = grid[1][2]  # Accessing an element in the second row and third column\n",
    "\n",
    "# Printing the accessed element\n",
    "print(\"Value:\", value)  # Output: Value: 6"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "584488cd",
   "metadata": {
    "papermill": {
     "duration": 0.023635,
     "end_time": "2023-10-22T03:21:04.406206",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.382571",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **List Sclicing**\n",
    "List slicing in Python is a technique that allows you to extract a portion or subsequence of a list by specifying a start index, an end index, and an optional step (stride). Slicing provides a convenient way to work with specific sections of a list. Here's a breakdown of list slicing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "e852275c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:04.454191Z",
     "iopub.status.busy": "2023-10-22T03:21:04.453846Z",
     "iopub.status.idle": "2023-10-22T03:21:04.458014Z",
     "shell.execute_reply": "2023-10-22T03:21:04.457399Z"
    },
    "papermill": {
     "duration": 0.030525,
     "end_time": "2023-10-22T03:21:04.460078",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.429553",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Creating a sample list\n",
    "my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "6bdf76cd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:04.508036Z",
     "iopub.status.busy": "2023-10-22T03:21:04.507614Z",
     "iopub.status.idle": "2023-10-22T03:21:04.512062Z",
     "shell.execute_reply": "2023-10-22T03:21:04.511439Z"
    },
    "papermill": {
     "duration": 0.032001,
     "end_time": "2023-10-22T03:21:04.515149",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.483148",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# Basic slicing: extracting a portion of the list\n",
    "subset = my_list[2:6]  # Elements at index 2, 3, 4, and 5 (end index is exclusive)\n",
    "print(subset)  # Output: [2, 3, 4, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "7bad7717",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:04.564895Z",
     "iopub.status.busy": "2023-10-22T03:21:04.564531Z",
     "iopub.status.idle": "2023-10-22T03:21:04.569957Z",
     "shell.execute_reply": "2023-10-22T03:21:04.568732Z"
    },
    "papermill": {
     "duration": 0.033816,
     "end_time": "2023-10-22T03:21:04.572665",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.538849",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "# Slicing with a step (stride)\n",
    "every_second_element = my_list[1:9:2]  # Elements at odd indices (1, 3, 5, 7)\n",
    "print(every_second_element)  # Output: [1, 3, 5, 7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "004097b7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:04.620846Z",
     "iopub.status.busy": "2023-10-22T03:21:04.620483Z",
     "iopub.status.idle": "2023-10-22T03:21:04.626152Z",
     "shell.execute_reply": "2023-10-22T03:21:04.624887Z"
    },
    "papermill": {
     "duration": 0.033186,
     "end_time": "2023-10-22T03:21:04.629124",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.595938",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# Omitting the start and end indices\n",
    "start_to_end = my_list[:]  # Copy of the entire list\n",
    "print(start_to_end)  # Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "8952d610",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:04.678912Z",
     "iopub.status.busy": "2023-10-22T03:21:04.678112Z",
     "iopub.status.idle": "2023-10-22T03:21:04.683892Z",
     "shell.execute_reply": "2023-10-22T03:21:04.682979Z"
    },
    "papermill": {
     "duration": 0.033422,
     "end_time": "2023-10-22T03:21:04.687047",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.653625",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# Slicing from the beginning to a specified index\n",
    "first_half = my_list[:5]  # Elements at indices 0, 1, 2, 3, and 4\n",
    "print(first_half)  # Output: [0, 1, 2, 3, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "6259d638",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:04.738539Z",
     "iopub.status.busy": "2023-10-22T03:21:04.737206Z",
     "iopub.status.idle": "2023-10-22T03:21:04.743486Z",
     "shell.execute_reply": "2023-10-22T03:21:04.742288Z"
    },
    "papermill": {
     "duration": 0.033377,
     "end_time": "2023-10-22T03:21:04.745738",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.712361",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# Slicing from a specified index to the end\n",
    "second_half = my_list[5:]  # Elements at indices 5, 6, 7, 8, and 9\n",
    "print(second_half)  # Output: [5, 6, 7, 8, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "1cd5d427",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:04.794672Z",
     "iopub.status.busy": "2023-10-22T03:21:04.794260Z",
     "iopub.status.idle": "2023-10-22T03:21:04.800266Z",
     "shell.execute_reply": "2023-10-22T03:21:04.799057Z"
    },
    "papermill": {
     "duration": 0.033969,
     "end_time": "2023-10-22T03:21:04.803432",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.769463",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# Negative indices: counting from the end\n",
    "last_three = my_list[-3:]  # Elements at indices -3, -2, and -1\n",
    "print(last_three)  # Output: [7, 8, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "7aae3ece",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:04.854223Z",
     "iopub.status.busy": "2023-10-22T03:21:04.853825Z",
     "iopub.status.idle": "2023-10-22T03:21:04.859846Z",
     "shell.execute_reply": "2023-10-22T03:21:04.858668Z"
    },
    "papermill": {
     "duration": 0.034791,
     "end_time": "2023-10-22T03:21:04.862760",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.827969",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "# Reverse a list using slicing\n",
    "reversed_list = my_list[::-1]  # Reverse the entire list\n",
    "print(reversed_list)  # Output: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8b5d227",
   "metadata": {
    "papermill": {
     "duration": 0.025191,
     "end_time": "2023-10-22T03:21:04.911819",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.886628",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **List Operations**\n",
    "Lists in Python support various operations and methods for manipulating and working with data. Here are some commonly used list operations:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cff5a1a4",
   "metadata": {
    "papermill": {
     "duration": 0.023785,
     "end_time": "2023-10-22T03:21:04.959484",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.935699",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Concatenation (+):** You can combine two or more lists using the + operator to create a new list that contains all the elements of the original lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "b50e8756",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:05.009335Z",
     "iopub.status.busy": "2023-10-22T03:21:05.008930Z",
     "iopub.status.idle": "2023-10-22T03:21:05.014803Z",
     "shell.execute_reply": "2023-10-22T03:21:05.013747Z"
    },
    "papermill": {
     "duration": 0.034579,
     "end_time": "2023-10-22T03:21:05.017790",
     "exception": false,
     "start_time": "2023-10-22T03:21:04.983211",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "list1 = [1, 2, 3]\n",
    "list2 = [4, 5, 6]\n",
    "concatenated_list = list1 + list2\n",
    "print(concatenated_list)  # Output: [1, 2, 3, 4, 5, 6]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "792b1255",
   "metadata": {
    "papermill": {
     "duration": 0.023688,
     "end_time": "2023-10-22T03:21:05.065471",
     "exception": false,
     "start_time": "2023-10-22T03:21:05.041783",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Repetition (*):** You can create a new list by repeating the elements of an existing list using the * operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "18fa2dcd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:05.116002Z",
     "iopub.status.busy": "2023-10-22T03:21:05.115594Z",
     "iopub.status.idle": "2023-10-22T03:21:05.121315Z",
     "shell.execute_reply": "2023-10-22T03:21:05.120174Z"
    },
    "papermill": {
     "duration": 0.033428,
     "end_time": "2023-10-22T03:21:05.123915",
     "exception": false,
     "start_time": "2023-10-22T03:21:05.090487",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 1, 2, 3, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "original_list = [1, 2, 3]\n",
    "repeated_list = original_list * 3\n",
    "print(repeated_list)  # Output: [1, 2, 3, 1, 2, 3, 1, 2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24127600",
   "metadata": {
    "papermill": {
     "duration": 0.02369,
     "end_time": "2023-10-22T03:21:05.171684",
     "exception": false,
     "start_time": "2023-10-22T03:21:05.147994",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Membership (in and not in):** You can check if an element is present in a list using the in and not in operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "4af537c4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:05.220798Z",
     "iopub.status.busy": "2023-10-22T03:21:05.220440Z",
     "iopub.status.idle": "2023-10-22T03:21:05.226459Z",
     "shell.execute_reply": "2023-10-22T03:21:05.225290Z"
    },
    "papermill": {
     "duration": 0.033598,
     "end_time": "2023-10-22T03:21:05.229046",
     "exception": false,
     "start_time": "2023-10-22T03:21:05.195448",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "print(3 in my_list)    # Output: True\n",
    "print(6 not in my_list)  # Output: True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "282d17af",
   "metadata": {
    "papermill": {
     "duration": 0.023452,
     "end_time": "2023-10-22T03:21:05.276384",
     "exception": false,
     "start_time": "2023-10-22T03:21:05.252932",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Length (len()):** You can find the number of elements in a list using the len() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "e911acd5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:05.325784Z",
     "iopub.status.busy": "2023-10-22T03:21:05.325383Z",
     "iopub.status.idle": "2023-10-22T03:21:05.331635Z",
     "shell.execute_reply": "2023-10-22T03:21:05.330224Z"
    },
    "papermill": {
     "duration": 0.034121,
     "end_time": "2023-10-22T03:21:05.334186",
     "exception": false,
     "start_time": "2023-10-22T03:21:05.300065",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "length = len(my_list)\n",
    "print(length)  # Output: 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bcb8625",
   "metadata": {
    "papermill": {
     "duration": 0.024293,
     "end_time": "2023-10-22T03:21:05.382748",
     "exception": false,
     "start_time": "2023-10-22T03:21:05.358455",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**Iteration:** You can iterate through the elements of a list using loops like for and while."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "49311bb5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:05.432658Z",
     "iopub.status.busy": "2023-10-22T03:21:05.432270Z",
     "iopub.status.idle": "2023-10-22T03:21:05.438073Z",
     "shell.execute_reply": "2023-10-22T03:21:05.436909Z"
    },
    "papermill": {
     "duration": 0.034211,
     "end_time": "2023-10-22T03:21:05.441158",
     "exception": false,
     "start_time": "2023-10-22T03:21:05.406947",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "for item in my_list:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acb5db87",
   "metadata": {
    "papermill": {
     "duration": 0.023848,
     "end_time": "2023-10-22T03:21:05.490300",
     "exception": false,
     "start_time": "2023-10-22T03:21:05.466452",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**List Comprehensions:** List comprehensions provide a concise way to create new lists by applying an expression to each item in an existing list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "d37b236f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-22T03:21:05.540116Z",
     "iopub.status.busy": "2023-10-22T03:21:05.539743Z",
     "iopub.status.idle": "2023-10-22T03:21:05.546010Z",
     "shell.execute_reply": "2023-10-22T03:21:05.544934Z"
    },
    "papermill": {
     "duration": 0.033914,
     "end_time": "2023-10-22T03:21:05.548322",
     "exception": false,
     "start_time": "2023-10-22T03:21:05.514408",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "squared_list = [x ** 2 for x in my_list]\n",
    "print(squared_list)  # Output: [1, 4, 9, 16, 25]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c58b5294",
   "metadata": {
    "papermill": {
     "duration": 0.024204,
     "end_time": "2023-10-22T03:21:05.597419",
     "exception": false,
     "start_time": "2023-10-22T03:21:05.573215",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Closing Thoughts**\n",
    "In this document, we've explored various aspects of Python lists, one of the most fundamental and versatile data structures in the Python programming language. We've covered the basics of creating, manipulating, and working with lists, including operations, methods, and common use cases. Additionally, we discussed the key differences between lists and tuples, another commonly used data structure, to help you make informed choices in your Python programming.\n",
    "\n",
    "Lists provide a flexible and powerful way to store and manipulate collections of data, whether it's a list of numbers, strings, or more complex data structures like nested lists. By mastering the concepts and operations covered here, you'll be better equipped to harness the full potential of lists in your Python programs and efficiently handle a wide range of tasks and scenarios."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d3c3ee5",
   "metadata": {
    "papermill": {
     "duration": 0.024856,
     "end_time": "2023-10-22T03:21:05.646920",
     "exception": false,
     "start_time": "2023-10-22T03:21:05.622064",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## **Learn More**\n",
    "Here are a few more basic and fundamental Python topics I tried to cover.\n",
    "\n",
    "- **[Comprehensive Guide on NumPy for Beginners](https://www.kaggle.com/code/tanvirnwu/comprehensive-guide-on-numpy-for-beginners#Learn-More)**\n",
    "- **[Boolean in Python with Example and Explanation](https://www.kaggle.com/code/tanvirnwu/boolean-in-python-with-example-and-explanation)**\n",
    "- **[Dictionary in Python with Examples & Explanations](https://www.kaggle.com/code/tanvirnwu/dictionary-in-python-with-examples-explanations)**\n",
    "\n",
    "**Please leave an upvote if you think these are some helpful materials for the beginners. **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "559f6157",
   "metadata": {
    "papermill": {
     "duration": 0.023935,
     "end_time": "2023-10-22T03:21:05.695358",
     "exception": false,
     "start_time": "2023-10-22T03:21:05.671423",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.10.12"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 7.939321,
   "end_time": "2023-10-22T03:21:06.038294",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2023-10-22T03:20:58.098973",
   "version": "2.4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}