0-Python Científico.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Python Científico\n",
    "=================\n",
    "\n",
    "Neste _notebook_ estudaremos a sintaxe básica da linguagem Python e três de seus módulos científicos mais conhecidos: Numpy, scipy e matplotlib. O Python científico será utilizado durante todo o curso na implementação de algoritmos e visualização de dados referentes à disciplina de métodos numéricos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Variáveis\n",
    "---------\n",
    "\n",
    "Variáveis são utilizadas para armazenar e trabalhar com diferentes tipos de dados. Python é uma linguagem de tipagem dinâmica, o usuário não especifica o tipo de dado que será atribuído à cada variável. Porém, a tipagem de Python é forte, as variáveis tem tipos bem definidos. Alguns tipos de dados:\n",
    "\n",
    "* **Inteiros:** podem assumir valores numéricos inteiros positivos e negativos.\n",
    "\n",
    "* **Pontos flutuantes:** podem assumir valores numéricos reais.\n",
    "\n",
    "* **Booleanos:** só podem assumir dois valores, **True** ou **False**.\n",
    "\n",
    "Variáveis podem armazenar valores inteiros, de ponto flutuante e booleanos da seguinte maneira:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "my_int = 15\n",
    "my_float = 17.52\n",
    "my_bool = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Lembrando que valores numéricos em Python tem precisão arbitrária, ou seja, não tem tamanho limite, sendo limitados apenas pela quantidade de memória."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Indentação\n",
    "----------\n",
    "\n",
    "Em Python, os blocos de código são diferenciados por seu nível de indentação, e não por chaves, como na linguagem C. Por isso, é necessário que todo o código tenha uma indentação correta para que ele seja executado. Abaixo são mostrados trechos de código indentados de forma incorreta e correta, respectivamente.\n",
    "\n",
    "``` Python\n",
    "# Código incorreto, não irá funcionar\n",
    "def hello_world():\n",
    "return 'hello world'\n",
    "print(hello_world())\n",
    "```\n",
    "\n",
    "O código acima irá gerar o seguinte erro: `IndentationError: expected an indented block`. Para corrigir este problema, é preciso indentar a função _hello\\_world()_, como visto abaixo:\n",
    "\n",
    "``` Python\n",
    "# Código correto\n",
    "def hello_world():\n",
    "\treturn 'hello world'\n",
    "print(hello_world())\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Comentários\n",
    "-----------\n",
    "\n",
    "Comentários são trechos de código ignorados pelo interpretador. Existem dois tipos de comentários em Python: de única linha e de múltiplas linhas, como visto abaixo.\n",
    "\n",
    "``` Python\n",
    "# Comentários de única linha\n",
    "\n",
    "\"\"\" Comentários de\n",
    "múltiplas linhas.\n",
    "\"\"\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Operações Aritméticas\n",
    "---------------------\n",
    "\n",
    "As operações aritméticas são utilizadas para a manipulação matemática de qualquer variável numérica. Operações aritméticas básicas: `+`, `-`, `*`, `/`, `**` e `%`.\n",
    "\n",
    "``` Python\n",
    "soma = 72 + 23\n",
    "subtracao = 108 - 204\n",
    "multiplicacao = 108 * 0.5\n",
    "divisao = 108 / 9\n",
    "exponenciacao = 15 ** 3\n",
    "modulo = 16 % 5\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Strings\n",
    "-------\n",
    "\n",
    "String é um tipo de dado utilizado para armazenar e manipular texto. Uma string pode ser declarada em Python entre aspas simples ou duplas ou entre três aspas simples ou duplas, para declaração de string em múltiplas linhas. Como no exemplo abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "str1 = 'It\\'s easy to code in Python!'\n",
    "str2 = \"Python strings\"\n",
    "str3 = '''Some\n",
    "\t\tPython code'''\n",
    "str4 = \"\"\"One\n",
    "\t\tmore time\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "É possível acessar caracteres individuais de uma string através de seu índice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "str = 'python'\n",
    "p = str[0]\n",
    "n = str[5]\n",
    "print(str, p, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "É possível aplicar uma série de métodos às strings para modificá-las. Os métodos mais básicos são:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Retorna o tamanho da string\n",
    "len(str)\n",
    "\n",
    "# Retorna string 'str' em letras minúsculas\n",
    "print(str.lower())\n",
    "\n",
    "# Retorna string 'str' em letras maiúsculas\n",
    "print(str.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "É possível ainda concatenar e formatar strings em python utilizando os caracteres `+` e `%`, respectivamente, como visto abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Concatenando strings\n",
    "str = 'string 1' + 'string 2' + 'string 3'\n",
    "print(str)\n",
    "\n",
    "# Formatando strings\n",
    "str = 'Valores do %s: x = %d, y = %.1f' % ('vetor A', 15, 3.5)\n",
    "print(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Estruturas condicionais\n",
    "-----------------------\n",
    "\n",
    "Estruturas condicionais são utilizadas para mudar o comportamento de um programa de acordo com um conjunto específico de condições. Para checar tais condições, o Python fornece a estrutura **if-else**, comparadores e operadores booleanos.\n",
    "\n",
    "* Comparadores: `<`, `<=`, `>`, `>=`, `==` e `!=`.\n",
    "* Operadores Booleanos: `and`, `or` e `not`.\n",
    "\n",
    "Sintaxe `if-else` para Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "condicao1 = False\n",
    "condicao2 = True\n",
    "\n",
    "if (condicao1):\n",
    "    print('Condição 1 é verdadeira')\n",
    "elif (condicao2):\n",
    "    print('Condição 1 é falsa e condição 2 é verdadeira')\n",
    "else:\n",
    "    print('Ambas a condições são falsas')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Funções\n",
    "-------\n",
    "\n",
    "Uma função é um bloco de código utilizado para realizar uma tarefa específica. Funções são reutilizáveis e garantem melhor modulariazção e baixo acoplamento para sua aplicação. O Python provê uma série de funções prontas, como o **print()**. Também é possível criar e utilizar funções, as chamadas funções definidas por usuário. A sintaxe para criação de uma função em Python é a seguinte:\n",
    "\n",
    "``` Python\n",
    "def nome_da_funcao ( PARAMETROS ):\n",
    "\t\"\"\" Texto de documentação da função. \"\"\"\n",
    "\tDECLARACOES\n",
    "\treturn EXPRESSAO\n",
    "```\n",
    "\n",
    "Utilizemos a função abaixo como exemplo, para estudar um pouco mais sobre funções."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def area_quadrilatero( b=1, h=1 ):\n",
    "    \"\"\"\n",
    "    Calcula a área de um quadrilátero de de base _b_ e altura _h_.\n",
    "    Args:\n",
    "        b: a base do quadrilátero\n",
    "        h: a altura do quadrilátero   \n",
    "    Retuns:\n",
    "        Retorna a área de um quadrilátero.\n",
    "    \"\"\"\n",
    "    return b * h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "O padrão é que, na chamada da função, cada parâmetro seja passado de acordo com sua ordem de declaração."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "A = area_quadrilatero(3, 7)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Utilizando a ordem de declaração, podemos ocultar alguns parâmetros. Neste caso, o parâmetro ocultado irá receber seu valor padrão, de acordo com a declaração da função."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "A = area_quadrilatero(3)\n",
    "print(A) # A = 3, pois o parâmetro _h_ foi ocultado e seu valor padrão é 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Ainda é possível explicitar a ordem de inserção dos parâmetros, evidenciando o nome das variáveis, conforme o exemplo abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "A = area_quadrilatero(h=3, b=6)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "As funções são documentadas através de seu _Texto de Documentação_, para acessar a documentação de uma função, utilize a função **\\_\\_doc\\_\\_**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "print(area_quadrilatero.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Módulos\n",
    "-------\n",
    "\n",
    "Um módulo é um arquivo com código Python. Dentro desse arquivo, pode-se definir funções, classes, variáveis e constantes. Módulos também podem incluir código executável.\n",
    "\n",
    "Os módulos são utilizados para organizar um código Python, geralmente funções e constantes relacionadas são agrupadas em um mesmo módulo e este módulo é importado para o código principal. Os módulos fazem com que um código seja mais fácil de ser entendido e utilizado.\n",
    "\n",
    "Qualquer código fonte pode ser importado como um módulo utilizando o comando **import**. Para que o módulo seja importado, ele precisa ser encontrado pelo interpretador Python, o interpretador irá procurar por módulos na seguinte sequência:\n",
    "\n",
    "* Diretório atual;\n",
    "* Lista de diretórios presentes na variável de ambiente _PYTHONPATH_;\n",
    "* Diretório padrão, comumente localizado em `/usr/local/lib/python/` em sistemas Unix-like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Exemplo: importando o módulo Numpy\n",
    "import numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Neste caso, todas as funções e constantes do módulo _Numpy_ só são reconhecidas com o prefixo **Numpy.**, da seguinte forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Exemplo: utilizando a função seno e constante PI do módulo Numpy\n",
    "a = numpy.sin( 2.0 * numpy.pi / 3.0 )\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Para renomear o módulo _Numpy_ na importação, basta utilizar a palavra reservada **as**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "a = np.sin( 2.0 * np.pi / 3.0 )\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Também é possível importar funções e constantes específicas de um módulo utilizando a palavra reservada **from**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "from numpy import sin, pi\n",
    "a = sin( 2.0 * pi / 3.0 )\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Estruturas de repetição\n",
    "-----------------------\n",
    "\n",
    "Em geral, programas são executados de forma sequencial. Porém, existem situações onde é preciso executar um bloco de código diversas vezes. As estruturas de repetição nos permitem executar trechos de código quantas vezes desejarmos. A linguagem Python fornece duas estruturas de repetição, os laços **for** e **while**.\n",
    "\n",
    "O laço **for** processa cada item em uma sequência. Este laço é utilizado com tipos de dados que representam sequências em Python. Os mais comuns são: strings, listas e tuplas.\n",
    "\n",
    "Neste laço, a variável de loop recebe um item da sequência a cada vez que o bloco de declarações é executado. A forma geral do laço **for** é a seguinte:\n",
    "\n",
    "``` Python\n",
    "for VARIAVEL_DE_LOOP in SEQUENCIA:\n",
    "    DECLARACOES\n",
    "```\n",
    "\n",
    "O laço **while** executa um bloco de declarações enquanto uma dada condição é verdadeira. A forma geral do laço **while** é a seguinte:\n",
    "\n",
    "``` Python\n",
    "while CONDICAO:\n",
    "    DECLARACOES\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Numpy\n",
    "-----\n",
    "\n",
    "Numpy (http://www.numpy.org/) é um módulo fundamental para trabalhar com a computação científica em Python. Este módulo fornece um array multidimensional e diversas ferramentas para trabalhar com estes arrays. Entre as características do módulo _Numpy_, estão:\n",
    "\n",
    "* Objeto de array multidimensional;\n",
    "* Ferramentas de álgebra linear;\n",
    "* Ferramentas de Transformada de Fourier;\n",
    "* Ferramentas de geração de números aleatórios.\n",
    "\n",
    "Para utilizar o módulo _Numpy_, basta importá-lo. Neste _notebook_, o _Numpy_ será importado sempre da seguinte maneira:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Arrays\n",
    "\n",
    "Array é uma sequência de elementos do mesmo tipo, formando um conjunto n-dimensional. A forma do array pode ser visualizada através da função _shape()_, que retorna uma tupla com o tamanho do array em cada dimensão. Os arrays podem ser inicializados com listas e seus elementos podem ser acessados com colchetes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Declarando um array unidimensional com 3 elementos\n",
    "A = np.array([1, 2, 3])\n",
    "\n",
    "# Visualizando a forma do array A\n",
    "print(A.shape)\n",
    "\n",
    "# Visualizando o tipo de dados do array A\n",
    "print(A.dtype)\n",
    "\n",
    "# Acessando elementos individuais de A\n",
    "print(A[0], A[1], A[2])\n",
    "\n",
    "# Modificando o valor de um elemento de A\n",
    "A[1] = 10\n",
    "print(A)\n",
    "\n",
    "# Arrays bidimensionais\n",
    "B = np.array([[1,2,3],[4,5,6]])\n",
    "print(B, B.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "O _Numpy_ também fornece funções para **criação** de arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Criando: array([0, 1, 2, 3, 4, 5])\n",
    "A = np.arange(6)\n",
    "print(A)\n",
    "\n",
    "# Criando: array([[0, 1, 2], [3, 4, 5]])\n",
    "A = np.arange(6).reshape((2,3))\n",
    "print(A)\n",
    "\n",
    "# Criando um array com 10 valores linearmente espaçados entre 0 e 9\n",
    "A = np.linspace(0, 9, 10)\n",
    "print(A)\n",
    "\n",
    "# Criando um array de zeros\n",
    "A = np.zeros((2,3))\n",
    "print(A)\n",
    "\n",
    "# Criando um array de uns\n",
    "A = np.ones((2,3))\n",
    "print(A)\n",
    "\n",
    "# Criando um array de valores aleatórios\n",
    "A = np.random.random((2,3))\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "O **acesso aos elementos** de arrays multidimensionais é feito através de colchetes, é possível acessar tanto elementos específicos, quanto sub-arrays através do colchetes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Criando um array 3x3\n",
    "A = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "print(A)\n",
    "\n",
    "# Acessando um elemento específico\n",
    "b = A[1,2]\n",
    "print(b)\n",
    "\n",
    "# Acessando sub-arrays\n",
    "B = A[:2,:1]\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "É possível realizar **operações elemento a elemento** com arrays. As operações elemento a elemento são: soma (`+`), subtração (`-`), multiplicação (`*`) e divisão (`/`). Para realizar este tipo de operação, é preciso que os arrays tenham o mesmo tamanho em todas as dimensões ou um deles tenha tamanho 1 na dimensão. A figura abaixo ilustra o comportamento de somas de dois arrays com formas iguais e diferentes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "%%HTML\n",
    "<img src=\"Material Complementar/sum_array.png\", width=600>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Declarando dois arrays\n",
    "A = np.arange(6).reshape((2,3))\n",
    "B = np.ones((2,3))\n",
    "\n",
    "# Soma entre os arrays A e B\n",
    "print(A + B)\n",
    "\n",
    "# Subtração entre os arrays A e B\n",
    "print(A - B)\n",
    "\n",
    "# Multiplicação entre os arrays A e B\n",
    "print(A * B)\n",
    "\n",
    "# Divisão entre os arrays A e B\n",
    "print(A / B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "O _Numpy_ também pode ser utilizado para realizar **operações vetoriais** e **operações matriciais** em arrays. Entre elas, estão: produto interno, produto externo, produto escalar, matriz transposta e matriz inversa.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Declarando dois vetores (arrays unidimensionais)\n",
    "A = np.array([1, 2, 3, 4])\n",
    "B = np.array([2, 3, 5, 6])\n",
    "\n",
    "# Produto interno\n",
    "C = np.inner(A, B)\n",
    "print(C)\n",
    "\n",
    "# Produto externo\n",
    "C = np.outer(A, B)\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Declarando duas matrizes (arrays bidimensionais)\n",
    "A = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
    "B = np.array([[2, 3, 5, 6], [4, 1, 9, 0]])\n",
    "\n",
    "# Matriz Transposta\n",
    "C = A.T\n",
    "print(C)\n",
    "\n",
    "# Produto escalar\n",
    "C = np.dot(A, B.T)\n",
    "print(C)\n",
    "\n",
    "# Matriz inversa\n",
    "A = np.arange(4).reshape((2,2))\n",
    "C = np.linalg.inv(A)\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "O _Numpy_ conta com a função _solve()_ para resolver problemas do tipo $Ax = b$. A função funciona da seguinte forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Declarando A e b\n",
    "A = np.array([[1, 2, 3], [9, 4, 2], [6, 0, 1]])\n",
    "b = np.ones((3, 1))\n",
    "\n",
    "# Encontrando a solução do sistema linear\n",
    "x = np.linalg.solve(A, b)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Por fim, é possível iterar sobre um array. Neste caso, a variável de loop irá assumir o valor de cada linha do array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Declarando um array bidimensional\n",
    "A = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
    "\n",
    "# Iterando sobre os elementos de um array\n",
    "for row in A:\n",
    "    print(row)\n",
    "    for i in row:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "SciPy\n",
    "-----\n",
    "\n",
    "O SciPy (https://scipy.org/) é um módulo de algoritmos e ferramentas matemáticas feito para trabalhar com os array do Numpy em Python. Algumas as principais funções do SciPy é trabalhar com:\n",
    "\n",
    "* Álgebra Linear;\n",
    "* Estatística;\n",
    "* Problemas de Otimização;\n",
    "* Operações com Matrizes Esparsas;\n",
    "* Processamento de Sinais."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Matplotlib\n",
    "----------\n",
    "\n",
    "O Matplotlib (http://matplotlib.org/) é um módulo para a confecção de gráficos em Python. O Matplotlib inclui diversos outros módulos, neste _notebook_ será apresentado o `matplotlib.pyplot`. Este módulo funciona muito bem com o módulo _Numpy_ e sua sintaxe é bem próxima ao MatLab. Ele será importado da forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "O segundo comando foi necessário para habilitar a geração de gráfico no ambiente Jupyter Notebook.\n",
    "\n",
    "Para confeccionar gráficos, basta criar dois arrays, um para o eixo das abcsissas e outro para o eixo das coordenadas. Então utiliza-se a função _plot()_ para gerar o gráfico e a função _show()_ para mostrá-lo, conforme o exemplo abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Declarando arrays para a confecção do gráfico\n",
    "x = np.linspace(-5, 5, 100)\n",
    "y = np.power(x, 3)\n",
    "\n",
    "# Gerando o gráfico\n",
    "plt.plot(x, y)\n",
    "\n",
    "# Mostrando o gráfico\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Para acrescentar título, rótulos, grade e legendas ao gráfico, basta utilizar as funções _title()_, _xlabel()_, _ylabel()_, _grid()_ e _legend()_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Gerando o gráfico\n",
    "plt.plot(x, y)\n",
    "plt.title('Meu primeiro gráfico')\n",
    "plt.xlabel('eixo x: x')\n",
    "plt.ylabel('eixo y: f(x) = $x^3$')\n",
    "plt.grid(True)\n",
    "plt.legend(['y = $x^3$'])\n",
    "\n",
    "# Mostrando o gráfico\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Muitas vezes é preciso confeccionar um mesmo gráfico com diversas funções ou vários gráficos em uma mesma área de figura. Com o `pyplot` estes gráficos podem ser confeccionados utilizando a função _plot()_ repetidas vezes e a função _subplot()_, respectivamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Declarando arrays para a confecção dos gráficos\n",
    "x = np.linspace(-3, 3, 100)\n",
    "y1 = np.power(x, 2)\n",
    "y2 = np.power(x, 3)\n",
    "\n",
    "# Gerando os gráficos\n",
    "plt.plot(x, y1)\n",
    "plt.plot(x, y2)\n",
    "plt.title('Meu primeiro gráfico')\n",
    "plt.xlabel('eixo x: x')\n",
    "plt.ylabel('eixo y: f(x)')\n",
    "plt.grid(True)\n",
    "plt.legend(['y = $x^2$', 'y = $x^3$'])\n",
    "\n",
    "# Mostrando o gráfico\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Declarando arrays para a confecção dos gráficos\n",
    "x = np.linspace(-3, 3, 100)\n",
    "y1 = np.power(x, 2)\n",
    "y2 = np.power(x, 3)\n",
    "\n",
    "# Gerando os gráficos\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(x, y1)\n",
    "plt.title('Meu primeiro gráfico')\n",
    "plt.xlabel('eixo x: x')\n",
    "plt.ylabel('eixo y: f(x)')\n",
    "plt.grid(True)\n",
    "plt.legend(['y = $x^2$'])\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(x, y2)\n",
    "plt.title('Meu segundo gráfico')\n",
    "plt.xlabel('eixo x: x')\n",
    "plt.ylabel('eixo y: f(x)')\n",
    "plt.grid(True)\n",
    "plt.legend(['y = $x^3$'])\n",
    "\n",
    "# Mostrando o gráfico\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Para personalizar os valores mostrados nos eixos _x_ e _y_, são utilizadas as funções _xtick()_ e _ytick()_.\n",
    "\n",
    "Para visualizar ou limitar os valores dos eixos do gráfico, utiliza-se a função _axis()_.\n",
    "\n",
    "Para personalizar a cor e o tipo de linha de cada função do gráfico, acrescenta-se um parâmetro à função _plot()_. Uma string especificando cor e/ou tipo de linha do gráfico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "x = np.linspace(-3,3,10)\n",
    "y = np.sin(x)\n",
    "\n",
    "plt.plot(x,y, 'go--')"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}