03 - Introdução ao Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Básico para Computação Numérica"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## André Luiz da Costa Carvalho\n",
    "### andre@icomp.ufam.edu.br"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Nas próximas aulas:\n",
    "\n",
    "-  Python básico\n",
    "-  Básico do use de Notebooks Jupyter\n",
    "-  Vetores em Numpy\n",
    "-  Plotando com Matplotlib\n",
    "\n",
    "\n",
    "## Introdução\n",
    "\n",
    "Nesta aula, veremos algumas formas de utilizar Python para computação numérica. Se você já conhece Python, ótimo. Esta aula não focará na linguagem básica. Se não conhece, tudo bem. Para o que veremos nesta aula, basta um conhecimento bem básico.\n",
    "\n",
    "Pré-Requisitos de Software: Python 3.X + Numpy + Matplotlib + Jupyter.\n",
    "\n",
    "#### Como instalar?\n",
    "\n",
    "Jeito mais simples: baixe o Anaconda, que já instalará todos os pacotes necessários https://www.anaconda.com/download/\n",
    "\n",
    "Se quiser, pode ir instalando tudo manualmente também (se vire)\n",
    "\n",
    "#### Para rodar o Jupyter notebook\n",
    "\n",
    "__No lab:__ Vá a um terminal e rode: `jupyter notebook`\n",
    "\n",
    "__Com o Anaconda:__ abra um prompt anaconda e lá rode o mesmo comando (ou escolha no menu)\n",
    "\n",
    "\n",
    "## Python Básico com Notebooks\n",
    "\n",
    "_Tenha certeza que você rodou o jupyter notebook e que usou ele pra rodar o arquivo 03 - Introdução ao Python_\n",
    "\n",
    "\n",
    "Um notebook python é uma forma simplificada de misturar texto e código Python, simplificando a documentação e explicação de seu funcionamento. A unidade básica em um notebook é a célula.\n",
    "\n",
    "#### Rode a célula abaixo selecionando-a e pressionando Shift+enter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "4*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aperte 'a' para criar uma célula acima da atual, e 'b' abaixo. Você também pode usar os menus para isto. Para transformar uma célula em texto (markdown), aperte m. Para transformar em código de novo, aperte y. Ctrl+Shift+- Quebra a célula em duas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kernels\n",
    "\n",
    "As células de código são interpretadas pelo Python. Após uma célula ser rodada, um número aparece entre os colchetes. Este número indica __a ordem__ em que as células foram executadas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pacotes\n",
    "\n",
    "Uma das grandes vantagens de Python (especialmente para esta disciplina) é a grande facilidade para encontrar e usar novas bibliotecas como módulos que são triviais para usar.\n",
    "\n",
    "### Gerenciadores de pacotes\n",
    "\n",
    "O gerenciador de pacotes mais básico do Python é o Pip. Ele é um gerenciador de pacotes e configurações que vai ser muito útil para toda a vida de vocês com o Python\n",
    "\n",
    " - Usando anaconda não é legal de usar ele. Usem conda install.\n",
    " \n",
    "#### Instalando pacotes\n",
    "\n",
    "`pip install pacote`\n",
    "\n",
    "Ou se precida de uma versão específica:\n",
    "\n",
    "`pip install pacote==3.0`\n",
    "\n",
    "Isso instala o pacote e suas _dependências_\n",
    "\n",
    "#### Atualizando e desinstalando\n",
    "\n",
    "`pip install --upgrade pacote`\n",
    "\n",
    "`pip uninstall pacote`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Básico\n",
    "\n",
    "Python é uma linguagem de programação com variáveis com tipos definidos, porém determinados _implicitamente_. Isto significa que o Python infere o tipo de uma variável de acordo com o contexto do seu primeiro uso. Você só vai ver erros de variável em Python se tentar fazer condições com variáveis não previamente criadas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "n = 2+3\n",
    "fl = 2.0 + 3.0\n",
    "st = \"string\"\n",
    "l = [n,fl,st]\n",
    "print(n,fl,st)\n",
    "print(l[0])\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Além disto, Python também aceita formatos mais \"estranhos\" de atribuição"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "x,y,a = 1,2,-3\n",
    "x,y = y,x\n",
    "b = c = 123\n",
    "a+=n # n veio da celula anterior"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cada notebook tem um ambiente que guarda os valores das variáveis criadas até então, que existirão enquanto o kernel não for parado.\n",
    "\n",
    "Cada célula, ao ser executada, mostra o conteúdos dos prints imediatamente abaixo da mesma. Se você modificar e rodar de novo, a saída anterior é apagada e a nova é mostrada.\n",
    "\n",
    "#### Exercício\n",
    "\n",
    "Dadas as variaveis a,b e c criadas anteriormente, assuma que são os coeficientes de uma equação de segundo grau e calcule o seu delta na célula abaixo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estruturas de bloco\n",
    "\n",
    "Em Python, os blocos são indicados unicamente atráves de __identação__. Nada de {}s nem nada. Por isso a identação em códigos Python é essencial (se estiver errada o interpretador vai dar erro). No final de cada comando que pode gerar um bloco, o operador `:` é colocado para indicar que vai começar um novo nível de identação \n",
    "\n",
    "#### Exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "if x < 5 or (x > 10 and x < 20):\n",
    "    print(\"O Valor esta OK.\")\n",
    "\n",
    "if x < 5 or 10 < x < 20:\n",
    "    print(\"O Valor esta OK.\")\n",
    "\n",
    "for i in [1,2,3,4,5]:\n",
    "    print(\"Iteracao n#\", i)\n",
    "\n",
    "x = 10\n",
    "while x >= 0:\n",
    "    print(\"x ainda nao eh negativo.\",end='\\r')\n",
    "    x = x-1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício\n",
    "\n",
    "Adicione os valores de a,b e c abaixo e verifique quantas raízes reais uma equação de segundo grau com eles tem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "a = \n",
    "b = \n",
    "c = \n",
    "\n",
    "#Checa se estes valores geram duas, uma ou nenhuma raiz real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "    print(\"Valor é\",i)\n",
    "    \n",
    "for x in range(1,5):\n",
    "    print(\"Outro Intervalo\",x)\n",
    "\n",
    "#Decrescente com passo -2\n",
    "for j in range(10,1,-2):\n",
    "    print(\"Decrescente:\",j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Altere o código abaixo para arredondar os valores da lista abaixo para o valor inteiro mais próximo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [1.4,1.3,2.7,4.8,1.3,0.9]\n",
    "a = int(lista[0])\n",
    "a\n",
    "#arredonda aqui cara"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O comando `for` em Python tem uma sintaxe um pouco diferente. Um `for` itera _sobre os elementos de uma lista_. A cada iteração, a variável de controle (o `i`, por exemplo) recebe um dos elementos da lista. Para fazer um for com contadores, pode-se usar a função `range()`, que cria uma lista com elementos em um intervalo dado."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estruturas de dados\n",
    "\n",
    "A estrutura de dados composta mais básica no Python é a lista. Ela funciona como um vetor padrão, porém com muito mais flexibilidade. Cada elemento pode ter um tipo diferente, int, float, string ou até outras listas, e podem ser acessados via `[]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "l1 = [1,2,3]\n",
    "print(l1[2])\n",
    "l2 = [1, 2.0, \"string\",[4,5,l]] #valor de l vem la de cima\n",
    "\n",
    "print(l2)\n",
    "print(l2[3][2][1])\n",
    "print(len(l2),len(l2[3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O acesso também pode ser feito com o operador de intervalos `:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "nums = list(range(1,100,2))\n",
    "print(nums)\n",
    "#print(nums[10:20])\n",
    "#print(nums[-3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outra estrutura impotante em Python são os dicionários: Eles são _hashs_, estruturas que associam uma chave a um conteúdo. Na prática, eles são como listas, contudo ao invés de serem indexados por números, cada elemento tem uma chave, ou nome, que é usada para identificar cada elemento. Dicionários são identificados, na criação, pelo uso de `{}` (o acesso ainda é feito por colchetes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "telefones = {\"Jose\":12345678,\"Maria\":66666666,\"Carlos\":9876543}\n",
    "print(telefones[\"Carlos\"])\n",
    "pessoa = {'Nome':\"Andre\",\"Sobrenome\":\"Luiz\",'Telefone Comercial':2345678}\n",
    "print(pessoa['Nome'],pessoa['Sobrenome']+\":\",pessoa['Telefone Comercial'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para adicionar novos campos ao dicionário, basta fazer novas atribuições. Para verificar se um valor existe, use o operador `in`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "pessoa['Profissao']=\"Professor Universitario\"\n",
    "if(\"Joao\" not in telefones):\n",
    "    print(\"Sem João\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interessante também são os _conjuntos_: set.\n",
    "\n",
    "Qual é a definição de um conjunto?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set_1 = set([1, 2, 2, 3, 2, 1, 2])\n",
    "set_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set_2 = set((2, 4, 6, 5, 2))\n",
    "print(set_2)\n",
    "print(set('Banana'))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos fazer operações esperadas de conjuntos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(set_1.union(set_2))\n",
    "print(set_1.intersection(set_2))\n",
    "print(set_1.issubset({1, 2, 3, 3, 4, 5}))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funções\n",
    "\n",
    "Funções e procedimentos em Python são feitos através da palavra reservada `def`. Parametros ficam entre parêntesis separados por vírgulas, __sem precisar do tipo__. Funções podem ter um retorno, que funciona como no C `return <valor>`. Contudo, lembre: __Tudo que está no menor nível de identação é considerado como parte da main__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "def quadrado(x):\n",
    "    return x**2\n",
    "\n",
    "def delta(a,b,c):\n",
    "    return #adicione aqui o seu delta\n",
    "\n",
    "def raizseg(a,b,c):\n",
    "    return ((-b + delta(a,b,c)**(1/2))/2*a,(-b - delta(a,b,c)**(1/2))/2*a)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta última função é estranha né? Ela retorna uma tupla, no caso uma dupla. E como acessar isto?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "r = raizseg(1,-5,6)\n",
    "(x1,x2) = raizseg(1,-5,6)\n",
    "print(r)\n",
    "print(x1)\n",
    "print(x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercícios\n",
    "\n",
    "1 - Faça uma função norm1 que receba uma lista de valores e os normalize dividindo pelo maior da lista\n",
    "\n",
    "2 - Faça uma função norm2 que receba uma lista de valores e os normalize dividindo pela média da lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compreensões em listas\n",
    "\n",
    "Para terminar o básico, uma parte mais interessante: Compreensão de listas. Compreensões (_Comprehentions_) são listas criadas a partir de uma regra.\n",
    "\n",
    "Por exemplo: Você tem uma lista e você quer gerar uma nova que contenha apenas os elementos positivos, você pode:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = [1,-2,-3,4,-5,6,-7,8]\n",
    "\n",
    "l2 = [e for e in l1 if e>=0]\n",
    "l2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou se você quiser os elementos pares de uma lista sejam elevados ao quadrado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l3 = [x**2 for x in l2 if x%2==0]\n",
    "print(l3)\n",
    "\n",
    "\n",
    "def cubo(x):\n",
    "    return x**3\n",
    "n = 5\n",
    "dx = 1.0/(n-1)\n",
    "xlist = [i*dx for i in range(n)]\n",
    "ylist = [cubo(x) for x in xlist]\n",
    "print(xlist,ylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy\n",
    "\n",
    "Para usar bibliotecas em Python, você deve usar o comando `import`. Para usar a numpy, basta fazer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install numpy --user\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Se você usar apenas `import numpy`, você vai ter que usar o nome da biblioteca antes de todas as funções (tipo `numpy.linspace()`. O `as` gera um apelido pra classe, simplificando.\n",
    " \n",
    " Numpy é a biblioteca básica de computação numérica do Python. Ela disponibiliza objetos para vetores/matrizes/tensores, bem como funções otimizadas para eles (similar ao que o MATLAB faz).\n",
    " \n",
    " ### Arrays\n",
    " \n",
    " Arrays são os arranjos padrão de Python. Podem ser vetores (1d), Matrizes (2d) ou Tensores (3+d), e são indexados por tuplas de inteiros não negativos (negativos acessam o array do fim para o início.\n",
    " \n",
    " Qual a diferença para as listas? Arrays tem um único tipo, e são __extremamente__ melhor otimizados.\n",
    " \n",
    "  - São vetores n-dimensionais super poderosos.\n",
    "  - Funções de Broadcast (vetorização)\n",
    "  - Integrados com código C/C++ e Fortran\n",
    "  - Muito úteis para álgebra linear, transformadas de fourier e geração de valores aleatórios.\n",
    " \n",
    " Usando arrays de numpy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.array([1, 2, 3])   \n",
    "print(type(a))            \n",
    "print(a.shape)            # O que este shape está dizendo?\n",
    "print(a[0], a[1], a[2])   \n",
    "a[0] = 5                  \n",
    "print(a)                  \n",
    "\n",
    "b = np.array([ [1,2,3],[4,5,6] ])    \n",
    "print(b.shape)                     # E este?\n",
    "print(b.size)\n",
    "print(b[0][0], b[0, 1], b[1, 0])   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.zeros( (5,5) )\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "estamos usando `np` no lugar de numpy devido ao comando `as`. Além disto, o numpy dá acesso um monte de funções para a criação de matrizes padrão:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.zeros((2,2))   \n",
    "print(\"A:\")\n",
    "print(a)              \n",
    "\n",
    "b = np.ones((1,2))   \n",
    "print(\"B:\")\n",
    "print(b)              \n",
    "\n",
    "c = np.full((2,2), 7)  \n",
    "print(\"C:\") \n",
    "print(c)                         \n",
    "\n",
    "d = np.eye(4)         \n",
    "print(\"D:\")\n",
    "print(d)              \n",
    "                      \n",
    "\n",
    "e = np.random.random((2,2))  \n",
    "print(\"E:\")\n",
    "print(e)                     \n",
    "                             \n",
    "f = np.linspace(0,1,1001)\n",
    "print(\"F:\")\n",
    "print(f)\n",
    "         \n",
    "\n",
    "i = np.arange(1,100,2)\n",
    "print(\"I:\")\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim como com as listas, podemos acessar os arrays de numpy de forma poderosa usando o operador `:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
    "\n",
    "row_r1 = a[1, :]    \n",
    "row_r2 = a[1:3, :] \n",
    "print(row_r1, row_r1.shape)  \n",
    "print(row_r2, row_r2.shape)  # Qual a diferenca entre row_r1 e row_r2\n",
    "\n",
    "# Fica mais fácil de ver com colunas\n",
    "col_r1 = a[:, 1]\n",
    "col_r2 = a[:, 1:2]\n",
    "print(col_r1, col_r1.shape)\n",
    "print(col_r2, col_r2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[(2,1,0),:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Além disso, você pode usar também indexação booleana para escolher elementos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[a%2==0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operações em Numpy são lindas: Basta fazer as operações que você está acostumado (quase):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
    "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
    "\n",
    "\n",
    "print(x + y)\n",
    "print(np.add(x, y)) # Sao Equivalentes\n",
    "\n",
    "print(x - y)\n",
    "\n",
    "print(x * y) # PRODUTO ESCALAR\n",
    "\n",
    "print(x / y)\n",
    "\n",
    "print(np.sqrt(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como dá para ver no comentário, `*` é o produto escalar, ao invés de multiplicação matricial. Para multiplicar duas matrizes, você deve usar a função `dot()`, que pode ser usada de duas formas, `numpy.dot(m1,m1)` ou `m1.dot(m2)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([[1,2],[3,4]])\n",
    "y = np.array([[5,6],[7,8]])\n",
    "\n",
    "v = np.array([9,10])\n",
    "w = np.array([11, 12])\n",
    "\n",
    "#Produto interno\n",
    "print(v.dot(w))\n",
    "print(np.dot(v, w))\n",
    "\n",
    "#Matriz x vetor\n",
    "print(x.dot(v))\n",
    "print(np.dot(x, v))\n",
    "\n",
    "#Matriz x Matriz\n",
    "print(x.dot(y))\n",
    "print(np.dot(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Além disto, numpy dá diversas funções úteis sobre seus arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x.sum())\n",
    "print(v.mean())\n",
    "print(y.min())\n",
    "print(y.T)\n",
    "print(v/v.max())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercícios\n",
    "\n",
    "1 - Faça uma função norm1 que receba um arranjo numpy e o normalize dividindo pelo maior da lista\n",
    "\n",
    "2 - Faça uma função norm2 que receba uma arranjo numpy e os normalize dividindo pela média da lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def norm1(m):\n",
    "    return \n",
    "\n",
    "def norm2(m):\n",
    "    return \n",
    "\n",
    "print(norm1(x))\n",
    "print(norm2(x))\n",
    "print(x)\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Por que usar Numpy?\n",
    "\n",
    "A maioria das funções de Numpy pode ser feita sobre listas, com menos complicações.... Então por que usar Numpy?\n",
    "\n",
    "__VETORIZAÇÃO__\n",
    "\n",
    "Numpy utiliza de diversas operações otimizadas, que funcionam sobre grandes pedaços de vetores/matrizes ao invés de ser elemento por elemento. Ou seja, apesar da lógica ser a mesma, numpy faz operações de lote com vários elementos ao mesmo tempo, acelerando o processamento.\n",
    "\n",
    "Por isto é importante se manter utilizando numpy quando for trabalhar com arranjos (multiplicar um arranjo por uma lista, por exemplo, não é vetorizável)\n",
    "\n",
    "Então mesmo quando for utilizar funções simples como log ou seno, é melhor utilizar as versões de numpy para manter a vetorização:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.linspace(0,0.5,10)\n",
    "a = np.sin(a*np.pi)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funções também podem ser vetorizáveis, ou seja, rodar tanto pra escalares quanto para vetores de forma otimizada. Contudo, isto só serve para funções sem blocos condicionais ou repetições de saída."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pedindo Ajuda\n",
    "\n",
    "Muitas vezes em Python, seja em notebooks ou em modo iterativo, você pode ficar com muita dúvida sobre como as coisas funcionam. Nestas horas, geralmente o rapaz corre pro google/stackoverflow. Contudo, o Python tem funções de Help embutidas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(np.mean)\n",
    "#np."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "source": [
    "## Funçoes lambdas\n",
    "\n",
    "Muitas vezes, precisamos criar uma função de uma linha ou precisamos de uma função apenas para um contexto rápido. Para estes casos, podemos usar funções lambdas, que são criadas somente naquele instante e não ficam no nosso escopo.\n",
    "\n",
    "Estas funções recebem argumentos e retornam o valor de uma única expressão.\n",
    "\n",
    "`lambda argumentos: expressao`\n",
    "\n",
    "E também podem ser usadas para variáveis que guardam funções.\n",
    "\n",
    "Exemplo: A função sorted pede uma função de comparação. Podemos usar lambda:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted([(1, 2), (2, 0), (4, 1)], key=lambda x: x[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também colocar o resultado em uma função específica:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quadrado = lambda x:x**2\n",
    "\n",
    "print(quadrado(2))\n",
    "print(quadrado(36))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isso pode ser útil para usarmos um trecho de código para diferentes tipos de dados por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "flag_int = 0\n",
    "\n",
    "if(flag_int==1):\n",
    "    compara = lambda a,b: a==b\n",
    "else:\n",
    "    compara = lambda a,b: a-b<0.0000000000001 and a-b >-0.0000000000001\n",
    "\n",
    "print(compara(3,4),compara(0.1+0.2-0.3,0))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercícios\n",
    "\n",
    "1. Crie um vetor numpy com 100 elementos igualmente espaçados usando a função `linspace` do numpy.\n",
    "\n",
    "2. Dado um `vetor_a` [-1, 0, 1, 2, 0, 3], escreva um comando que retorne o vetor contendo todos os elementos maiores que 0 deste vetor, em um comando.\n",
    "\n",
    "3. Crie uma matriz:\n",
    "\n",
    "\n",
    "\\begin{pmatrix}\n",
    "3& 5 &3 \\\\\\\\\n",
    "2 & 2 & 5 \\\\\\\\\n",
    "3 & 8 & 9\n",
    "\\end{pmatrix}\n",
    "\n",
    "E calcule sua transposta\n",
    "\n",
    "4. Crie uma matriz com zeros no formato (2, 4).\n",
    "\n",
    "5. Altere a segunda coluna da matriz acima para 1.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}