05-Cap03-Operacoes-Matematicas-Arrays-Matrizes-Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dentro do np Arrays e matrizes são ligeiramente diferentes\n",
    "### Arrays NumPy - objetos multidimensionais com N dimensões.\n",
    "### Matrizes NumPy - objetos com 2 dimensões. \n",
    "\n",
    "A principal vantagem de utilizar matrizes com NumPy, é que este tipo de objeto possui convenientes notações para multiplicação de matrizes.\n",
    "Arrays e Matrizes NumPy possuem o atributo .T para retornar a transposta da matriz, enquanto objetos do tipo matriz possuem adicionalmente os atributos .I (Inversa) e .H (Transposta Conjugada).\n",
    "\n",
    "Em determinados momentos dentro do processo de manipulação e organização de dados pode ser necessário realizar operações matemáticas de arrays com matrizes. \n",
    "\n",
    "Podemos chamar uma matriz com duas dimensões de Array? SIM. \n",
    "Temos matrizes com 3, 4, 5 dimensões... Matematicamente não mudamos o conceito. ENTRETANTO, em termos de organização os desenvolvedores do NumPy dividiram Métodos, Atributos e operações de álgebra linear diferentes para cada estrutura de dados.\n",
    "\n",
    "    • Métodos e atributos para objetos do tipo Matriz bidimensional\n",
    "    • Métodos e atributos para objetos do tipo Array multitidimensional\n",
    "\n",
    "**Muitas funções NumPy RETORNAM ARRAYS e não matrizes como objeto resultante.\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.7.6 (default, Jan  8 2020, 20:23:39) [MSC v.1916 64 bit (AMD64)]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'1.18.1'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "import numpy as np\n",
    "print(sys.version)\n",
    "np.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Criando Matrizes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "# Função np.matrix(\"antes do p.virgula uma linha ; depois do p.virgula outra linha\")\n",
    "mat1 = np.matrix(\"1,2,3; 4,5,6\")\n",
    "print(mat1) # Matriz duas linhas, três colunas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.matrix"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(mat1) #Tipo matriz NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "# Função np.matrix\n",
    "mat2 = np.matrix( [ [1,2,3], [4,5,6] ] ) # [[Lista] de ListaS]\n",
    "print(mat2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0 10  0  0  0]\n",
      " [ 0  0 20  0  0]\n",
      " [ 0  0  0 30  0]\n",
      " [ 0  0  0  0 40]\n",
      " [ 0  0  0  0  0]]\n"
     ]
    }
   ],
   "source": [
    "# Função np.matrix\n",
    "mat3 = np.matrix([ [0,10,0,0,0], [0,0,20,0,0], [0,0,0,30,0], [0,0,0,0,40], [0,0,0,0,0] ]) \n",
    "print(mat3) #Matriz de cinco listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.matrix"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(mat3) #Tipo Matriz NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat3[2, 3] #Fatiamento de matriz, 3a linha, 4a coluna"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operações Matemáticas com Arrays e Matrizes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Criar array Numpy\n",
    "a = np.array([[1,2],[3,4]])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a) # Tipo Array NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * a # Multplicação entre dois Arryas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 2],\n",
       "        [3, 4]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Transformar o Array em Matriz com a função np.mat()\n",
    "A = np.mat(a) \n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.matrix"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(A) # Tipo Matriz NumPy agora com métodos e atributos diferentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 7, 10],\n",
       "        [15, 22]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * A # Multiplicação entre duas Matrizes é DIFERENTE. \n",
    "# A Multiplicação dos Arrays é entre seus CORRESPONDENTES. \n",
    "# A Multiplicação de Matrizes é entre cada linha da 1a matriz por cada coluna da 2a matriz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## $$  \\boxed{ \\begin{align} \\begin{pmatrix} 1 & 2    \\\\ 3 &  4   \\end{pmatrix} & \\begin{pmatrix} 1 & 2    \\\\ 3 &  4   \\end{pmatrix}  = \\begin{pmatrix} 7 & 10    \\\\ 15 &  22   \\end{pmatrix} \\end{align} }$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image('imagens/Matriz.png')\n",
    "# primeira linha da m1 por primeira columa m2\n",
    "# segunda linha da m1 por primeira coluna m2\n",
    "# primeira"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7, 10],\n",
       "       [15, 22]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Em Machine Learning a multplicação de matrizes é MASSIVA.\n",
    "#Esta técnica se chama \"dot product\" produto do ponto\n",
    "np.dot(a, a) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convertendo um Array para Matriz\n",
    "mat5 = np.asmatrix(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 2],\n",
       "        [3, 4]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 7, 10],\n",
       "        [15, 22]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat5 * mat5 # Multiplicação entre matriz dot.product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convertendo uma Matriz para Array\n",
    "array2 = np.asarray(mat5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array2 * array2"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}