Lists_Py.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Insert \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 4]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=[];\n",
    "a.insert(0,1);\n",
    "a.insert(1,2);\n",
    "print(a);\n",
    "a.insert(20,4)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "a.insert(1,3); #inserting '3' at index 1\n",
    "print(a);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Append"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 2, 4]\n",
      "[1, 2, 3, 4, 5]\n",
      "[1, 2, 3, [4, 5]]\n"
     ]
    }
   ],
   "source": [
    "a.append(4);\n",
    "print(a);\n",
    "\n",
    "li1=[1,2,3];\n",
    "\n",
    "li2=[4,5];\n",
    "\n",
    "li1.append(li2);\n",
    "\n",
    "print(li1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Append Using '+'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "li1 = [1,2,3];\n",
    "\n",
    "li2 = [4,5];\n",
    "\n",
    "print(li1 + li2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Remove uisng value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 1]\n"
     ]
    }
   ],
   "source": [
    "lst = [1,2,3,1];\n",
    "\n",
    "lst.remove(1); #it will remove first occurance of '1'\n",
    "print(lst);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Extend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "li1=[1,2,3];\n",
    "\n",
    "li2=[4,5];\n",
    "\n",
    "li1.extend(li2)\n",
    "\n",
    "print(li1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Delete or Pop using index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'c']\n"
     ]
    }
   ],
   "source": [
    "lst=[\"a\",\"b\",\"c\",\"d\"];\n",
    "\n",
    "del lst[1];\n",
    "\n",
    "#or\n",
    "\n",
    "lst.pop(2);\n",
    "\n",
    "print(lst);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List.Contains() equivalent in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "its present\n",
      "25 not in list\n"
     ]
    }
   ],
   "source": [
    "lst=[1,2,3,4,5];\n",
    "\n",
    "if(1 in lst):\n",
    "    print(\"its present\");\n",
    "    \n",
    "if(25 not in lst):\n",
    "    print(\"25 not in list\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Reverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "lst=[1,2,3,4];\n",
    "lst.reverse();\n",
    "print(lst);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 2, 4, 5, 6]\n",
      "[0.9, 1, 2.2]\n"
     ]
    }
   ],
   "source": [
    "lst=[2,4,1,5,2,6];\n",
    "\n",
    "sort_lst=sorted(lst);\n",
    "\n",
    "print(sort_lst);\n",
    "\n",
    "li= [1,2.2,0.9]\n",
    "\n",
    "srt=sorted(li);\n",
    "\n",
    "print(srt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 5, 4, 2, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "lst=[2,4,1,5,2,6];\n",
    "\n",
    "sort_lst=sorted(lst, reverse=True); #reverse sort\n",
    "\n",
    "print(sort_lst);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Multiple References"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2818797455816\n",
      "2818797455816\n"
     ]
    }
   ],
   "source": [
    "lst=[1,2,3,4];\n",
    "\n",
    "li=lst; #both li and lst points to same memory location.\n",
    "\n",
    "\n",
    "print(id(lst));\n",
    "\n",
    "print(id(li));\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# List Copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2818797800392\n",
      "2818797796448\n"
     ]
    }
   ],
   "source": [
    "lst = [1,2,3];\n",
    "\n",
    "li=lst.copy;\n",
    "\n",
    "print(id(lst));\n",
    "\n",
    "print(id(li));\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "observation: As copy of one list is pasted in other both points to different Memory Locations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String Split will return List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'k', 'a', 'r', 's', 'h']\n",
      "['I', 'am', 'Learning', 'ML']\n"
     ]
    }
   ],
   "source": [
    "s = \"a,k,a,r,s,h\"\n",
    "\n",
    "lst = s.split(\",\");\n",
    "\n",
    "print(lst);\n",
    "\n",
    "s2= \"I am Learning ML\"\n",
    "\n",
    "lst = s2.split();\n",
    "\n",
    "print(lst);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "nums=[1,2,3,4,5,6,7,8,9]\n",
    "\n",
    "print(nums[0:4]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### To print Alternate nums in list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Syntax: nums[start : end : stepsize]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "print(nums[::2]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 6]\n"
     ]
    }
   ],
   "source": [
    "print(nums[2:8:3]); #stepSize is 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Count / Frequency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "li = [1,2,3,1,4,1,5,1,6];\n",
    "\n",
    "#prints frequency of 1 in li\n",
    "\n",
    "print(li.count(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Without list Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "even = [];\n",
    "for i in range(10):\n",
    "    if(i%2==0):\n",
    "        even.append(i);\n",
    "print(even);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### With List Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "even = [i for i in range(10) if i%2==0];\n",
    "\n",
    "print(even);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16)]\n"
     ]
    }
   ],
   "source": [
    "# List of Tuples\n",
    "\n",
    "sq = [(i,i**2) for i in range(5)];\n",
    "\n",
    "print(sq);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Nested List Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Without Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transposed Matrix is:  [[1, 4, 7], [2, 5, 8], [3, 6, 9]]\n"
     ]
    }
   ],
   "source": [
    "matrix = [\n",
    "    [1,2,3],\n",
    "    [4,5,6],\n",
    "    [7,8,9]\n",
    "];\n",
    "\n",
    "transposed= [];\n",
    "\n",
    "for i in range(3):\n",
    "    lst = [];\n",
    "    for row in matrix:\n",
    "        #getting column values\n",
    "        lst.append(row[i]);\n",
    "    transposed.append(lst);\n",
    "print(\"Transposed Matrix is: \",transposed);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### With Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 4, 7], [2, 5, 8], [3, 6, 9]]\n"
     ]
    }
   ],
   "source": [
    "transposed = [[row[i] for row in matrix] for i in range(3)]\n",
    "\n",
    "print(transposed);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Other Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0, 1], [0, 1]], [[0, 1], [0, 1]]]\n"
     ]
    }
   ],
   "source": [
    "x = [[[k for k in range(2)] for j in range(2)] for i in range(2)];\n",
    "\n",
    "print(x);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sum of matrises Using List Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2, 4, 6], [8, 10, 12], [14, 16, 18]]\n"
     ]
    }
   ],
   "source": [
    "a = [\n",
    "    [1,2,3],\n",
    "    [4,5,6],\n",
    "    [7,8,9]\n",
    "];\n",
    "\n",
    "b = [\n",
    "    [1,2,3],\n",
    "    [4,5,6],\n",
    "    [7,8,9]\n",
    "];\n",
    "\n",
    "sum = [ [a[i][j]+b[i][j] for j in range(3)] for i in range(3) ];\n",
    "\n",
    "print(sum);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Repeating ele in List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ML', 'ML', 'ML']\n"
     ]
    }
   ],
   "source": [
    "l = [\"ML\"] * 3;\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, [4, 3]]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "li1 =[1,2,3]\n",
    "li2=[4,3]\n",
    "li1.append(li2)\n",
    "li1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "li1[3][0]"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}