TranCongDat_51800183_numpy_exercises.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "from numpy import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "# mang 1 chieu\n",
    "arr = np.array([1, 2, 3])\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 4]\n",
      " [1 2 3 4]]\n"
     ]
    }
   ],
   "source": [
    "# mang 2 chieu : 2 hang , 4 cot\n",
    "arr2D = np.array([[1,2,3,4],[1,2,3,4]])\n",
    "print(arr2D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [1 2 3]]\n"
     ]
    }
   ],
   "source": [
    "# mang 2 chieu lay tu mang (1)\n",
    "arr2d = np.array([arr,arr])\n",
    "print(arr2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1 2 3]\n",
      "  [1 2 3]]\n",
      "\n",
      " [[1 2 3]\n",
      "  [1 2 3]]]\n"
     ]
    }
   ],
   "source": [
    "# mang 3 chieu voi shape [2,3,4]\n",
    "arr3d = np.array([[[1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3]]])\n",
    "print(arr3d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 1 1 1 1 1 1 1 1]\n"
     ]
    }
   ],
   "source": [
    "# Mảng 1 mờ có kích thước 10 và tất cả các giá trị là 1\n",
    "x = np.array([1]*10)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[18.11758435 47.99446036  6.9929679 ]\n",
      " [35.131858   16.06983382  5.37740405]]\n"
     ]
    }
   ],
   "source": [
    "#tao 2 chieu mang so thuc co 2 hang 3 cot tu 5 - 19\n",
    "x = random.rand(2,3)\n",
    "print(x*50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[19 18 18]\n",
      " [16 12 17]]\n"
     ]
    }
   ],
   "source": [
    "#tao 2 chieu mang so nguyen co 2 hang 3 cot tu 10 - 20\n",
    "x = random.choice([10,11,12,13,14,15,16,17,18,19,20], size=(2,3))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "get col: [1 2 3]\n",
      "get row: [2 5]\n"
     ]
    }
   ],
   "source": [
    "# get col and row of 2-D array \n",
    "A = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "print(A)\n",
    "print('get col:',A[0, 0:3]) \n",
    "print('get row:',A[0:3, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1 2 3]\n",
      "  [4 5 6]]\n",
      "\n",
      " [[1 2 3]\n",
      "  [4 5 6]]]\n"
     ]
    }
   ],
   "source": [
    "#create a 3-dim array and show its shape: call it B\n",
    "B = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "#convert A to 1-dim array\n",
    "B = A.reshape(-1)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "#convert A to 2-dim array with k rows \n",
    "C = A.reshape(3,2)\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "#create an 1-dim array and convert it to 2-dim array with shape(m,n)\n",
    "arr = np.array([1,2,3,4,5,6])\n",
    "print(arr.reshape(2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 7 72 59 68 95 20 21 60 22 82 45 23 22 65  7 50 98 50 71 30 92 46 73 79\n",
      " 97 30 43 46 49 98 41 59 25 40 21 69 29 98 48 21 24 25 68 55 11 24  5 67\n",
      "  1 56 14 52 14 74 20 30 53 36 88 68 18 32  7 64 84  2 49 54 61 41 21 16\n",
      " 25 37  0  6 19 27 15 74 78 60 76 55 29 26 27 32 12 54 92 75  1 49 68 38\n",
      " 40 63 81 14]\n",
      "20 first elements: [ 7 72 59 68 95 20 21 60 22 82 45 23 22 65  7 50 98 50 71 30]\n",
      "20 last elements: [78 60 76 55 29 26 27 32 12 54 92 75  1 49 68 38 40 63 81 14]\n"
     ]
    }
   ],
   "source": [
    "from numpy import random\n",
    "x = random.randint(100, size=100)\n",
    "print(x)\n",
    "print('20 first elements:',x[:20])\n",
    "print('20 last elements:',x[80:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[77  0 71  2  0 46 67 11 58 29 17 66 33 59 99  3 53]\n"
     ]
    }
   ],
   "source": [
    "#get sub-array containing elements of index m to n\n",
    "print(x[3:20])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mang ban dau: [[ 1  2  3  4  5]\n",
      " [ 6  7  8  9 10]]\n",
      "mang da xoa: [[1 2 3 4]\n",
      " [6 7 8 9]]\n",
      "[[ 5]\n",
      " [10]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1,2,3,4,5],[6,7,8,9,10]])\n",
    "print('Mang ban dau:',A)\n",
    "b = np.delete(A,4,1)\n",
    "print('mang da xoa:',b)\n",
    "\n",
    "\n",
    "print(A[:2, 4:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nhan 2 ma tran :\n",
      "[[ 2  2  2  2]\n",
      " [ 1  4  9 16]]\n",
      "\n",
      "\n",
      "concatenate by colums [[1 1 1 1 2 2 2 2]\n",
      " [1 2 3 4 1 2 3 4]]\n",
      "\n",
      "\n",
      "concatenate by row [[1 1 1 1]\n",
      " [1 2 3 4]\n",
      " [2 2 2 2]\n",
      " [1 2 3 4]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as geek\n",
    "a = np.array([[1,1,1,1],[1,2,3,4]])\n",
    "b = np.array([[2,2,2,2],[1,2,3,4]])\n",
    "\n",
    "multi = geek.multiply(a, b)\n",
    "print('nhan 2 ma tran :')\n",
    "print(multi)\n",
    "print('\\n')\n",
    "c = np.concatenate((a, b), axis=1)\n",
    "print('concatenate by colums',c)\n",
    "print('\\n')\n",
    "d = np.concatenate((a, b), axis=0)\n",
    "print('concatenate by row',d)\n",
    "# e = np.concatenate((a,b[0:3, 3]), axis=1)\n",
    "# print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# '''\n",
    "# E. Operation with condition \n",
    "# 1) given an 1-dim array A = [1 2 3 5 7 4]\n",
    "# - remove all odd numbers in A\n",
    "# - get array B by removing elements so that their indexs of even numbers \n",
    "# 2) given two 1-dim arrays, \n",
    "# - get the intersection of them\n",
    "# - get the union of them \n",
    "# '''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "remove all odd: [2, 4]\n",
      "\n",
      "\n",
      "get even index:  [3, 7]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3,5,7,4])\n",
    "b = [x for x in a if x%2==0]\n",
    "print('remove all odd:',b)\n",
    "print('\\n')\n",
    "c = []\n",
    "for i in a:\n",
    "    if i % 2 == 0:\n",
    "        c.append(a[i])        \n",
    "print('get even index: ',c)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "intersection of a and b: [3 5 7]\n",
      "\n",
      "\n",
      "uniono of a and b: [1 2 3 4 5 6 7]\n"
     ]
    }
   ],
   "source": [
    "import numpy as geek \n",
    "a = np.array([1,2,3,5,7,4])\n",
    "b = np.array([3,5,5,7,6,6])\n",
    "inter = geek.intersect1d(a,b)\n",
    "print('intersection of a and b:',inter)\n",
    "print('\\n')\n",
    "uni = np.union1d(a,b)\n",
    "print('uniono of a and b:',uni)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}