ListExample.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List 1: ['physics', 'chemistry', 1997, 2000]\n",
      "Value available at index 2 :  1997\n",
      "New value available at index 2 of list1 :  2001\n",
      "List 1: ['physics', 'chemistry', 2001, 2000]\n",
      "List 3: ['a', 'b', 'c', 'd']\n",
      "After deleting value at index 2  of list 3:  ['a', 'b', 'd']\n"
     ]
    }
   ],
   "source": [
    "list1 = ['physics', 'chemistry', 1997, 2000]\n",
    "list2 = [1, 2, 3, 4, 5]\n",
    "list3 = ['a', 'b', 'c', 'd']\n",
    "list = [ 'abcd', 786 , 2.23, 'Hari', 70.2 ]\n",
    "tinylist = [123, 'Ram']\n",
    "\n",
    "print(\"List 1:\",list1)\n",
    "print(\"Value available at index 2 : \", list1[2])\n",
    "list1[2] = 2001\n",
    "print(\"New value available at index 2 of list1 : \", list1[2])\n",
    "print(\"List 1:\",list1)\n",
    "print(\"List 3:\",list3)\n",
    "del list3[2]\n",
    "print (\"After deleting value at index 2  of list 3: \", list3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['abcd', 786, 2.23, 'Hari', 70.2]\n",
      "abcd\n",
      "[786, 2.23]\n",
      "[2.23, 'Hari', 70.2]\n",
      "[123, 'Ram', 123, 'Ram']\n",
      "['abcd', 786, 2.23, 'Hari', 70.2, 123, 'Ram']\n"
     ]
    }
   ],
   "source": [
    "print (list)          # Prints complete list\n",
    "print (list[0])       # Prints first element of the list\n",
    "print (list[1:3])     # Prints elements starting from 2nd till 3rd\n",
    "print (list[2:])      # Prints elements starting from 3rd element\n",
    "print (tinylist * 2)  # Prints list two times\n",
    "print (list + tinylist) # Prints concatenated lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7]\n",
      "[1, 3, 5, 7, 9, 11, 13]\n"
     ]
    }
   ],
   "source": [
    "odd = [1, 3, 5]\n",
    "odd.append(7)\n",
    "print(odd)                        \n",
    "odd.extend([9, 11, 13])\n",
    "print(odd)                      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e\n",
      "Be Happy\n",
      "[2, 0, 2, 2]\n",
      "2\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "# Nested List\n",
    "alist = [\"Be Happy\", [2,0,2,2],100]\n",
    "\n",
    "print(alist[0][1])  \n",
    "print(alist[0])\n",
    "print(alist[1])\n",
    "print(alist[1][3])  \n",
    "print(alist[2])   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "N = [1, 4, 9, 16]\n",
    "sum = 0\n",
    "for num in N:\n",
    "    sum += num\n",
    "print (sum)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The general idea of a simple list comprehension syntactically looks like this:\n",
    "    [do_something for each_thing in a_group_of_things]\n",
    "    \n",
    "So this is analogous to:\n",
    "    for each_thing in a_group_of_things:\n",
    "        do_something"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Cr', 'hs', 'fsh', 'fshrmn', 'Bk', 'TV']\n"
     ]
    }
   ],
   "source": [
    "vowels = ['a', 'e', 'i', 'o', 'u']\n",
    "words = ['Car', 'house', 'fish', 'fisherman', 'Bike', 'TV']\n",
    "\n",
    "def remove_vowels(word):\n",
    "    for letter in word:\n",
    "        if letter in vowels:\n",
    "            word = word.replace(letter, '')\n",
    "    return word\n",
    "\n",
    "new_words = [remove_vowels(word) for word in words]\n",
    "print(new_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 8, 6]\n",
      "[[4, 16, 64, 36], [4, 16, 64, 36], [4, 16, 64, 36], [4, 16, 64, 36], [4, 16, 64, 36], [4, 16, 64, 36], [4, 16, 64, 36]]\n",
      "\n",
      " ++++++++  without Using List Comprehension  +++++++++\n",
      "\n",
      "[4, 16, 64, 36, 4, 16, 64, 36]\n"
     ]
    }
   ],
   "source": [
    "list2=[]\n",
    "def square(x):\n",
    "    if x % 2==0:\n",
    "        list2.append(x**2)\n",
    "    return list2\n",
    "\n",
    "list1=[1,2,3,4,5,8,6]\n",
    "print(list1)\n",
    "\n",
    "list3=[square(y) for y in list1 ]\n",
    "print(list3)\n",
    "\n",
    "print(\"\\n ++++++++  without Using List Comprehension  +++++++++\\n\")\n",
    "for y in list1:\n",
    "    list4=square(y)\n",
    "print(list4)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditionals Within List Comprehensions\n",
    "    List comprehensions also allow us to use if and else statements, giving them even more specific functionality.                      For conditional logic in a list comprehension like                            \n",
    "             •[if_condition_true if condition else if_condition_false for element in group_of_elements]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 2, 4, 4, 6, 6, 8, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "new_numbers = [number + 1 if number % 2 == 1 else number for number in numbers]\n",
    "print(new_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you’re not using an else statement, the if statement needs to be moved to the end of the list comprehension, like so:\n",
    "\n",
    "[result for element in group_of_elements if condition]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9]\n",
      "[3, 6, 9, 12, 15, 18]\n",
      "[4, 16, 36, 64, 100]\n"
     ]
    }
   ],
   "source": [
    "new_numbers = [number for number in numbers if number % 2 == 1]\n",
    "print(new_numbers)\n",
    "\n",
    "A=[x for x in range(1,20) if x%3==0]\n",
    "print(A)\n",
    "\n",
    "# Create `new_list` \n",
    "new_list = [n**2 for n in range(1,11) if n%2==0]\n",
    "\n",
    "# Print `new_list`\n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple if and else statements in a single list comprehension"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "[result_1 if condition_1 else\n",
    " result_2 if condition_2 else\n",
    " result_3 if condition_3 else\n",
    " result_if_no_conditions_met for element in group_of_elements]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['fail', 'fail', 'fail', 'pass', 'pass', 'pass', 'first', 'first', 'Distinction', 'Distinction']\n",
      "\n",
      " ++++++++  Using List Comprehension  +++++++++\n",
      "\n",
      "['Fail', 'Fail', 'Fail', 'Pass', 'Pass', 'Pass', 'First', 'First', 'Distinction', 'Distinction']\n"
     ]
    }
   ],
   "source": [
    "A =[]\n",
    "for number in range(1,11):\n",
    "    if number < 4:\n",
    "        A.append(\"fail\")\n",
    "    elif number <= 6:\n",
    "        A.append('pass')\n",
    "    elif number <= 8:\n",
    "        A.append('first')\n",
    "    else:\n",
    "        A.append('Distinction')\n",
    "print(A) \n",
    "\n",
    "print(\"\\n ++++++++  Using List Comprehension  +++++++++\\n\")\n",
    "\n",
    "new_numbers = ['Fail' if number < 4 else \n",
    "               'Pass' if number <= 6 else \n",
    "               'First' if number <= 8 else \n",
    "               'Distinction' for number in range(1,11)]\n",
    "print(new_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple If Conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]\n",
      "\n",
      " ++++++++  Using List Comprehension  +++++++++\n",
      "\n",
      "[0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]\n"
     ]
    }
   ],
   "source": [
    "divided = []\n",
    "for x in range(100):\n",
    "    if x%2 == 0 :\n",
    "        if x%6 == 0:\n",
    "            divided.append(x)\n",
    "print(divided)\n",
    "\n",
    "print(\"\\n ++++++++  Using List Comprehension  +++++++++\\n\")\n",
    "\n",
    "divided = [x for x in range(100) if x % 2 == 0 if x % 6 == 0]\n",
    "print(divided)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested Loops in a List Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[40, 100, 120, 80, 200, 240, 120, 300, 360]\n",
      "\n",
      " ++++++++  Using List Comprehension 1 +++++++++\n",
      "\n",
      "[40, 100, 120, 80, 200, 240, 120, 300, 360]\n",
      "\n",
      " ++++++++  Using List Comprehension 2 +++++++++\n",
      "\n",
      "[40, 80, 120, 100, 200, 300, 120, 240, 360]\n"
     ]
    }
   ],
   "source": [
    "my_list = []\n",
    "for x in [20, 40, 60]:\n",
    "    for y in [2, 5, 6]:\n",
    "        my_list.append(x * y)\n",
    "print(my_list)\n",
    "\n",
    "print(\"\\n ++++++++  Using List Comprehension 1 +++++++++\\n\")\n",
    "\n",
    "my_list = [x * y for x in [20, 40, 60] for y in [2, 5, 6]]\n",
    "print(my_list)\n",
    "\n",
    "print(\"\\n ++++++++  Using List Comprehension 2 +++++++++\\n\")\n",
    "\n",
    "my_list = [x * y for y in [2, 5, 6] for x in [20, 40, 60]]\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "\n",
      " ++++++++  Using List Comprehension  +++++++++\n",
      "\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# 2-D List \n",
    "matrix = [[1, 2, 3], [4, 5], [6, 7, 8, 9]] \n",
    "flatten_matrix = [] \n",
    "for sublist in matrix: \n",
    "    for val in sublist: \n",
    "        flatten_matrix.append(val) \n",
    "print(flatten_matrix) \n",
    "\n",
    "print(\"\\n ++++++++  Using List Comprehension  +++++++++\\n\")\n",
    "\n",
    "# 2-D List \n",
    "matrix = [[1, 2, 3], [4, 5], [6, 7, 8, 9]] \n",
    "# Nested List Comprehension to flatten a given 2-D matrix \n",
    "B = [val for sublist in matrix for val in sublist] \n",
    "print(B) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cr', 'hs', 'plnt', 'bk', 'mv', 'tv']\n",
      "\n",
      " ++++++++  Using List Comprehension  +++++++++\n",
      "\n",
      "['cr', 'hs', 'plnt', 'bk', 'mv', 'tv']\n"
     ]
    }
   ],
   "source": [
    "words = ['car', 'house', 'plant', 'bike', 'movie', 'tv']\n",
    "new_words = []\n",
    "vowels = ['a', 'e', 'i', 'o', 'u']\n",
    "\n",
    "for word in words:\n",
    "    for letter in word:\n",
    "        if letter in vowels:\n",
    "            word = word.replace(letter, '')\n",
    "    new_words.append(word)\n",
    "print(new_words)\n",
    "\n",
    "print(\"\\n ++++++++  Using List Comprehension  +++++++++\\n\")\n",
    "\n",
    "new_words = [''.join([letter for letter in word if letter not in vowels]) for word in words]\n",
    "print(new_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['h', 'u', 'm', 'a', 'n', ' ', 'm', 'a', 'n', ' ', 'k', 'i', 'n', 'd']\n"
     ]
    }
   ],
   "source": [
    "# Iterating through a string Using List Comprehension\n",
    "letters = [letter for letter in 'human man kind' ]\n",
    "print( letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}