Basico_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Basico Python.ipynb",
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyO3ytaP1Im/jKXa7vA/gPZJ",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/thalisreboucas/Python-codes-ML/blob/main/Basico_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FnaoLhznOecv"
      },
      "source": [
        "**Comandos Basicos do Python**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "03ZsxAihP0-G",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "adc21d29-904d-4554-eaf6-6347f05ad845"
      },
      "source": [
        "#Definir uma variavel\n",
        "x= 5\n",
        "#para ver x você tem que printar ou seja , usar a função print().\n",
        "print(x)\n",
        "\n",
        "#Qual o tipo de variavel x\n",
        "type(x)\n",
        "\n",
        "#Variavel string\n",
        "\n",
        "y= 'a'  #Sempre que for uma varaivel é string obrigatoriamente ao definir essa variavel é nescessario utlizar as aspas(\"\")\n",
        "\n",
        "print(y,type(y))\n",
        "\n",
        "#Temos como qualquer outra linguagem de programação os tipos de variaveis,podendo ser \"int\" ,nesse caso um número inteiro,\"float\",nesse caso uma \n",
        "#varaivel de ponto flutuante ou seja um varaivel real, \"string\" , ou seja uma varaivel de caracteres.\n",
        "\n",
        "#Temos tambem as varaiveis \"list\" , \"tuple\" e \"dic\"\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "a <class 'str'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G_gXVKyUA4Wd",
        "outputId": "e032fa9e-f275-49ad-8f54-db7619eef1ab"
      },
      "source": [
        "#Criando uma lista \n",
        "x=[1,2,3,4,5]\n",
        "print(x)\n",
        "type(x)\n",
        "\n",
        "#Tamanho da Lista, usa-se o comando ,len().\n",
        "print(len(x))\n",
        "\n",
        "#Valor maximo de uma número na list usa-se , max().\n",
        "print(max(x))\n",
        "\n",
        "#Valor minimo de uma número na list usa-se , min().\n",
        "print(min(x))\n",
        "\n",
        "#Manipulação de listas\n",
        "y = [6,7,8,9,10]\n",
        "\n",
        "#Adiciona um valor ou mais a uma lista, list.append(valor ou variavel).\n",
        "y.append(1)\n",
        "y.append(x)\n",
        "print(y)\n",
        "\n",
        "#inserir o valor em uma espaço definido, utiliza o comando list.insert(posição,variavel/valor).\n",
        "#Lembrando que o a primeira posição é zero\n",
        "y.insert(0,5) \n",
        "print(y)\n",
        "\n",
        "#Para contar algum valor ou caractere na lista, list.count(valor).\n",
        "y.count(1)\n",
        "\n",
        "#Remover valores de uma lista , list.remove().\n",
        "y.remove(1)\n",
        "y.remove(x)\n",
        "\n",
        "print(y)\n",
        "\n",
        "#Para organizar um lista , temos o comando , list.sort().\n",
        "z=[1,3,2,6,5,8]\n",
        "\n",
        "print(z)\n",
        "\n",
        "#Agora organizando a lista em ordem cresente utiliza , reverse=False.\n",
        "z.sort(reverse= False)\n",
        "print(z)\n",
        "\n",
        "#Agora organizando a lista em ordem decresente utiliza , reverse=True ou list.reverse().\n",
        "z.sort(reverse= True)\n",
        "\n",
        "print(z)\n",
        "\n",
        "#Ver um valor especifico da lista list[posição]\n",
        "z[2]\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 5]\n",
            "5\n",
            "5\n",
            "1\n",
            "[6, 7, 8, 9, 10, 1, [1, 2, 3, 4, 5]]\n",
            "[5, 6, 7, 8, 9, 10, 1, [1, 2, 3, 4, 5]]\n",
            "[5, 6, 7, 8, 9, 10]\n",
            "[1, 3, 2, 6, 5, 8]\n",
            "[1, 2, 3, 5, 6, 8]\n",
            "[8, 6, 5, 3, 2, 1]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "82V-QHK3JyZy",
        "outputId": "cfb85ab9-f64b-4761-dab8-48f86aacdc13"
      },
      "source": [
        "#Operações com Listas \n",
        "#Definindo duas listas\n",
        "A = [0,2,4]\n",
        "B = [6,8,10]\n",
        "#\"Somar\" duas listas \n",
        "C = A+B\n",
        "\n",
        "print(C) #como podemos ver esse comando junta duas listas\n",
        "\n",
        "#Repetir a lista n vezes , list*n\n",
        "D = A*2\n",
        "\n",
        "print(D)\n",
        "\n",
        "#Saber se um objeto pertence a lista\n",
        "\n",
        "3 in A\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 2, 4, 6, 8, 10]\n",
            "[0, 2, 4, 0, 2, 4]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u-5kEgtnBB8N",
        "outputId": "8d8b62d3-8877-4b05-b438-4937da54173e"
      },
      "source": [
        "#Crinado um tuple\n",
        "x = (1,2,3,4,5)\n",
        "print(x)\n",
        "\n",
        "type(x)\n",
        "\n",
        "#Comandos para Tuple\n",
        "\n",
        "#Tamanho de um Tuple, usa-se o comando ,len().\n",
        "print(len(x))\n",
        "\n",
        "#Valor maximo de uma número na Tuple usa-se , max().\n",
        "print(max(x))\n",
        "\n",
        "#Valor minimo de uma número na Tuple usa-se , min().\n",
        "print(min(x))\n",
        "\n",
        "#os comandos são o mesmo das listas"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(1, 2, 3, 4, 5)\n",
            "5\n",
            "5\n",
            "1\n",
            "(1, 2, 3, 4, 5, 2, 3, 4, 5)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_jmWbPZVL-xx",
        "outputId": "acc3675d-00f5-4493-f2ec-37bb3cbb035b"
      },
      "source": [
        "#Strings \n",
        "x = 'Meu nome'\n",
        "print(x)\n",
        "\n",
        "#comando input(),serve para receber um objeto .\n",
        "y = input(\"Digite seu nome\")\n",
        "print(y)\n",
        "\n",
        "z = input(\"Digite sua idade\")\n",
        "print(z)\n",
        "\n",
        "print('Meu nome é ',y,'e tenho',z ,'anos de idade')\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Meu nome\n",
            "Digite seu nomeThalis\n",
            "Thalis\n",
            "Digite sua idadeRebouças\n",
            "Rebouças\n",
            "Meu nome é  Thalis e tenho Rebouças anos de idade\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wghgttJsOdBH"
      },
      "source": [
        "**Condicionais e Estrutura**\n",
        "\n",
        "Python suporta **três codigos** para controle de estrutura : **if, while, and for**\n",
        "\n",
        "> **Estrutura If**\n",
        "\n",
        "\n",
        "O \"if\" é um paramentro de condição , que é a condição \"se\" ,dentro dessa estrutura temos o \"else\"que é o comando \"se não\" ,caso exista mais de condições pode usar o \"elif\" que é o \"else + if \" , que também é um \"se não\" , mas é para caso haja varias condições.\n",
        "\n",
        "\n",
        "\n",
        "> **Exemplo do If**  .\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "a=1\n",
        "b=2\n",
        "c=5\n",
        "if a > b :\n",
        "  print('a é maior que b')\n",
        "elif a > c :\n",
        "  print('a é maior que c')\n",
        "else:\n",
        "    print('b é maior que a')\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "72APFvEKOcKI"
      },
      "source": [
        "a=1\n",
        "b=2\n",
        "c=5\n",
        "if a > b :\n",
        "  print('a é maior que b')\n",
        "elif a > c :\n",
        "  print('a é maior que c')\n",
        "else:\n",
        "    print('b é maior que a')\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S749yH6fSeTm"
      },
      "source": [
        "**Estrutura While**\n",
        "\n",
        "Essa é uma estrutura para criar loops, neste caso o \"while\" é o comando \"enquanto\". Um dos cuidados que temos que ter é que o While precisa de uma condição para termina o \"equanto\" se não ficará em um looping infinito.\n",
        "\n",
        "\n",
        "\n",
        "> **Exemplo do While**\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "Idade = 0 \n",
        "while(Idade < 90):\n",
        "  print('A idade é ',Idade)\n",
        "  Idade = Idade + 1\n",
        "print('Finalizou o While')\n",
        "```\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0AbeGCLmV3T4"
      },
      "source": [
        "Idade = 0 \n",
        "while(Idade < 90):\n",
        "  print('São idade menos que noventa : ',Idade,'Anos')\n",
        "  Idade = Idade + 1 #serve para finalizar o looping ,pois se não só imprimiria o valor 0\n",
        "print('Finalizou o While')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cBO5R2ZAWriA"
      },
      "source": [
        "**Estrutura For**\n",
        "\n",
        "O \"For\" é uma estrutura de loop que \"anda\" em cima de algumas tipos de variavéis em sequência como , \"list\", \"string\" e \"dictionary\". O \"For\" é a estrutura \"para\".\n",
        "\n",
        "\n",
        "\n",
        "> **Exemplo do For**\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "bolas = [ 1,2,3,4,5,6,6,7,8,8,9,10,60,61,62,63]\n",
        "\n",
        "for numero in bolas :\n",
        "  if numero == 4 :\n",
        "   print('Saiu a bola é a 4')\n",
        "  elif numero == 62 :\n",
        "   print('Saiu a bola é a 62')\n",
        "  else:\n",
        "   print('Bola que não saiu')\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nSjOEp9Zjtkq"
      },
      "source": [
        "bolas = range(1,11)\n",
        "#range funciona criando uma lista de números ,range(x,y,n) ,sendo x o número que começa a lista e y o número que irá termina a lista, e n caso queria fazer a lista pulando em n em n .\n",
        "\n",
        "for numero in bolas :\n",
        "  if numero == 1 :\n",
        "   print('Saiu a bola é a 1')\n",
        "  elif numero == 2 :\n",
        "   print('Saiu a bola é a 2')\n",
        "  else:\n",
        "   print('Bola que não saiu')\n",
        "\n",
        "\n",
        "\n",
        "#Podemos também fazer com strings\n",
        "for x in 'bola':\n",
        "  print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KLI2szzWlTdn"
      },
      "source": [
        "\n",
        "**Programação orientada a Objetos**\n",
        "\n",
        "É um paradigma de programação baseado no conceito de \"objetos\", que podem conter dados na forma de campos, também conhecidos como atributos, e códigos, na forma de procedimentos, também conhecidos como métodos.\n",
        "\n",
        "> **Class**\n",
        "\n",
        "\n",
        "Temos a 'class' que define um atribudo a dados comuns e metodos para funções para um objeto. O termo 'class' , classes em português é um conceito abstrato. Um programa objeto orientado pode possuir multiplas classes. \n",
        "\n",
        "> **Objects**\n",
        "\n",
        "Um objeto é uma instacia de uma classe. É o que vai receber e guadar o atual tipo de dado e seu valor atribuido e vão chamar o metodo, podemos ter sub-classes de objetos também.\n",
        "\n",
        "O objeto pode representar várias coisas do nosso mundo , como uma imagem,video,base de dados , etc.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R6btoOk8dB-6"
      },
      "source": [
        "**Expreção Regulares e manipulação de arquivos**\n",
        "\n",
        "\n",
        "Expreção Regulares são como se fosse mini-liguagem definida dentro da linguagem usadas para manipular/definida regras especificas para strings definidas pelo programador .\n",
        "\n",
        "Expreção Regulares são usadas em diferentes tarefas como :\n",
        "\n",
        "*   Dividir ou mudar strings\n",
        "*   Encontrar uma sentença \n",
        "* Pré processamento de texto \n",
        "* Indetificar numeros ou outros simbolos\n",
        "\n",
        "É importante saber saber usar a sintaxes apropriadas como :\n",
        "\n",
        "\n",
        "*   Usar os simbolos . ^$+?[]{}\\|()\n",
        "*   [0-9]\n",
        "*   [a-z]\n",
        "*   a{4}\n",
        "\n",
        "\n",
        "> **Exemplo**\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "Import re #importante importa a library re no python \n",
        "\n",
        "texto_para_encotrar = \"sou um programador\"\n",
        "\n",
        "pattern = re.compile (r'sou') \n",
        "\n",
        "match = pattern.match(texto_para_encotrar)\n",
        "\n",
        "if match :\n",
        "  print(match.group())\n",
        "```\n",
        "\n",
        "**R.E modulo de funções**\n",
        "\n",
        "* match -> Encontrar um expreção regular padrão para o inicio do string\n",
        "* fullmatch -> Encontrar um expreção regular padrão para toda a string\n",
        "* search -> procurar um r.e padrão para toda a string\n",
        "* sub -> para substituir a ocorrencia de um padrão em uma string\n",
        "* split -> dividir uma string pela a ocorrencia de padrões \n",
        "* compile -> compilar um padrão em uma objeto padrão \n",
        "\n",
        "entre outros ,pode acessar o [r.e no python ](https://pymotw.com/2/re/) para entender melhor.\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gd1aObVKgNLz",
        "outputId": "b51bafe9-122f-43e5-8fb9-27f5ac9221c9"
      },
      "source": [
        "import re \n",
        "#importante importa a library re no python \n",
        "\n",
        "texto_para_encotrar = \"sou um programador\"\n",
        "\n",
        "pattern = re.compile (r'sou') \n",
        "padrao = re.compile (r'Programador')\n",
        "\n",
        "match = pattern.match(texto_para_encotrar)\n",
        "\n",
        "\n",
        "if match :\n",
        "  print(match.group())\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "sou\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l-WnL7zcgaMR"
      },
      "source": [
        "**Acessar arquivos no Python**\n",
        "\n",
        "Uma arquivo pode ser acessada com seguindo as seguides funções.\n",
        "\n",
        "* 'w' -> cria um novo arquivo apenas para escrever ou sobescrever um aquirvo que já existe.\n",
        "* 'r' -> ler um arquivo \n",
        "* 'a' -> Abri um arquivo para escreve-lo, caso não haja um arquivo para escrever\n",
        "\n",
        "* 'w+','r+','a+' , criação de arquivos para ler e escrever ,sendo respectivamente para criar um novo arquivo, abrir um novo arquivo  e abrir um arquivo já existente.\n",
        "\n",
        "\n",
        "> **Exemplo**\n",
        "\n",
        "```\n",
        "#Ler arquivo\n",
        "\n",
        "f = open('filename.txt','r')\n",
        "linhas = f.readlines()\n",
        "for linha in linhas:\n",
        "  print(linhas)\n",
        "f.close()\n",
        "\n",
        "#Escrever arquivo\n",
        "\n",
        "f =  open('filename.txt','w')\n",
        "f.write('hello world\\n!')\n",
        "f.close()\n",
        "\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A9mxQ8mVmynL"
      },
      "source": [
        "# **Algebra Linear**\n",
        "\n",
        "> **Revisão**\n",
        "\n",
        "As matrizes representação tansformações lineares em espaços vetorias, um espaço vetorial possui varias coodernadas.\n",
        "Transformações lineares são funções com vetores de entrada e saida.\n",
        "\n",
        "```\n",
        "Eg.v' = Mv\n",
        "```\n",
        "O vetor v é a transformação da matriz M resultando no vetor v'.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "> **Composição de Matrizes**\n",
        "\n",
        "A composição de matrizes descrevem o efeito de multiplicação e transformações .\n",
        "\n",
        "> Eg,v' = ABv\n",
        "\n",
        "A operação  de multiplicação entre as matrizes A,B  é a matriz de composição .\n",
        "\n",
        "Função rotação : Esquerda e Direta. \n",
        "\n",
        "*  A multiplicações de matrizes não são comutativas \n",
        "*  A multiplicação de matrizes são associativas.\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "> **Operações Lineares**\n",
        "\n",
        "A multiplicação de um vetor V_nxc pela uma matriz M_mxn ,resulta no caso geral de  :  \n",
        "\n",
        "> v'_mxc = M_mxn.v_nxc\n",
        "\n",
        "> **Determinante** \n",
        "O determinate é uma variavel escalar que representa o quanto que o espaço vetorial foi modificado por uma transformação.\n",
        "\n",
        "* Det(M) > 1, A area aumenta. \n",
        "* Det(M) < 1, A area diminui.\n",
        "* Det(M) = 0, Mostra que a diminuição do espaço vetorial em um menor.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3wqn59GBw-JR"
      },
      "source": [
        "# **Algebra no Python**\n",
        "\n",
        "Para fazer calculos de matrizes no Python teremos que utilizar a blibioteca numpy , que tem varias funções matematicas e operações com matrizes .\n",
        "\n",
        "> Referencia API [Numpy Python](https://numpy.org/doc/stable/user/quickstart.html)\n",
        "\n",
        "> Referencia [Cheat sheets](https://www.datacamp.com/community/blog/python-numpy-cheat-sheet)\n",
        "\n",
        "Você pode instalar o usando o comando :\n",
        "\n",
        "\n",
        "```\n",
        "pip3 install numpy\n",
        "\n",
        "import numpy as np\n",
        "```\n",
        "\n",
        "\n",
        "Alguns tipos de variaveis que nos esperamos trabalhar no numpy.\n",
        "* bool\n",
        "* int_\n",
        "* float_\n",
        "* complex_\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "bold = True\n",
        "int = 10\n",
        "float = 3.0\n",
        "complex = 1+2x\n",
        "```\n",
        "> **Criando um vetor**\n",
        "\n",
        "A criação de vetor segue a seguite linha de codigo, sendo que o dados presentes podendo ser inteiros ou reais e também matrizes de multiplas dimensões.\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "import numpy as np\n",
        "\n",
        "vetor =np.array([[1,2,3]])\n",
        "\n",
        "#criando vetor real com type float\n",
        "\n",
        "vetor_2 =np.array([[1,2,3]],dtype=np.float_)\n",
        "\n",
        "# criando matriz de multiplas dimensões\n",
        "\n",
        "vetor_3 =np.array([[1,2],[3,4]])\n",
        "\n",
        "```\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qr5sdJ1NIc_Y",
        "outputId": "c3f0fc28-6e72-499c-ac00-a14af02d9b8f"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "vetor =np.array([[1,2,3]])\n",
        "\n",
        "print(vetor)\n",
        "#criando vetor real com type float\n",
        "\n",
        "vetor_2 =np.array([[1,2,3]],dtype=np.float_)\n",
        "print(vetor_2)\n",
        "\n",
        "# criando matriz de multiplas dimensões\n",
        "\n",
        "vetor_3 =np.array([[1,2],[3,4]])\n",
        "\n",
        "print(vetor_3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1 2 3]]\n",
            "[[1. 2. 3.]]\n",
            "[[1 2]\n",
            " [3 4]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iV0kbihZImus"
      },
      "source": [
        "> **Matriz indentidade**\n",
        "\n",
        "A matriz indentidade é a que tem a diagonal principal igual a 1, e é criado pelo comando np.eye(x), sendo x um número inteiro.\n",
        "\n",
        "```\n",
        "import numpy as pd\n",
        "\n",
        "ind = np.eye(4)\n",
        "\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jUrXvaFbJa0l"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "ind = np.eye(4)\n",
        "print(ind)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TjxmDsLaKGol"
      },
      "source": [
        ">**Operações e funções**\n",
        "  Dado uma matriz m de 3 dimensões \n",
        "\n",
        "```\n",
        "import numpy as np\n",
        "\n",
        "M = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
        "\n",
        "```\n",
        "  * M[0] Seleciona a primeira linha\n",
        "  * M[1,2] Seleciona a segunda linha e o terceiro elemento\n",
        "  * M[:] Seleciona todos os elementos da matriz\n",
        "  * M[:,0] Seleciona a primeira coluna\n",
        "  * M[:,:2] Seleciona as duas primeiras colunas\n",
        "  * M[:,1:3] Seleciona as duas ultimas colunas\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1yydz9LAL93m"
      },
      "source": [
        "import numpy as np\n",
        " \n",
        "M = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
        "\n",
        "print(M[0])\n",
        "print(M[1,2])\n",
        "print(M[:])\n",
        "print(M[:,0])\n",
        "print(M[:,:2])\n",
        "print(M[:,1:3])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x_FrrjdVNSUt"
      },
      "source": [
        "> **Multiplição,soma ,subtração , divisão , transposta**\n",
        "\n",
        "\n",
        "*   Produto utiliza o operador : *\n",
        "*   Soma utiliza o operador : +\n",
        "*   Subtração utiliza o operador : -\n",
        "*   Divisão utiliza o operador : /\n",
        "*   Transposta utiliza o operador : .T\n",
        "*  Multiplicação utiliza o operador : @\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "import numpy as np\n",
        "\n",
        "A = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
        "B = np.array([[1,0,0],[0,5,0],[0,0,9]])\n",
        "\n",
        "print(A*B)\n",
        "\n",
        "print(A+B)\n",
        "\n",
        "print(A.T)\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iGOM45tXONCe"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "A = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
        "B = np.array([[1,0,0],[0,5,0],[0,0,9]])\n",
        "\n",
        "print(A*B)\n",
        "\n",
        "print(A+B)\n",
        "\n",
        "print(A.T)\n",
        "\n",
        "print(A@B)\n",
        "\n",
        "#Bônus: Produto vetorial \n",
        "x = np.array([[1,2,3]])\n",
        "y = np.array([[1,0,1]])\n",
        "\n",
        "z = np.cross(x,y)\n",
        "print(z)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z2EIE560O-e2"
      },
      "source": [
        "#**Decomposição e fatoração de Matrizes**\n",
        "\n",
        "\n",
        "> **Introdução a decomposição de matrizes**\n",
        "\n",
        "A a decomposição de matriz , também conhecido como fatoriazação , nada mas é que transformar as matrizes em produtos de matrizes ,assim otimizando a solução de sistemas. facilindado achar os auto valores e auto vetores.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "> **Decomposição L.U**\n",
        "\n",
        "Uma matiz A é transformada em uma matriz L é uma matiz triangular inferior e na qual a diagonal principal é 1 e U é uma matriz triagunlar diagonal superior \n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "> **Decomposição em QR**\n",
        "\n",
        "Uma matriz A é tranformarda em uma matriz Q ortogonal e R é uma matriz superior triangular ,nessa decomposição a matriz A não precisar ser nescessáriamente quadrada. \n",
        "Essa decomposição é uma aplicação de SVD e minimos quadrados.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "> **Decomposição em SVD**\n",
        "\n",
        "É uma decomposição em valores singulares,sendo a decomposição em eign valores e vetores de uma Matriz A,que pode não pode ser quadradas. \n",
        "Essa decomposição transformar a matriz A em três valores sendo U e V matrizes ortogonais sendo chamada matriz esquerda e direita , temos a matriz D que é a diagonal positiva que tem números reais sendo os valores singulares \n",
        "\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        ">**Aplicação**\n",
        "\n",
        "Temos LLS e PCA"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W6LHa_0HGGot"
      },
      "source": [
        "#**Machine Learning**\n",
        "\n",
        "Machine learnig nada mais é do que o estudo dos algoritimos de apredizagem com dados.\n",
        "\n",
        "Um computador é capaz de aprender tarefas e executa-las através de experiencia e melhorar o seu desempenho.\n",
        "\n",
        "Temos os algoritimos de :\n",
        "\n",
        "\n",
        "*   Clasificação\n",
        "*   Regressão\n",
        "*  Clusterização\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LeVoP47lTS4c"
      },
      "source": [
        "#**Rede Neurais**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fZQodWC0Vfvc",
        "outputId": "3b4af633-a215-443e-8d57-48fd03864118"
      },
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "\n",
        "A = np.array([[4,0,0],[-3,8,3],[0,0,12]])\n",
        "print(A)\n",
        "B = np.array([[4,0,0,96],[-3,8,3,192],[0,0,12,96]])\n",
        "print(B)\n",
        "\n",
        "np.linalg.eig(A)\n",
        "\n",
        "\n",
        "def f(x):\n",
        "\n",
        "  return x**2 - x - 1\n",
        "\n",
        "\n",
        "N,a,b = 4,1,2\n",
        "\n",
        "for n in range(1,N+1):\n",
        "\n",
        "  m_n = (a + b)/2\n",
        "\n",
        "  f_m_n = f(m_n)\n",
        "\n",
        "  if f(a)*f_m_n < 0:\n",
        "\n",
        "    b = m_n\n",
        "\n",
        "  else:\n",
        "\n",
        "    a = m_n\n",
        "\n",
        "x= (a + b)/2\n",
        "\n",
        "print(x)\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 4  0  0]\n",
            " [-3  8  3]\n",
            " [ 0  0 12]]\n",
            "[[  4   0   0  96]\n",
            " [ -3   8   3 192]\n",
            " [  0   0  12  96]]\n",
            "1.59375\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SOqSMS24YJDC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "90e57def-e0c6-4a10-db1a-8561fbdea5d4"
      },
      "source": [
        "from statistics import variance\n",
        "\n",
        "data = [2.75, 1.75, 1.25, 0.25]\n",
        "\n",
        "x = variance(data)\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1.0833333333333333\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}