numpy_basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# numpy basics"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2023-07-10T08:39:20.274444Z",
     "start_time": "2023-07-10T08:39:20.047761Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "print(arr)\n",
    "print(arr[0])"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-10T08:46:49.418258Z",
     "start_time": "2023-07-10T08:46:49.383544Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.24.4\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(np.__version__)\n",
    "print(type(arr))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-10T08:39:22.062809Z",
     "start_time": "2023-07-10T08:39:22.018243Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dimension 2\n",
      "shape (2, 3)\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "[1 2 3]\n",
      "6\n",
      "[[4 5 6]] (1, 3)\n",
      "[1 4] (2,)\n"
     ]
    }
   ],
   "source": [
    "#2d\n",
    "twoD = np.array([[1,2,3],\n",
    "                 [4,5,6]])\n",
    "\n",
    "print(\"dimension\", twoD.ndim)\n",
    "print(\"shape\", twoD.shape)\n",
    "\n",
    "print(twoD)\n",
    "\n",
    "print(twoD[0])\n",
    "print(twoD[1,2])\n",
    "\n",
    "print(twoD[1:], twoD[1:].shape)       #keeps the dimension in the slice\n",
    "print(twoD[:, 0], twoD[:, 0].shape)   #(2,)\n",
    "\n",
    "\n",
    "# print(twoD[0:])\n",
    "# print(twoD[0:1])\n",
    "# print(twoD[0][0:2])\n",
    "# print(twoD[0:2,1])  #both rows, only 2nd elements\n",
    "# print(twoD[:,1:3])  #both rows, only 2nd & 3rd elements, 2-d nparray"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-10T09:04:49.274869Z",
     "start_time": "2023-07-10T09:04:49.252962Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dim 3\n",
      "shape (2, 2, 3)\n",
      "[4 5 6] (3,)\n"
     ]
    }
   ],
   "source": [
    "# [ count is the dimension :)\n",
    "#  3-d means [[[d1, d2, element]\n",
    "#  it is kinda a tree or think first row!\n",
    "# 3d's 1st row, then 2d's 1st row then column ...\n",
    "\n",
    "threeD = np.array([                #2 row, (2,3)\n",
    "                   [[1,2,3],\n",
    "                    [4,5,6]],\n",
    "                   [[7,8,9],\n",
    "                    [10,11,12]]\n",
    "                   ])\n",
    "\n",
    "print(\"dim\", threeD.ndim)\n",
    "print(\"shape\", threeD.shape)\n",
    "\n",
    "print(threeD[0,1,:], threeD[0,1,].shape )   # print(threeD[0][1][1])  #same as above!"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-10T08:54:15.973577Z",
     "start_time": "2023-07-10T08:54:15.950942Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## types"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "int64\n"
     ]
    }
   ],
   "source": [
    "print(type(arr))\n",
    "print(arr.dtype)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-10T09:05:17.495390Z",
     "start_time": "2023-07-10T09:05:17.467325Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<U6\n",
      "|S1\n"
     ]
    }
   ],
   "source": [
    "arrString = np.array(['apple', 'orange', 'berry'])\n",
    "arrIntAsString = np.array([1, 2, 3], dtype='S')\n",
    "\n",
    "print(arrString.dtype)\n",
    "print(arrIntAsString.dtype)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-10T09:05:35.249065Z",
     "start_time": "2023-07-10T09:05:35.213221Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# conversion"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "int64\n"
     ]
    }
   ],
   "source": [
    "# astype, copy the array, then converts!\n",
    "\n",
    "arrIntFromString = arrIntAsString.astype(dtype='i8')\n",
    "\n",
    "print(arrIntFromString)\n",
    "print(arrIntFromString.dtype)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T20:40:43.272637Z",
     "start_time": "2023-07-04T20:40:43.214372Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True  True  True]\n"
     ]
    }
   ],
   "source": [
    "arrBool = arrIntAsString.astype(dtype=bool)\n",
    "\n",
    "print(arrBool)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T20:40:43.273074Z",
     "start_time": "2023-07-04T20:40:43.223083Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## copy"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20  4  1  6 83 10]\n",
      "[ 2  4  1  6 83 10]\n",
      "[20  4  1  6 83 10]\n",
      "None\n",
      "[20  4  1  6 83 10]\n"
     ]
    }
   ],
   "source": [
    "original = np.array([2, 4, 1, 6, 83, 10])\n",
    "\n",
    "x = original.copy()  #new array\n",
    "y = original.view()  #same pointer as original\n",
    "\n",
    "original[0] = 20\n",
    "\n",
    "print(original)\n",
    "print(x)   #copy - as a new array\n",
    "print(y)   #view - bound to the original\n",
    "\n",
    "print(x.base)   #does it own the original\n",
    "print(y.base)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T20:49:39.199776Z",
     "start_time": "2023-07-04T20:49:39.177338Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6,)\n"
     ]
    }
   ],
   "source": [
    "print(original.shape)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T20:51:57.772559Z",
     "start_time": "2023-07-04T20:51:57.749682Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## reshaping (increasing the dimension)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'original' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mNameError\u001B[0m                                 Traceback (most recent call last)",
      "Cell \u001B[0;32mIn[31], line 3\u001B[0m\n\u001B[1;32m      1\u001B[0m \u001B[38;5;66;03m# original is 1-d and 6 elements\u001B[39;00m\n\u001B[0;32m----> 3\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[43moriginal\u001B[49m\u001B[38;5;241m.\u001B[39msize)    \u001B[38;5;66;03m# 6 elements\u001B[39;00m\n\u001B[1;32m      5\u001B[0m originalReshaped \u001B[38;5;241m=\u001B[39m original\u001B[38;5;241m.\u001B[39mreshape(\u001B[38;5;241m2\u001B[39m, \u001B[38;5;241m3\u001B[39m)   \u001B[38;5;66;03m# (2 * 3) = 6 !!!\u001B[39;00m\n\u001B[1;32m      7\u001B[0m \u001B[38;5;28mprint\u001B[39m(originalReshaped)     \u001B[38;5;66;03m# returns a view (the original!!)\u001B[39;00m\n",
      "\u001B[0;31mNameError\u001B[0m: name 'original' is not defined"
     ]
    }
   ],
   "source": [
    "# original is 1-d and 6 elements\n",
    "\n",
    "print(original.size)    # 6 elements\n",
    "\n",
    "originalReshaped = original.reshape(2, 3)   # (2 * 3) = 6 !!!\n",
    "\n",
    "print(originalReshaped)     # returns a view (the original!!)\n",
    "print(originalReshaped.shape)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-10T09:07:42.310736Z",
     "start_time": "2023-07-10T09:07:42.252155Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## flatting (decreasing the dimension to 1D !)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "[1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "#\n",
    "print(twoD)  # 2-d array\n",
    "\n",
    "twoDFlat = twoD.reshape(-1)  # make it 1-d\n",
    "\n",
    "print(twoDFlat)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T21:07:36.899209Z",
     "start_time": "2023-07-04T21:07:36.883375Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5,)\n",
      "(2, 3)\n",
      "(2, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "print(arr.shape)\n",
    "print(twoD.shape)\n",
    "print(threeD.shape)\n",
    "\n",
    "# (x, y, z)\n",
    "# x * y * z = total => means element count\n",
    "# x, y, z count is 3 => means 3-d\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T21:14:27.335406Z",
     "start_time": "2023-07-04T21:14:27.321620Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## iteration"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "print(arr)\n",
    "\n",
    "for i in arr:  # kinda foreach\n",
    "    print(i)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T21:24:46.117176Z",
     "start_time": "2023-07-04T21:24:46.100858Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "print(twoD)\n",
    "\n",
    "for x in twoD:\n",
    "    for y in x:\n",
    "        print(y)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T21:19:59.498252Z",
     "start_time": "2023-07-04T21:19:59.482939Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 1  2  3]\n",
      "  [ 4  5  6]]\n",
      "\n",
      " [[ 7  8  9]\n",
      "  [10 11 12]]]\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "print(threeD)\n",
    "\n",
    "for x in threeD:\n",
    "    for y in x:\n",
    "        for z in y:\n",
    "            print(z)\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T21:25:06.556868Z",
     "start_time": "2023-07-04T21:25:06.543505Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "# more optimized way! esp. for N-d arrays\n",
    "for x in np.nditer(threeD):\n",
    "    print(x)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T21:24:58.567910Z",
     "start_time": "2023-07-04T21:24:58.537614Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## enumeration (index, value)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0,) - 1\n",
      "(1,) - 2\n",
      "(2,) - 3\n",
      "(3,) - 4\n",
      "(4,) - 5\n"
     ]
    }
   ],
   "source": [
    "# enumeration (index, value)\n",
    "\n",
    "for equality, x in np.ndenumerate(arr):\n",
    "    print(equality, '-', x)\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T21:39:46.792204Z",
     "start_time": "2023-07-04T21:39:46.783636Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 0) - 1\n",
      "(0, 1) - 2\n",
      "(0, 2) - 3\n",
      "(1, 0) - 4\n",
      "(1, 1) - 5\n",
      "(1, 2) - 6\n"
     ]
    }
   ],
   "source": [
    "for equality, x in np.ndenumerate(twoD):\n",
    "    print(equality, '-', x)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T21:40:03.956434Z",
     "start_time": "2023-07-04T21:40:03.944649Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## join _by axis_ or stack"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n",
      "[1 2 3 4 5 6]\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "x1 = np.array([1, 2, 3])\n",
    "x2 = np.array([4, 5, 6])\n",
    "\n",
    "j = np.concatenate((x1, x2), axis=0)  #1 dim, max_axis=1 !\n",
    "J = np.hstack((x1, x2))\n",
    "K = np.vstack((x1, x2))\n",
    "\n",
    "print(j)\n",
    "print(J)\n",
    "print(K)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-09T13:10:11.104574Z",
     "start_time": "2023-07-09T13:10:11.075792Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]\n",
      " [7 8]]\n",
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]\n",
      " [7 8]]\n",
      "[[1 2 5 6]\n",
      " [3 4 7 8]]\n",
      "[[1 2 5 6]\n",
      " [3 4 7 8]]\n"
     ]
    }
   ],
   "source": [
    "t1 = np.array([[1, 2],\n",
    "               [3, 4]])    #shape => (2,2)\n",
    "t2 = np.array([[5, 6],\n",
    "               [7, 8]])\n",
    "\n",
    "j1 = np.concatenate((t1, t2), axis=0)  #vertical\n",
    "J1 = np.vstack((t1, t2))\n",
    "\n",
    "j2 = np.concatenate((t1, t2), axis=1)  #horizontal\n",
    "J2 = np.hstack((t1, t2))\n",
    "\n",
    "print(j1); print(J1)\n",
    "print(j2); print(J2)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T22:39:56.503326Z",
     "start_time": "2023-07-04T22:39:56.480768Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "outputs": [],
   "source": [
    "k1 = np.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]]])\n",
    "k2 = np.array([[[19, 20, 21], [22, 23, 24], [25, 26, 27], [28, 29, 130], [31, 32, 33], [34, 35, 36]]])\n",
    "\n",
    "# k-shape => (1,6,3)\n",
    "\n",
    "jX =  np.concatenate((k1, k2), axis=0) #vertical   = .vstack(\n",
    "jY =  np.concatenate((k1, k2), axis=1) #horizontal = .hstack(\n",
    "jZ =  np.concatenate((k1, k2), axis=2) #sliced     = .dstack(\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T22:21:53.169584Z",
     "start_time": "2023-07-04T22:21:53.165023Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 6, 3)\n",
      "[[[  1   2   3]\n",
      "  [  4   5   6]\n",
      "  [  7   8   9]\n",
      "  [ 10  11  12]\n",
      "  [ 13  14  15]\n",
      "  [ 16  17  18]]\n",
      "\n",
      " [[ 19  20  21]\n",
      "  [ 22  23  24]\n",
      "  [ 25  26  27]\n",
      "  [ 28  29 130]\n",
      "  [ 31  32  33]\n",
      "  [ 34  35  36]]]\n"
     ]
    }
   ],
   "source": [
    "print(jX.shape)\n",
    "\n",
    "print(jX)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T22:09:29.286271Z",
     "start_time": "2023-07-04T22:09:29.270315Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 12, 3)\n",
      "[[[  1   2   3]\n",
      "  [  4   5   6]\n",
      "  [  7   8   9]\n",
      "  [ 10  11  12]\n",
      "  [ 13  14  15]\n",
      "  [ 16  17  18]\n",
      "  [ 19  20  21]\n",
      "  [ 22  23  24]\n",
      "  [ 25  26  27]\n",
      "  [ 28  29 130]\n",
      "  [ 31  32  33]\n",
      "  [ 34  35  36]]]\n"
     ]
    }
   ],
   "source": [
    "print(jY.shape)\n",
    "print(jY)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T22:10:43.859279Z",
     "start_time": "2023-07-04T22:10:43.833363Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 6, 6)\n",
      "[[[  1   2   3  19  20  21]\n",
      "  [  4   5   6  22  23  24]\n",
      "  [  7   8   9  25  26  27]\n",
      "  [ 10  11  12  28  29 130]\n",
      "  [ 13  14  15  31  32  33]\n",
      "  [ 16  17  18  34  35  36]]]\n"
     ]
    }
   ],
   "source": [
    "print(jZ.shape)\n",
    "print(jZ)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-04T22:10:37.596329Z",
     "start_time": "2023-07-04T22:10:37.588923Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## split"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([1, 2]), array([3, 4]), array([5, 6])]\n",
      "[1 2]\n",
      "1\n",
      "[array([1, 2]), array([3, 4]), array([5, 6])]\n"
     ]
    }
   ],
   "source": [
    "# number of split as parameter\n",
    "\n",
    "s = np.array([1, 2, 3, 4, 5, 6])\n",
    "splitArray = np.array_split(s, 3)    #splits into array of arrays! no dimension increase!\n",
    "split = np.split(s, 3)               #same as array_split, but it cannot divide into such as 4 !\n",
    "\n",
    "\n",
    "print(splitArray)\n",
    "print(splitArray[0])\n",
    "print(splitArray[0][0])\n",
    "\n",
    "print(split)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-05T08:15:07.048175Z",
     "start_time": "2023-07-05T08:15:07.026028Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([[1, 2],\n",
      "       [3, 4]]), array([[5, 6],\n",
      "       [7, 8]])]\n",
      "[array([[1],\n",
      "       [3],\n",
      "       [5],\n",
      "       [7]]), array([[2],\n",
      "       [4],\n",
      "       [6],\n",
      "       [8]])]\n"
     ]
    }
   ],
   "source": [
    "k = np.array([[1, 2],\n",
    "              [3, 4],\n",
    "              [5, 6],\n",
    "              [7, 8]])    # shape => 4 * 2\n",
    "\n",
    "# print(k.shape)\n",
    "\n",
    "kk = np.array_split(k, 2, axis=0)    #axis=0 vertical is the default\n",
    "\n",
    "kkkkk = np.array_split(k, 2, axis=1)  #\n",
    "\n",
    "print(kk)\n",
    "# print(kk[0].shape)        # shape => 2 * 2\n",
    "\n",
    "print(kkkkk)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-05T08:34:42.050911Z",
     "start_time": "2023-07-05T08:34:42.039456Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## search"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([ 3,  4, 11]),)\n",
      "(array([ 1,  3,  4,  6,  8, 10, 11]),)\n"
     ]
    }
   ],
   "source": [
    "#where\n",
    "i = np.array([1, 2, 3, 4, 4, 5, 6, 7, 8, 9, 10, 4])\n",
    "\n",
    "equality = np.where(i == 4)   #returns idx !\n",
    "mod = np.where( i%2 == 0)\n",
    "\n",
    "\n",
    "print(equality)        # print(i[equality[0][0]])\n",
    "print(mod)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-05T08:41:55.769488Z",
     "start_time": "2023-07-05T08:41:55.763191Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "[3 5]\n"
     ]
    }
   ],
   "source": [
    "#searchsorted - only if, in a sorted array!!\n",
    "i = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])\n",
    "\n",
    "equality = np.searchsorted(i, v = 4)       #returns idx !\n",
    "equalityForVs = np.searchsorted(i, [4, 6])\n",
    "\n",
    "print(equality)\n",
    "print(equalityForVs)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-05T09:33:32.804496Z",
     "start_time": "2023-07-05T09:33:32.795014Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### sorting"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  2  3  4  4  4  5  6  7  8  9 10]\n",
      "['apple' 'banana' 'cherry']\n",
      "[[2 3 4]\n",
      " [0 1 5]]\n"
     ]
    }
   ],
   "source": [
    "i = np.array([1, 2, 3, 4, 4, 5, 6, 7, 8, 9, 10, 4])\n",
    "s = np.array(['banana', 'cherry', 'apple'])\n",
    "twoD = np.array([[3, 2, 4], [5, 0, 1]])\n",
    "\n",
    "print(np.sort(i))\n",
    "print(np.sort(s))\n",
    "print(np.sort(twoD))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-05T09:38:19.329463Z",
     "start_time": "2023-07-05T09:38:19.322530Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### filtering  - _search and get a new array_"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['banana' 'apple']\n"
     ]
    }
   ],
   "source": [
    "# search and get a new array !\n",
    "\n",
    "s = np.array(['banana', 'cherry', 'apple'])\n",
    "f = [True, False, True]\n",
    "\n",
    "print(s[f])"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-05T09:42:01.976918Z",
     "start_time": "2023-07-05T09:42:01.970324Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['banana']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "fEnhanced = []\n",
    "\n",
    "for e in s:\n",
    "    if str.startswith(e, 'b') :\n",
    "        fEnhanced.append(True)\n",
    "    else:\n",
    "        fEnhanced.append(False)\n",
    "\n",
    "print(s[fEnhanced])"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-07-05T09:46:27.753468Z",
     "start_time": "2023-07-05T09:46:27.685539Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}