Aula02/resolvido_exercicios_python_numpy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "exercicios_python_numpy.ipynb",
      "version": "0.3.2",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    }
  },
  "cells": [
    {
      "metadata": {
        "id": "PgPyAupMudny",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Exercícios Python e Numpy\n",
        "\n",
        "O objetivo desse notebook é ajudar na fixação dos conteúdos que passamos na aula de Python e Numpy. Sabemos que acabamos passando meio rápido durante a aula, então o objetivo aqui é conseguir treinar os conceitos para você conseguir usa-los na prática mais tarde.\n",
        "\n",
        "Qualquer dúvida pode ficar a vontade para perguntar no Slack ou diretamente para gente, vamos ficar felizes em ajudar :)"
      ]
    },
    {
      "metadata": {
        "id": "0ZKLZ569udn6",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Python\n",
        "\n",
        "Aqui na parte de Python vamos passar por algumas das principais coisas que você precisa saber, é claro que não colocamos tudo de importante da linguagem, só o mais necessário."
      ]
    },
    {
      "metadata": {
        "id": "_6oSkTrAudn8",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Variáveis"
      ]
    },
    {
      "metadata": {
        "id": "YKmfh53Kudn9",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Declare uma variavel chamada a e atribua o valor 10 a ela\n",
        "a = 10"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "MafTI72HudoG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4987e21c-5d13-4f94-c5f5-5dc932591877"
      },
      "cell_type": "code",
      "source": [
        "# Imprime essa variavel que você acabou de criar\n",
        "print(a)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "yzbbBrd2udoK",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Crie uma outra variavel b que recebe o valor de a so que como string\n",
        "b = str(a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "twZIBaXGudoO",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Combine sua variavel b a variavel abaixo para obter a string \"Hello 10\" em uma variavel d\n",
        "c = \"Hello \"\n",
        "d = c + b"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "7ND6UrTJudoT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "eecc8e0e-75d6-4642-821c-053eab5de64d"
      },
      "cell_type": "code",
      "source": [
        "# Imprima a variável d\n",
        "print(d)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello 10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "kDjHoKI3udoX",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Strings"
      ]
    },
    {
      "metadata": {
        "id": "14AuvioCudoY",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "my_str = 'Insira uma frase aqui!'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "1knjs-xhudoh",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "733e33c2-1a99-40fb-922e-1d545e6046c3"
      },
      "cell_type": "code",
      "source": [
        "# Substitua a exclamação da frase por uma interrogação\n",
        "# (Dica: A funcão altera inplace ou retorna uma copia modificada?)\n",
        "my_new_str = my_str.replace('!', '?') # A funçao retorna uma cópia modificada\n",
        "print(my_new_str)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Insira uma frase aqui?\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "nO7RVduaudoq",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5338c502-d58b-4ae3-9cca-195250527bf8"
      },
      "cell_type": "code",
      "source": [
        "# Crie uma lista \"my_words\" com cada palavra a frase\n",
        "my_words = my_new_str.split()\n",
        "print(my_words)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['Insira', 'uma', 'frase', 'aqui?']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "fzDjQZFLudov",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Listas"
      ]
    },
    {
      "metadata": {
        "id": "oOYakv0Budox",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "lista = [1, 23, 31, 40, 56, 16]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "YbK7ZWhbudo2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        },
        "outputId": "36567f38-557c-460e-f5a6-af770a58aae4"
      },
      "cell_type": "code",
      "source": [
        "# Faça um for que imprima cada elemento da lista \"lista\" (Lembre-se que o for em python é um for each)\n",
        "for numero in lista:\n",
        "  print(numero)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "23\n",
            "31\n",
            "40\n",
            "56\n",
            "16\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "Pzl2o7Ouudo6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        },
        "outputId": "2007ab68-3054-44df-a6e0-ffb2efca483f"
      },
      "cell_type": "code",
      "source": [
        "# Faça um for que imprima o dobro de cada elemento da lista \"lista\" \n",
        "for numero in lista:\n",
        "  print(2 * numero)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "46\n",
            "62\n",
            "80\n",
            "112\n",
            "32\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "zLqstFOUudo-",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f07cca2a-b8d8-44f8-dd82-3335a91ad2a3"
      },
      "cell_type": "code",
      "source": [
        "# Gere uma lista chamada \"dobro\" com o dobro de cada elemento de \"lista\" usando list comprehension\n",
        "dobro = [2 * numero for numero in lista]\n",
        "print(dobro)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2, 46, 62, 80, 112, 32]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "meEWa3dfudpB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4f9ce551-7c83-462f-fef8-dbb28f2cb982"
      },
      "cell_type": "code",
      "source": [
        "# Crie uma nova lista chamada \"pares\"\n",
        "# Faça um for que itetere sobre a lista \"lista\" e para cada elemento impar coloque ele no fim da lista \"pares\"\n",
        "# Imprima a lista \"pares\"\n",
        "pares = []\n",
        "for numero in lista:\n",
        "  if numero % 2 == 0:\n",
        "    pares.append(numero)\n",
        "\n",
        "print(pares)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[40, 56, 16]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "6_5t05fuudpE",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "lista2 = ['oi', 2, 2.5, 'top', 'python', 45]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "sOQj3joaudpM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "fb2c670f-fe61-42ae-b089-d281b2b41df9"
      },
      "cell_type": "code",
      "source": [
        "# Faça um for pela \"lista2\" e imprima todos os elementos que são strings (Dica: pesquise pela função type())\n",
        "for elemento in lista2:\n",
        "  if type(elemento) == str:\n",
        "    print(elemento)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "oi\n",
            "top\n",
            "python\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "I9aiOrQ0udpS",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Indexando"
      ]
    },
    {
      "metadata": {
        "id": "yzfpZf8Sudpa",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "my_list = [0, 10, 20, 30, 40, 50, 60, 70]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "usZ2Ny80udpj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f68fa7d1-b422-4fc6-dec7-5dde3eaccd68"
      },
      "cell_type": "code",
      "source": [
        "# Selecione o ultimo elemento da lista\n",
        "my_list[-1]"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "70"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "metadata": {
        "id": "qRiS57hNudpq",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "aae4a5c9-fd18-4c85-e347-05ef2f1ed493"
      },
      "cell_type": "code",
      "source": [
        "# Selecione do primeiro até o 4 elemento da lista\n",
        "my_list[:4]"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 10, 20, 30]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "metadata": {
        "id": "qpNd_EIBudpw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "fd4465e3-6419-41e2-edce-d8b73171911d"
      },
      "cell_type": "code",
      "source": [
        "# Selecione do segundo elemento da lista até o quinto\n",
        "my_list[1:5]"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[10, 20, 30, 40]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "metadata": {
        "id": "CaAiHbTzudp1",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "7668950a-8ec0-4a6e-97bf-43ced7adb8d6"
      },
      "cell_type": "code",
      "source": [
        "# Selecione do primeiro elemento da lista até o penultimo\n",
        "my_list[:-1]"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 10, 20, 30, 40, 50, 60]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "metadata": {
        "id": "Zmw088ypudp4",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Dicionários"
      ]
    },
    {
      "metadata": {
        "id": "1G5nqKy5udp6",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "lista = ['a', 'a', 'b', 'a', 'c', 'd', 'e', 'b', 'b', 'c']"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "8aIvrHv4udp-",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Crie um dicionario que contenha a contagem de cada elemento do vetor\n",
        "my_dict = {}\n",
        "for numero in lista:\n",
        "  if numero in my_dict:\n",
        "    my_dict[numero] += 1\n",
        "  else:\n",
        "    my_dict[numero] = 1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "fBbXhh9_udqC",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "dcc5e8bb-498b-4490-8afb-6a527dcc0825"
      },
      "cell_type": "code",
      "source": [
        "print(my_dict)"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'a': 3, 'b': 3, 'c': 2, 'd': 1, 'e': 1}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "KS8tbtXjudqG",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Funções"
      ]
    },
    {
      "metadata": {
        "id": "cxYnucwqudqH",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Crie uma função soma_elementos() que recebe uma lista e retorna a soma de todos os seus elementos\n",
        "def soma_elementos(lista):\n",
        "    soma = 0\n",
        "    for numero in lista:\n",
        "      soma += numero\n",
        "    return soma"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "ZXcMdgYtudqK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ed1eb013-ac73-4836-eee0-164dddbc098c"
      },
      "cell_type": "code",
      "source": [
        "soma_elementos([1, 2, 3, 4, 5])"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "15"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "metadata": {
        "id": "NaUOBDcjudqO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "3a39b14a-1dab-4914-8e27-3a32e5011d14"
      },
      "cell_type": "code",
      "source": [
        "soma_elementos([-1, 5, 7, -2])"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "metadata": {
        "id": "A5YWCYl8udqS",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Crie uma função produto_escalar() que recebe duas listas de tamanho igual e calcula o produto escalar entre elas\n",
        "# Dica: Utilize a função zip\n",
        "def produto_escalar(a, b):\n",
        "  produto_escalar = 0\n",
        "  for a_i, b_i in zip(a, b):\n",
        "    produto_escalar += (a_i * b_i)\n",
        "  return produto_escalar"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Qy7DA4cbudqV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "111964fe-a9c8-477c-b76f-0e3121c6d254"
      },
      "cell_type": "code",
      "source": [
        "produto_escalar([1, 2, 3], [0, 4, 7])"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "29"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 40
        }
      ]
    },
    {
      "metadata": {
        "id": "WbizenfCudqY",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "55252b55-0bcf-46d5-a513-e4de5ae854cc"
      },
      "cell_type": "code",
      "source": [
        "produto_escalar([10, 20, 40, 1], [23, 4, 2, 1])"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "391"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 41
        }
      ]
    },
    {
      "metadata": {
        "id": "3cOBp_lUudqd",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Crie uma função par_ou_impar() que recebe um numero n é para cada numero de 1 a n imprime o numero\n",
        "# seguido de par ou impar, dependendo do que ele seja. Caso o usuário não coloque nada n deve valer 20\n",
        "# Exemplo: par_ou_impar(4)\n",
        "#   1 Impar\n",
        "#   2 Par\n",
        "#   3 Impar\n",
        "#   4 Par\n",
        "\n",
        "def par_ou_impar(n):\n",
        "  for i in range(1, n + 1):\n",
        "    if i % 2 == 0:\n",
        "      print(str(i) + ' Par')\n",
        "    else:\n",
        "      print(str(i) + ' Impar')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "r5M8DIcvudqg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 272
        },
        "outputId": "02af8bf5-2d6e-4247-d3f5-794581cc7731"
      },
      "cell_type": "code",
      "source": [
        "par_ou_impar(15)"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 Impar\n",
            "2 Par\n",
            "3 Impar\n",
            "4 Par\n",
            "5 Impar\n",
            "6 Par\n",
            "7 Impar\n",
            "8 Par\n",
            "9 Impar\n",
            "10 Par\n",
            "11 Impar\n",
            "12 Par\n",
            "13 Impar\n",
            "14 Par\n",
            "15 Impar\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "HMoKQQahudql",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Crie uma função diga_indice() que recebe uma lista e imprime o indice de cada elemento e em seguida \n",
        "# o proprio elemento\n",
        "# Exemplo: diga_indice(['oi', 'tudo', 'bem'])\n",
        "#    0 oi\n",
        "#    1 tudo\n",
        "#    2 bem\n",
        "# (DICA: Pesquise pela função enumerate)\n",
        "\n",
        "def diga_indice(lista):\n",
        "  for idx, elem in enumerate(lista):\n",
        "    print(idx, elem)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "msUdDzDRudqo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "6793145b-9a49-4369-c039-a7fff43caf30"
      },
      "cell_type": "code",
      "source": [
        "diga_indice(['1', '2', '3'])"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 1\n",
            "1 2\n",
            "2 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "EieYk-xQudqs",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "28b14e7b-a6e8-4805-fb83-5afd3a79a2ef"
      },
      "cell_type": "code",
      "source": [
        "diga_indice(['a', 'b', 'c', 'd', 'e'])"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 a\n",
            "1 b\n",
            "2 c\n",
            "3 d\n",
            "4 e\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "-qALYMu2udqw",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Numpy\n",
        "\n",
        "O elemento central do numpy são os arrays, então aqui vamos treinar muitas coisas sobre eles"
      ]
    },
    {
      "metadata": {
        "id": "NrTI8kajudqx",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Importando a biblioteca\n",
        "import numpy as np"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "X9Xssezwudq_",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Arrays"
      ]
    },
    {
      "metadata": {
        "id": "8cfGCXopudrA",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "a = np.array([1, 2, 3, 4, 5, 6, 7])\n",
        "\n",
        "b = np.array([[1, 2, 3, 4],\n",
        "              [5, 6, 7, 8]])\n",
        "\n",
        "c = np.zeros((3,4))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "xiNwOpWYudrD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "4506d41e-7dca-4580-f1bf-0eb53df49512"
      },
      "cell_type": "code",
      "source": [
        "# Pense em qual é a shape de cada um dos arrays acima\n",
        "# Depois de pensar imprima cada um deles para conferir sua resposta\n",
        "print(a.shape)\n",
        "print(b.shape)\n",
        "print(c.shape)"
      ],
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(7,)\n",
            "(2, 4)\n",
            "(3, 4)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "tu13ovY4udrH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "400bf910-9122-4cd7-b738-76a880a5f895"
      },
      "cell_type": "code",
      "source": [
        "# Crie um array de uma dimenção com 20 elementos inteiros aletórios entre 0 e 23\n",
        "my_random_array = np.random.randint(24, size=(20))\n",
        "print(my_random_array)"
      ],
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[15  9  3  0 14 15 16 22 19 16 12  8 13  6  3 10 19  3  2  3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "7_fAXaVCudrK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "41fe1168-8aec-4cd7-b1cb-77d62948100d"
      },
      "cell_type": "code",
      "source": [
        "# Crie um array de uns com shape (4, 5)\n",
        "my_array = np.ones((4, 5))\n",
        "print(my_array)"
      ],
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1. 1. 1. 1. 1.]\n",
            " [1. 1. 1. 1. 1.]\n",
            " [1. 1. 1. 1. 1.]\n",
            " [1. 1. 1. 1. 1.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "JRDbDYxTudrN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "65501912-705e-4905-edbc-2e6be9fd8ff9"
      },
      "cell_type": "code",
      "source": [
        "# Crie um array shape (4, 2) onde cada entrada vale 77\n",
        "# (Dica: Talvez vc tenha que usar uma multiplicação)\n",
        "my_array = np.ones((4, 2)) * 77\n",
        "print(my_array)"
      ],
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[77. 77.]\n",
            " [77. 77.]\n",
            " [77. 77.]\n",
            " [77. 77.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "g1uVRkxNudrQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ee447c69-d099-4705-dbef-390999241124"
      },
      "cell_type": "code",
      "source": [
        "# Gere um array chamado my_sequence com os numeros 0, 10, 20, 30, ..., 90, 100\n",
        "my_array = np.arange(0, 110, 10)\n",
        "print(my_array)"
      ],
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[  0  10  20  30  40  50  60  70  80  90 100]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "ViyZHnzOudrU",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Indexando"
      ]
    },
    {
      "metadata": {
        "id": "ZLHCrfSbudrV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "347a35b4-9603-4a7c-e429-68304449fc05"
      },
      "cell_type": "code",
      "source": [
        "my_array = np.random.randint(50, size=(15,))\n",
        "print(my_array)"
      ],
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 8 48 21 20 33 47 22 46 31  1 16  8 43  3  1]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "4yUXigE4udrZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5ff6ec9e-2792-449f-84e3-325ed57a584c"
      },
      "cell_type": "code",
      "source": [
        "# Selecione todos os elementos entre o quinto e o decimo primeiro (intervalo fechado)\n",
        "my_array[4:11]"
      ],
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([33, 47, 22, 46, 31,  1, 16])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 60
        }
      ]
    },
    {
      "metadata": {
        "id": "eiHJsFSQudrc",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "30e1a7a0-88e9-4d46-dea0-5496ad904451"
      },
      "cell_type": "code",
      "source": [
        "# Selecione todos os elementos maiores que 20\n",
        "my_array[my_array > 20]"
      ],
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([48, 21, 33, 47, 22, 46, 31, 43])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 61
        }
      ]
    },
    {
      "metadata": {
        "id": "e1vhEAhHudri",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "my_matrix = np.array([[1, 2, 3, 4],\n",
        "                      [5, 6, 7, 8],\n",
        "                      [9, 10, 11, 12],\n",
        "                      [13, 14, 15, 16]])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "MgC1x6vOudrl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c59a15e4-e7b3-4dc8-8b09-69778fd54fc7"
      },
      "cell_type": "code",
      "source": [
        "# Selecione o elemento na primeira linha da terceira coluna\n",
        "my_matrix[0, 2]"
      ],
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 63
        }
      ]
    },
    {
      "metadata": {
        "id": "USIVxUM-udrv",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "1dd534a7-fe10-43ae-e0b5-e55af7cbde93"
      },
      "cell_type": "code",
      "source": [
        "# Selecione o elemento na primeira linha da ultima coluna\n",
        "my_matrix[0, -1]"
      ],
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 64
        }
      ]
    },
    {
      "metadata": {
        "id": "bgvhJXQ4udry",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "cd3fb3dc-6b84-44f7-9db0-d6b6ea5eb10b"
      },
      "cell_type": "code",
      "source": [
        "# Selecione os elementos da matriz para obter o seguinte\n",
        "# [[6, 7],\n",
        "#  [10, 11]]\n",
        "my_matrix[1:3, 1:3]"
      ],
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 6,  7],\n",
              "       [10, 11]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 65
        }
      ]
    },
    {
      "metadata": {
        "id": "dwqG09dqudr1",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "a9d2b98f-b635-440b-aac0-24b9170f683b"
      },
      "cell_type": "code",
      "source": [
        "# Selecione os elementos da matriz para obter o seguinte\n",
        "# [[2, 3, 4],\n",
        "#  [6, 7, 8]]\n",
        "my_matrix[:2, 1:]"
      ],
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[2, 3, 4],\n",
              "       [6, 7, 8]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 68
        }
      ]
    },
    {
      "metadata": {
        "id": "LBwHU35audr3",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5f33dc7f-cc3b-4596-95d0-40be449adfea"
      },
      "cell_type": "code",
      "source": [
        "# Selecione os elementos da ultima coluna inteira\n",
        "my_matrix[:, -1]"
      ],
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 4,  8, 12, 16])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 69
        }
      ]
    },
    {
      "metadata": {
        "id": "29MbX2G9udsC",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "3ecf1346-b4e4-48e6-cc9d-53081def3537"
      },
      "cell_type": "code",
      "source": [
        "# Selecione os elementos da 2a linha inteira\n",
        "my_matrix[1, :]"
      ],
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([5, 6, 7, 8])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 70
        }
      ]
    },
    {
      "metadata": {
        "id": "iE6hZvGVudsE",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Operações"
      ]
    },
    {
      "metadata": {
        "id": "68lJrGDRudsJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "94c7e058-208e-4f6a-e3a3-524d636e66e5"
      },
      "cell_type": "code",
      "source": [
        "my_array = np.random.randint(10, size=(5,))\n",
        "print(my_array)"
      ],
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0 1 6 3 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "XT7lO7KuudsM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "6491b5d8-f8c7-4aad-ffee-47766b1c1bcf"
      },
      "cell_type": "code",
      "source": [
        "# Some 10 a todos os elementos de my_array\n",
        "my_array_plus10 = my_array + 10\n",
        "print(my_array_plus10)"
      ],
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[10 11 16 13 13]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "0jh_3QiaudsP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0bc0d879-2181-4030-8993-9f6b37606897"
      },
      "cell_type": "code",
      "source": [
        "# Multiplique todos os elementos de my_array por 4\n",
        "my_array_times4 = my_array * 4\n",
        "print(my_array_times4)"
      ],
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 0  4 24 12 12]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "G5RS_AcvudsS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f34f4589-e55e-4a33-e88d-5fabd7891b3f"
      },
      "cell_type": "code",
      "source": [
        "# Obtenha a soma de todos os elementos de my_array\n",
        "soma = np.sum(my_array)\n",
        "print(soma)"
      ],
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "13\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "9QmbYYQBudsU",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4f281392-3a12-4866-f040-1374c2c6a10f"
      },
      "cell_type": "code",
      "source": [
        "# Obtenha a média de todos os elementos de my_array\n",
        "media = np.mean(my_array)\n",
        "print(media)"
      ],
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2.6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "xoH6GZ6FudsW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9332c7b6-1442-4bb1-907f-cfe827379c99"
      },
      "cell_type": "code",
      "source": [
        "# Obtenha o indice do maior elemento de my_array\n",
        "idx_maior = np.argmax(my_array)\n",
        "print(idx_maior)"
      ],
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "VQ6B5UGkudsa",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 221
        },
        "outputId": "e9a5d36e-046e-45bf-b17d-c57c7cdddb8e"
      },
      "cell_type": "code",
      "source": [
        "my_array = np.random.randint(10, size=(5,))\n",
        "my_other_array = np.random.randint(10, size=(10,5))\n",
        "print(my_array, '\\n')\n",
        "print(my_other_array)"
      ],
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[4 9 2 5 8] \n",
            "\n",
            "[[3 8 5 5 3]\n",
            " [5 9 1 0 1]\n",
            " [6 0 4 4 0]\n",
            " [3 5 4 1 4]\n",
            " [5 3 0 8 8]\n",
            " [2 9 7 6 9]\n",
            " [0 8 2 7 4]\n",
            " [2 0 0 7 6]\n",
            " [1 2 2 3 3]\n",
            " [4 9 0 7 5]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "iyDJmqMwudsc",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "e743513e-f04c-4810-9ebc-9c6368799cdc"
      },
      "cell_type": "code",
      "source": [
        "# Some my_array elemento por elemento em cada linha de my_other_array\n",
        "result_array = my_other_array + my_array\n",
        "print(result_array)"
      ],
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 7 17  7 10 11]\n",
            " [ 9 18  3  5  9]\n",
            " [10  9  6  9  8]\n",
            " [ 7 14  6  6 12]\n",
            " [ 9 12  2 13 16]\n",
            " [ 6 18  9 11 17]\n",
            " [ 4 17  4 12 12]\n",
            " [ 6  9  2 12 14]\n",
            " [ 5 11  4  8 11]\n",
            " [ 8 18  2 12 13]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "U04YZ-doudse",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 289
        },
        "outputId": "88354149-1cdd-4ead-fc1a-1d40228f38b4"
      },
      "cell_type": "code",
      "source": [
        "my_array = np.random.randint(10, size=(5,4))\n",
        "my_other_array = np.random.randint(10, size=(10,5))\n",
        "print(my_array, '\\n')\n",
        "print(my_other_array)"
      ],
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[8 9 6 3]\n",
            " [3 1 7 7]\n",
            " [4 5 3 9]\n",
            " [5 6 8 0]\n",
            " [0 7 9 3]] \n",
            "\n",
            "[[2 5 0 7 4]\n",
            " [6 8 6 6 0]\n",
            " [8 1 6 9 4]\n",
            " [0 8 9 9 0]\n",
            " [3 1 3 0 2]\n",
            " [6 5 4 9 4]\n",
            " [9 3 0 8 2]\n",
            " [3 4 2 2 6]\n",
            " [4 5 8 2 1]\n",
            " [6 4 7 3 5]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "s_6JgBpUudsj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "1aa8386c-68d8-4a2d-ae7d-ff37b512359d"
      },
      "cell_type": "code",
      "source": [
        "# Faça a multiplicação entre my_other_array e my_array\n",
        "mult_array = np.dot(my_other_array, my_array)\n",
        "print(mult_array)"
      ],
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 66  93 139  53]\n",
            " [126 128 158 128]\n",
            " [136 185 181  97]\n",
            " [105 107 155 137]\n",
            " [ 39  57  52  49]\n",
            " [124 161 191 101]\n",
            " [121 146 157  54]\n",
            " [ 54  95 122  73]\n",
            " [ 89 100 108 122]\n",
            " [103 146 154 124]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "BMStn8lJudsl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "443dda08-7b7e-463a-a463-b4f6a0665064"
      },
      "cell_type": "code",
      "source": [
        "# Descubra a soma dos valores de cada linha de my_other_array\n",
        "# (Dica: Pesquise sobre o atributo axis da função de soma)\n",
        "soma_linhas = np.sum(my_other_array, axis=1)\n",
        "print(soma_linhas)"
      ],
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[18 26 28 26  9 28 22 17 20 25]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "Fh2fLcXiudso",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "4827da4c-d19f-4c62-dc20-ec509dad1fae"
      },
      "cell_type": "code",
      "source": [
        "my_array = np.random.randint(10, size=(5,4))\n",
        "print(my_array)"
      ],
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[5 3 0 0]\n",
            " [7 3 9 9]\n",
            " [9 6 2 0]\n",
            " [0 1 9 2]\n",
            " [7 0 7 9]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "JyczGBmyudsq",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "096d8cbb-5264-44f7-8e33-aa29bb36adb2"
      },
      "cell_type": "code",
      "source": [
        "# Usando reshape transforme a matriz acima em um vetor (Concatendo a linha de baixo na de cima\n",
        "my_array_vetor = my_array.reshape(-1)\n",
        "print(my_array_vetor)"
      ],
      "execution_count": 91,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[5 3 0 0 7 3 9 9 9 6 2 0 0 1 9 2 7 0 7 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "gsYucCe4udst",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "06bb3c2b-5a58-49a9-a071-eb128975b6c5"
      },
      "cell_type": "code",
      "source": [
        "np.array([[ 0,  1,  2,  3,  4,  5,  6,  7],\n",
        "          [ 8,  9, 10, 11, 12, 13, 14, 15]])"
      ],
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0,  1,  2,  3,  4,  5,  6,  7],\n",
              "       [ 8,  9, 10, 11, 12, 13, 14, 15]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 92
        }
      ]
    },
    {
      "metadata": {
        "id": "X9P64rLNudsx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "fada36ea-1aa3-4ba8-c0b2-fe06caef608c"
      },
      "cell_type": "code",
      "source": [
        "# Gere a array anterior usando np.arange e a função reshape\n",
        "sequencia = np.arange(16)\n",
        "resultado = sequencia.reshape(2, -1)\n",
        "print(resultado)"
      ],
      "execution_count": 95,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 0  1  2  3  4  5  6  7]\n",
            " [ 8  9 10 11 12 13 14 15]]\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}