dia1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5eb73704",
   "metadata": {},
   "source": [
    "# Dia 1 \n",
    "\n",
    "## Apresentação geral\n",
    "\n",
    "- Objetivos gerais\n",
    "- Estrutura do curso\n",
    "- Metodologia\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e846af6",
   "metadata": {},
   "source": [
    "## Sairemos daqui programadores e hackers?\n",
    "\n",
    "Não, né.\n",
    "\n",
    "Aprender uma linguagem de programação demanda dedicação de tempo quase como\n",
    "aprender um novo idioma.\n",
    "\n",
    "É mais importante aprender a famosa *lógica de programação* e compreender o \n",
    "funcionamento e possibilidades e limites da linguagem. Assim podemos, não só\n",
    "avançar no aprendizado, mas também seremos capazes de trabalhar colaborativamente\n",
    "com programadores/as de forma mais eficiente e criativa."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2231b32",
   "metadata": {},
   "source": [
    "## Erros\n",
    "\n",
    "### Vamos errar muito, e isso é importante!\n",
    "\n",
    "Vamos esquecer uma vírgula, deixar de fechar um parênteses, colocar aspas no lugar\n",
    "errado e faz parte.\n",
    "\n",
    "Os erros são muito importantes para aprendermos a perguntar, testar e corrigir.\n",
    "\n",
    "### Erramos. E agora? Onde vamos pedir ajuda?\n",
    "\n",
    "- O velho [Google](google.com.br)? Sim, mas cuidado...\n",
    "- ChatGPT's da vida? Sim, mas cuidado...\n",
    "- [StackOverflow](https://stackoverflow.com/)? Sim, mas paciência..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f271431",
   "metadata": {},
   "source": [
    "## Introdução à linguagem de programação Python\n",
    "\n",
    "- O que é Python e por que é usado?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03284f34",
   "metadata": {},
   "source": [
    "### Pq Python?\n",
    "\n",
    "[Python](https://docs.constellate.org/key-terms/#python) é uma das linguagens de programação que mais crescem no mundo. Aprender Python é uma ótima escolha pois é uma linguagem:\n",
    "\n",
    "* amplamente adotada nas humanidades digitais e ciência de dados;\n",
    "* que tem uma curva de aprendizado menor do que outras linguagens; \n",
    "* flexível, possuindo amplo suporte para lidar com dados numéricos e textuais;\n",
    "* que lembra o inglês e é legível para quem sabe esse idioma."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c34df7f",
   "metadata": {},
   "source": [
    "### Como executamos um programa em Python?\n",
    "\n",
    "Várias formas de executar o Python ou programas e scripts em Python. Vejamos algumas que serão utilizadas neste curso.\n",
    "\n",
    "#### Python interativo e o temido terminal\n",
    "\n",
    "O Python interativo é uma forma de executar o Python diretamente no terminal. Para acessar o Python interativo, basta digitar `python` no terminal ou no GitBash. [^bash]\n",
    "\n",
    "[^bash]: Sobre usos básicos do terminal, ver \"Introdução à Linha de Comando Bash\" de Ian Milligan e James Baker no [The Programming Historian](https://programminghistorian.org/en/lessons/intro-to-bash). A versão em português da lição está em faze de revisão e sua pré-visualização pode ser acessada [aqui](http://programminghistorian.github.io/ph-submissions/pt/esbocos/traducoes/introducao-linha-comando-bash)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d8fc5b7",
   "metadata": {},
   "source": [
    "```bash\n",
    "python\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06211cdc",
   "metadata": {},
   "source": [
    "Assim que você pressionar enter, você verá uma mensagem de boas-vindas e o prompt `>>>`. Isso significa que o Python está pronto para receber comandos."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfec428e",
   "metadata": {},
   "source": [
    "```bash\n",
    ">>> print('Alô, Mundo!')\n",
    "Alô, Mundo!\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c2124e6",
   "metadata": {},
   "source": [
    "Podemos e comumente vamos executar *scripts* diretamente através de linhas de comando no terminal."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10752f3a",
   "metadata": {},
   "source": [
    "```bash\n",
    "python <nome-do-script>.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da350a69",
   "metadata": {},
   "source": [
    "Vamos explorar um pouco o terminal e o python interativo."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7596391e",
   "metadata": {},
   "source": [
    "#### Jupyter Notebooks\n",
    "\n",
    "OS Jupyter Notebooks são documentos que podem conter texto, código, gráficos e muito mais. Eles são uma ótima maneira de compartilhar e executar código Python diretamente no navegador ou em um ambiente de desenvolvimento integrado (IDE) como o VSCode, basta baixar o arquivo `.ipynb` e executá-lo.[^jupyter]\n",
    "\n",
    "[^jupyter]: instale o Jupyter Notebook com o comando `pip install notebook` no terminal ou GitBash. E também instale a extensão do Jupyter Notebook no VSCode: procure por \"Jupyter\" no menu de extensões."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20da6d0a",
   "metadata": {},
   "source": [
    "É possível utilizar a sintaxe do Markdown para formatar o texto e inserir imagens, links, tabelas, etc.\n",
    "\n",
    "Por exemplo, podemos **destacar um trecho de texto** de *várias formas* ~~diferentes~~."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d5235d8",
   "metadata": {},
   "source": [
    "Podemos inserir uma imagem no nosso arquivo:\n",
    "\n",
    "![exemplo](./assets/11042359303_263751817b_c.jpg)\n",
    "\n",
    "Ou ainda a partir de uma URL:\n",
    "\n",
    "![](https://live.staticflickr.com/65535/51129326143_65f793320a_h.jpg)\n",
    "\n",
    "Podemos inserir links para sites, como a url com os dados completos da [primeira imagem](https://www.flickr.com/photos/britishlibrary/11042359303/in/gallery-193817602@N06-72157719813672860/) e da [segunda imagem](https://www.flickr.com/photos/biodivlibrary/51129326143/in/gallery-193817602@N06-72157719813672860/).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24f4f1cd",
   "metadata": {},
   "source": [
    "E criar tabelas:\n",
    "\n",
    "| Nome | Idade | Cidade |\n",
    "| ---- | ----- | ------ |\n",
    "| João | 25    | SP     |\n",
    "| Maria| 30    | RJ     |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e86b873f",
   "metadata": {},
   "source": [
    "E, o mais importante, podemos executar código Python diretamente no notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b134039",
   "metadata": {},
   "source": [
    "Nesse curso vamos utilizar Jupyter Notebooks em vários momentos para facilitar a execução de códigos e a visualização de resultados.\n",
    "\n",
    "É possível executar notebooks diretamente no navegador através do [Binder](https://mybinder.org/), [Google Colab](https://colab.research.google.com/) ou [Azure Notebooks](https://notebooks.azure.com/).\n",
    "\n",
    "Para saber mais, veja a lição \"Introdução ao Jupyter Notebook\" de Quinn Dombrowski, Tassie Gniady e David Kloster no [The Programming Historian](https://programminghistorian.org/pt/licoes/introducao-jupyter-notebooks).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "182652a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "2+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d997899c",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Meu nome é Eric.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34a6c6d0",
   "metadata": {},
   "source": [
    "## Conceitos básicos de programação em Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cad5f43",
   "metadata": {},
   "source": [
    "### Variáveis\n",
    "\n",
    ">Um dos recursos mais eficientes de uma linguagem de programação é a capacidade de manipular variáveis. Uma variável é um nome que se refere a um valor. (Downey, 2016)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b746b4c1",
   "metadata": {},
   "source": [
    "Uma variável é uma etiqueta atribuída a um objeto. Em Python, você pode criar uma variável atribuindo um valor a ela usando o operador de atribuição `=`. Por exemplo, para criar uma variável chamada `x` e atribuir o valor `1` a ela, você pode fazer o seguinte:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2d99272",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa4b80ee",
   "metadata": {},
   "source": [
    "\n",
    "A variável `x` agora aponta para o valor `1` que está armazenado na memória do seu computador. Se disser que `a = x` e `b = x`, então `a` e `b` também apontarão para o valor `1` na memória do seu computador.\n",
    "\n",
    "Ou seja, uma variável não é um caixinha que guarda um valor, mas uma etiqueta que aponta para um valor.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d158324",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = x\n",
    "b = x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6c23198",
   "metadata": {},
   "source": [
    "Se quisermos encontrar o espaço na memória que a variável `x` está apontando, podemos usar a função `id()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b680f43",
   "metadata": {},
   "outputs": [],
   "source": [
    "id(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d69c69f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "id(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "993c678d",
   "metadata": {},
   "outputs": [],
   "source": [
    "id(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35afc71d",
   "metadata": {},
   "source": [
    "\n",
    "Percebemos que `x`, `a` e `b` apontam para o mesmo espaço na memória. Isso significa que se mudarmos o valor de `x`, `a` e `b` também mudarão? Vamos testar.\n",
    "\n",
    "**Importante**: Em Python, um único sinal de igual `=` é o \"operador de atribuição\". Um sinal de igual duplo `==` é o sinal de igual \"real\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "475f8a12",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ce61650",
   "metadata": {},
   "outputs": [],
   "source": [
    "id(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa5fdb1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "id(a), id(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9882ac64",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [],
   "source": [
    "# criar uma variável\n",
    "nome = 'Maria'\n",
    "#imprimir o valor da variável\n",
    "print(nome)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c7dc449",
   "metadata": {},
   "source": [
    "#### Nomeando variáveis\n",
    "\n",
    "Trechos traduzido de [Variables](https://melaniewalsh.github.io/Intro-Cultural-Analytics/02-Python/04-Variables.html) Melanie Walsh.\n",
    "\n",
    "Os nomes das variáveis podem ser tão longos ou curtos quanto você quiser e podem incluir:\n",
    "- letras maiúsculas e minúsculas (A-Z)\n",
    "- dígitos (0-9)\n",
    "- underscores (_)\n",
    "\n",
    "No entanto, os nomes das variáveis *não podem* incluir:\n",
    "- ❌ outras pontuações (-.!?@)\n",
    "- ❌ espaços \n",
    "- ❌ uma palavra reservada do Python\n",
    "\n",
    "Variáveis claras e nomeadas com precisão irão:\n",
    "\n",
    "* tornar seu código mais legível (para você e para outras pessoas)\n",
    "* reforçar sua compreensão do Python e do que está acontecendo no código\n",
    "* esclarecer e fortalecer seu pensamento\n",
    "\n",
    "**Para maiores informações veja o [Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b18c072",
   "metadata": {},
   "source": [
    "#### Palavras-chave do Python\n",
    "\n",
    "Retirado de [Pense Python](https://penseallen.github.io/PensePython2e/02-vars-expr-instr.html) de Allen Downey, capítulo 2:\n",
    "\n",
    "O interpretador usa palavras-chave para reconhecer a estrutura do programa e elas não podem ser usadas como nomes de variável.\n",
    "\n",
    "O Python 3 tem estas palavras-chave:\n",
    "\n",
    "```\n",
    "and         del         from        None        True\n",
    "as          elif        global      nonlocal    try\n",
    "assert      else        if          not         while\n",
    "break       except      import      or          with\n",
    "class       False       in          pass        yield\n",
    "continue    finally     is          raise\n",
    "def         for         lambda      return\n",
    "```\n",
    "\n",
    "Você não precisa memorizar essa lista. Na maior parte dos ambientes de desenvolvimento, as palavras-chave são exibidas em uma cor diferente; se você tentar usar uma como nome de variável, vai perceber.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "025cd38d",
   "metadata": {},
   "source": [
    "#### Redefinindo variáveis\n",
    "\n",
    "As variáveis não são fixas, é possível atribuir novos valores a uma variável que já havia sido definida anteriormente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c601ee37",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(nome)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7e75986",
   "metadata": {},
   "outputs": [],
   "source": [
    "nome = 'Eric'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6afca805",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(nome)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "901e02c6",
   "metadata": {},
   "source": [
    "### Tipos de Dados\n",
    "\n",
    "Python é uma linguagem dinamicamente tipada, o que significa que o tipo de uma variável é determinado em tempo de execução e não precisa ser declarado explicitamente. Em linguagens dinamicamente tipadas como Python, é possível atribuir valores de diferentes tipos a uma mesma variável sem precisar especificar o tipo previamente"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd381ab2",
   "metadata": {},
   "source": [
    "\n",
    "Existem quatro tipos essenciais de dados Python com diferentes poderes e capacidades:\n",
    "\n",
    "- Strings (texto)\n",
    "- Integers (números inteiros)\n",
    "- Floats (números decimais)\n",
    "- Booleans (verdadeiro / falso)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e0a9adf",
   "metadata": {},
   "source": [
    "|Tipo | Explicação | Exemplo |\n",
    "|---|---|---|\n",
    "|integer `int` |número inteiro| -3, 0, 2, 534|\n",
    "|float `float` |número decimal | 6.3, -19.23, 5.0, 0.01|\n",
    "|string `str` |texto| 'Olá mundo', 'Ligue 190', '', '1823'|\n",
    "|boolean `bool` |Verdadeiro ou Falso| True/False|\n",
    "\n",
    "Você pode verificar o tipo de dados de qualquer valor usando a função `type()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6169d0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(nome)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4cfa249",
   "metadata": {},
   "source": [
    "### Operadores Aritméticos\n",
    "\n",
    "[Python Basics 1](https://github.com/ithaka/constellate-notebooks/blob/master/Python-basics/python-basics-1.ipynb) de [Nathan Kelber](http://nkelber.com/) e Ted Lawless\n",
    "\n",
    "|Operador| Operação| Exemplo | Resultado |\n",
    "|---|----|---|---|\n",
    "|\\*\\*| Potência| 3 ** 3 | 27 |\n",
    "|%| Resto da divição| 34 % 6 | 4 |\n",
    "|/| Divisão | 30 / 6 | 5|\n",
    "|//| Divisão inteira | 27 // 6 | 4 |\n",
    "|\\*| Multiplicação | 7 * 8 | 56 |\n",
    "|-| Subtração | 18 - 4| 14|\n",
    "|+| Adição | 4 + 3 | 7 |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f47973fe",
   "metadata": {},
   "source": [
    "### Operadores relacionais\n",
    "\n",
    "[Python Basics 2](https://github.com/ithaka/constellate-notebooks/blob/master/Python-basics/python-basics-2.ipynb) de [Nathan Kelber](http://nkelber.com/) e Ted Lawless\n",
    "\n",
    "|Operador|Significado|\n",
    "|---|---|\n",
    "|==|Igual|\n",
    "|!=|diferente|\n",
    "|<|Menor que|\n",
    "|>|Maior que|\n",
    "|<=|Menor ou igual que|\n",
    "|>=|Maior ou igual que|"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae799f7b",
   "metadata": {},
   "source": [
    "### Operadores Booleanos (and/or/not)\n",
    "\n",
    "[Python Basics 2](https://github.com/ithaka/constellate-notebooks/blob/master/Python-basics/python-basics-2.ipynb) de [Nathan Kelber](http://nkelber.com/) e Ted Lawless\n",
    "\n",
    "- and\n",
    "\n",
    "```True and True = True```\n",
    "\n",
    "- or"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43c54825",
   "metadata": {},
   "source": [
    "### print() input() e format()\n",
    "\n",
    "Vejamos três funções básicas do Python que nos ajudarão a interagir com o usuário e a imprimir valores na tela.\n",
    "\n",
    "Funções em Python são blocos de código que executam uma tarefa específica. As funções podem receber valores de entrada (argumentos) e retornar valores de saída. Elas são reconhecidas por terem um nome seguido de parênteses.\n",
    "\n",
    "Para imprimir na tela um valor devemos utilizar a função `print()`.\n",
    "\n",
    "Para receber um valor de entrada do usuário, usamos a função `input()`.\n",
    "\n",
    "Usamos format() para formatar strings.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01f73905",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_name = input('Digite seu nome: ')\n",
    "print(new_name)\n",
    "\n",
    "print(f'Olá, {new_name}! Como vai?')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af850e6f",
   "metadata": {},
   "source": [
    "## Desafio 1: *Seu primeiro script*\n",
    "\n",
    "Um script é um arquivo de texto que contém uma sequência de instruções que serão executadas pelo computador. Vejamos um exemplo de script em Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "031dfd93",
   "metadata": {},
   "outputs": [],
   "source": [
    "# linha de comentário contém um # no início\n",
    "# comentários são ignorados pelo computador\n",
    "# geralmente iniciamos um script com comentários que explicam o que ele faz\n",
    "\n",
    "# importamos as bibliotecas que serão necessárias\n",
    "import time # biblioteca para trabalhar com horas\n",
    "\n",
    "# cada linha abaixo é uma instrução que será executada pelo computador\n",
    "# na ordem em que aparecem\n",
    "\n",
    "# obtemos a hora atual com a função time.localtime()\n",
    "hora_atual = time.localtime() # obtemos a hora atual\n",
    "\n",
    "nome = input('Digite seu nome: ') # recebemos um valor de entrada do usuário\n",
    "print(f'Olá, {nome}!') # imprimimos uma mensagem na tela\n",
    "print(f'São {hora_atual.tm_hour} horas e {hora_atual.tm_min} minutos.') # imprimimos outra mensagem na tela"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f51a6a7f",
   "metadata": {},
   "source": [
    "Esse documento de texto simples, deve ser salvo com a extensão `.py` para que o computador reconheça que se trata de um script em Python. Podemos salvar com o título `hora_atual.py`.\n",
    "\n",
    "Para executar o script, basta digitar no terminal:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e48c840c",
   "metadata": {},
   "source": [
    "```bash\n",
    "python hora_atual.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "131c3727",
   "metadata": {},
   "source": [
    "**Vamos ao desafio!**\n",
    "\n",
    "Monte um script que receba o **nome** de uma pessoa e a **idade**. Imprima na tela **uma mensagem de saudação** (que inclua o nome) e informe **quantos anos ela terá em 2030**.\n",
    "\n",
    "Tente utilizar os operadores aritméticos e as funções `print()`, `format()` e `input()`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8f3f68b",
   "metadata": {},
   "source": [
    "[Próximo →](dia2.ipynb)\n",
    "\n",
    "[← Anterior](dia0.md)\n",
    "\n",
    "[↑ Início](#dia-1)"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "-all",
   "main_language": "python",
   "notebook_metadata_filter": "-all"
  },
  "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}