Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "53ea6c19",
   "metadata": {},
   "source": [
    "# Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47c16c06",
   "metadata": {},
   "source": [
    "## Creating array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5fca50bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "77a35fe4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "# Array from 2d list.\n",
    "\n",
    "x = np.array([\n",
    "    [ 3 , 4 , 5],\n",
    "    [ 2 , 8 , 9]\n",
    "])\n",
    "\n",
    "print(x.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1aab4e18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 3)\n"
     ]
    }
   ],
   "source": [
    "# Single array in 2d list.\n",
    "y = np.array([\n",
    "    [ 1 , 2 , 3]\n",
    "])\n",
    "\n",
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7e44b7f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0. 0. 0.]\n",
      " [0. 1. 0. 0. 0.]\n",
      " [0. 0. 1. 0. 0.]\n",
      " [0. 0. 0. 1. 0.]\n",
      " [0. 0. 0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# Identity matrix (I) with size 5.\n",
    "z = np.eye(5)\n",
    "\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1b55d9c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# To print matrix all element have zero.\n",
    "m = np.zeros((3,3))\n",
    "\n",
    "print(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9160513a",
   "metadata": {},
   "source": [
    "# Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e9c20d1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "[4 2 1 7]\n",
      "[2 2 8]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([\n",
    "    [10, 2, 4, 9],\n",
    "    [4, 2, 1, 7],\n",
    "    [1, 8, 5,4]\n",
    "])\n",
    "\n",
    "# Select a single element.\n",
    "print(x[0,1])\n",
    "\n",
    "# Select Row.\n",
    "print(x[1,:])\n",
    "\n",
    "# Select Column. \n",
    "print(x[:,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5f383429",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4 9]\n",
      " [0 7]]\n"
     ]
    }
   ],
   "source": [
    "# To select part of array  ==> sub matrix.\n",
    "n = np.array([\n",
    "    [ 3 , 4 , 9 ],\n",
    "    [ 1 , 0 , 7 ],\n",
    "    [ 5 , 2 , 1 ]\n",
    "])\n",
    "\n",
    "print(n[0:2,1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1c88f14c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False False  True]\n",
      " [False False  True]\n",
      " [False False False]]\n",
      "[9 7]\n"
     ]
    }
   ],
   "source": [
    "# To make condion in matrix show specific element True only.\n",
    "mask = ( n > 5 )\n",
    "\n",
    "print(mask)\n",
    "print(n[mask])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c54c0e46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9 7]\n"
     ]
    }
   ],
   "source": [
    "# Write condiction direct in Matrix ==> in one step.\n",
    "print(n[ n > 5 ])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e4d04e8",
   "metadata": {},
   "source": [
    "# Transpose and reshape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "39bccf06",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 1 5]\n",
      " [4 0 2]\n",
      " [9 7 1]]\n"
     ]
    }
   ],
   "source": [
    "n = np.array([\n",
    "    [ 3 , 4 , 9 ],\n",
    "    [ 1 , 0 , 7 ],\n",
    "    [ 5 , 2 , 1 ]\n",
    "])\n",
    "\n",
    "# Transpose the array.\n",
    "print(n.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "93a8d121",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 4 9 2 1 0]\n",
      " [7 1 5 2 1 7]]\n"
     ]
    }
   ],
   "source": [
    "n = np.array([\n",
    "    [ 3 , 4 , 9 , 2],\n",
    "    [ 1 , 0 , 7 , 1],\n",
    "    [ 5 , 2 , 1 , 7]\n",
    "])\n",
    "\n",
    "# To change the matrix and reshape to be 2x6.\n",
    "print(n.reshape(2,6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "578c7e33",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 4 9 1 0 7 5 2 1]]\n",
      "\n",
      "[3 4 9 1 0 7 5 2 1]\n"
     ]
    }
   ],
   "source": [
    "n = np.array([\n",
    "    [ 3 , 4 , 9 ],\n",
    "    [ 1 , 0 , 7 ],\n",
    "    [ 5 , 2 , 1 ]\n",
    "])\n",
    "\n",
    "print(n.reshape(1,9)) #Two dimension\n",
    "print()\n",
    "print(n.reshape(-1)) #One dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3d2f9319",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 4 9 1 0 7 5 2 1]\n",
      "\n",
      "[3 4 9 1 0 7 5 2 1]\n"
     ]
    }
   ],
   "source": [
    "n = np.array([\n",
    "    [ 3 , 4 , 9 ],\n",
    "    [ 1 , 0 , 7 ],\n",
    "    [ 5 , 2 , 1 ]\n",
    "])\n",
    "\n",
    "print(n.flatten()) \n",
    "print()             # Or ( To show array in one dimention )\n",
    "print(n.reshape(-1)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f9343dc1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3]\n",
      " [2]\n",
      " [4]]\n"
     ]
    }
   ],
   "source": [
    "# To show one Row in the shap of row.\n",
    "o = np.array([\n",
    "    [ 4 , 3 , 6 , 9 ],\n",
    "    [ 1 , 2 , 8 , 7 ],\n",
    "    [ 6 , 4 , 5 , 2 ]\n",
    "])\n",
    "\n",
    "# Get the first column and reshaping it to 3x1.\n",
    "print(o[:,1].reshape( -1 , 1 ))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e327bd23",
   "metadata": {},
   "source": [
    "# Maths"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e80bd85f",
   "metadata": {},
   "source": [
    "## Matrix Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "58fc8e55",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[24 19 37 29]\n",
      " [57 46 94 83]]\n",
      "\n",
      "(2, 3)\n",
      "(3, 4)\n",
      "\n",
      "(2, 4)\n"
     ]
    }
   ],
   "source": [
    "x = np.array([\n",
    "    [ 1 , 2 , 3 ],\n",
    "    [ 4 , 5 , 6 ]\n",
    "])\n",
    "\n",
    "y = np.array([\n",
    "    [ 4 , 3 , 6 , 9 ],\n",
    "    [ 1 , 2 , 8 , 7 ],\n",
    "    [ 6 , 4 , 5 , 2 ]\n",
    "])\n",
    "\n",
    "z = np.dot( x , y )    # To make multiple between two matrix .\n",
    "\n",
    "print(z)\n",
    "print()\n",
    "print(x.shape)\n",
    "print(y.shape)\n",
    "print()\n",
    "print(z.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24c0de9f",
   "metadata": {},
   "source": [
    "## Sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d70be95b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n"
     ]
    }
   ],
   "source": [
    "x = np.array([\n",
    "    [ 1 , 2 , 3 ],\n",
    "    [ 4 , 5 , 6 ]\n",
    "])\n",
    "\n",
    "# Summ all elements.\n",
    "print(x.sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5fa7453e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 7 9]]\n"
     ]
    }
   ],
   "source": [
    "# Sum each column.\n",
    "print(x.sum(axis = 0, keepdims = True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f25630e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6]\n",
      " [15]]\n"
     ]
    }
   ],
   "source": [
    "# Sum each row.\n",
    "print(x.sum(axis = 1, keepdims = True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "cbbc3c86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 7 9]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([\n",
    "    [ 1 , 2 , 3 ],\n",
    "    [ 4 , 5 , 6 ]\n",
    "])\n",
    "\n",
    "print(x.sum( axis = 0 , keepdims = True )) # 0 ==> To sum row , 1 ==> To sum column \n",
    "                                           # keepdims To keep array in dimention one or two D"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06147a00",
   "metadata": {},
   "source": [
    "## Exponent and log Function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3c14caaf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.         1.         1.5849625 ]\n",
      " [2.         2.32192809 2.5849625 ]]\n"
     ]
    }
   ],
   "source": [
    "# To make log ==> ( log(x) , log2(x) , log10(x) )\n",
    "x = np.array([\n",
    "    [ 1 , 2 , 3 ],\n",
    "    [ 4 , 5 , 6 ]\n",
    "])\n",
    "\n",
    "print(np.log2(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "25495c49",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  2.71828183   7.3890561   20.08553692]\n",
      " [ 54.59815003 148.4131591  403.42879349]]\n"
     ]
    }
   ],
   "source": [
    "# To make exp.\n",
    "x = np.array([\n",
    "    [ 1 , 2 , 3 ],\n",
    "    [ 4 , 5 , 6 ]\n",
    "])\n",
    "\n",
    "print(np.exp(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7bca675",
   "metadata": {},
   "source": [
    "# Some of treat with math."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "4fea0c71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.49999999999999994\n",
      "0.8660254037844387\n",
      "0.5773502691896257\n"
     ]
    }
   ],
   "source": [
    "a = np.sin(30*np.pi/180)\n",
    "b = np.cos(30*np.pi/180)\n",
    "c = np.tan(30*np.pi/180)\n",
    "\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a37ebba6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "2.1\n",
      "5.28\n"
     ]
    }
   ],
   "source": [
    "a = round(3.789)\n",
    "b = round(2.134,1)\n",
    "c = round(5.284,2)\n",
    "\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "811c2796",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [5, 3, 6], [9, 6, 5]]\n",
      "\n",
      "[[1 2 3]\n",
      " [5 3 6]\n",
      " [9 6 5]]\n"
     ]
    }
   ],
   "source": [
    "a = [[1,2,3],[5,3,6],[9,6,5]]\n",
    "b = np.array(a)\n",
    "\n",
    "print(a)\n",
    "print()\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "755c044c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 3 4]\n",
      " [4 5 6]\n",
      " [6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "# i+2 ==> the number of column and [2,4,6] ==> number of rows and start number of row .\n",
    "a = np.array([range( i , i + 3 )for i in [2,4,6]])\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "ee0bd327",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.73445195e-01 4.15482783e-01 1.69533018e-01]\n",
      " [3.43297228e-01 3.70191431e-01 9.17606219e-01]\n",
      " [1.98901913e-01 8.47198970e-01 7.10230046e-02]\n",
      " [3.41383315e-04 6.91358773e-01 3.67455834e-01]\n",
      " [3.40014479e-01 4.91251572e-01 3.10961841e-01]]\n",
      "\n",
      "[[[0.6732681  0.27072576 0.85897046]\n",
      "  [0.35576837 0.50856357 0.58029754]\n",
      "  [0.93619772 0.33046636 0.72885243]]\n",
      "\n",
      " [[0.87971178 0.56532954 0.97368423]\n",
      "  [0.6704599  0.00514046 0.41503709]\n",
      "  [0.28745177 0.19751795 0.98703559]]]\n"
     ]
    }
   ],
   "source": [
    "# Random matrix from 0 to 1.\n",
    "a = np.random.rand(5,3)\n",
    "b = np.random.rand(2,3,3)\n",
    "\n",
    "print(a)\n",
    "print()\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "515af438",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7 5 8 8 7]\n",
      "[17  8 22 17]\n",
      "[[17  8]\n",
      " [22 17]]\n"
     ]
    }
   ],
   "source": [
    "# Random intger number .( randint(startint , endint , the random number need))\n",
    "a = np.random.randint(0,10,5)\n",
    "b = np.random.randint(1,25,4)\n",
    "\n",
    "print(a)\n",
    "print(b)\n",
    "print(b.reshape(2,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "09769b3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]\n",
      "[9, 8, 3, 2, 1, 6, 5, 7, 0, 4]\n"
     ]
    }
   ],
   "source": [
    "# shuffle(array_of_number) to random set of number . ==> use in data set to be part in testing and part in traning.\n",
    "x = [1,2,3,4,5,6,7,8,9,0]\n",
    "print(x)\n",
    "\n",
    "np.random.shuffle(x)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "d60c318f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "[4 8 0]\n"
     ]
    }
   ],
   "source": [
    "# choice(array_of_number) to choice random int from array.\n",
    "y = [3,4,2,7,1,0,8]\n",
    "a = np.random.choice(y)\n",
    "b = np.random.choice(y, size = 3)\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f69a1e94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.          1.59183673  2.18367347  2.7755102   3.36734694  3.95918367\n",
      "  4.55102041  5.14285714  5.73469388  6.32653061  6.91836735  7.51020408\n",
      "  8.10204082  8.69387755  9.28571429  9.87755102 10.46938776 11.06122449\n",
      " 11.65306122 12.24489796 12.83673469 13.42857143 14.02040816 14.6122449\n",
      " 15.20408163 15.79591837 16.3877551  16.97959184 17.57142857 18.16326531\n",
      " 18.75510204 19.34693878 19.93877551 20.53061224 21.12244898 21.71428571\n",
      " 22.30612245 22.89795918 23.48979592 24.08163265 24.67346939 25.26530612\n",
      " 25.85714286 26.44897959 27.04081633 27.63265306 28.2244898  28.81632653\n",
      " 29.40816327 30.        ]\n",
      "[  0.  25.  50.  75. 100.]\n"
     ]
    }
   ],
   "source": [
    "# To seperate between two number .\n",
    "a = np.linspace(1,30)\n",
    "b = np.linspace(0,100,5)\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "e1d93e4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 0 0 0]\n",
      " [0 2 0 0 0]\n",
      " [0 0 3 0 0]\n",
      " [0 0 0 4 0]\n",
      " [0 0 0 0 5]]\n",
      "\n",
      "[[0 0 0 1 0 0 0 0]\n",
      " [0 0 0 0 2 0 0 0]\n",
      " [0 0 0 0 0 3 0 0]\n",
      " [0 0 0 0 0 0 4 0]\n",
      " [0 0 0 0 0 0 0 5]\n",
      " [0 0 0 0 0 0 0 0]\n",
      " [0 0 0 0 0 0 0 0]\n",
      " [0 0 0 0 0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "# Diagonal matrix . k ==> (number of extra rows and columns)\n",
    "a = np.diag(np.array([1,2,3,4,5]))\n",
    "b = np.diag(np.array([1,2,3,4,5]), k = 3)\n",
    "\n",
    "print(a)\n",
    "print()\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "276693e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4 4 9]\n",
      " [1 7 2]\n",
      " [3 4 4]]\n",
      "\n",
      "9\n",
      "\n",
      "[1 1 0]\n"
     ]
    }
   ],
   "source": [
    "x = np.random.randint(1,10,9).reshape(3,3)\n",
    "y = np.count_nonzero(x)\n",
    "z = np.count_nonzero(x > 5 , axis = 1 )\n",
    "\n",
    "print(x)\n",
    "print()\n",
    "print(y)\n",
    "print()\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b599a09d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}