Lambda Functions and User defined functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lambda functions and UDF (User defined functions) extended concepts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The syntax of lambda functions should be clear at this point. Let's recap the following key points about lambda expressions.\n",
    "1. A Lambda Function in Python programming is an anonymous function or a function having no name. \n",
    "2. It is a small and restricted function having no more than one line. \n",
    "3. Just like a normal function, a Lambda function can have multiple arguments with one expression.\n",
    "4. In Python, lambda expressions (or lambda forms) are utilized to construct anonymous functions. \n",
    "5. To do so, you will use the lambda keyword (just as you use def to define normal functions). \n",
    "6. Every anonymous function you define in Python will have 3 essential parts:\n",
    "-       The Lambda Keyword.\n",
    "-       The parameters (or bound variables)\n",
    "-       The function body/expression\n",
    "7. One important point to note is, lambda expressions cannot be used for functions with multi line conditions \n",
    "- Let's look at a few examples using lambda expressions and understand\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Addition using lambda expression\n",
    "adder = lambda x, y: x + y \n",
    "print(adder(1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Addition using user defined function \n",
    "def addition():\n",
    "        x = input('Enter first number : ')\n",
    "        y = input('Enter second number : ')\n",
    "        result = 0\n",
    "        x = float(x)\n",
    "        y = float(y)\n",
    "        if (x and y) !=0:\n",
    "                result = x + y\n",
    "        elif x == 0:\n",
    "                result = y\n",
    "        elif y == 0:\n",
    "                result = x\n",
    "        return result\n",
    "\n",
    "print(addition())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above is a demonstration of the difference between a lambda operation and a user defined function. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the above to experiment with the following operations : \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write a lambda operation for subtraction of two elements and, write a user defined function for the same as well. \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Solution\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write a lambda operation for multiplication and, write a user defined function for the same as well.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Solution\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57dc6dbb",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## **Numpy**\n",
    "#### Numpy is short for Numerical Python. It is the fundamental package required for high performance scientific computing and data analysis. \n",
    "\n",
    "Some uses :\n",
    "\n",
    "- `ndarray`, a fast and space-efficient multidimensional array for large data\n",
    "- providing vectorized arithmetic operations and sophisticated broadcasting capabilities.\n",
    "- Standard mathematical functions for fast operations on entire arrays of data without having to write loops.\n",
    "- Tools for reading/writing array data to disk and working with memory-mapped files.\n",
    "- Linear algebra, random generation, and Fourier transform capabilities.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "623337bc",
   "metadata": {},
   "source": [
    "## Importing package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c809b9ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d8d7419",
   "metadata": {},
   "source": [
    "### The NumPy ndarray : A Multidimensional object\n",
    "\n",
    "A numpy array is a grid of values, all of the `same type`, and is indexed by a tuple of nonnegative integers. \n",
    "Every object has \n",
    "- a shape = Shape is a tuple giving size of each dimension\n",
    "- and a dtype = data type. \n",
    "\n",
    "Array() tries to infer a good type, if not given explicitly."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17a07b9c",
   "metadata": {},
   "source": [
    "Each array has attributes \n",
    "- ``ndim``: the number of dimensions\n",
    "- ``shape``: the size of each dimension\n",
    "- ``size``: the total size of the array\n",
    "- ``dtype``: data type of each element"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4e81ef9",
   "metadata": {},
   "source": [
    "### Creating 1-D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24d1b501",
   "metadata": {},
   "outputs": [],
   "source": [
    "a1 = np.array([1,2,3,4,5])\n",
    "print(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18d80928",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"a1 ndim    :\", a1.ndim)\n",
    "print(\"a1 shape   :\", a1.shape)\n",
    "print(\"a1 size    :\", a1.size)\n",
    "print(\"a1 datatype:\", a1.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cb666c3",
   "metadata": {},
   "source": [
    "### Creating 2-D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ddf5742b",
   "metadata": {},
   "outputs": [],
   "source": [
    "a2 = np.array([[1,2,3],[4,7,9]])\n",
    "print(a2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5034e48",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"a2 ndim    :\", a2.ndim)\n",
    "print(\"a2 shape   :\", a2.shape)\n",
    "print(\"a2 size    :\", a2.size)\n",
    "print(\"a2 datatype:\", a2.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66c82e5f",
   "metadata": {},
   "source": [
    "### Creating 3-D array\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "900dce32",
   "metadata": {},
   "outputs": [],
   "source": [
    "a3 = np.array([\n",
    "               [[1,11],[2,22]],\n",
    "               [[3,33],[4,44]],\n",
    "               [[1,111],[2,222]],\n",
    "               [[3,333],[4,444]]\n",
    "              ])\n",
    "print(a3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b617528",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"a3 ndim    :\", a3.ndim)\n",
    "print(\"a3 shape   :\", a3.shape)\n",
    "print(\"a3 size    :\", a3.size)\n",
    "print(\"a3 datatype:\", a3.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73b3cd52",
   "metadata": {},
   "source": [
    "### Creating a 2-D array filled with ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d838b0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "a3 = np.ones((10,5),dtype=int)\n",
    "print(a3)\n",
    "print(a3.shape)\n",
    "print(a3.ndim)\n",
    "print(type(a3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77916dc3",
   "metadata": {},
   "source": [
    "### Generating numbers between a range with a specific difference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ec1fc10",
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.arange(start,stop,stepsize)\n",
    "np.array(range(0,100,11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e85b0a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.arange(0,100,11)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47667add",
   "metadata": {},
   "source": [
    "### Generating **n** numbers between a range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fd717f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.linspace(0,2,11)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24300488",
   "metadata": {},
   "source": [
    "### Generating random sample of given dimensions\n",
    "**Note - Random numbers are generated between 0 to 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ac50f85",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.random((3,3,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61a1ac2f",
   "metadata": {},
   "source": [
    "### Basic array operations\n",
    "**Note - The operations are vectorised**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1b31aef",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([2,4,8,16])\n",
    "y = np.array([1,1,0,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2241382",
   "metadata": {},
   "outputs": [],
   "source": [
    "x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "590a088f",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(x + y)\n",
    "print(x - y)\n",
    "print(x * y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "abe4d440",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(3,10,1)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c6324f4",
   "metadata": {},
   "source": [
    "### Transpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fef2b29",
   "metadata": {},
   "outputs": [],
   "source": [
    "a2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07f986c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "a2.T"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d541bf9d",
   "metadata": {},
   "source": [
    "### Array Manipulations\n",
    "#### Append a element to array\n",
    "#### Sorting a array\n",
    "#### delete element from array\n",
    "#### "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13a42ae4",
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68f367f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.append(x,10)\n",
    "print(x)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03a50c30",
   "metadata": {},
   "outputs": [],
   "source": [
    "a4 = np.append(x,[11,12])\n",
    "a4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ca9317d",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sort(a4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "784ce42b",
   "metadata": {},
   "outputs": [],
   "source": [
    "a4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a80ad96",
   "metadata": {},
   "outputs": [],
   "source": [
    "a4 = np.delete(a4,2) # 2 is index not an item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfeb2e8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "a4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f10806f",
   "metadata": {},
   "outputs": [],
   "source": [
    "a4.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd494211",
   "metadata": {},
   "outputs": [],
   "source": [
    "# a4.reshape(1,7)\n",
    "a4.reshape(1,6)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22ba01e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "a4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19207ea5",
   "metadata": {},
   "outputs": [],
   "source": [
    "a4.reshape(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65566416",
   "metadata": {},
   "outputs": [],
   "source": [
    "a4.resize(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a465ca92",
   "metadata": {},
   "outputs": [],
   "source": [
    "a4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "247e8d0c",
   "metadata": {},
   "source": [
    "### Matrix multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bf0f4e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = np.array([1,2])\n",
    "t = np.array([[10,20,30,40],[100,200,300,400]])\n",
    "print(np.matmul(s,t))\n",
    "\n",
    "s * t "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0d7b316",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(1,19,2)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e4e3f43",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = a.reshape([3,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13b552af",
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f5424f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.append(a,[14,15,16,14])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9dff20d",
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "528a0497",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.append(a,[14,15,16,14,16]).reshape(7,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "062f30cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a numpy array of 100 integers\n",
    "my_arr = np.arange(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "448c7977",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_arr\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2b0dec1",
   "metadata": {},
   "source": [
    "Let's square each number in the sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d43418e",
   "metadata": {},
   "outputs": [],
   "source": [
    "%time my_arr2 = my_arr ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8025b363",
   "metadata": {},
   "source": [
    "Wall-clock time is the time that a clock on the wall (or a stopwatch in hand) would measure as having elapsed between the start of the process and 'now'.\n",
    "\n",
    "The user-cpu time and system-cpu time are - the amount of time spent in user code and the amount of time spent in kernel code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a9ce5f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "#print(sys.getsizeof(my_list))\n",
    "print(sys.getsizeof(my_arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8894613",
   "metadata": {},
   "source": [
    "**NumPy-based algorithms are generally 10 to 100 times faster (or more) than their\n",
    "pure Python counterparts and use significantly less memory.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3016074a",
   "metadata": {},
   "source": [
    "## The NumPy ndarray: A Multidimensional Array Object\n",
    "\n",
    "One of the key features of NumPy is its N-dimensional array object, or ndarray,\n",
    "which is a fast, flexible container for large datasets in Python. Arrays enable us to\n",
    "perform mathematical operations on whole blocks of data using similar syntax to the\n",
    "equivalent operations between scalar elements."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b80fd31",
   "metadata": {},
   "source": [
    "### Creating Arrays from Python Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c39e520b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# integer array:\n",
    "np.array([1, 4.3, 2, 5, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15a3ae6d",
   "metadata": {},
   "source": [
    "Remember that unlike Python lists, NumPy is constrained to arrays that all contain\n",
    "the same type. If types do not match, NumPy will upcast if possible (here, integers are\n",
    "upcast to floating point):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "606af654",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array([3.14, 4, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12edfb04",
   "metadata": {},
   "source": [
    "If we want to explicitly set the data type of the resulting array, we can use the dtype\n",
    "keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "043cb522",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array([1, 2, 3, 4], dtype='float64')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eda14351",
   "metadata": {},
   "source": [
    "Finally, unlike Python lists, NumPy arrays can explicitly be multidimensional; here’s\n",
    "one way of initializing a multidimensional array using a list of lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ae4f963",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(1,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d93de874",
   "metadata": {},
   "outputs": [],
   "source": [
    "# nested lists result in multidimensional arrays\n",
    "[list(range(i, i + 3)) for i in [1, 3, 5]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c04691e",
   "metadata": {},
   "source": [
    "The inner lists are treated as rows of the resulting two-dimensional array."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28809919",
   "metadata": {},
   "source": [
    "### Creating Arrays from Scratch\n",
    "Especially for larger arrays, it is more efficient to create arrays from scratch using routines\n",
    "built into NumPy. Here are several examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "695e41de",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a length-10 integer array filled with zeros\n",
    "np.zeros(10, dtype=int)\n",
    "# np.zeros((10, 10, 1), dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2e17fb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a 3x5 floating-point array filled with 1s\n",
    "np.ones((3, 5), dtype=float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6785dfb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a 3x5 array filled with 3.14\n",
    "np.full((3, 5), 3.14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ede8fe16",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an array filled with a linear sequence\n",
    "# Starting at 0, ending at 20, stepping by 2\n",
    "# (this is similar to the built-in range() function)\n",
    "np.arange(0, 20, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17586ece",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an array of five values evenly spaced between 0 and 100\n",
    "np.linspace(0, 100, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecca11aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a 3x3 array of uniformly distributed\n",
    "# random values between 0 and 1\n",
    "np.random.random((3, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd8999f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a 3x3 array of normally distributed random values\n",
    "# with mean 0 and standard deviation 1\n",
    "np.random.normal(0, 1, (30, ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "505d9269",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a 3x3 array of random integers in the interval [0, 100)\n",
    "np.random.randint(0, 100, (3, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0454799f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a 3x3 identity matrix\n",
    "np.eye(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36a26007",
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4312199",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.ones_like(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "452d6456",
   "metadata": {},
   "source": [
    "**<center>Array creation functions</center>**\n",
    "- ``array``: Convert input data (list, tuple, array, or other sequence type) to an ndarray either by inferring a dtype\n",
    "or explicitly specifying a dtype; copies the input data by default\n",
    "- ``asarray``: Convert input to ndarray, but do not copy if the input is already an ndarray\n",
    "- ``arange``: Like the built-in range but returns an ndarray instead of a list\n",
    "- ``ones``: Produce an array of all 1s with the given shape and dtype; \n",
    "- ``ones_like``: Takes another array and produces a ones array of the same shape and dtype\n",
    "- ``zeros and zeros_like``: Like ones and ones_like but producing arrays of 0s instead\n",
    "- ``empty and empty_like``: Create new arrays by allocating new memory, but do not populate with any values like ones and\n",
    "zeros\n",
    "- ``full``: Produce an array of the given shape and dtype with all values set to the indicated “fill value”\n",
    "- ``full_like``: Takes another array and produces a filled array of the same shape and dtype\n",
    "- ``eye``: Identity Create a square N × N identity matrix (1s on the diagonal and 0s elsewhere)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "003cfe02",
   "metadata": {},
   "source": [
    "## Arithmetic with NumPy Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "941edb93",
   "metadata": {},
   "source": [
    "Arrays are important because they enable you to express batch operations on data\n",
    "without writing any for loops. NumPy users call this vectorization. Any arithmetic\n",
    "operations between equal-size arrays applies the operation element-wise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c74b124",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([[1., 2., 3.], [4., 5., 6.]])\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fcae2e14",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr * arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb28460b",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr - arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32888eb3",
   "metadata": {},
   "source": [
    "Arithmetic operations with scalars propagate the scalar argument to each element in\n",
    "the array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79d24a8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "1/arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c72a0ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "447823bc",
   "metadata": {},
   "source": [
    "Comparisons between arrays of the same size yield boolean arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61bff76b",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr2 = np.array([[0., 4., 1.], [7., 2., 12.]])\n",
    "arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec35371d",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "632d97a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr2 > arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c866cda0",
   "metadata": {},
   "source": [
    "## NumPy Array Attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4124d936",
   "metadata": {},
   "source": [
    "Use NumPy’s random number generator, which we will seed with a set value in order to\n",
    "ensure that the same random arrays are generated each time this code is run:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75a021e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(0) # seed for reproducibility\n",
    "\n",
    "arr1 = np.random.randint(10, size=10) # One-dimensional array\n",
    "arr2 = np.random.randint(10, size=(3, 4)) # Two-dimensional array\n",
    "arr3 = np.random.randint(10, size=(3, 4, 5)) # Three-dimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6495f66a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(arr1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64607e7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(arr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd727f92",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(arr3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78c2e45f",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"arr3 ndim: \", arr3.ndim)\n",
    "print(\"arr3 shape:\", arr3.shape)\n",
    "print(\"arr3 size: \", arr3.size)\n",
    "print(\"arr3 size: \", arr3.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a85ea789",
   "metadata": {},
   "source": [
    "## Basic Indexing and Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58a0cb49",
   "metadata": {},
   "source": [
    "### Array Indexing: Accessing Single Elements"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "815ea3e5",
   "metadata": {},
   "source": [
    "NumPy array indexing is a rich topic, as there are many ways you may want to select\n",
    "a subset of your data or individual elements. One-dimensional arrays are simple; on\n",
    "the surface they act similarly to Python lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0049c33e",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8369e68a",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3ead5ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "233edf6b",
   "metadata": {},
   "source": [
    "To index from the end of the array, you can use negative indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca8dfd0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc95fd25",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49905e54",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c55c901",
   "metadata": {},
   "source": [
    "In a multidimensional array, you access items using a comma-separated tuple of\n",
    "indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7a7594f",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce622424",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr2[0, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd9b827c",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr2[2, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e8ef31f",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr2[1, -3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e43b7eaf",
   "metadata": {},
   "source": [
    "### Array Slicing: Accessing Subarrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55b6b223",
   "metadata": {},
   "source": [
    "As we can use square brackets to access individual array elements, we can also use\n",
    "them to access subarrays with the slice notation, marked by the colon (:) character.\n",
    "The NumPy slicing syntax follows that of the standard Python list; to access a slice of\n",
    "an array x, use this:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "b0481dfc",
   "metadata": {},
   "source": [
    "x[start:stop:step]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f4aa77e",
   "metadata": {},
   "source": [
    "If any of these are unspecified, they default to the values start=0, stop=size of\n",
    "dimension, step=1."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7a0a74b",
   "metadata": {},
   "source": [
    "#### One-dimensional subarrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb97ed99",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de7a258f",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53c0ff65",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1[:5] # first five elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "735536b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bf43c43",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1[5:] # elements after index 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78e74bcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1[5:7] # middle subarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9aedc2a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1[::2] # every other element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8441de6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1[1::2] # every other element, starting at index 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "013207dc",
   "metadata": {},
   "source": [
    "A potentially confusing case is when the step value is negative. In this case, the\n",
    "defaults for start and stop are swapped. This becomes a convenient way to reverse\n",
    "an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f54ee31",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a44e8bae",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41768267",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fcce28c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1[2::-1] # reversed every other from index 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81ce1f9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1[2:0:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SOLUTIONS\n",
    "\n",
    "# sub = lambda x, y: x-y\n",
    "# print(sub(5, 2))\n",
    "\n",
    "# def subtraction(x, y):\n",
    "#         result = 0\n",
    "#         x = float(x)\n",
    "#         y = float(y)\n",
    "#         result = x-y\n",
    "#         return result\n",
    "\n",
    "# print(subtraction(5,2))\n",
    "\n",
    "\n",
    "\n",
    "# mul = lambda x, y: x*y\n",
    "# print(mul(2, 3))\n",
    "\n",
    "# def multiplication(x,y):\n",
    "#         result = 0 \n",
    "#         x = float(x)\n",
    "#         y = float(y)\n",
    "#         result = x*y\n",
    "#         return result\n",
    "\n",
    "# print(multiplication(2,3))"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "d76a6713ea065ccca64d993c02c6b9e279dcce4f62a99101c64210a1216fb1dc"
  },
  "kernelspec": {
   "display_name": "Python 3.8.5 64-bit ('anaconda3': conda)",
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}