Lab_1_Working with NumPy .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "27b5d974",
   "metadata": {},
   "source": [
    "# Exp_1. Numpy API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9c24c801",
   "metadata": {},
   "outputs": [],
   "source": [
    "from platform import python_version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d34a842d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.8.8\n"
     ]
    }
   ],
   "source": [
    "print(python_version())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3c248512",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.8.8 (default, Apr 13 2021, 15:08:03) [MSC v.1916 64 bit (AMD64)]\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print(sys.version)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70f9c129",
   "metadata": {},
   "source": [
    "# Check NumPy Version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "77e135ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.19.5'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy\n",
    "numpy.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d87aa37b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# conda list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d94b564",
   "metadata": {},
   "source": [
    "# numerical python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "210e32fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "283cbe91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1, 2, 3, 4, 5]\n",
    "print(type(x))\n",
    "print(len(x))\n",
    "len(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d4e6b072",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "x1 = [[1, 2, 3, 4], [5, 6, 7, 8]]\n",
    "print(type(x1))\n",
    "print(len(x1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "afc36308",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 4)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X1 = np.array(x1, dtype=np.double)\n",
    "X1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d07b45d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-8. -6. -4. -2.]\n",
      " [ 4.  3.  2.  1.]]\n"
     ]
    }
   ],
   "source": [
    "y1 = np.array([\n",
    "    [9, 8, 7, 6],\n",
    "    [1, 3, 5, 7]\n",
    "], dtype=np.float16)\n",
    "print(X1 - y1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09368b2b",
   "metadata": {},
   "source": [
    "# creating 1D arrays with functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "24d63b8f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  6 11 16 21 26 31 36 41 46]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(1, 50, 5, dtype=np.uint)\n",
    "print(x)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "82200d70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.         1.10126582 1.20253165 1.30379747 1.40506329 1.50632911\n",
      " 1.60759494 1.70886076 1.81012658 1.91139241 2.01265823 2.11392405\n",
      " 2.21518987 2.3164557  2.41772152 2.51898734 2.62025316 2.72151899\n",
      " 2.82278481 2.92405063 3.02531646 3.12658228 3.2278481  3.32911392\n",
      " 3.43037975 3.53164557 3.63291139 3.73417722 3.83544304 3.93670886\n",
      " 4.03797468 4.13924051 4.24050633 4.34177215 4.44303797 4.5443038\n",
      " 4.64556962 4.74683544 4.84810127 4.94936709 5.05063291 5.15189873\n",
      " 5.25316456 5.35443038 5.4556962  5.55696203 5.65822785 5.75949367\n",
      " 5.86075949 5.96202532 6.06329114 6.16455696 6.26582278 6.36708861\n",
      " 6.46835443 6.56962025 6.67088608 6.7721519  6.87341772 6.97468354\n",
      " 7.07594937 7.17721519 7.27848101 7.37974684 7.48101266 7.58227848\n",
      " 7.6835443  7.78481013 7.88607595 7.98734177 8.08860759 8.18987342\n",
      " 8.29113924 8.39240506 8.49367089 8.59493671 8.69620253 8.79746835\n",
      " 8.89873418 9.        ]\n"
     ]
    }
   ],
   "source": [
    "x = np.linspace(1, 9, 80)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "934c6d50",
   "metadata": {},
   "source": [
    "# arange doesnot control the number of items it has step size and linspace has items.\n",
    "# 2D Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a406df83",
   "metadata": {},
   "source": [
    "# 2D identify matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "3850e743",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0.]\n",
      " [0. 1.]]\n",
      "[[1. 0. 0. 0. 0.]\n",
      " [0. 1. 0. 0. 0.]\n",
      " [0. 0. 1. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.eye(2)\n",
    "print(x)\n",
    "print(np.eye(3, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32d7bda4",
   "metadata": {},
   "source": [
    "# diagonal matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "9dea6e64",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 0 0]\n",
      " [0 0 0 0 0]\n",
      " [2 0 0 0 0]\n",
      " [0 3 0 0 0]\n",
      " [0 0 4 0 0]]\n"
     ]
    }
   ],
   "source": [
    "x = np.diag([2, 3, 4], -2)   # Replace 0 with +1 and -1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd446f6c",
   "metadata": {},
   "source": [
    "# generation of linear least squares models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "1adbb9f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1   1   1   1   1]\n",
      " [ 16   8   4   2   1]\n",
      " [ 81  27   9   3   1]\n",
      " [256  64  16   4   1]]\n"
     ]
    }
   ],
   "source": [
    "x = np.vander([1, 2, 3, 4], 5)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b46eae9b",
   "metadata": {},
   "source": [
    "# matrix of one's, zeros and randoms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "c0f77082",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.ones((3, 3))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "3b5b0a1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0.]\n",
      " [0. 0.]\n",
      " [0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.zeros((3, 2))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13a624d4",
   "metadata": {},
   "source": [
    "# Random Number Generator using Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "35f7b7b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import default_rng"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "ec2f1986",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.36634692 0.19929538 0.08855837]\n",
      " [0.65319169 0.45933704 0.98767562]]\n"
     ]
    }
   ],
   "source": [
    "x = default_rng(22).random((2, 3)) # Change 0 to 42 or any other like 6\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b09a41a",
   "metadata": {},
   "source": [
    "# index matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "073e5db6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0 0]]\n",
      "\n",
      " [[0 1]]]\n"
     ]
    }
   ],
   "source": [
    "x = np.indices((1,2))\n",
    "#x = np.indices((2,3))\n",
    "#x = np.indices((3,3))\n",
    "#x = np.indices((1,3))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68c91f74",
   "metadata": {},
   "source": [
    "# operations on arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "11952407",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[40]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4, 5, 6])\n",
    "b = a[3:4].copy()\n",
    "b *= 10 # b = b*10\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "1db43f05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5], dtype=int64)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = np.where(a)[0] # type 1 in place of 0\n",
    "index"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12f2d321",
   "metadata": {},
   "source": [
    "# joining pre defined arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "965545ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1.]\n",
      "[[1]\n",
      " [2]\n",
      " [3]\n",
      " [4]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4])\n",
    "b = np.eye(4, 4)\n",
    "print(np.hstack(b))\n",
    "print(np.vstack(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "2de8620f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 1. 1.]\n",
      " [0. 1. 1. 1.]\n",
      " [0. 0. 3. 0.]\n",
      " [0. 0. 0. 4.]]\n"
     ]
    }
   ],
   "source": [
    "C1 = np.eye(2, 2)\n",
    "C2 = np.ones((2, 2))\n",
    "C3 = np.zeros((2, 2))\n",
    "C4 = np.diag((3, 4))\n",
    "B = np.block([[C1, C2], [C3, C4]])\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58adbe72",
   "metadata": {},
   "source": [
    "# array indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "156520b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "2\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(10)\n",
    "print(x)\n",
    "print(x[2])  # forward index\n",
    "print(x[-2])  # reverse indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "7d9d9a8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 3)\n",
      "8\n",
      "[[1]\n",
      " [4]\n",
      " [7]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 8, 9]\n",
    "])\n",
    "print(x.shape)\n",
    "print(x[-1, -2])\n",
    "print(x[:3, :1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a834d0b",
   "metadata": {},
   "source": [
    "# \"\"\"slicing and striding \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "43abc9ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 5 7]\n",
      "[9 7 5 3]\n",
      "[8 9]\n",
      "[7 6 5 4]\n",
      "[5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(10)\n",
    "print(x[1:9:2])\n",
    "print(x[-1:-9:-2])\n",
    "print(x[-2:10])\n",
    "print(x[-3:3:-1])\n",
    "print(x[5:])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e572d4bc",
   "metadata": {},
   "source": [
    "# for loop "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "9ade330e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 12, 15]\n",
      "[0 0 0]\n",
      "[1 1 1]\n",
      "[1 2 3]\n",
      "[3 3 3]\n"
     ]
    }
   ],
   "source": [
    "X = [1, 2, 3]\n",
    "Z = [4, 5, 6]\n",
    "y = [a + b * 2 for a, b in zip(X, Z)]\n",
    "print(y)\n",
    "print(np.zeros_like(X))\n",
    "print(np.ones_like(X))\n",
    "print(np.empty_like(X))\n",
    "print(np.full_like(X, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f2b7118",
   "metadata": {},
   "source": [
    "# sequences generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5bc6b611",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.arange(3))\n",
    "print(np.arange(1, 6))\n",
    "print(np.arange(1., 6., 2))\n",
    "print(np.linspace(1, 6, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17f5c18c",
   "metadata": {},
   "source": [
    "# linspace s,s,no.of items\n",
    "# arange s,s,gap between items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "990095ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "rng = np.random.default_rng()\n",
    "print(rng.integers(0, 9, 3))  # excluding 9\n",
    "print(rng.integers(0, 9, 3, endpoint=True))  # include 9\n",
    "print(rng.random(3))\n",
    "print(rng.standard_normal(3))\n",
    "print(rng.uniform(0, 7, 2))\n",
    "print(rng.normal(5, 2, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0d6dc26",
   "metadata": {},
   "source": [
    "mean 5, var 2\n",
    "# indexing of Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e58d0631",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(0, 6)\n",
    "print(a)\n",
    "print(a[2])\n",
    "print(a[2:4])\n",
    "print(a[-3:])\n",
    "print(a[::-2])\n",
    "print(a[2::])\n",
    "print(a[:2:])\n",
    "b = a.copy()\n",
    "print(b[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fe1eb7f",
   "metadata": {},
   "source": [
    "# Arrays are mutable meaning that they can be modified"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0f3367a",
   "metadata": {},
   "source": [
    "# BOOLEAN INDEXING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "1d606331",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 5, 8, 4, 9, 3])\n",
    "b = a > 5\n",
    "b = np.any(a > 5)\n",
    "b = np.all(a > 5)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb474859",
   "metadata": {},
   "source": [
    "# indexing Boolean to extract values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd40563c",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a[a > 5])\n",
    "a[a > 5] = 0\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b37e620",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([1, 2, 4, 5, 7, 3, 9, 2])\n",
    "a[(a >= 3) & (a <= 5)] = 0\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5523c1c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([\n",
    "    [1, 2, 3, 4],\n",
    "    [5, 6, 7, 8],\n",
    "    [9, 10, 11, 12],\n",
    "    [13, 14, 15, 16]\n",
    "])\n",
    "print(a.shape)\n",
    "print(a[:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eab00703",
   "metadata": {},
   "source": [
    "# the meaning of colon in\n",
    "# arrays or lists is copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46798634",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([1, 2, 3, 4, 5, 3, 4, 6, 7, 8, 4])\n",
    "print(np.where(a > 3))\n",
    "print(np.nonzero(a > 4))\n",
    "print(len(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e7a82fb",
   "metadata": {},
   "source": [
    "# math operations on arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ca85374",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([1, 2])\n",
    "b = np.array([3, 4])\n",
    "print(a + b)\n",
    "print(a - b)\n",
    "print(a * b)\n",
    "print(a / b)\n",
    "print(a // b)\n",
    "print(a ** b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "310139d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.sqrt(a))\n",
    "print(np.exp(a))\n",
    "print(np.log(a))\n",
    "print(np.dot(a, b))\n",
    "print(np.cross(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8345e38",
   "metadata": {},
   "source": [
    "# Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "617d20ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72c3a37b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(s.capitalize())  # Capitalize a string; prints \"Hello\"\n",
    "print(s.upper())       # Convert a string to uppercase; prints \"HELLO\"\n",
    "print(s.rjust(7))      # Right-justify a string, padding with spaces; prints \"  hello\"\n",
    "print(s.center(7))     # Center a string, padding with spaces; prints \" hello \"\n",
    "print(s.replace('l', '(ell)'))  # Replace all instances of one substring with another;\n",
    "                                # prints \"he(ell)(ell)o\"\n",
    "print('  world '.strip())  # Strip leading and trailing whitespace; prints \"world\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b2d4851",
   "metadata": {},
   "outputs": [],
   "source": [
    "birds = ['hen', 'pegion', 'parrot','peacock','duck']\n",
    "for bird in birds:\n",
    "    print(bird) # Try birds"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf5defb6",
   "metadata": {},
   "source": [
    "# Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8b4a93a",
   "metadata": {},
   "outputs": [],
   "source": [
    "xs = [3, 1, 2]    # Create a list\n",
    "print(xs, xs[2])  # Prints \"[3, 1, 2] 2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "894cbe14",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(xs[-1])     # Negative indices count from the end of the list; prints \"2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "987a10cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "xs[2] = 'Mlwp'     # Lists can contain elements of different types\n",
    "print(xs)         "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e19b9414",
   "metadata": {},
   "outputs": [],
   "source": [
    "xs.append('python')  # Add a new element to the end of the list\n",
    "print(xs)         "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df4e60e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = xs.pop()      # Remove and return the last element of the list\n",
    "print(x, xs)      "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2acf024c",
   "metadata": {},
   "source": [
    "# Slicing on lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73785541",
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list = list(range(8))     # range is a built-in function that creates a list of integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cae375e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "845d28c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a_list[2:4])          # Get a slice from index 2 to 4 (exclusive); prints \"[2, 3]\"\n",
    "print(a_list[2:])           # Get a slice from index 2 to the end; prints \"[2, 3, 4]\"\n",
    "print(a_list[:2])           # Get a slice from the start to index 2 (exclusive); prints \"[0, 1]\"\n",
    "print(a_list[:])            # Get a slice of the whole list; prints \"[0, 1, 2, 3, 4]\"\n",
    "print(a_list[:-1])          # Slice indices can be negative; prints \"[0, 1, 2, 3]\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8a8fbef",
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list[2:4] = [9, 10]        # Assign a new sublist to a slice\n",
    "print(a_list)           "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f62c97b4",
   "metadata": {},
   "source": [
    "# Weekly Assesment Questions - Submit using this one drive link. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "070740c3",
   "metadata": {},
   "source": [
    "https://kluniversityin-my.sharepoint.com/:f:/g/personal/pvvkishore_kluniversity_in/EsKd3jmPbHtFreSilPrPG6YB5Mpt7UfgF8Ee_p3LBeNiwg?e=9WM7DT"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58d947bd",
   "metadata": {},
   "source": [
    "# File Name Should be: RollNo_WANo"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3ed4474",
   "metadata": {},
   "source": [
    "# 1. Construct a list of 50 floating point numbers and find the square root on the list. Convert the list into a numpy intiger array."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "347ae1fd",
   "metadata": {},
   "source": [
    "# 2. Construct a list of 10 contineous numbers and swap the first and last elements of the list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c45fcb4",
   "metadata": {},
   "source": [
    "# 3. Construct two arrays of random numbers and perform all the mathmatical operations on these two arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a16e3db6",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}