Apostila2_BootcampPython.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Apostila2_BootcampPython.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyPj7TZ53mwpeBLJ1YXPcZ4R",
      "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/raulc27/python_testes/blob/master/Apostila2_BootcampPython.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wT9ZExCua8wV"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "seutCWNobVUR",
        "outputId": "27b20b46-ee36-433c-8384-09677fc4f871"
      },
      "source": [
        "a = np.array([[1,2,3],[2,3,4],[3,4,5]])\n",
        "print(\"Array criado:\\n\",a)\n",
        "print(\"shape:\", a.shape)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Array criado:\n",
            " [[1 2 3]\n",
            " [2 3 4]\n",
            " [3 4 5]]\n",
            "shape: (3, 3)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mKYuvlRfcG69",
        "outputId": "4b21c7ed-3991-48c0-c43f-a88c51ce9df3"
      },
      "source": [
        "print(\"Criação de uma matriz 3x2 de 0's:\")\n",
        "print(np.zeros((3,2)))\n",
        "\n",
        "print(\" \\n Criação de uma matriz 3x2 de 1's:\")\n",
        "print(np.ones((3,2)))\n",
        "\n",
        "print(\"\\n Criação de uma matriz identidade 3x3:\")\n",
        "print(np.eye(3))\n",
        "\n",
        "print(\"\\n Criação de uma matriz 3x3 com números aleatórios:\")\n",
        "print(np.random.random((3,3)))"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Criação de uma matriz 3x2 de 0's:\n",
            "[[0. 0.]\n",
            " [0. 0.]\n",
            " [0. 0.]]\n",
            " \n",
            " Criação de uma matriz 3x2 de 1's:\n",
            "[[1. 1.]\n",
            " [1. 1.]\n",
            " [1. 1.]]\n",
            "\n",
            " Criação de uma matriz identidade 3x3:\n",
            "[[1. 0. 0.]\n",
            " [0. 1. 0.]\n",
            " [0. 0. 1.]]\n",
            "\n",
            " Criação de uma matriz 3x3 com números aleatórios:\n",
            "[[0.6779379  0.64369911 0.84590214]\n",
            " [0.45417495 0.23274161 0.7035004 ]\n",
            " [0.65939963 0.94142351 0.74311614]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VldjbzJHcnuK"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zmXJifxScsEk",
        "outputId": "5dede324-6b72-4c5e-997b-dfe94f5b81cc"
      },
      "source": [
        "# Criação de uma matriz bidimensional de tamanho (3,4)\n",
        "print(\"A:\")\n",
        "A = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])\n",
        "print(A)\n",
        "\n",
        "# indexacao do array A para extracao de um sub-array das duas primeiras 2 linhas de A e das colunas de índice 1 e 2, resultando em novo array\n",
        "# B de tamanho (2,2)\n",
        "print(\"B:\")\n",
        "B = A[:2, 1:3]\n",
        "print(B)\n"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A:\n",
            "[[ 1  2  3  4]\n",
            " [ 5  6  7  8]\n",
            " [ 9 10 11 12]]\n",
            "B:\n",
            "[[2 3]\n",
            " [6 7]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ntHvnH1ZnaYh",
        "outputId": "83022df8-0053-40c1-cd7d-ade35f1ca4db"
      },
      "source": [
        "# B[0,0] aponta para a mesma posição de memória de A[0,1]\n",
        "print(\"A[0,1] antes:\")\n",
        "print(A[0,1])\n",
        "B[0,0]=77\n",
        "print(\"A[0,1] depois:\")\n",
        "print(A[0,1])"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A[0,1] antes:\n",
            "2\n",
            "A[0,1] depois:\n",
            "77\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C8-YZ1Xwq5hs",
        "outputId": "0746ff08-f7bb-4be9-9299-6c6cccbfb37e"
      },
      "source": [
        "# Criação de uma matriz bidimensional de tamanho (3,4)\n",
        "A = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])\n",
        "\n",
        "# indexação do array A para extração de um sub-array onde as duas primeiras 2 linhas de A e das colunas de índice 1 e 2..\n",
        "B = A[:2, 1:3].copy() #slicing com cópia do objeto\n",
        "\n",
        "# B[0,0] agora não aponta para a mesma posição de memória de A[0,1]\n",
        "print(\"A[0,1] antes:\")\n",
        "print(A[0,1])\n",
        "B[0,0]=77\n",
        "print(\"A[0,1] depois:\")\n",
        "print(A[0,1])\n"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A[0,1] antes:\n",
            "2\n",
            "A[0,1] depois:\n",
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WkylhnbluxDW",
        "outputId": "c45efc08-9254-41bd-b0d9-6cf58feab3ed"
      },
      "source": [
        "#arrays\n",
        "x=np.array([[1,2],[3,4]])\n",
        "y=np.array([[5,6],[7,8]])\n",
        "\n",
        "#soma por elemento\n",
        "print(\"Sobrecarga de operador:\")\n",
        "print(x+y)\n",
        "print(\"Função do módulo:\")\n",
        "print(np.add(x,y))\n",
        "print(\"Soma entre um array e um escalar:\")\n",
        "print(x+10)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Sobrecarga de operador:\n",
            "[[ 6  8]\n",
            " [10 12]]\n",
            "Função do módulo:\n",
            "[[ 6  8]\n",
            " [10 12]]\n",
            "Soma entre um array e um escalar:\n",
            "[[11 12]\n",
            " [13 14]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fDste4kivS77",
        "outputId": "fe9f0b49-0326-4366-ff6e-a8733d4a328c"
      },
      "source": [
        "#Diferença por elemento\n",
        "print(x-y)\n",
        "print(np.subtract(x,y))"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[-4 -4]\n",
            " [-4 -4]]\n",
            "[[-4 -4]\n",
            " [-4 -4]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GCJGePqtvbPm",
        "outputId": "4f4d68d8-8aa5-4911-aca3-9aea626c916d"
      },
      "source": [
        "#Produto por elemento\n",
        "print(x*y)\n",
        "print(np.multiply(x,y))"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 5 12]\n",
            " [21 32]]\n",
            "[[ 5 12]\n",
            " [21 32]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AknqSU6Fvl7v",
        "outputId": "fcb7caca-193c-41bd-c451-8f85da0e0387"
      },
      "source": [
        "#Matrizes\n",
        "x=np.array([[1,2],[3,4]])\n",
        "y=np.array([[5,6],[7,8]])\n",
        "\n",
        "#vetores\n",
        "v=np.array([5,5])\n",
        "w=np.array([2,3])\n",
        "\n",
        "#Produto interno de vetores\n",
        "print(v.dot(w))\n",
        "print(np.dot(v,w))"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "25\n",
            "25\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j0oXhtgAwAqM",
        "outputId": "abbb5390-66e3-4ae0-a5d8-2205fc7d36c2"
      },
      "source": [
        "#Produto de um vetor e uma matriz\n",
        "print(x.dot(v))\n",
        "print(np.dot(x,v))"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[15 35]\n",
            "[15 35]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KCvVzXNZwLiN",
        "outputId": "ff24a7dd-fc2b-4c06-fdf5-5b66b0a77268"
      },
      "source": [
        "#Produto de matrizes\n",
        "print(x.dot(y))\n",
        "print(np.dot(x,y))"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[19 22]\n",
            " [43 50]]\n",
            "[[19 22]\n",
            " [43 50]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gI2zkPtTwTy6",
        "outputId": "5f995b67-a215-47a0-e462-5171387c08a2"
      },
      "source": [
        "#Divisão por elemento\n",
        "print(x/y)\n",
        "print(np.divide(x,y))"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0.2        0.33333333]\n",
            " [0.42857143 0.5       ]]\n",
            "[[0.2        0.33333333]\n",
            " [0.42857143 0.5       ]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aeuUV27CwfWg",
        "outputId": "2ccbbe93-be1b-4b90-b2ba-60f89c0e2d2e"
      },
      "source": [
        "#Raiz quadrada por elemento\n",
        "print(np.sqrt(x))"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1.         1.41421356]\n",
            " [1.73205081 2.        ]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hrm6hjdGwkHo",
        "outputId": "09828907-d98f-47dc-f1d8-a987ec05c030"
      },
      "source": [
        "#Exponenciação por elemento\n",
        "print(x**2)"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1  4]\n",
            " [ 9 16]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tkXU2Moewp14",
        "outputId": "c63a5bcb-cb15-4b3a-ac30-56cffca18161"
      },
      "source": [
        "#Logarítmo por elemento\n",
        "print(np.log(x))"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0.         0.69314718]\n",
            " [1.09861229 1.38629436]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 254
        },
        "id": "4LMSPbBB0Vgi",
        "outputId": "0a81c5ba-b864-4944-95d8-077fdce06257"
      },
      "source": [
        "#maior\n",
        "print(\"Comparação maior:\")\n",
        "print(A > B)\n",
        "print(A > s)\n",
        "\n",
        "#maior ou igual\n",
        "print(\"Comparação maior ou igual:\")\n",
        "print(A >= B)\n",
        "print(A >= s)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Comparação maior:\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-24-d7a73dfa3cac>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#maior\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Comparação maior:\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0mB\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (3,4) (2,2) "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FVayJgmQ08DU",
        "outputId": "15b38899-7519-44f1-c8e5-5a7df6dae479"
      },
      "source": [
        "# comparações booleanas\n",
        "A = np.array([1,2,3])\n",
        "B = np.array([2,0,2])\n",
        "s=3\n",
        "\n",
        "# menor\n",
        "print(\"Comparação menor:\")\n",
        "print(A<B)\n",
        "print(A<s)\n",
        "\n",
        "# menor ou igual\n",
        "print(\"Comparação menor ou igual:\")\n",
        "print(A<=B)\n",
        "print(A<=s)"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Comparação menor:\n",
            "[ True False False]\n",
            "[ True  True False]\n",
            "Comparação menor ou igual:\n",
            "[ True False False]\n",
            "[ True  True  True]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jrrFDHXN1X_8",
        "outputId": "a7bda0c7-6f6a-40f6-fae5-904fb18b4471"
      },
      "source": [
        "# igual\n",
        "print(\"Comparação de igualdade:\")\n",
        "print(A==B)\n",
        "print(A==s)"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Comparação de igualdade:\n",
            "[False False False]\n",
            "[False False  True]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HZWSlhvC1h27",
        "outputId": "8bfd3e99-5703-475d-c660-6f503ab07b77"
      },
      "source": [
        "# indexação booleana: um novo subarray contendo uma cópia dos elementos\n",
        "# em que a condição de verificação se aplica\n",
        "\n",
        "cond = A <= 2\n",
        "D = A[cond]\n",
        "print(\"A:\", A)\n",
        "print(\"condição:\", cond)\n",
        "print(\"D:\", D)"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A: [1 2 3]\n",
            "condição: [ True  True False]\n",
            "D: [1 2]\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}