List.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists\n",
    "\n",
    "\n",
    "In Python, a list is created by placing all the elements inside a square bracket [ ], separated by commas. It can have any number of items and they may be of different types (integer, float, string etc.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating List\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# empty list\n",
    "my_list = []\n",
    "\n",
    "# list of integers\n",
    "my_list = [1, 2, 3]\n",
    "\n",
    "# list with different datatypes\n",
    "my_list = [1, \"Hello world\", 4.09]\n",
    "\n",
    "my_list = [0]*4\n",
    "\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List index\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# nested list\n",
    "my_list = [\"This is a nested list\", [1, 2, 3], ['this is the first item of third element of my_list']]\n",
    "\n",
    "# first element of my_list\n",
    "print(my_list[0])\n",
    "\n",
    "# second element of my_list\n",
    "print(my_list[1])\n",
    "\n",
    "\n",
    "print(my_list[1][2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Negative indexing\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = ['I','I','T','B','O','M','B','A','Y']\n",
    "\n",
    "\n",
    "print(my_list[-1])\n",
    "\n",
    "print(my_list[-5])\n",
    "\n",
    "#print(my_list[-len(my_list)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List slicing\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = ['I','I','T','B','O','M','B','A','Y']\n",
    "# elements 3rd to 5th\n",
    "print(my_list[2:5])\n",
    "\n",
    "# elements beginning to 4th\n",
    "print(my_list[:-5])\n",
    "\n",
    "# elements 6th to end\n",
    "print(my_list[5:])\n",
    "\n",
    "# elements beginning to end\n",
    "print(my_list[:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_list[0:9])\n",
    "\n",
    "# every 2nd element is taken\n",
    "print(my_list[0:9:2])\n",
    "\n",
    "# every 2nd element is taken\n",
    "print(my_list[::2])\n",
    "\n",
    "#nice little trick to reverse a list\n",
    "print(my_list[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python List methods\n",
    "\n",
    "| Method | Description |\n",
    "|---|:---|\n",
    "|append()|  Add an element to the end of the list|\n",
    "|extend() | Add all elements of a list to the another list|\n",
    "|insert() | Insert an item at the defined index|\n",
    "|remove()|  Removes an item from the list|\n",
    "|pop() | Removes and returns an element at the given index|\n",
    "|clear()|  Removes all items from the list|\n",
    "|index() | Returns the index of the first matched item|\n",
    "|count()|  Returns the count of number of items passed as an argument|\n",
    "|sort() | Sort items in a list in ascending order|\n",
    "|reverse()|  Reverse the order of items in the list|\n",
    "|copy() | Returns a shallow copy of the list|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "# change the element in the 0th position\n",
    "my_list[0] = 10\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list.append(10)\n",
    "print(my_list)\n",
    "\n",
    "my_list.extend([11, 12, 13])\n",
    "print(my_list)\n",
    "\n",
    "# will throw error if the item is not in the list\n",
    "my_list.remove(2)\n",
    "print(my_list)\n",
    "\n",
    "my_list.sort()\n",
    "print(my_list)\n",
    "\n",
    "my_list.reverse()\n",
    "print(my_list)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehension: Elegant way to create new List\n",
    "List comprehension is an elegant and concise way to create new list from an existing list in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pow2 = [x**2 for x in range(10)]\n",
    "\n",
    "print(pow2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# similar program\n",
    "pow2 = []\n",
    "for x in range(10):\n",
    "    pow2.append(x**2)\n",
    "\n",
    "print(pow2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pow2 = [x**2 for x in range(10) if x > 5]\n",
    "\n",
    "pow2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "odd = [x for x in range(20) if x % 2 == 1]\n",
    "odd\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x+y for x in ['Python ','C '] for y in ['Language','Programming']]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix multiplication - Normal way and Pythonic approach\n",
    "\n",
    "#### requires: List, List comprehension, functions, zip( ), "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3x3 matrix\n",
    "matrix_A = [[12,7,3],\n",
    "            [4 ,5,6],\n",
    "            [7 ,8,9]]\n",
    "\n",
    "# 3x4 matrix\n",
    "matrix_B = [[5,8,1,2],\n",
    "            [6,7,3,0],\n",
    "            [4,5,9,1]]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Program to multiply two matrices the non pythonic way\n",
    "\n",
    "def multiply_matrices(X, Y):\n",
    "    '''This function multiplies two matrices.'''\n",
    "    \n",
    "    result = [[0,0,0,0],\n",
    "              [0,0,0,0],\n",
    "              [0,0,0,0]]\n",
    "    \n",
    "    # iterate through rows of X\n",
    "    for i in range(len(X)):\n",
    "    # iterate through columns of Y\n",
    "        for j in range(len(Y[0])):\n",
    "        # iterate through rows of Y\n",
    "            for k in range(len(Y)):\n",
    "                result[i][j] += X[i][k] * Y[k][j]\n",
    "    \n",
    "    return result\n",
    "\n",
    "\n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = multiply_matrices(matrix_A, matrix_B)\n",
    "for r in result:\n",
    "    print(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lets make the code more generalized. results matrices should take the dimension automatically**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dimension of result = (rows of matrix A) x (columns of matrix B) \n",
    "result = [[0]*len(matrix_B[0]) for i in range(3)]\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiply_matrices(X, Y):\n",
    "    '''This function multiplies two matrices.'''\n",
    "    \n",
    "    result = [[0]*len(Y[0]) for i in range(len(Y))] ## genraized result matrix\n",
    "    \n",
    "    for i in range(len(X)):\n",
    "        for j in range(len(Y[0])):\n",
    "            for k in range(len(Y)):\n",
    "                result[i][j] += X[i][k] * Y[k][j]\n",
    "    return result\n",
    "\n",
    "result = multiply_matrices(matrix_A, matrix_B)\n",
    "for r in result:\n",
    "    print(r)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use of zip function\n",
    "list_a = [1, 2, 3, 4, 5]\n",
    "list_b = [10, 20, 30, 40, 50]\n",
    "\n",
    "list(zip(list_a, list_b))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[a*b for a,b in zip(list_a, list_b)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_a = [1, 2, 3, 4, 5]\n",
    "sum(list_a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum([a*b for a,b in zip(list_a, list_b)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(zip(matrix_B[0], matrix_B[1], matrix_B[2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#written in a consize manner\n",
    "\n",
    "list(zip(*matrix_B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pythonic way\n",
    "\n",
    "def multiply_matrices(X, Y):\n",
    "    result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]\n",
    "    return result\n",
    "\n",
    "result = multiply_matrices(matrix_A, matrix_B)\n",
    "for r in result:\n",
    "    print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lets make the code better.\n",
    "# fill the if statements such that it checks if the matrix multiplication can be done\n",
    "\n",
    "def multiply_matrices(X, Y):\n",
    "    if():\n",
    "        pass\n",
    "    else:\n",
    "        print(\"Dimensions don't match\")\n",
    "        return [False]\n",
    "    result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]\n",
    "    return result\n",
    "\n",
    "result = multiply_matrices(matrix_A, matrix_B)\n",
    "for r in result:\n",
    "    print(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transpose of a Matrix\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Non pythonic way\n",
    "\n",
    "# Program to transpose a matrix using nested loop\n",
    "\n",
    "X = [[12,7],\n",
    "    [4 ,5],\n",
    "    [3 ,8]]\n",
    "\n",
    "result = [[0,0,0],\n",
    "         [0,0,0]]\n",
    "\n",
    "# iterate through rows\n",
    "for i in range(len(X)):\n",
    "   # iterate through columns\n",
    "   for j in range(len(X[0])):\n",
    "        result[j][i] = X[i][j]\n",
    "\n",
    "for r in result:\n",
    "    print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using List comprehension\n",
    "\n",
    "X = [[12,7],\n",
    "    [4 ,5],\n",
    "    [3 ,8]]\n",
    "\n",
    "result = [[X[j][i] for j in range(len(X))] for i in range(len(X[0]))]\n",
    "\n",
    "for r in result:\n",
    "   print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Transpose Using zip\n",
    "\n",
    "X = [[12,7],\n",
    "    [4 ,5],\n",
    "    [3 ,8]]\n",
    "\n",
    "result = list(zip(*X)) # these are tuples inside a list\n",
    "print(result)"
   ]
  },
  {
   "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}