4.modulos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Módulos"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Básico"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O Python tem uma forma de colocar definições em um arquivo e usar eles em um script ou em um shell. Esse arquivo é chamado de `módulo`. As definições do módulo podem ser **importados** em outros módulos ou no nosso script.\n",
    "\n",
    "Um módulo é um arquivo contendo definições e declarações. O nome do arquivo é o nome do módulo com o suffixo `.py`. Dentro do módulo, o nome do módulo (como uma string) é uma variável como um valor da variável global `__name__`."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja o arquivo `fibonacci.py` para o código da sequência de Fibonacci."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import fibonacci"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isto não adiciona os nomes das funções definidas em `fibonacci` diretamente ao [namespace](https://docs.python.org/3/glossary.html#term-namespace) atual, somente adiciona o módulo `fibonacci` lá. Usando o nome do módulo você pdoe acessar as funções."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`namspaces` : é o local onde a variável é armazenada. Namespaces são implementadas como dicionários. Há os namespaces **local**, **global** e **built-in** assim como namespaces em **objetos** (nos métodos).\n",
    "\n",
    "Namespaces suportam modularidade ao previnir os conflitos de nomes.<br>\n",
    "Por exemplo : as funções [builtins.open](https://docs.python.org/3/library/functions.html#open) e [os.open()](https://docs.python.org/3/library/os.html#os.open) são distinguíveis pelos seus namespaces.\n",
    "\n",
    "Namespaces também ajudam na legibilidade e manutenção ao deixar claro qual módulo implementa a função.<br>\n",
    "Por exemplo : escrever [random.seed()](https://docs.python.org/3/library/random.html#random.seed) ou [itertools.islice()](https://docs.python.org/3/library/itertools.html#itertools.islice) deixa claro que estas funções são implementadas pelos módulos [random](https://docs.python.org/3/library/random.html#module-random) e [itertools](https://docs.python.org/3/library/itertools.html#module-itertools), respectivamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import fibonacci\n",
    "\n",
    "fibonacci.fib(1000)\n",
    "print(fibonacci.fib2(100))\n",
    "print(fibonacci.__name__)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se você pretende usar uma função mais seguida, você pode associar ela a uma variável local."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import fibonacci\n",
    "\n",
    "fibo = fibonacci.fib\n",
    "fibo(500)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Mais com Módulos"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um módulo pode conter declarações executáveis assim como definições de funções. Estas declarações são usados para inicializar o módulo. Elas são executadas **apenas** na primeira vez que o nome do módulo é encontrado em uma declaração **import**.\n",
    "\n",
    "Cada módulo tem seu próprio namespace particular, que é usado como um namespace global por todas as funções definidas no módulo. Assim, o autor de um módulo pode usar variáveis globais no módulo sem se preocupar sobre com colisões acidentais com as variáveis globais do usuário. Por outro lado, se você sabe o que você está fazendo, você usar as variáveis globais do módulo com a mesma notação usada para se referir às funções, `modulo_nome.item_nome`.\n",
    "\n",
    "Módulos podem importar outros módulos. É comum, mas não obrigatório, colocar todos os [import](https://docs.python.org/3/reference/simple_stmts.html#import) no começo do módulo. Os nomes importados pelo módulo, se colocados no nível mais alto do módulo (fora de funções ou classes), são adicionados para o namespace global do módulo."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Há uma variação do `import` que importa nomes de um módulo diretamente no namespace do módulo que está importando."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fibonacci import fib\n",
    "fib(500)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isso não trás o nome do módulo do qual é importado ao namespace local (então, no código acima, `fibonacci` não é definida)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Há ainda uma variação que importa todos os nomes que o módulo define."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fibonacci import *\n",
    "fib(500)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isso importa todos os nomes do módulo, exceto aqueles que começam com o sublinhado `_`. Na maioria dos casos, os programadores Python não usam essa funcionalidade, já que ela traz um conjunto de nomes para o interpretador, possivelmente ocultando algumas coisas que você já definiu.\n",
    "\n",
    "Veja que, em geral, a prática de importar com `*` de um módulo ou pacote não é aprovado, já que isso deixa o código ruim de entender. Contudo, é ok usar em sessões interativas (usar no shell)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se um módulo é seguido de `as`, então o nome seguido do `as` é referenciado diretamente ao módulo importado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import fibonacci as fibo\n",
    "fibo.fib(500)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isso vai importar o módulo da mesma maneira que `import fibonacci` faz, com a única diferença de que o módulo estará disponível como `fibo`."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É também possível ser usado utilizando o `from` com efeitos similares."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fibonacci import fib as fibon\n",
    "fibon(500)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`NOTA` : por rações de eficiência, cada módulo é importado apenas uma vez por sessão do interpretador. Contudo, se você mudar seus módulos, você deve reiniciar o interpretador - ou, se é apenas um móduloque você quer testar interativamente, use [importlib.reload()](https://docs.python.org/3/library/importlib.html#importlib.reload), que vai reimportar um módulo previamente carregado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import importlib\n",
    "import fibonacci\n",
    "\n",
    "fibonacci.fib(500)\n",
    "importlib.reload(fibonacci)\n",
    "fibonacci.fib(500)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1. Executando Módulos como Scripts"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando você executa um módulo Python com :\n",
    "\n",
    "`C:\\python>python fibonacci.py <argumentos`\n",
    "\n",
    "o código do módulo será executado, como se você tivesse importado ele, mas com o `__name__` definido como `\"__main__\"`. Que quer dizer que ao adicionar o seguinte código ao final do módulo :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == '__main__':\n",
    "    import sys\n",
    "    fib(int(sys.argv[1]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "você pode tornar o arquivo um script utilizável assim como o módulo que o importou, porque o código analisa a linha de comando e só executa se o módulo é executado como o arquivo `main`.\n",
    "\n",
    "Tente executar o comando abaixo diretamente no **Prompt de Comando** :<br>\n",
    "`C:\\python>python arquivo.py 50`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se o módulo é importado, o código não é executado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import fibonacci"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isso é geralmente usado tanto para disponibilizar uma forma conveniente de se ter uma interface com o módulo, tanto para testar (executar o módulo como um script executável com casos de teste)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2. O Caminho de Busca do Módulo"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando o módulo chamado `spam` é importado, o interpretador primeiro busca por um módulo **built-in** com aquele nome. Estes nomes dos módulos são listados em [sys.builtin_module_names](https://docs.python.org/3/library/sys.html#sys.builtin_module_names)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "print(sys.builtin_module_names)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se não for encontrado, o interpretador buscará por um arquivo chamado `spam.py` em uma lista de pastas dados pela variável [sys.path](https://docs.python.org/3/library/sys.html#sys.path)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "print(sys.path)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sys.path` é inicializada destas localizações :\n",
    "\n",
    "- a pasta contendo o script de entrada (ou a pasta atual quando nenhum arquivo é especificado);\n",
    "- [PYTHONPATH](https://docs.python.org/3/using/cmdline.html#envvar-PYTHONPATH) (uma lista de nomes de pastas, com a mesma sintaxe as da variável `PATH` no shell);\n",
    "- a dependência padrão da instalação (por convenção inclui a pasta `site-package`, gerenciado pelo módulo [site](https://docs.python.org/3/library/site.html#module-site))\n",
    "\n",
    "Mais detalhes em [A inicialização do módulo sys.path](https://docs.python.org/3/library/sys_path_init.html#sys-path-init)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2.1. sys.path"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Retorna** uma lista de strings que especifica a busca pelo caminho dos módulos. Inicializado da variável de ambiente [PYTHONPATH](https://docs.python.org/3/using/cmdline.html#envvar-PYTHONPATH), mais a instalação padrão.\n",
    "\n",
    "Por padrão, é inicializada quando o programa inicializa, um caminho potencialmente não seguro é anexada ao [sys.path](https://docs.python.org/3/library/sys.html#sys.path) (antes das entradas inseridas como resultado do PYTHONPATH).\n",
    "\n",
    "- `python -m modulo` : precede a pasta atual de trabalho;\n",
    "- `python script.py` : precede a pasta do script. Se o link é simbólico, determina os links simbólicos;\n",
    "- `python -c code` e `python` : precede uma string vazia, que significa a pasta de trabalho atual;"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3. Arquivos Python \"Compilados\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Módulos Padrão"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O Python vem com uma biblioteca de módulos padrão, descritos em um documento separado, chamado de `Python Library Reference`. Alguns módulos são **built-in** do interpretador; estes módulos fornecem acesso à operações que não são parte do centro da linguagem, mas são **built-in**, seja por eficiência ou por prover acesso a operações de sistema primitivas, como chamadas de sistema. O conjunto de tais módulos é uma opção de configuração que também depende da plataforma que está sendo executado. Por exemplo, o módulo [winreg](https://docs.python.org/3/library/winreg.html#module-winreg) só existe em sistemas Windows."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um módulo em particular merece atenção : [sys](https://docs.python.org/3/library/sys.html#module-sys), que é **built-in** em todos os interpretadores Python. As variáveis `sys.ps1` e `sys.ps2` definem as strings usadas como primárias e secundárias."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "print(sys.ps1)\n",
    "print(sys.ps2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estas duas variáveis são definidar se o interpretador estiver em modo interativo."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A variável `sys.path` é uma lista de strings que determinam o caminho de busca por módulos do interpretador. É inicializada para um caminho padrão pego da variável de ambiente [PYTHONPATH](https://docs.python.org/3/using/cmdline.html#envvar-PYTHONPATH). Você pode modificar elas usando operações de listas :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "print(sys.path)\n",
    "sys.path.append('/um/caminho/python')\n",
    "print(sys.path)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1. Módulo os"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este módulo fornece uma maneira simples de usar funcionalidades que são dependentes de sistema operacional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "print(__file__)\n",
    "print(os.path.basename(__file__))\n",
    "print(os.path.dirname(__file__))\n",
    "print(os.path.abspath(__file__))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lista todos os arquivos e pastas na pasta atual."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "caminho = '.'\n",
    "items = os.listdir(caminho)\n",
    "\n",
    "for item in items:\n",
    "    print(item)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verifica o que é pasta e o que é arquivo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "caminho = '.'\n",
    "for i in os.listdir(caminho):\n",
    "    if os.path.isdir(i):\n",
    "        print(f'Sou uma pasta {i = }')\n",
    "    elif os.path.isfile(i):\n",
    "        print(f'Sou um arquivo {i = }')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verifica se uma pasta ou arquivo existe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "if os.path.exists('teste.txt'):\n",
    "    print(f'A pasta / arquivo existe.')\n",
    "else:\n",
    "    print(f'A pasta / arquivo não existe.')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Links :\n",
    "- https://docs.python.org/pt-br/3/library/os.html"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2. Módulo time"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esse módulo provê várias funções relacionadas ao tempo.<br>\n",
    "Apesar desse módulo sempre estar disponível, nem todas as suas funções estão disponíveis em todas as plataformas. A maioria das funções definidas nesse módulo chamam funções da biblioteca da plataforma de C com mesmo nome."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A seguir, uma explicação de algumas terminologias e convenções :\n",
    "- O `epoch` ([mais aqui](https://pt.wikipedia.org/wiki/Era_Unix)) é o ponto onde o tempo começa, no retorno do valor de `time.gmtime(0)`. A data é 01 de Janeiro de 1970, 00:00:00 (UTC) em todas as plataformas;\n",
    "- UTC é Coordinated Universal Time (antigamente conhecido como Greenwich Mean Time ou GMT). O acrônimo UTC não é um erro, mas um acordo entre inglês e francês;\n",
    "- A função [strptime()](https://docs.python.org/pt-br/3/library/time.html#time.strptime) pode analisar anos de 2 dígitos quando é passado o código de formato %y. Quando anos de 2 dígitos são analisados, eles são convertidos de acordo com os padrões POSIX e ISO C: valores 69–99 são mapeados para 1969–1999, e valores 0–68 são mapeados para 2000–2068."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recuperando o `epoch`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "print(time.gmtime(0))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Segundos atuais desde o `epoch`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "atual = time.time()\n",
    "print(f'Segundos desde o epoch {atual}')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Atrasando o tempo de execução."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "for i in range(5):\n",
    "    time.sleep(1)\n",
    "    print(i)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mostrando o tempo formatado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "agora = time.strftime(\"%a, %d %b %Y %H:%M:%S\", time.gmtime())\n",
    "print(agora)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convertendo a formação em objeto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "data = \"Tue, 01 Jan 2023 12:00:00\"\n",
    "objeto = time.strptime(data, \"%a, %d %b %Y %H:%M:%S\")\n",
    "\n",
    "print(objeto)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Links :\n",
    "- https://docs.python.org/pt-br/3/library/time.html"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3. Módulo datetime"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O módulo datetime fornece as classes para manipulação de datas e horas.\n",
    "\n",
    "Ainda que a aritmética de data e hora seja suportada, o foco da implementação é na extração eficiente do atributo para formatação da saída e manipulação."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "\n",
    "agora = datetime.datetime.now()\n",
    "print(agora)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mostrando os dias, meses e anos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "\n",
    "agora = datetime.datetime.now()\n",
    "print(agora)\n",
    "print(agora.day)\n",
    "print(agora.month)\n",
    "print(agora.year)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pegando apenas a data com o `date`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date\n",
    "\n",
    "agora = date.today()\n",
    "print(agora)\n",
    "print(agora.day)\n",
    "print(agora.month)\n",
    "print(agora.year)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Criando o objeto datetime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "\n",
    "data = datetime.datetime(2023, 1, 23)\n",
    "print(data)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Formatando a data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date\n",
    "\n",
    "agora = date.today()\n",
    "data_str = agora.strftime('%d/%m/%Y')\n",
    "print(data_str)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pegando a data com hora."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date, datetime\n",
    "\n",
    "agora = date.today()\n",
    "data_str = agora.strftime('%d/%m/%Y %H:%M')\n",
    "print(data_str)\n",
    "\n",
    "agora = datetime.now()\n",
    "data_str = agora.strftime('%d/%m/%Y %H:%M')\n",
    "print(data_str)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convertendo uma `string` para `datetime`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "data_str = '01/01/2023 12:35'\n",
    "data_dt = datetime.strptime(data_str, '%d/%m/%Y %H:%M')\n",
    "print(data_dt)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando `timezone()` e `timedelta()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime, timedelta, timezone\n",
    "\n",
    "variacao = timedelta()\n",
    "print(variacao)\n",
    "\n",
    "variacao = timedelta(hours=-3)\n",
    "print(variacao)\n",
    "\n",
    "agora = datetime.now()\n",
    "fuso = timezone(variacao)\n",
    "print(fuso)\n",
    "\n",
    "data_hora = agora.astimezone(fuso)\n",
    "data_hora_str = data_hora.strftime('%d/%m/%Y %H:%M')\n",
    "\n",
    "print(data_hora_str)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Links :\n",
    "- https://docs.python.org/pt-br/3/library/datetime.html"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3. Módulo random"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O módulo implementa geradores de números pseudoaleatórios para várias distribuições.\n",
    "\n",
    "Para números inteiros, há uma seleção uniforme de um intervalo. Para sequências, há uma seleção uniforme de um elemento aleatório, uma função para gerar uma permutação aleatória de uma lista internamanete e uma função para amostragem aleatória sem substituição."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "for _ in range(10):\n",
    "    print(random.random())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algumas vezes, queremos que o gerador de número reproduza a sequência de números criada uma vez. Isso é obtido ao prover a mesma semente ambas as vezes ao gerador, usando a função `seed(s, version)`. Se o parâmetro `s` é omitido, o gerador usará o tempo atual do sistema para gerar os números."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "random.seed(5)\n",
    "print(random.random())\n",
    "print(random.random())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gerando inteiros aleatórios. Podemos usando `randrange(x)` para gerar números inteiros menores que `x`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "for _ in range(10):\n",
    "    print(random.randrange(10), end=' ')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A funcionalidade do `randrange()` é parecida com a do `range()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "for _ in range(10):\n",
    "    print(random.randrange(5,10), end=' ')\n",
    "print('\\n')\n",
    "for _ in range(100):\n",
    "    print(random.randrange(5,20,3), end=' ')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sequências e `random`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "nomes = ['Gandalf', 'Frodo', 'Witch-king', 'Aragorn', 'Sauron', 'Bilbo']\n",
    "\n",
    "# sorteando\n",
    "for _ in range(3):\n",
    "    print(random.choice(nomes))\n",
    "\n",
    "# embaralhando\n",
    "random.shuffle(nomes)\n",
    "print(nomes)\n",
    "\n",
    "# amostras\n",
    "print(random.sample(nomes,1))\n",
    "print(random.sample(nomes,2))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Links : \n",
    "- https://docs.python.org/pt-br/3/library/random.html"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4. Módulo json"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "JSON (JavaScript Object Notation), especificado pela [RFC 7159](https://datatracker.ietf.org/doc/html/rfc7159.html) e pelo [ECMA-404](https://www.ecma-international.org/publications-and-standards/standards/ecma-404/), é um formato leve de troca de dados inspirado pela sintaxe de objeto JavaScript (embora não seja um subconjunto estrito de JavaScript)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em Python, caso tenhamos uma string JSON, nós usamos o método `json.loads()` para fazer o parse e convertermos em um dicionário para que seja mais fácil de trabalharmos com os dados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "# repare que o json usa aspas duplas para seu objeto\n",
    "pessoa = '{ \"nome\":\"fulano\", \"idade\":26, \"planeta\":\"Marte\"}'\n",
    "\n",
    "pessoa_dict = json.loads(pessoa)\n",
    "\n",
    "print(type(pessoa_dict))\n",
    "print(pessoa_dict)\n",
    "print(pessoa_dict['planeta'])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se quisermos, também podemos converter um objeto de Python em uma string JSON, para esta tarefa vamos usar o método `json.dumps()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "pessoa = {\n",
    "    'nome':'fulano',\n",
    "    'idade':26,\n",
    "    'planeta':'Vênus'\n",
    "}\n",
    "\n",
    "pessoa_json = json.dumps(pessoa)\n",
    "print(type(pessoa_json))\n",
    "print(pessoa_json)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repare que a codificação não ficou boa. Para arrumar, devemos colocar o atributo `ensure_ascii` como `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "pessoa = {\n",
    "    'nome':'fulano',\n",
    "    'idade':26,\n",
    "    'planeta':'Vênus'\n",
    "}\n",
    "\n",
    "pessoa_json = json.dumps(pessoa, ensure_ascii=False)\n",
    "print(type(pessoa_json))\n",
    "print(pessoa_json)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando todos os dados possíveis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "mago = {\n",
    "    \"nome\": \"Gandalf\",\n",
    "    \"epiteto\": \"o Branco\",\n",
    "    \"nível\": 99,\n",
    "    \"vivo\": True,\n",
    "    \"atributos\": {\"força\": 12, \"destreza\": 26, \"inteligência\": 20},\n",
    "    \"mascotes\": (\"Scadufax\", \"Coruja\"),\n",
    "    \"residência\": None,\n",
    "    \"itens\": [\n",
    "        {\"nome\": \"poção de mana\", \"quantidade\": 5},\n",
    "        {\"nome\": \"poção de vida\", \"quantidade\": 7}\n",
    "    ]\n",
    "}\n",
    "\n",
    "print(json.dumps(mago, ensure_ascii=False))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos mostrar a saída dos dados formatado e ordenado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "mago = {\n",
    "    \"nome\": \"Gandalf\",\n",
    "    \"epiteto\": \"o Branco\",\n",
    "    \"nível\": 99,\n",
    "    \"vivo\": True,\n",
    "    \"atributos\": {\"força\": 12, \"destreza\": 26, \"inteligência\": 20},\n",
    "    \"mascotes\": (\"Scadufax\", \"Coruja\"),\n",
    "    \"residência\": None,\n",
    "    \"itens\": [\n",
    "        {\"nome\": \"poção de mana\", \"quantidade\": 5},\n",
    "        {\"nome\": \"poção de vida\", \"quantidade\": 7}\n",
    "    ]\n",
    "}\n",
    "\n",
    "print(json.dumps(mago, ensure_ascii=False))\n",
    "print(json.dumps(mago, sort_keys=True, ensure_ascii=False))\n",
    "print(json.dumps(mago, indent=4, ensure_ascii=False))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mais adiante veremos como salvar os dados `json` em um arquivo."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Links : \n",
    "- https://docs.python.org/pt-br/3/library/json.html"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. A Função dir()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função **built-in** [dir()](https://docs.python.org/3/library/functions.html#dir) é usada para encontrar quais nomes um módulo está definindo. Ele retorna uma lista de strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import fibonacci, sys\n",
    "print(f'{dir(fibonacci) = }')\n",
    "print(f'{dir(sys) = }')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sem argumentos, [dir()](https://docs.python.org/3/library/functions.html#dir) lista os nomes de você definou atualmente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import fibonacci\n",
    "print(f'{dir() = }')\n",
    "\n",
    "lista = [1, 2, 3, 4, 5]\n",
    "print(f'\\n{dir() = }')\n",
    "\n",
    "fibo = fibonacci.fib\n",
    "print(f'\\n{dir() = }')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que ela lista todos os tipos de nomes : `variáveis`, `módulos`, `funções`, etc."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função [dir()](https://docs.python.org/3/library/functions.html#dir) não lista os nomes das funções e variáveis **built-in**. Se você quer uma lista delas, elas são definidas no módulo padrão [builtins](https://docs.python.org/3/library/builtins.html#module-builtins)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import builtins\n",
    "\n",
    "print(f'{dir(builtins) = }')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Pacotes"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a ser adicionado"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.1 (tags/v3.11.1:a7a450f, Dec  6 2022, 19:58:39) [MSC v.1934 64 bit (AMD64)]"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "68f6cf9ddf20b8330c35f9eb8d38bef7105e3b161f09b6b7e5f8b2d3944d5325"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}