G5.List _built.in .function.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "what is list in python:\n",
    "\n",
    "A list is a data structure in Python that is a mutable, or changeable, ordered sequence of elements. Each element or value that is inside of a list is called an item"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "why we use list in python:\n",
    "\n",
    "Lists are used to store multiple items in a single variable. Lists are one of 4 built-in data types in Python used to store collections of data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Advantage of list in python:\n",
    "\n",
    "*Conciseness and Readability. Python list comprehensions allow you to express complex operations on lists in a single line of code. ...\n",
    "\n",
    "*Efficiency. ...\n",
    "\n",
    "*Expressive Filtering and Mapping. ...\n",
    "\n",
    "*Versatility. ...\n",
    "\n",
    "*Limited Expressiveness. ...\n",
    "\n",
    "*Debugging Challenges.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Python list is an ordered and changeable collection of data objects."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PROGRAM ON LIST WITH ALL BUILT-IN FUNCTION"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A EMPTY LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A empty list\n",
    "list=[]\n",
    "list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ALL THE METHODS USED IN PYTHON LIST DATA STRUCTURE"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "USING INDEX()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "# PICKING PATICULAR OBJECT BY USING INDEX (value)\n",
    "\n",
    "list = [10,15,20,[100,200],\"gourav\"]\n",
    "print(list[3] [0])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "USING SPLIT FUNCTION()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['2']\n"
     ]
    }
   ],
   "source": [
    "# SPLITING VALUES BY ENTERED OBJECT BY USING split() METHOD\n",
    "\n",
    "list1 = input(\"Enter the value\")\n",
    "list2 = list1.split()\n",
    "print(list2)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "USING APPEND FUNCTION()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['23', '23', [30, 40, 50, 60]]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# USING APPEND IN LIST TO ADD OBJECT\n",
    "\n",
    "list=[]\n",
    "list.append(input(\"Enter the value\"))\n",
    "list.append(input(\"Enter the value\"))\n",
    "list.append([30,40,50,60])\n",
    "list"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "USING COUNT( ) FUNCTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# USING COUNT() IN LIST (Returns the count of how many times object occurs in the list.)\n",
    "\n",
    "list=['a','b','b','c','e','f']\n",
    "print(list.count('b'))\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "USING EXTEND( ) FUNCTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hi well come', 'Gourav']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# USING EXTEND IN LIST TO (ADD WHOLE LIST) \n",
    "\n",
    "list1=[\"Hi well come\"]\n",
    "list1.extend([\"Gourav\"])\n",
    "list1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "USING REVERSE( ) FUNCTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Good', 'Is', 'Gourav']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# USING REVERSE IN LIST, revers the whole list\n",
    "\n",
    "list = [\"Gourav\",\"Is\",\"Good\"]\n",
    "list.reverse()\n",
    "list"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "USING REMOVE( ) FUNCTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Gourav', 'popale']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# USING REMOVE IN LIST(IT WILL REMOVE ONLY DIRECT OBJECT)\n",
    "\n",
    "list = [\"Gourav\",'s',\"popale\"]\n",
    "list.remove(\"s\")\n",
    "list"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "USING POP( ) FUNCTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40, 50]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# USING POP() IN LIST WHICH REMOVE  LAST OBJECT,...note: BY DEFAULT(-1)(LAST OBJECT)\n",
    "\n",
    "list = [10,20,30,40,50,60]\n",
    "list.pop()\n",
    "list"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "USING SORT( ) FUNCTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "# USING SORT() IN LIST\n",
    "\n",
    "# note:sort will arange in accending order\n",
    "LIST=[1,5,3,6,9,4,7,8,10]  \n",
    "LIST.sort()               \n",
    "\n",
    "# LIST.sort(reverse=True)  reverse=True will sort the list in descending.\n",
    "print(LIST)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "USING INSERT( ) FUNCTION "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  USING INSERT() IN LIST\n",
    "\n",
    "list=[1,2,3,4,5,6]  \n",
    "list.insert(0,0)  #ndex: the index at which the element has to be inserted.\n",
    "list"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "USING INDEX AND (%d)TO PRINT PATICULAR  VALUES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total list= [10, 20, 30, 40, 50]\n",
      "first=10 ,last=50\n"
     ]
    }
   ],
   "source": [
    "#  program to print elements by using index and (%d))\n",
    "\n",
    "num=[10,20,30,40,50]\n",
    "print('total list=',num)\n",
    "print('first=%d ,last=%d' % (num[0],num[4]))\n",
    "# print(num[4])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LIST PROGRTAM ON COMPREHENSION METHOD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8, 10]\n",
      "[[0, 1, 2], [0, 1, 2], [0, 1, 2]]\n"
     ]
    }
   ],
   "source": [
    "#  python list program on Comprehension method\n",
    "\n",
    "list = [i for i in range(11) if i % 2 == 0]# condition to print even numbers\n",
    "print(list)\n",
    "\n",
    "# matrix in comprehension\n",
    "matrix = [[j for j in range(3)] for i in range(3)]\n",
    "   \n",
    "print(matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial List: \n",
      "['G', 'O', 'U', 'R', 'A', 'V', 'S', 'P', 'O', 'P', 'A', 'L', 'E']\n",
      "\n",
      "Elements sliced till 6th element from last: \n",
      "['G', 'O', 'U', 'R', 'A', 'V', 'S']\n",
      "\n",
      "Elements sliced from index -6 to -1\n",
      "['P', 'O', 'P', 'A', 'L']\n",
      "\n",
      "Printing List in reverse: \n",
      "['E', 'L', 'A', 'P', 'O', 'P', 'S', 'V', 'A', 'R', 'U', 'O', 'G']\n"
     ]
    }
   ],
   "source": [
    "# Creating a List\n",
    "List = ['G', 'O', 'U', 'R', 'A', 'V',\n",
    "        'S', 'P', 'O', 'P', 'A', 'L', 'E']\n",
    "print(\"Initial List: \")\n",
    "print(List)\n",
    "  \n",
    "# Print elements from beginning to a pre-defined point using Slice\n",
    "Sliced_List = List[:-6]\n",
    "print(\"\\nElements sliced till 6th element from last: \")\n",
    "print(Sliced_List)\n",
    "  \n",
    "# Print elements of a range using negative index List slicing\n",
    "Sliced_List = List[-6:-1]\n",
    "print(\"\\nElements sliced from index -6 to -1\")\n",
    "print(Sliced_List)\n",
    "  \n",
    "# Printing elements in reverse using Slice operation\n",
    "Sliced_List = List[::-1]\n",
    "print(\"\\nPrinting List in reverse: \")\n",
    "print(Sliced_List)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# list operation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LIST CONCATINATION METHOD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]\n"
     ]
    }
   ],
   "source": [
    "# The '+' operator concatenates list:\n",
    "\n",
    "a=[10,20,30,40,50]\n",
    "b=[60,70,80,90,100]\n",
    "c=a+b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LIST REPLICATION METHOD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0, 0]\n",
      "[1, 2, 3, 1, 2, 3, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "# similarly the '*'operator reapets a list a given number of time\n",
    "\n",
    "print([0]*4)\n",
    "\n",
    "print([1,2,3]*3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# list and function "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n",
      "2\n",
      "30\n",
      "6.0\n"
     ]
    }
   ],
   "source": [
    "nums=[2,4,6,8,10]\n",
    "\n",
    "print(len(nums))\n",
    "\n",
    "print(max(nums))\n",
    "\n",
    "print(min(nums))\n",
    "\n",
    "print(sum(nums))\n",
    "\n",
    "print(sum(nums)/len(nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# objects and value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [\"gourav\"]\n",
    "b = [\"gourav\"]\n",
    "a is b\n",
    "\n",
    "# Here, a and b are lists with identical values, but they are different objects in memory, so a is b will return False.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"gourav\"\n",
    "b = \"gourav\"\n",
    "a is b\n",
    "\n",
    "'''Here, a and b are strings with the same value, and since strings are immutable and Python caches small strings,\n",
    " a and b point to the same string object in memory, so a is b will return True.'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "IN AND NOT OPREATION IN LIST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "IN OPREATION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# IN OPREATION\n",
    "\n",
    "# The in operation in Python checks if an item is in a list, returning True if it is and False if it's not. \n",
    "LIST1=[0,1,2,3,4,'A','B',5,6,7,8]\n",
    "\n",
    "LIST2='A'in [0,1,2,3,4,'A','B',5,6,7,8]\n",
    "\n",
    "print(LIST2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NOT OPREATION "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not in list.\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "\n",
    "if \"orange\" not in fruits:\n",
    "    print(\"Not in list.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Orange is in the list.\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "\n",
    "if \"apple\" not in fruits:\n",
    "    print(\"Orange is not in the list.\")\n",
    "else:\n",
    "    print(\"Orange is in the list.\")\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "GouravENV",
   "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.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}