EX_04/ex_04_numpy_1.ipynb

{
 "metadata": {
  "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.7.3-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python37364bit49a3f827a4fd4d76955e1d5e29591a46",
   "display_name": "Python 3.7.3 64-bit"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Hello numpy!\n"
    }
   ],
   "source": [
    "print(\"Hello numpy!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PYTHON REVIEW o/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Python Review!\n",
    "# Function\n",
    "def times2(var):\n",
    "    return var*2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "10"
     },
     "metadata": {},
     "execution_count": 3
    }
   ],
   "source": [
    "times2(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(num):\n",
    "    '''\n",
    "    THIS IS DOCSTRING,\n",
    "    CAN GO MULTIPLE LINES\n",
    "    THIS FUNCTION SQUARES A NUMBER.\n",
    "    '''\n",
    "    return num**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "25"
     },
     "metadata": {},
     "execution_count": 5
    }
   ],
   "source": [
    "square(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MAP in PYTHON"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq=[1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "[2, 4, 6, 8, 10]"
     },
     "metadata": {},
     "execution_count": 7
    }
   ],
   "source": [
    "list(map(times2,seq))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LAMBDA in PYTHON"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=lambda var:var*2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "10"
     },
     "metadata": {},
     "execution_count": 9
    }
   ],
   "source": [
    "l(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "FILTER in PYTHON"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "[2, 4]"
     },
     "metadata": {},
     "execution_count": 10
    }
   ],
   "source": [
    "list(filter(lambda num:num%2==0, seq))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "STRING in PYTHON"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "s='hello my name is j3!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "'HELLO MY NAME IS J3!'"
     },
     "metadata": {},
     "execution_count": 12
    }
   ],
   "source": [
    "s.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "'hello my name is j3!'"
     },
     "metadata": {},
     "execution_count": 13
    }
   ],
   "source": [
    "s.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "'Hello my name is j3!'"
     },
     "metadata": {},
     "execution_count": 14
    }
   ],
   "source": [
    "s.capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "tweet='Go Sports!#Sport'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "'Go Sports!'"
     },
     "metadata": {},
     "execution_count": 16
    }
   ],
   "source": [
    "tweet.split('#')[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "'Sport'"
     },
     "metadata": {},
     "execution_count": 17
    }
   ],
   "source": [
    "tweet.split('#')[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of times the word 'dog' occurs in a string\n",
    "def countDog(phrase):\n",
    "    count=0\n",
    "    for word in phrase.lower().split():\n",
    "        if word == 'dog':\n",
    "            count+=1\n",
    "    return count\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "2"
     },
     "metadata": {},
     "execution_count": 19
    }
   ],
   "source": [
    "countDog('This dog runs faster than the other dog')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq=['soup', 'dog','salad','cat','gread']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "['soup', 'salad']"
     },
     "metadata": {},
     "execution_count": 21
    }
   ],
   "source": [
    "list(filter(lambda var:var[0]=='s', seq))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DICTIONARY in PYTHON"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "d={'key1':1, 'key2':2}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "dict_keys(['key1', 'key2'])"
     },
     "metadata": {},
     "execution_count": 23
    }
   ],
   "source": [
    "d.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "dict_items([('key1', 1), ('key2', 2)])"
     },
     "metadata": {},
     "execution_count": 24
    }
   ],
   "source": [
    "d.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "dict_values([1, 2])"
     },
     "metadata": {},
     "execution_count": 25
    }
   ],
   "source": [
    "d.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LIST in PYTHON"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst=[1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "item=lst.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "[1, 2]"
     },
     "metadata": {},
     "execution_count": 28
    }
   ],
   "source": [
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "3"
     },
     "metadata": {},
     "execution_count": 29
    }
   ],
   "source": [
    "item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.append(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "[1, 2, 3]"
     },
     "metadata": {},
     "execution_count": 31
    }
   ],
   "source": [
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TUPLE UNPACKING in PYTHON \n",
    "\n",
    "Python tuples are immutable means that they can not be modified in the whole program.\n",
    "\n",
    "Packing and Unpacking a Tuple: In Python, there is a very powerful tuple assignment feature that assigns the right-hand side of values into the left-hand side. In another way, it is called the unpacking of a tuple of values into a variable. In packing, we put values into a new tuple while in unpacking we extract those values into a single variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=[(1,2),(3,4),(5,6)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "1"
     },
     "metadata": {},
     "execution_count": 33
    }
   ],
   "source": [
    "x[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "list"
     },
     "metadata": {},
     "execution_count": 34
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "(1, 2)\n(3, 4)\n(5, 6)\n"
    }
   ],
   "source": [
    "for item in x:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "2 3\n4 5\n6 7\n"
    }
   ],
   "source": [
    "for (a,b) in x:\n",
    "    print(a+1, b+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "1\n3\n5\n"
    }
   ],
   "source": [
    "for a,b in x:\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "2\n4\n6\n"
    }
   ],
   "source": [
    "for a, b in x:\n",
    "    print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NUMPY\n",
    "\n",
    "Numpy is The fundamental Package for Scientific Computing with Python!\n",
    "\n",
    "The reason it is so important for Data Science with Python is that a lot of all the libraries in the Python Ecosystem rely on NUMPY as one of their main building blocks (Jose Portilla — Python For Data Science course).\n",
    "\n",
    "https://www.udemy.com/course/python-for-data-science-and-machine-learning-bootcamp/\n",
    "\n",
    "NUMPY ARRAYS . vectors (1-dimensional)\n",
    "             . matrices (1 or more dimensionals)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([1, 2, 3])"
     },
     "metadata": {},
     "execution_count": 39
    }
   ],
   "source": [
    "# Vectors\n",
    "my_list=[1,2,3]\n",
    "import numpy as np \n",
    "vec=np.array(my_list)\n",
    "vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([[1, 2],\n       [3, 4],\n       [5, 6]])"
     },
     "metadata": {},
     "execution_count": 40
    }
   ],
   "source": [
    "# Matrices\n",
    "# 2 brackets mean 2-dimensional\n",
    "my_mat=[[1,2],[3,4],[5,6]]\n",
    "import numpy as np \n",
    "mat=np.array(my_mat)\n",
    "mat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ARANGE in NUMPY\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
     },
     "metadata": {},
     "execution_count": 41
    }
   ],
   "source": [
    "# From zero to all the way up but not including 10 (return a sequence)\n",
    "np.arange(0,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([0, 2, 4, 6, 8])"
     },
     "metadata": {},
     "execution_count": 42
    }
   ],
   "source": [
    "# The third paramenter means STEP SIZE\n",
    "np.arange(0,10,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ZEROES in NUMPY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([0., 0., 0.])"
     },
     "metadata": {},
     "execution_count": 43
    }
   ],
   "source": [
    "np.zeros(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([[0., 0., 0., 0., 0.],\n       [0., 0., 0., 0., 0.],\n       [0., 0., 0., 0., 0.],\n       [0., 0., 0., 0., 0.],\n       [0., 0., 0., 0., 0.]])"
     },
     "metadata": {},
     "execution_count": 44
    }
   ],
   "source": [
    "np.zeros((5,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ONES in NUMPY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([1., 1., 1., 1.])"
     },
     "metadata": {},
     "execution_count": 45
    }
   ],
   "source": [
    "np.ones(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([[1., 1., 1., 1.],\n       [1., 1., 1., 1.],\n       [1., 1., 1., 1.]])"
     },
     "metadata": {},
     "execution_count": 46
    }
   ],
   "source": [
    "np.ones((3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LINSPACE (SPACED EVENLY) in NUMPY "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([0.        , 0.55555556, 1.11111111, 1.66666667, 2.22222222,\n       2.77777778, 3.33333333, 3.88888889, 4.44444444, 5.        ])"
     },
     "metadata": {},
     "execution_count": 47
    }
   ],
   "source": [
    "# From zero to 5 returning 10 points evenly spaced!\n",
    "np.linspace(0,5,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PLEASE DON’T CONFUSE linspace WITH arange:\n",
    "\n",
    "arange: will take in the third argument as the STEPS SIZE (you want)\n",
    "\n",
    "linspace: will take in the third argument as the NUMBER OF POINTS(evenly separated)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "IDENTITY in NUMPY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([[1., 0., 0., 0.],\n       [0., 1., 0., 0.],\n       [0., 0., 1., 0.],\n       [0., 0., 0., 1.]])"
     },
     "metadata": {},
     "execution_count": 48
    }
   ],
   "source": [
    "np.eye(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "RANDOM in NUMPY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([0.28977373, 0.84703946, 0.92282731, 0.71127506, 0.42314512])"
     },
     "metadata": {},
     "execution_count": 49
    }
   ],
   "source": [
    "# RAND differs from ARANGE because RAND returns random numbers and ARANGE return a sequence of them\n",
    "np.random.rand(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([-1.59483751, -0.95157664])"
     },
     "metadata": {},
     "execution_count": 50
    }
   ],
   "source": [
    "#  n means Normal Distribution (return values around the Mean in gaussian distribution)\n",
    "np.random.randn(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "75"
     },
     "metadata": {},
     "execution_count": 51
    }
   ],
   "source": [
    "# Without the third parameter, it will return one digit \n",
    "np.random.randint(1,100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([ 9, 54, 53, 15, 38, 71, 94, 96, 38, 55])"
     },
     "metadata": {},
     "execution_count": 52
    }
   ],
   "source": [
    "# The third parameter specifuy the digits you want to return\n",
    "np.random.randint(1,100,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Difference between ARANGE and RANDINT:\n",
    "\n",
    "ARANGE: returns sequence of digits\n",
    "\n",
    "RANDINT: returns randonly selected digits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr=np.arange(25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n       17, 18, 19, 20, 21, 22, 23, 24])"
     },
     "metadata": {},
     "execution_count": 54
    }
   ],
   "source": [
    "# It is a sequence!\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "randarr=np.random.randint(0,50,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([42, 12, 13, 11, 20, 43, 11, 11, 24, 46])"
     },
     "metadata": {},
     "execution_count": 56
    }
   ],
   "source": [
    "# it is a matrix...\n",
    "randarr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "RESHAPE in NUMPY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([[42, 12],\n       [13, 11],\n       [20, 43],\n       [11, 11],\n       [24, 46]])"
     },
     "metadata": {},
     "execution_count": 57
    }
   ],
   "source": [
    "# ...that can be reshapped!\n",
    "randarr.reshape(5,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "46"
     },
     "metadata": {},
     "execution_count": 58
    }
   ],
   "source": [
    "randarr.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "11"
     },
     "metadata": {},
     "execution_count": 59
    }
   ],
   "source": [
    "randarr.min()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ATTRIBUTES in NUMPY\n",
    "\n",
    "(there are no Parentheses cuz this is attributes:)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "(10,)"
     },
     "metadata": {},
     "execution_count": 60
    }
   ],
   "source": [
    "randarr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "dtype('int32')"
     },
     "metadata": {},
     "execution_count": 61
    }
   ],
   "source": [
    "randarr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import randint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FUN LITTLE QUIZ\n",
    "ADVANCED INDEXING\n",
    "\n",
    "**SOLUTION Nº 01**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "[[1. 1. 1. 1. 1.]\n [1. 0. 0. 0. 1.]\n [1. 0. 9. 0. 1.]\n [1. 0. 0. 0. 1.]\n [1. 1. 1. 1. 1.]]\n"
    }
   ],
   "source": [
    "# CREATING MATRIX_A\n",
    "matrix_a=np.ones((5,5))\n",
    "z=np.zeros((3,3))\n",
    "z[1,1]=9\n",
    "matrix_a[1:4,1:4]=z\n",
    "print(matrix_a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**SOLUTION Nº 02**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([[1., 2., 3., 4., 5.],\n       [6., 7., 8., 9., 0.],\n       [1., 2., 3., 4., 5.],\n       [6., 7., 8., 9., 0.],\n       [1., 2., 3., 4., 5.]])"
     },
     "metadata": {},
     "execution_count": 64
    }
   ],
   "source": [
    "# Loading Matrix_B\n",
    "matrix_b=np.genfromtxt('matrix_b.txt', delimiter=',')\n",
    "matrix_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "[[1. 2.]\n [6. 7.]]\n"
    }
   ],
   "source": [
    "# RESCUE MATRIX_C\n",
    "matrix_c=matrix_b[2:4,0:2]\n",
    "print(matrix_c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "[2. 8. 4. 0.]\n"
    }
   ],
   "source": [
    "# RESCUE MATRIX_D\n",
    "matrix_d=matrix_b[[0,1,2,3],[1,2,3,4]]\n",
    "print(matrix_d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "[[3. 4. 5.]\n [3. 4. 5.]]\n"
    }
   ],
   "source": [
    "# RESCUE MATRIX_E \n",
    "matrix_e=matrix_b[[2,4],2:5]\n",
    "print(matrix_e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Thank you for reading this page! Please favorite it, IF YOU LIKE IT!\n"
    }
   ],
   "source": [
    "# LINK https://medium.com/jungletronics/numpy-init-python-review-f5362abbaaf9\n",
    "print(\"Thank you for reading this page! Please favorite it, IF YOU LIKE IT!\")"
   ]
  }
 ]
}