Introducao_01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilizaremos este Jupyter Notebook para explorar alguns comandos simples que utilizaremos na Prática 01.\n",
    "\n",
    "Primeiro, vamos nos familiarizar com alguns comandos simples.\n",
    "\n",
    "O python pode executar cálculos pra nós:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja que obtivemos o resultado esperado. O pyhton também respeita as ordens corretas de caulo automaticamente. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3+1*4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3+1*5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se utilizarmos parênteses, é possível separar a ordem dos comandos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(3+1)*4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3+(1*4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bom, estes são comandos utilizando números diretamente, porém, quando lidamos com dados, temos colunas (vetores) ou matrizes cheias de dados. Como lidar com isso? Podemos atribuir os dados a variáveis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3\n",
    "b = 4\n",
    "c = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a*b+c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos, ainda, atribuir vários números a uma única variável:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,3,7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Você acabou de criar uma variável contendo algumas atribuições. O python tem várias denominações para cada tipo de variável. Descubra que tipo é utilizando este comando:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Não vamos perder muito tempo com isso nesse momento. Não temos que lidar com diferentes tipos de variáveis no python por enquanto.\n",
    "\n",
    "Agora vamos tentar uma operação, vamos multiplicar cada número da lista \"a\" por 3 e ver o que acontece:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a*3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Opa, o resultado foi diferente do esperado. Acontece que não estamos trabalhando com as ferramentas numéricas mais intuitivas do python. Nesse caso, o python entendeu que queríamos criar uma lista de tamanho 3 vezes maior que a, com os elementos de a repetidos. \n",
    "\n",
    "Para utilizar funções mais intuitivas, podemos usar bibliotecas feitas para o python, como a numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O que fizemos aqui foi importar a biblioteca numpy (que contém os comandos que estamos interessados em utilizar) e demos a essa biblioteca o nome np. Toda vez que quisermos utilizar uma função desta biblioteca, a chamamos com o prefixo np. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_np = np.array(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(a_np)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja que agora o tipo da variável que criamos é diferente. Temos aqui uma \"array\" numérica. Vamos testar nossa multiplicação:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_np*10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bingo!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com esta biblioteca podemos facilmente realizar cálculos mais complexos, com equações com múltiplos termos.\n",
    "\n",
    "Por exemplo, por vezes utilizamos funções exponenciais nos nossos cálculos. Podemos fazer isso com o comando np.exp do numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expoentes = [2, 3, 4, 5]\n",
    "a_exp = 10*np.exp(expoentes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Você pode criar um gráfico que mostre essa relação, mas para isso precisamos de uma biblioteca para que possamos fazer os plots. Para isso, utilizamos o matplot lib."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(expoentes,a_exp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos, ainda, adicionar os nomes de cada eixo com comandos simples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(expoentes,a_exp)\n",
    "plt.xlabel('Expoentes')\n",
    "plt.ylabel('a_exp')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos controlar o intervalo que queremos mostrar no plot. Isto é útil para padronizar nossos gráficos (dica: sempre utilize o mesmo intervalo para gráficos diferentes mostrando as mesmas variáveis). Para isso, usamos o comando plt.axis. Esse comando aceita os intervalos mínimos e máximos de cada eixo no seguinte formato [min_x,max_x,min_y,max_y]. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(expoentes,a_exp)\n",
    "plt.xlabel('Expoentes')\n",
    "plt.ylabel('a_exp')\n",
    "plt.axis([0,6,0,1600])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avançando um pouco mais, pode ser que queiramos criar uma lista longa de valores que em um intervalo específico. Por exemplo, se você quiser montar uma variável de valores de altitude em um intervalo de 0 a 100 metros, pode fazer isso com np.linspace. Você ainda determina em quantos valores esse intervalo será dividido (ex: 50). Se você tiver dúvida sobre como usar as funções, você pode buscar a documentação dela usando o comando print(biblioteca.nome_da_função.__doc__). Neste caso o comando seria: print(np.linspace.__doc__). Mas vamos lá, criando uma variável com os valores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zz = np.linspace(0,100,50)\n",
    "zz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que os valores variam linearmente de 0 a 100 em intervalos de aproximadamente, mas não perfeitamente, 100/50. Isto acontence pois a função inclui o 0 no início. Se realizarmos o mesmo cálculo de 0 a 98, teremos 50 elementos em intervalos de 100/50. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zz = np.linspace(0,98,50)\n",
    "zz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outra função semelhante é np.arrange ou range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bom, continuando. Temos uma lista de valores e agora podemos aplicá-lo numa equação. Por exemplo, digamos que há uma relação não-linear entre uma variável ambiental qualquer e a elevação como, por exemplo, pressão atmosférica (Pa). Sabendo que Pa é função exponencial da elevação (h), escrevemos uma equação na forma de Pa = 760exp(−0.00012h). Vamos, também, aumentar o \"range\" de valores de altitude para aproximar de valores atmosféricos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zz=np.linspace(0,10000,100)\n",
    "Pa = 760*np.exp(-0.00012*zz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora, vamos plotar isso"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(zz,Pa)\n",
    "plt.xlabel('Elevação (m)')\n",
    "plt.ylabel('Pressão atmosférica (mmHg)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E se quisermos fazer cálculos em que o valor sendo calculado depende do valor anterior? Como uma sequência temporal, por exemplo? Podemos utilizar for loops para isso. Dê uma pausa aqui e procure no google sobre \"o que são for loops em python\" e retomaremos isso em aula."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}