Guia_Básico_de_Python [COLAB].ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/andrebelem/ensino/blob/main/Guia_B%C3%A1sico_de_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": "6_uSnW-BxUH-"
   },
   "source": [
    "![](http://observatoriooceanografico.org/wp-content/uploads/elementor/thumbs/logo-o2-2-p31vla9ib17i85olifd4l1xk0e5lktrkal6u0s4c6o.png)<br>\n",
    "# Python Notebook com funções básicas<br>\n",
    "\n",
    "Criado por [A.L. Belém](mailto:andrebelem@id.uff.br) @ [Observatório Oceanográfico](http://www.observatoiriooceanografico.uff.br) 2021 (versão 1) para disciplina de **Modelagem e Otimização de Sistemas Agrícolas e Ambientais** e **Mudanças Climáticas e seus Impactos**, ministrado no Departamento de Engenharia Agrícola e Ambiental (e também para quem mais se interessar)<br>\n",
    "[![DOI](https://zenodo.org/badge/342919527.svg)](https://zenodo.org/badge/latestdoi/342919527)\n",
    "###### Última atualização: 17 de Agosto de 2022.\n",
    "<br>\n",
    "   Para você usar o Python de forma eficiente, você precisa saber algumas operações básicas. Não é necessário saber tudo isso de cabeça, mas ao menos você pode usar esse notebook para \"copiar\" algumas soluções quando for necessário.<br>\n",
    "As linhas abaixo podem funcionar de forma separada ou conjunta. A sugestão é que você vá executando cada linha e estudando tanto o seu conteúdo quanto o resultado. Copie para o seu Google Drive e modifique quando necessário (além de incluir suas próprias anotações).<br>\n",
    "\n",
    "Este Notebook foi criado para ser usado no **Google Colab**, mas também serve o Jupyter Notebook ou o Jupyter Lab."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L6Vi5i-OCshe"
   },
   "source": [
    "# Variáveis e *Strings*\n",
    "\n",
    "Quando você precisa armazenar valores, fazemos isso com **Variáveis**. Já uma **_String_** é onde armazenamos uma série de caracteres, entre aspas simples ou duplas.\n",
    "\n",
    "Veja os exemplos abaixo:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "SmA1tXpqCoFC"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "# (note que todos os comentários nas linhas de código iniciam por \"hashtag\" ou #)\n",
    "# esta é uma frase clássica de todo o curso de linguagem de programação\n",
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "rkT2XWR_DZ-1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "# da mesma forma que eu posso colocar o que quero imprimir em uma **_string_**\n",
    "msg = \"Hello World\"\n",
    "print(msg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "zg7o5YjADufD"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "# posso juntar duas strings ou outra informação aqui\n",
    "msg1 = \"hello \"\n",
    "msg2 = 'world' # e note que não faz diferença ter as aspas simples ou duplas\n",
    "print(msg1 + msg2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "gecHXAYuEw08"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world 2x\n"
     ]
    }
   ],
   "source": [
    "# e você pode ainda juntar números no meio de texto\n",
    "numero = 2\n",
    "print(f'Hello world {numero}x') # note que neste caso colocamos o numero entre {} e um 'f' na frente do texto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "pgMhCxcdFarR"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14159265359\n",
      "Pi=3.14159265359\n",
      "Pi=3.1416\n"
     ]
    }
   ],
   "source": [
    "# caso você queria formatar o número, veja como é fácil\n",
    "# imagine pi 3.14159265359\n",
    "pi = 3.14159265359\n",
    "print(pi)             # imprimindo direto\n",
    "print(f'Pi={pi}')     # com formato\n",
    "print(f'Pi={pi:.4f}') # neste caso limitamos em 4 casas decimais"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9gSCblRAJGgG"
   },
   "source": [
    "# Listas\n",
    "\n",
    "Digamos agora que você precisa criar uma lista com nomes específicos ou uma série de itens, para depois acessar os itens usando um índice ou dentro de um loop de repetição. Usamos aqui o símbolo **[** **]**. \n",
    "\n",
    "Veja os exemplos abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "-bvk-_mxJoQk"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Almada', 'Fazenda Cariri', 'Córrego do Meio', 'Ponte Quebrada']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lista de localidades\n",
    "myloc = ['Almada', 'Fazenda Cariri','Córrego do Meio','Ponte Quebrada']\n",
    "# ou se eu quiser, de códigos (Estações por exemplo)\n",
    "mycod = ['SAMBA001','SAMBA002','SAMBA003','SAMBA004']\n",
    "\n",
    "# ao dar print, fazemos apenas 1x\n",
    "myloc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "Flm7wMbtKI28"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['SAMBA001', 'SAMBA002', 'SAMBA003', 'SAMBA004']\n"
     ]
    }
   ],
   "source": [
    "# ou assim\n",
    "print(mycod)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "FB_HHWZ9KN_u"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "primeiro valor :Almada\n",
      "último valor :Ponte Quebrada\n",
      "misturando tudo :Córrego do Meio e SAMBA004\n"
     ]
    }
   ],
   "source": [
    "#ou posso acessar apenas 1 valor da lista\n",
    "print(f'primeiro valor :{myloc[0]}') # imprime o primeiro valor da lista\n",
    "print(f'último valor :{myloc[-1]}') # note que o último é referenciado como -1\n",
    "print(f'misturando tudo :{myloc[2]} e {mycod[-1]}') # tudo misturado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "fV85ltcELB6j"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Localidade:Almada\n",
      "Localidade:Fazenda Cariri\n",
      "Localidade:Córrego do Meio\n",
      "Localidade:Ponte Quebrada\n"
     ]
    }
   ],
   "source": [
    "# posso ainda fazer um loop ou laço. Veja que a sintaxe é especial e a identação também é importante\n",
    "for loc in myloc:\n",
    "  print(f'Localidade:{loc}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "PEE7A2u2LcDD"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Almada', 'SAMBA001', 'Fazenda Cariri', 'SAMBA002']\n"
     ]
    }
   ],
   "source": [
    "# listas podem começar vazias e depois adicionamos coisas\n",
    "meus_locais = []\n",
    "\n",
    "meus_locais.append(myloc[0]) # e posso misturar listas diferentes com o append\n",
    "meus_locais.append(mycod[0])\n",
    "meus_locais.append(myloc[1])\n",
    "meus_locais.append(mycod[1])\n",
    "\n",
    "print(meus_locais)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "O95L0kDSL32P"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]\n"
     ]
    }
   ],
   "source": [
    "# posso ainda criar listas numéricas\n",
    "serie_numeros = []\n",
    "\n",
    "# em um laço\n",
    "for x in range(0,12): # note que o valor inicial é 0 e o final é 12\n",
    "  serie_numeros.append(x)\n",
    "\n",
    "print(serie_numeros) # note que a saida só vai até 11 (!) isso é característico do python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "3ijl6-y4MT--"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Posso ainda criar uma série numérica diretamente e com uma equação\n",
    "serie_numeros = [x**2 for x in range(0,12)] # neste caso estou elevando ao quadrado\n",
    "serie_numeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "x66BEGrpMw48"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Começando a partir do 2° da série:[4, 9, 16, 25, 36, 49, 64, 81, 100, 121]\n",
      "do 2° ao antipenúltimo da série:[4, 9, 16, 25, 36, 49, 64, 81]\n",
      "pulando de 2 em 2:[0, 4, 16, 36, 64, 100]\n"
     ]
    }
   ],
   "source": [
    "# também posso \"fatiar\" uma lista\n",
    "print(f'Começando a partir do 2° da série:{serie_numeros[2:]}') \n",
    "print(f'do 2° ao antipenúltimo da série:{serie_numeros[2:-2]}') \n",
    "print(f'pulando de 2 em 2:{serie_numeros[0:-1:2]}') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RDHgqLialew_"
   },
   "source": [
    "# Condicionantes\n",
    "\n",
    "Quando trabalhamos com variáveis, **declarações** são usadas para testar condições particulares e responder apropriadamente uma pergunta sobre uma variável ou os valores guardados em uma lista, por exemplo\n",
    "\n",
    "Veja os exemplos abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "O4SSIgGtl8fY"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "teste 1: igualdade :False\n",
      "teste 2: diferença :True\n",
      "teste 3: maior :False\n",
      "teste 4: maior ou igual :False\n",
      "teste 5: menor :True\n",
      "teste 6: menor ou igual :True\n"
     ]
    }
   ],
   "source": [
    "# primeiro eu declaro minha variável\n",
    "x = 0\n",
    "\n",
    "# teste se é igual a um número\n",
    "print(f'teste 1: igualdade :{x == 1}')\n",
    "# teste se é diferente de um númer\n",
    "print(f'teste 2: diferença :{x != 1}') #  deve ser verdadeiro já que x=0\n",
    "# teste se é maior, maior ou igual\n",
    "print(f'teste 3: maior :{x > 1}')\n",
    "print(f'teste 4: maior ou igual :{x >= 1}')\n",
    "# teste se é menos, menos ou igual\n",
    "print(f'teste 5: menor :{x < 1}') #  deve ser verdadeiro já que x=0\n",
    "print(f'teste 6: menor ou igual :{x <= 1}') #  deve ser verdadeiro já que x=0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "K7TtHN2Xn3YG"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# é possível ainda validar condicionantes em listas\n",
    "mycod = ['SAMBA001','SAMBA002','SAMBA003','SAMBA004']\n",
    "\n",
    "'SAMBA003' in mycod # o resultado deve ser True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "_w4zftZloKSj"
   },
   "outputs": [],
   "source": [
    "# ou você pode declara uma variável Booleana (verdadeiro ou falso)\n",
    "estacao_completa = True\n",
    "pixel_valido = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "lhosvHfIoenf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aqui é Fundo\n",
      "Fundo\n"
     ]
    }
   ],
   "source": [
    "# Uma condição pode ser testada tanto de forma numérica quanto booleana\n",
    "\n",
    "# primeiro a numérica\n",
    "profundidade = 500\n",
    "\n",
    "if profundidade >100:\n",
    "  print('Aqui é Fundo')\n",
    "\n",
    "# ou várias condicionantes\n",
    "if profundidade < 100:\n",
    "  print('Raso')\n",
    "elif profundidade >= 100 and profundidade <= 700:\n",
    "  print('Fundo')\n",
    "else:\n",
    "  print('Muito fundo')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "pn2tJapxprWH"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "estação incompleta .. completando agora\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# agora a booleana\n",
    "\n",
    "estacao_completa = False\n",
    "if estacao_completa:\n",
    "  print('estação foi completa')\n",
    "else:\n",
    "  print('estação incompleta .. completando agora')\n",
    "  estacao_completa = True  # note que o que identifica o controle do if-else é a identação\n",
    "\n",
    "print(estacao_completa) # verifica se mudou de False para True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "htM-7r63qlzm"
   },
   "source": [
    "# Dicionários\n",
    "\n",
    "Os dicionários são listas de variáveis que armazenam conexões entre informações. Cada item de um dicionário é um par de valores-chave\n",
    "\n",
    "Veja os exemplos abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "oXZozMsdq1vA"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Nome': 'Soja', 'Plantio': 'Agosto', 'Rendimento': 45}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dicionário de culturas\n",
    "cultura = {'Nome':'Soja',\n",
    "           'Plantio':'Agosto',\n",
    "           'Rendimento':45}\n",
    "cultura"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "iUEFbRDPznnh"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Nome': 'Soja', 'Plantio': 'Agosto', 'Rendimento': 45, 'Colheita': 'Dezembro'}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# você pode ainda acrescentar mais valores.\n",
    "cultura['Colheita'] = 'Dezembro'\n",
    "cultura"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "Szjc_QRz1rqP"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A Cultura é Soja com rendimento de 45 kg/ha\n"
     ]
    }
   ],
   "source": [
    "# e ainda fazer um print de valores selecionados:\n",
    "print('A Cultura é '+cultura['Nome'] + ' com rendimento de '+ str(cultura['Rendimento']) + ' kg/ha')\n",
    "# note a conversão de um valor inteiro para string para o Rendimento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "gQHvH1F77h63"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Dezembro'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# note que você pode chamar 1 elemento do dicionário\n",
    "cultura['Colheita']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SLyfc_rGG-Gy"
   },
   "source": [
    "Embora este conceito de dicionário seja bastante amplo, não perca muito seu tempo aprendendo sobre dicionarios já que há outra ferramenta muito mais poderosa chamada `pandas` (e que veremos em outra oportunidade).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r_TzLqb0HR_x"
   },
   "source": [
    "# Laços de repetição (loops)\n",
    "\n",
    "Os laços são interações muito importantes no Python porque permitem que você programe um número grande de operações repetitivas. Essa é justamente a força de qualquer linguagem de programação.<br>\n",
    "\n",
    "Um laço do tipo `for` é usado para interagir dentro de uma sequência (ou seja, uma lista, uma tupla, um dicionário, um conjunto, etc etc). Outro tipo de laço é o `while`, também muito útil. Veja os exemplos abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "iU6i1467LfB_"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O cultivo é Soja\n",
      "O cultivo é Milho\n",
      "O cultivo é Café\n",
      "O cultivo é Arroz\n"
     ]
    }
   ],
   "source": [
    "# for aplicado em uma lista. Primeiro, eu tenho que ter a lista !\n",
    "culturas = ['Soja','Milho','Café','Arroz']\n",
    "# veja o número de itens da sua lista\n",
    "len(culturas)\n",
    "\n",
    "# agora faça o laço 'for'\n",
    "for cultivo in culturas: # note que esta linha termina em \":\"\n",
    "  print(f'O cultivo é {cultivo}') # note que a identação desta linha é diferente\n",
    "\n",
    "# não há indicativo do final das operações do laço. Então, o controle é feito pela identação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "pQYJ8LeGMMwm"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O caracter 1 é c\n",
      "O caracter 2 é l\n",
      "O caracter 3 é i\n",
      "O caracter 4 é m\n",
      "O caracter 5 é a\n",
      "O caracter 6 é t\n",
      "O caracter 7 é o\n",
      "O caracter 8 é l\n",
      "O caracter 9 é o\n",
      "O caracter 10 é g\n",
      "O caracter 11 é i\n",
      "O caracter 12 é c\n",
      "O caracter 13 é a\n",
      "O caracter 14 é m\n",
      "O caracter 15 é e\n",
      "O caracter 16 é n\n",
      "O caracter 17 é t\n",
      "O caracter 18 é e\n"
     ]
    }
   ],
   "source": [
    "# o laço pode ser feito sobre caracteres em uma variável\n",
    "# e posso ainda contar dentro de um laço\n",
    "ic = 0\n",
    "for x in 'climatologicamente':\n",
    "  ic = ic+1\n",
    "  print(f'O caracter {ic} é {x}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "s2jnW0MWMmq_"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo 1 *****************\n",
      "Número 0\n",
      "Número 1\n",
      "Número 2\n",
      "Número 3\n",
      "Número 4\n",
      "Número 5\n",
      "Exemplo 2 *****************\n",
      "Número 4\n",
      "Número 5\n",
      "Número 6\n",
      "Número 7\n",
      "Exemplo 3 *****************\n",
      "Número 2.0\n",
      "Número 2.5\n",
      "Número 3.0\n",
      "Número 3.5\n"
     ]
    }
   ],
   "source": [
    "# você pode fazer o laço sobre uma faixa de valores\n",
    "print('Exemplo 1 *****************')\n",
    "for i in range(6):\n",
    "  print(f'Número {i}')\n",
    "# faça um experimento: apague o \":\" no final da linha do for e veja o erro que ele mostra (invalid sintax)\n",
    "\n",
    "print('Exemplo 2 *****************')\n",
    "# outro tipo de range\n",
    "for i in range(4,8):\n",
    "  print(f'Número {i}')\n",
    "\n",
    "print('Exemplo 3 *****************')\n",
    "# outro tipo de range (com float)\n",
    "import numpy as np  # note que para isso você precisa de uma biblioteca\n",
    "for i in np.arange(2.0,4.0,0.5): # entre 2 e 4, com step de 0.5\n",
    "  print(f'Número {i}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "jy2CwnOrN7a0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A sequencia é 0\n",
      "A sequencia é 1\n",
      "A sequencia é 2\n",
      "--- passou pela metade\n",
      "A sequencia é 4\n",
      "A sequencia é 5\n"
     ]
    }
   ],
   "source": [
    "# outro exemplo muito útil é você aplicar uma condição `if` nas operações\n",
    "for x in range(6): \n",
    "  if x == 3:       # note como o if é construido, a identação, e o \":\" no final do if e do else\n",
    "    print(\"--- passou pela metade\")\n",
    "  else:\n",
    "    print(f'A sequencia é {x}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "Z7zBj6DlOlyj"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O número 1 é menor do que 5\n",
      "O número 2 é menor do que 5\n",
      "O número 3 é menor do que 5\n",
      "O número 4 é menor do que 5\n",
      "Acabei o laço com o contador igual à 5\n"
     ]
    }
   ],
   "source": [
    "# while simples - como aplicar em uma sequencia aberta\n",
    "contador = 1\n",
    "while contador < 5:  # modifique para \"<=\" para ver o que acontece\n",
    "  print(f'O número {contador} é menor do que 5')\n",
    "  contador += 1\n",
    "print(f'Acabei o laço com o contador igual à {contador}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "id": "hgS6k-quPFNU"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O número 1 é menor do que 5\n",
      "O número 2 é menor do que 5\n",
      "O número 3 é menor do que 5\n",
      "Acabei o laço com o contador igual à 3\n"
     ]
    }
   ],
   "source": [
    "# while - veja como condicionar a parada\n",
    "contador = 1\n",
    "while contador < 5:  # modifique para \"<=\" para ver o que acontece\n",
    "  print(f'O número {contador} é menor do que 5')\n",
    "  if contador == 3:\n",
    "    break            # nesse caso, eu quebrei a sequencia antes\n",
    "  contador += 1\n",
    "print(f'Acabei o laço com o contador igual à {contador}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bwpBjiAnPZfP"
   },
   "source": [
    "# Funções\n",
    "\n",
    "Funções são muito importantes ! porque você pode executar códigos ou tarefas específicas sobre um bloco de dados ou organizar funções repetitivas.<br>\n",
    "\n",
    "Note que um detalhe importante é você comentar BEM a sua função de forma que um usuário qualquer entenda o que você fez."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "id": "OK7imMiiQIRg"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O resultado é 12\n"
     ]
    }
   ],
   "source": [
    "# um exemplo muito simples\n",
    "def adicione(a, b):\n",
    "  'Esta função é tão simples que não precisa de *contrato*'\n",
    "  'Um *contrato* é o texto que vai aqui logo depois do def e que indica o que essa rotina faz'\n",
    "  'criada por MeuNome em 2021 (por exemplo, para sabermos quem fez)'\n",
    "  result = a + b\n",
    "  return result\n",
    "\n",
    "# agora veja como posso chama-la\n",
    "soma = adicione(5, 7)\n",
    "print(f'O resultado é {soma}')\n",
    "# o resultado tem que ser 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "id": "V79wVIeXQygA"
   },
   "outputs": [],
   "source": [
    "# uma função pode (deve?!) ser colocada em uma linha no colab para facilitar sua vida\n",
    "# não necessariamente você vai ter que chamá-la sempre.\n",
    "def find_numero_mais_alto(numbers):\n",
    "    'encontra o número mais alto'\n",
    "    highest = 0\n",
    "    for n in numbers:\n",
    "        if n > highest:\n",
    "            highest = n\n",
    "    return highest\n",
    "\n",
    "# note a estrutura de construção acima, identado e com os \":\" nos lugares certos\n",
    "# executando esta linha, a função já está definida."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "id": "7nBaKSswROeh"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O número mais alto é 148\n"
     ]
    }
   ],
   "source": [
    "# agora criei uma lista com vários números e chamo a função\n",
    "scores = [21, 14, 72, 148, 54]\n",
    "top_score = find_numero_mais_alto(scores)\n",
    "\n",
    "print(f'O número mais alto é {top_score}')\n",
    "# O resultado deve ser 148"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "35eBzR_qSIZj"
   },
   "source": [
    "Existe uma infinidade de coisas que você pode fazer com funções e acima estão as mais simples. Mas procure saber que você pode ainda usar parâmetros e argumentos (ou `*args`), palavras-chave (ou `keywords`), entre outras. Abaixo estão alguns exemplos. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "id": "54I2T3hpSpXv"
   },
   "outputs": [],
   "source": [
    "# Exemplo 1\n",
    "def tipo_cultivo(produtor, *args):\n",
    "    print(produtor, 'é o produtor')\n",
    "    for cultivo in culturas:\n",
    "        print(f'Cultivo: {cultivo}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "id": "vsc8UvXnTBmr"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seu José é o produtor\n",
      "Cultivo: Soja\n",
      "Cultivo: Milho\n",
      "Cultivo: Café\n",
      "Cultivo: Arroz\n"
     ]
    }
   ],
   "source": [
    "# note que o primeiro argumento é o host e os outros são os cultivos no exemplo acima.\n",
    "tipo_cultivo('Seu José', 'Milho', 'Soja', 'Feijão', 'Cana') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "id": "6Z23cRHcUEid"
   },
   "outputs": [],
   "source": [
    "def tabela_preços(produtor, **kwargs):\n",
    "    print(produtor, \"preços:\")\n",
    "    for key, value in kwargs.items():\n",
    "        print(key, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QBDKq9MLURzF"
   },
   "source": [
    "`**kwargs` é semelhante a `*args`, exceto que é usado para dizer a uma função para aceitar qualquer número de argumentos de palavra-chave, que podem ser chamados assim:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "id": "genypnPUUYaP"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seu José preços:\n",
      "milho 98\n",
      "cana 250\n",
      "soja 176\n"
     ]
    }
   ],
   "source": [
    "tabela_preços(\"Seu José\", milho=98, cana=250, soja=176)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "d30MXE0UUvHs"
   },
   "source": [
    "### Melhores Práticas\n",
    "#### **Princípio de responsabilidade única**\n",
    "\n",
    "Você pode ter ouvido falar do princípio da responsabilidade única. Isso significa que suas funções devem se concentrar apenas em lidar com um **único** aspecto de seu programa.<br>\n",
    "\n",
    "Por exemplo, digamos que você queira escrever algum código que faça três coisas: buscar um dado na web, extrair dados da web e imprimir os dados no terminal. Você não escreveria uma função que extraísse os dados da página da web E imprimisse os resultados no terminal, porque talvez um dia você precise alterar seu código para salvar esses resultados em um arquivo ou enviá-los para outro programa.<br>\n",
    "\n",
    "Você pode notar que quebrar seu código em funções reutilizáveis ​​menores evita que ele se torne exponencialmente mais complicado e o mantém flexível para reutilização em sua base de código (e de outras pessoas).<br>\n",
    "#### **Nomeando suas funções**\n",
    "Uma função bem nomeada deve quase ser lida como uma frase quando usada. Quando alguém está lendo o código, deve ser imediatamente óbvio o que está acontecendo no código. Uma boa regra é projetar e nomear sua função de forma que ela possa ser usada para simplificar um conjunto mais complexo de operações em uma única expressão. E **nunca use** nomes que confundam variáveis com funções ou que sejam idênticas à funções que já existem no python (por exemplo, a função `pi` no pacote `math`. Se você quiser ter seu próprio `pi`, use o nome `my_pi`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "id": "ytjJ2fERVt30"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O pi real é 3.141592653589793\n",
      "O meu pi é 3.14\n"
     ]
    }
   ],
   "source": [
    "# seu pi\n",
    "import math\n",
    "print(f'O pi real é {math.pi}')\n",
    "\n",
    "def my_pi():\n",
    "  return(3.14)\n",
    "  \n",
    "print(f'O meu pi é {my_pi()}') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hY6MCJ_SWyxX"
   },
   "source": [
    "# Imprimindo resultados\n",
    "\n",
    "Aqui temos algumas regras básicas para você imprimir resultados no seu terminal.<br>\n",
    "\n",
    "O comando `print` muda um pouco dependendo da versão do python e do ambiente que você está. A regra de ouro é *seja o mais simples possível*. Seguem alguns exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "id": "4maHX-WnXe3T"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      "imprime qualquer texto...\n",
      "O valor e pi é 3.141592653589793(você sabia ?)\n",
      "O valor de pi é 3.141592653589793\n",
      "ou arredondando 3.142\n",
      "ou próximo de  3\n"
     ]
    }
   ],
   "source": [
    "print() # imprime \"nada\"\n",
    "print('\\n') # imprime uma nova linha\n",
    "print('') # imprime uma linha vazia\n",
    "message = 'imprime qualquer texto...'\n",
    "print(message)\n",
    "# um pouco mais complexo\n",
    "import math\n",
    "print('O valor e pi é ' + str(math.pi) + '(você sabia ?)') # note que pi é um número e print só trabalha com caracteres\n",
    "\n",
    "# imprimindo formatado\n",
    "print(f'O valor de pi é {math.pi}')\n",
    "print(f'ou arredondando {math.pi:.3f}') # note que arredondamos aqui para 3 casas decimais\n",
    "print(f'ou próximo de  {int(math.pi):d}') # note que arredondamos um float para um inteiro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ESqo1npqYtub"
   },
   "source": [
    "Espero que você **seja muito feliz com o Python !**"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "authorship_tag": "ABX9TyMoUwl1ZkhPXwccPJq99mEn",
   "collapsed_sections": [
    "RDHgqLialew_",
    "htM-7r63qlzm",
    "r_TzLqb0HR_x",
    "bwpBjiAnPZfP",
    "d30MXE0UUvHs",
    "hY6MCJ_SWyxX",
    "ESqo1npqYtub"
   ],
   "include_colab_link": true,
   "name": "Guia Básico de Python.ipynb",
   "provenance": []
  },
  "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.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}