9_NumPy_e_Matplotlib.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "9_NumPy_e_Matplotlib.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/PetEletricaUfes/MiniCursoPython/blob/main/9_NumPy_e_Matplotlib.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Nessa Sessão do minicurso veremos as bibliotecas NumPy e matplotlib"
      ],
      "metadata": {
        "id": "yQdqXxP6Pn0u"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# NumPy\n",
        "NumPy (Numerical Python) é uma biblioteca Python de código aberto que é usada em quase todos os campos da ciência e engenharia. É o padrão universal para trabalhar com dados numéricos em Python\n",
        "\n",
        "A biblioteca NumPy contém matrizes multidimensionais e estruturas de dados de matriz Ele fornece ndarray, um objeto de array n-dimensional homogêneo, com métodos para operar com eficiência nele. NumPy pode ser usado para realizar uma ampla variedade de operações matemáticas em arrays. Ele adiciona poderosas estruturas de dados ao Python que garantem cálculos eficientes com arrays e matrizes e fornece uma enorme biblioteca de funções matemáticas de alto nível que operam nesses arrays e matrizes."
      ],
      "metadata": {
        "id": "kqxBOmRrtyZH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Como usar:\n",
        ". para usar a biblioteca numpy, é preciso primeiroinstala-la no seu python. . após instalar é preciso importar a biblioteca."
      ],
      "metadata": {
        "id": "nXTxHL6ft3jo"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mRuva1eOPkhe"
      },
      "outputs": [],
      "source": [
        "#exemplo de instalação\n",
        "conda install numpy\n",
        "#ou\n",
        "pip install numpy"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#como importar:\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "gGufoHwKuA9-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Como criar um array?\n",
        ".Existem algumas formas básicas de se criar arrays, aqui estão algumas delas: .Para saber mais formas, você pode consultar em: https://numpy.org/doc/stable/reference/routines.array-creation.html"
      ],
      "metadata": {
        "id": "qFK3meTAuJIy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "arr = np.array([10,22,34,20,56,88])\n",
        "print(arr)\n",
        "print(type(arr))\n",
        "a = [1,2,3,4]\n",
        "print(a)\n",
        "print(type(a))"
      ],
      "metadata": {
        "id": "MKvKZLW4uPO7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "zeros = np.zeros([4,5])\n",
        "print(zeros)"
      ],
      "metadata": {
        "id": "YzQCCbNSuVeX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "ones = np.ones([5,3])\n",
        "print(ones)"
      ],
      "metadata": {
        "id": "tYqEO43iuXZg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "ara = np.arange(20, 50, 5)\n",
        "print(ara)"
      ],
      "metadata": {
        "id": "JpalvDAYuXfc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "lin = np.linspace(10,20,5)\n",
        "print(lin)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SQjSVPiYujOH",
        "outputId": "5ca1eb74-ef84-441e-d33b-f42b831f8c77"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[10.  12.5 15.  17.5 20. ]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Como Manipular Arrays?\n",
        ".Existem algumas funções do numpy para manipular ou extrair informações de um array.\n",
        ".Você pode consultar aqui: https://numpy.org/doc/stable/reference/routines.array-manipulation.html\n",
        ".aqui estão algumas funções:"
      ],
      "metadata": {
        "id": "dGjO6_fGuv7Q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "arr = np.array([10,22,34,20,56,88])\n",
        "print(np.shape(arr))\n",
        "print(np.ndim(arr))\n",
        "print(np.size(arr))"
      ],
      "metadata": {
        "id": "LQ84mjDYuxbg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "a = np.arange(6).reshape((2, 3))\n",
        "print(a)"
      ],
      "metadata": {
        "id": "g69yMy2duz7w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "a = np.arange(5)\n",
        "b = np.arange(5, 10, 1)\n",
        "c = np.concatenate((a,b))\n",
        "d = np.concatenate((b,a))\n",
        "print(c)\n",
        "print(d)\n",
        "print(c + d)\n",
        "\n",
        "\n",
        "e = [1,2,3]\n",
        "f = [4,5,6]\n",
        "print(e+f)"
      ],
      "metadata": {
        "id": "P7UbRa6Eu0Av"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Operações matemáticas\n",
        ".O numpy possui funções para realizar operações matemáticas em arrays. .você pode conferi-las em: https://numpy.org/doc/stable/reference/routines.math.html .Aqui estão algumas delas:\n",
        "\n"
      ],
      "metadata": {
        "id": "xCUK-WOSvBBo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = np.array([np.pi/6, np.pi/4, np.pi/3, np.pi/2, np.pi ])\n",
        "b = np.degrees(a)\n",
        "c =np.sin(a)\n",
        "#print(a)\n",
        "#print(b)\n",
        "print(c)\n",
        "d = np.around(c, decimals = 3)\n",
        "print(d)\n"
      ],
      "metadata": {
        "id": "vqurHgwDu76x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "arr = np.array([10,22,34,20,56,88])\n",
        "print(arr.sum()) #soma dos valores do array.\n",
        "print(arr.max()) #maior valor do array.\n",
        "print(arr.min()) #menor valor do array.\n",
        "print(arr.mean()) #média dos valores do array.\n"
      ],
      "metadata": {
        "id": "biMqZe4ZvLzO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = np.arange(1,6,1)\n",
        "b = np.prod(a)\n",
        "print(b)\n",
        "print(a)"
      ],
      "metadata": {
        "id": "KOUlONWNvL6X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Matplotlib\n",
        "Matplotlib é uma biblioteca abrangente para criar visualizações estáticas, animadas e interativas em Python. Assim como a numpy, a matplotlib precisa ser instalada e importada para ser utilizada\n",
        "\n"
      ],
      "metadata": {
        "id": "qkrqwhM3vodx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib as mpl\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "GHWXZmlAvbpf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Plotando Gráficos:\n",
        "Ao utilizar essa biblioteca, é possível construir gráficos com dados numéricos de Arrays e até listas. Abaixo estão algumas funções importantes para plotar.\n",
        "você pode encontrar mais funções e suas documentações aqui:\n",
        "https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.html#module-matplotlib.pyplot\n"
      ],
      "metadata": {
        "id": "TJjrz1OGwIX5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#matplotlib.pyplot\n",
        "matplotlib.pyplot é uma interface baseada em estado para matplotlib. Ele fornece uma maneira implícita, semelhante ao MATLAB, de plotagem. Ele também abre figuras em sua tela e atua como o gerenciador de interface gráfica da figura.\n",
        "\n",
        "pyplot destina-se principalmente a gráficos interativos e casos simples de geração de gráficos programáticos:\n",
        "\n",
        "aqui vocês podem encontrar exemplos de diversos plots e os códigos que os geraram: https://matplotlib.org/stable/gallery/index.html#pyplots-examples"
      ],
      "metadata": {
        "id": "L3LC9BHYxdKH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "vr2 = np.array([13.3,11.4,10,8.89,8,7.27,6.67])\n",
        "r1 = np.arange(1000, 4500, 500)\n",
        "plt.plot(vr2,r1)\n",
        "plt.title('Relação entre Tensão em R2 e valor de R1')\n",
        "plt.xlabel('Tensão no resistor em Volts [V]')\n",
        "plt.ylabel('Valor da resistência em R1 em Ohms [Ohm]')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "rvY6rjKTvw8-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "a = np.arange(100)\n",
        "b = np.arange(100)\n",
        "a = np.sqrt(a)\n",
        "plt.plot(b,a)\n",
        "plt.title('gráfico da curva f(x) = sqrt(x)')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "NqJKeSMJvxEn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pylab as plt\n",
        "x = np.linspace(-np.pi, np.pi, 201)\n",
        "plt.plot(x, np.sin(x))\n",
        "plt.xlabel('Angle [rad]')\n",
        "plt.ylabel('sin(x)')\n",
        "plt.axis('tight')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "GCxGLi9DvxVP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pylab as plt\n",
        "fig, ax = plt.subplots(figsize=(5, 2.7))\n",
        "\n",
        "t = np.arange(0.0, 5.0, 0.01)\n",
        "s = np.cos(2 * np.pi * t)\n",
        "line, = ax.plot(t, s, lw=2)\n",
        "\n",
        "ax.annotate('máximo local', xy=(2, 1), xytext=(3, 1.5),\n",
        "            arrowprops=dict(facecolor='black', shrink=0.05))\n",
        "\n",
        "ax.set_ylim(-2, 2);"
      ],
      "metadata": {
        "id": "ncjz5LQkwB93"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#esse codigo calcula os termos de uma serie de fibonacci a partir do quarto termo\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "n = int(input('qual termo? ')) #ler o termo final da série\n",
        "fibo = np.zeros(n+1) #array para ser preenchido pelos números da série\n",
        "fibo[0] = 0 #aqui são definidos os valores das posições 0,1 e 2 da série\n",
        "fibo[1] = 1\n",
        "fibo[2] = 1\n",
        "t1=1   #penultimo termo da série\n",
        "t2=1   #ultimo termo da série\n",
        "count = 3 #contador\n",
        "t = int   # termo da série\n",
        "while count <= n: #o loop calcula o termo da série e preenche o array a partir da posição 3\n",
        "    t = t1 + t2\n",
        "    t1 = t2\n",
        "    t2 = t\n",
        "    fibo[count] = t\n",
        "    count += 1\n",
        "    #print(t)\n",
        "y = fibo  \n",
        "x = np.arange(n+1)\n",
        "plt.plot(x,y)\n",
        "plt.title('Sequencia de fibonacci')\n",
        "plt.xlabel('posição do número na sequência')\n",
        "plt.ylabel('númeto de Fibonacci')\n",
        "plt.show()              #cria um array para os valores do eixo x e plota o gráfico\n",
        "divi = np.zeros(n)      #cria um array e o preenche com os valores da divisão de um termo pelo seu antecessor\n",
        "for i in range(n):\n",
        "    divi[i] = fibo[i+1]/y[i]\n",
        "print(divi)\n",
        "x1 = np.arange(n)\n",
        "plt.plot(x1,divi)   #cria um novo array para o eixo x e plota o gráfico das divisões.\n",
        "plt.title('divisões do termo atual pelo anterior')\n",
        "plt.xlabel('posição na sequência')\n",
        "plt.ylabel('valor da divisão')\n",
        "plt.show()\n",
        "derivada = np.zeros(n) #cria um novo array para receber o valor da derivada da série\n",
        "for i in range(n):\n",
        "    derivada[i] = fibo[i+1] - y[i] #calcula a derivada(nesse caso uma diferença)\n",
        "plt.plot(x1,derivada) #plota o gráfico da derivada\n",
        "plt.title('diferença entre os termos')\n",
        "plt.xlabel('posição na sequência')\n",
        "plt.ylabel('valor da diferença')\n",
        "plt.show()\n",
        "    "
      ],
      "metadata": {
        "id": "ByhSR6IJvxOu"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}