1.3-Lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NdXy-T5zaAaF"
   },
   "source": [
    "# Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "d2abr_4DaAaG"
   },
   "source": [
    "Data Structure:\n",
    "    \n",
    "A data structure is a collection of data elements (such as numbers or characters—or even other data structures) that is structured in some way, for example, by numbering the elements. The most basic data structure in Python is the \"sequence\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_OkL1n_saAaI"
   },
   "source": [
    "-> List is one of the Sequence Data structure\n",
    "\n",
    "-> Lists are collection of items (Strings, integers or even other lists)\n",
    "\n",
    "-> Lists are enclosed in [ ]\n",
    "\n",
    "-> Each item in the list has an assigned index value.\n",
    "\n",
    "-> Each item in a list is separated by a comma\n",
    "\n",
    "-> Lists are mutable, which means they can be changed.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "collapsed": true,
    "id": "y6E87CNkaAaI"
   },
   "source": [
    "# List Creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3xDIU3qfaAaJ",
    "outputId": "95be36e3-6048-4231-8b84-86ed03f92eb8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'ramu', 24, 1.24]\n"
     ]
    }
   ],
   "source": [
    "emptyList = []\n",
    "\n",
    "lst = ['one', 'two', 'three', 'four'] # list of strings\n",
    "\n",
    "lst2 = [1, 2, 3, 4] #list of integers\n",
    "\n",
    "lst3 = [[1, 2], [3, 4]] # list of lists\n",
    "\n",
    "lst4 = [1, 'ramu', 24, 1.24] # list of different datatypes\n",
    "\n",
    "print(lst4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6CEa5juJaAaP"
   },
   "source": [
    "# List Length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ELTxkoZAaAaQ",
    "outputId": "779b1f15-3461-4704-ebd3-5b587166297e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "lst = ['one', 'two', 'three', 'four']\n",
    "\n",
    "#find length of a list\n",
    "print(len(lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BWtzSHqEaAaT"
   },
   "source": [
    "# List Append"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lgxkiUKRaAaU",
    "outputId": "eb163944-cceb-4943-8494-f879111f1773"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'two', 'three', 'four', 'five']\n"
     ]
    }
   ],
   "source": [
    "lst = ['one', 'two', 'three', 'four']\n",
    "\n",
    "lst.append('five') # append will add the item at the end\n",
    "\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Yk3hugoCaAaX"
   },
   "source": [
    "# List Insert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hxFmwInfaAaY",
    "outputId": "40675a3c-2fb6-42e1-d4f1-fc5cc518a1ed"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'two', 'three', 'four']\n"
     ]
    }
   ],
   "source": [
    "#syntax: lst.insert(x, y) \n",
    "\n",
    "lst = ['one', 'two', 'four']\n",
    "\n",
    "lst.insert(2, \"three\") # will add element y at location x\n",
    "\n",
    "print(lst)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YcGKZ45BaAab"
   },
   "source": [
    "# List Remove"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Qz9E9r6IaAac",
    "outputId": "fcdf5357-8ebb-491d-8fa9-bf0d7e45011d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'three', 'four', 'two']\n"
     ]
    }
   ],
   "source": [
    "#syntax: lst.remove(x) \n",
    "\n",
    "lst = ['one', 'two', 'three', 'four', 'two']\n",
    "\n",
    "lst.remove('two') #it will remove first occurence of 'two' in a given list\n",
    "\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gP3lb_hlaAai"
   },
   "source": [
    "# List Append & Extend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AhQZ_S5WaAaj",
    "outputId": "3e023a9c-0291-4264-8c49-3d32d2a685e9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'two', 'three', 'four', ['five', 'six']]\n"
     ]
    }
   ],
   "source": [
    "lst = ['one', 'two', 'three', 'four']\n",
    "\n",
    "lst2 = ['five', 'six']\n",
    "\n",
    "#append \n",
    "lst.append(lst2)\n",
    "\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-eDRYerEaAan",
    "outputId": "dc992ec1-df5e-4190-c096-8f7b9e3b889c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'two', 'three', 'four', 'five', 'six']\n"
     ]
    }
   ],
   "source": [
    "lst = ['one', 'two', 'three', 'four']\n",
    "\n",
    "lst2 = ['five', 'six']\n",
    "\n",
    "#extend will join the list with list1\n",
    "\n",
    "lst.extend(lst2)\n",
    "\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HRsgFVblaAar"
   },
   "source": [
    "# List Delete"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "E0TcvgzCaAas",
    "outputId": "6337a874-61a3-495a-9d07-8eebe66def35"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'three', 'four', 'five']\n",
      "three\n",
      "['one', 'four', 'five']\n"
     ]
    }
   ],
   "source": [
    "#del to remove item based on index position\n",
    "\n",
    "lst = ['one', 'two', 'three', 'four', 'five']\n",
    "\n",
    "del lst[1]\n",
    "print(lst)\n",
    "\n",
    "#or we can use pop() method\n",
    "a = lst.pop(1)\n",
    "print(a)\n",
    "\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QZy8YqvraAav",
    "outputId": "41c18ac6-f55f-4a81-f949-8af520202363"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'two', 'four']\n"
     ]
    }
   ],
   "source": [
    "lst = ['one', 'two', 'three', 'four']\n",
    "\n",
    "#remove an item from list\n",
    "lst.remove('three')\n",
    "\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "B3taZUwqaAax"
   },
   "source": [
    "# List realted keywords in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KnvMpRFCaAay",
    "outputId": "0645c347-1c9c-44e4-aacb-20649a09234f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AI\n",
      "ML\n"
     ]
    }
   ],
   "source": [
    "#keyword 'in' is used to test if an item is in a list\n",
    "lst = ['one', 'two', 'three', 'four']\n",
    "\n",
    "if 'two' in lst:\n",
    "    print('AI')\n",
    "\n",
    "#keyword 'not' can combined with 'in'\n",
    "if 'six' not in lst:\n",
    "    print('ML')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ikBpRbI9aAa2"
   },
   "source": [
    "# List Reverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RQqzW-mEaAa3",
    "outputId": "781e6007-4649-4640-adde-8f4afde602d6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['four', 'three', 'two', 'one']\n"
     ]
    }
   ],
   "source": [
    "#reverse is reverses the entire list\n",
    "\n",
    "lst = ['one', 'two', 'three', 'four']\n",
    "\n",
    "lst.reverse()\n",
    "\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "o9lI--gRaAa7"
   },
   "source": [
    "# List Sorting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lUTiW5mcaAa8"
   },
   "source": [
    "The easiest way to sort a List is with the sorted(list) function. \n",
    "\n",
    "That takes a list and returns a new list with those elements in sorted order. \n",
    "\n",
    "The original list is not changed. \n",
    "\n",
    "The sorted() optional argument reverse=True, e.g. sorted(list, reverse=True), \n",
    "makes it sort backwards."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "LegBovHtaAa9",
    "outputId": "ce14fea3-fbd0-4858-b19d-f4066e000ee5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted list : [1, 2, 3, 6, 8]\n",
      "Original list:  [3, 1, 6, 2, 8]\n"
     ]
    }
   ],
   "source": [
    "#create a list with numbers\n",
    "numbers = [3, 1, 6, 2, 8]\n",
    "\n",
    "sorted_lst = sorted(numbers)\n",
    "\n",
    "\n",
    "print(\"Sorted list :\", sorted_lst)\n",
    "\n",
    "#original list remain unchanged\n",
    "print(\"Original list: \", numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qT_4cI63aAbB",
    "outputId": "c67d0b88-24c6-4cd4-c63e-7d64ae66c5c3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reverse sorted list : [8, 6, 3, 2, 1]\n",
      "Original list : [3, 1, 6, 2, 8]\n"
     ]
    }
   ],
   "source": [
    "#print a list in reverse sorted order\n",
    "print(\"Reverse sorted list :\", sorted(numbers, reverse=True))\n",
    "\n",
    "#orginal list remain unchanged\n",
    "print(\"Original list :\",  numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7YLaz7thaAbF",
    "outputId": "ed2b0657-3ddb-4390-8f3f-0a4c8c34db77"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted list:  [1, 4.2, 5, 5, 20]\n"
     ]
    }
   ],
   "source": [
    "lst = [1, 20, 5, 5, 4.2]\n",
    "\n",
    "#sort the list and stored in itself\n",
    "lst.sort()\n",
    "\n",
    "# add element 'a' to the list to show an error\n",
    "\n",
    "print(\"Sorted list: \", lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "WfPzBE_-aAbI",
    "outputId": "bbbf76f2-169f-4875-953b-d224feb0f0c5"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'<' not supported between instances of 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-98d08ff0e3ba>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mlst\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'b'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'a'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlst\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "lst = [1, 20, 'b', 5, 'a']\n",
    "print(lst.sort()) # sort list with element of different datatypes.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "eI34dleeaAbK"
   },
   "source": [
    "# List Having Multiple References"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "BcmPLhR6aAbM",
    "outputId": "bdfc1ccb-6af9-416a-c1a3-53823789de67"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list:  [1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "lst = [1, 2, 3, 4, 5]\n",
    "abc = lst\n",
    "abc.append(6)\n",
    "\n",
    "#print original list\n",
    "print(\"Original list: \", lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nsmc6A1YaAbP"
   },
   "source": [
    "# String Split to create a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YPLVh4TjaAbP",
    "outputId": "dc4b1445-3c8b-4aff-892b-cb1306c36499",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'two', 'three', 'four', 'five']\n"
     ]
    }
   ],
   "source": [
    "#let's take a string\n",
    "\n",
    "s = \"one,two,three,four,five\"\n",
    "slst = s.split(',')\n",
    "print(slst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PBYLi_UjaAbS",
    "outputId": "222b6691-9adf-4194-b9c9-c3acb65b5509"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['This', 'is', 'applied', 'AI', 'Course']\n"
     ]
    }
   ],
   "source": [
    "s = \"This is applied AI Course\"\n",
    "split_lst = s.split() # default split is white-character: space or tab\n",
    "print(split_lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "i0FJbejqaAbU"
   },
   "source": [
    "# List Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_ZJom4VxaAbW"
   },
   "source": [
    "Each item in the list has an assigned index value starting from 0.\n",
    "\n",
    "Accessing elements in a list is called indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_vYi0oRbaAbW",
    "outputId": "359ac752-72c9-47c3-df99-ffff292a088d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "lst = [1, 2, 3, 4]\n",
    "print(lst[1]) #print second element\n",
    "\n",
    "#print last element using negative index\n",
    "print(lst[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ihTfiGnGaAba"
   },
   "source": [
    "# List Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HJ6BnCxJaAba"
   },
   "source": [
    "Accessing parts of segments is called slicing. \n",
    "\n",
    "The key point to remember is that the :end value represents the first value that \n",
    "is not in the selected slice. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "yadzqSHAaAbc",
    "outputId": "89b39b80-69a2-4f01-9436-bbe9bf2b4f05"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40, 50, 60, 70, 80]\n",
      "[10, 20, 30, 40]\n"
     ]
    }
   ],
   "source": [
    "numbers = [10, 20, 30, 40, 50,60,70,80]\n",
    "\n",
    "#print all numbers\n",
    "print(numbers[:]) \n",
    "\n",
    "#print from index 0 to index 3\n",
    "print(numbers[0:4])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ESlZQ2aNaAbf",
    "outputId": "b62f05e9-031d-40de-d785-043d59160e45"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40, 50, 60, 70, 80]\n",
      "[10, 30, 50, 70]\n",
      "[30, 50, 70]\n"
     ]
    }
   ],
   "source": [
    "print (numbers)\n",
    "#print alternate elements in a list\n",
    "print(numbers[::2])\n",
    "\n",
    "\n",
    "#print elemnts start from 0 through rest of the list\n",
    "print(numbers[2::2])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "69BXgb4YaAbh"
   },
   "source": [
    "# List extend using \"+\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "paZsLKU7aAbh",
    "outputId": "4882a753-1daa-4357-c02c-d1c889ace73f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 'varma', 'naveen', 'murali', 'brahma']\n"
     ]
    }
   ],
   "source": [
    "lst1 = [1, 2, 3, 4]\n",
    "lst2 = ['varma', 'naveen', 'murali', 'brahma']\n",
    "new_lst = lst1 + lst2\n",
    "\n",
    "print(new_lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zR8AY0YCaAbk"
   },
   "source": [
    "# List Count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xLWcn0TcaAbl",
    "outputId": "ba7168f7-a97f-45d7-b123-38df8cc7c1ae"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 1, 3, 4, 2, 5]\n",
    "\n",
    "#frequency of 1 in a list\n",
    "print(numbers.count(1))\n",
    "\n",
    "#frequency of 3 in a list\n",
    "print(numbers.count(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ttuq4WbPaAbn"
   },
   "source": [
    "# List Looping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gGBIUhMvaAbn",
    "outputId": "b09c4261-5dd9-4bf0-f94f-a0590670d7cf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one\n",
      "two\n",
      "three\n",
      "four\n"
     ]
    }
   ],
   "source": [
    "#loop through a list\n",
    "\n",
    "lst = ['one', 'two', 'three', 'four']\n",
    "\n",
    "for ele in lst:\n",
    "    print(ele)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-EZO9D31aAbq"
   },
   "source": [
    "# List Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "y8DXRBM_aAbq"
   },
   "source": [
    "List comprehensions provide a concise way to create lists. \n",
    "\n",
    "Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence or iterable, or to create a subsequence of those elements that satisfy a certain condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-rHP7zw_aAbr",
    "outputId": "5adc1c49-9633-47bb-a83a-bf144dd1bbbb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "# without list comprehension\n",
    "squares = []\n",
    "for i in range(10):\n",
    "    squares.append(i**2)   #list append\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "CS6fvT8daAbu",
    "outputId": "87959059-b9d0-41bc-bb7d-3e9f3ed14995"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "#using list comprehension\n",
    "squares = [i**2 for i in range(10)]\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "N-v4Y9KDaAbw",
    "outputId": "f13d09a5-f6fd-41f7-b6d0-2af43f040afd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-20, -40, 20, 40, 100]\n",
      "[10, 20, 50]\n",
      "[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49), (8, 64), (9, 81)]\n"
     ]
    }
   ],
   "source": [
    "#example\n",
    "\n",
    "lst = [-10, -20, 10, 20, 50]\n",
    "\n",
    "#create a new list with values doubled\n",
    "new_lst = [i*2 for i in lst]\n",
    "print(new_lst)\n",
    "\n",
    "#filter the list to exclude negative numbers\n",
    "new_lst = [i for i in lst if i >= 0]\n",
    "print(new_lst)\n",
    "\n",
    "\n",
    "#create a list of tuples like (number, square_of_number)\n",
    "new_lst = [(i, i**2) for i in range(10)]\n",
    "print(new_lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Sp6JeODZaAb5"
   },
   "source": [
    "# Nested List Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "I7FzVx3CaAb5",
    "outputId": "20d171d1-25eb-4f5d-b01f-30639b8e0df6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]\n"
     ]
    }
   ],
   "source": [
    "#let's suppose we have a matrix\n",
    "\n",
    "matrix = [\n",
    "    [1, 2, 3, 4],\n",
    "    [5, 6, 7, 8],\n",
    "    [9, 10, 11, 12]\n",
    "]\n",
    "\n",
    "#transpose of a matrix without list comprehension\n",
    "transposed = []\n",
    "for i in range(4):\n",
    "    lst = []\n",
    "    for row in matrix:\n",
    "        lst.append(row[i])\n",
    "    transposed.append(lst)\n",
    "\n",
    "print(transposed)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "bc0Ij-kaaAb8",
    "outputId": "1005a34e-8982-46ab-9357-f7be29e16f61"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]\n"
     ]
    }
   ],
   "source": [
    "#with list comprehension\n",
    "transposed = [[row[i] for row in matrix] for i in range(4)]\n",
    "print(transposed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "__DT4BWEaAb_"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n"
     ]
    }
   ],
   "source": [
    "lst = [1,2,3,4,5,6,7,8,9]\n",
    "\n",
    "size = 3\n",
    "# test1 = []\n",
    "test2 =[]\n",
    "ctr=0\n",
    "\n",
    "\n",
    "test1 = [lst[i:i+size] for i in range(0,len(lst),size)]\n",
    "\n",
    "# for i in range(0, 9, 3):\n",
    "# #     test1 = []\n",
    "#     test1 = lst[i:i+3]\n",
    "#     test2.append(test1)\n",
    "    \n",
    "    \n",
    "        \n",
    "print(test1)\n",
    "\n",
    "\n",
    "# print(test2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "name": "2.1.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}