{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "advised-burlington",
   "metadata": {},
   "source": [
    "# Exercícios da aula 06: Arquivos\n",
    "\n",
    "Na aula 06, terminamos as funções e introduzimos a escrita e leitura de arquivos. Os exercícios referentes a funções já foram resolvidos junto com os exercícios da aula 05.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "another-relation",
   "metadata": {},
   "source": [
    "### Exercício 1\n",
    "Escreva um programa que receba o nome de um arquivo pela linha de comando e imprimia todas as linhas desse aqruivo"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "coordinate-amateur",
   "metadata": {},
   "source": [
    "O programa pode ser visto no arquivo exercicio01.py:\n",
    "\n",
    "```python\n",
    "#! /usr/bin/env python3\n",
    "\n",
    "import sys\n",
    "\n",
    "\n",
    "def imprimir_linhas(arquivo):\n",
    "    with open(arquivo, \"r\") as arq:\n",
    "        for linha in arq.readlines():\n",
    "            print(linha.strip())\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    arquivo = sys.argv[1]\n",
    "    imprimir_linhas(arquivo)\n",
    "```\n",
    "<!-- TEASER_END -->\n",
    "\n",
    "Para se executar o script acima, pode-se fazer o seguinte:\n",
    "```\n",
    "pjabardo@makhno> python3 exercicio01.py arquivo-ex01.txt \n",
    "Primeira linha\n",
    "Segunda\n",
    "Terceira\n",
    "...\n",
    "Última linha\n",
    "pjabardo@makhno:~/Documents/assipt/pythonassipt/06-aula$ \n",
    "```\n",
    "\n",
    "Essa solução vai funcionar tanto no Windows quanto no Linux ou MacOS ou qualquer Unix.\n",
    "\n",
    "#### Script como executável no Linux (e MacOS?)\n",
    "\n",
    "Muitas vezes é conveniente usar o script python como se fosse um programa executável executável (.exe no windows). A linha `#! /usr/bin/env python3` é para especificar, no unix (linux, macos) qual o interpretador que deve ser usado. Para que seja usado como executável, ainda é preciso avisar o sistema operacional para tratar o arquivo como executável:\n",
    "\n",
    "```\n",
    "pjabardo@makhno> chmod +x exercicio01.py\n",
    "```\n",
    "\n",
    "#### Script como executável no Windows\n",
    "É bem parecido com o Linux mas na primeira linha deve-se substituir `#! /usr/bin/env python3` por `#!\"C:\\Python39\\Python.exe\"`. Ajuste para o caminho do executável do Python que tem no teu sistema.\n",
    "\n",
    "#### Executando o script \"executável\":\n",
    "```\n",
    "pjabardo@makhno> ./exercicio01.py arquivo-ex01.txt \n",
    "Primeira linha\n",
    "Segunda\n",
    "Terceira\n",
    "...\n",
    "Última linha\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "grateful-wisdom",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Primeira linha\n",
      "Segunda\n",
      "Terceira\n",
      "...\n",
      "Última linha\n"
     ]
    }
   ],
   "source": [
    "imprimir_linhas(\"arquivo-ex01.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baking-township",
   "metadata": {},
   "source": [
    "Observe que nessa solução, a funcionalidade está implementada dentro da função `imprimir_linhas`. Com isso, podemos reutilizar o código. É por isso que existe o trecho\n",
    "\n",
    "```python\n",
    "if __name__ == '__main__':\n",
    "    arquivo = sys.argv[1]\n",
    "    imprimir_linhas(arquivo)\n",
    "```\n",
    "\n",
    "Caso o `if` seja verdadeiro, vamos executar essa trecho. Esse `if` *é verdadeiro se estamos usando o arquivo como um script*.\n",
    "\n",
    "O arquivo também pode ser usado como um módulo. E aí que vem a vantagem de escrever este programa desse jeito:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "lyric-meditation",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Usando o programa como um módulo:\n",
    "from exercicio02 import imprimir_linhas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "passive-tsunami",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Primeira linha\n",
      "Segunda\n",
      "Terceira\n",
      "...\n",
      "Última linha\n"
     ]
    }
   ],
   "source": [
    "imprimir_linhas(\"arquivo-ex01.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "stainless-knight",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "adaptive-billy",
   "metadata": {},
   "source": [
    "A idéia é sempre tentar reaproveitar código o máximo possível!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "consistent-distance",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "bacterial-forge",
   "metadata": {},
   "source": [
    "### Exercício 2\n",
    "Modifique o programa do exercício de tal modo que receba mais dois parâmetros: a linha de incício e a de fim de impressão. O programa deve imprimir apenas as linhas entre esses dois valores (inlcuindo as linhas de incício e fim)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faced-hardwood",
   "metadata": {},
   "source": [
    "A minha solução pode ser vista a seguir. Ela se encontra no arquivo `exercicio02.py` e tem algumas novidades."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "nasty-praise",
   "metadata": {},
   "source": [
    "```python\n",
    "import argparse\n",
    "\n",
    "\n",
    "def imprimir_linhas(arquivo, linha_inicio=0, linha_fim=-1):\n",
    "    with open(arquivo, \"r\") as arq:\n",
    "        i = 0\n",
    "        for linha in arq:\n",
    "            if i >= linha_inicio and (linha_fim < 0 or i < linha_fim):\n",
    "                print(linha.strip())\n",
    "            i = i + 1\n",
    "            if i == linha_fim:\n",
    "                break\n",
    "                \n",
    "\n",
    "if __name__ == '__main__':\n",
    "    parser = argparse.ArgumentParser(description=\"Imprimir linhas\")\n",
    "    parser.add_argument('arquivo', help=\"Nome do arquivo\", type=str, nargs=1)\n",
    "    parser.add_argument(\"-i\", \"--inicio\", help=\"Número da primeira linha para imprimir 0 caso não seja fornecido.\", default=0, type=int)\n",
    "    parser.add_argument(\"-f\", \"--fim\", help=\"Número da última que deve ser impressa. -1 para imprimir até o final\", default=-1, type=int)\n",
    "\n",
    "    args = parser.parse_args()\n",
    "    \n",
    "    imprimir_linhas(args.arquivo[0], args.inicio, args.fim)\n",
    "```    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "secure-things",
   "metadata": {},
   "source": [
    "A estrutura do código é a mesma que o programa do programa anterior. Temos uma função que implementa a funcionalidade que desejamos (função `imprimir_linhas`) e temos o trecho\n",
    "\n",
    "```python\n",
    "if __name__ == '__main__':\n",
    "    parser = argparse.ArgumentParser(description=\"Imprimir linhas\")\n",
    "    # ...\n",
    "```\n",
    "\n",
    "Assim o código pode ser usado como módulo e como script (programa).\n",
    "\n",
    "A primeira novidade é que o programa usa o módulo `argparse` da biblioteca padrão do Python. Este módulo ajuda a interpretar os argumentos de linha de comando. É muito melhor do que usar `sys.argv` diretamente como fizemos no exercício 01.\n",
    "\n",
    "Vejamos a funcionalidade do código:\n",
    "\n",
    "```\n",
    "pjabardo@makhno> ./exercicio02.py --help\n",
    "usage: exercicio02.py [-h] [-i INICIO] [-f FIM] arquivo\n",
    "\n",
    "Imprimir linhas\n",
    "\n",
    "positional arguments:\n",
    "  arquivo               Nome do arquivo\n",
    "\n",
    "optional arguments:\n",
    "  -h, --help            show this help message and exit\n",
    "  -i INICIO, --inicio INICIO\n",
    "                        Número da primeira linha para imprimir 0 caso não seja fornecido.\n",
    "  -f FIM, --fim FIM     Número da última que deve ser impressa. -1 para imprimir até o final\n",
    "\n",
    "```\n",
    "\n",
    "Ao usar o módulo `argparse` já temos um help! Como funciona? Primeiro é necessário criar o *parser* que vai interpretar as opções. O parser é inicializado na linha \n",
    "\n",
    "```python\n",
    "parser = argparse.ArgumentParser(description=\"Imprimir linhas\")\n",
    "```\n",
    "\n",
    "A descrição (`description`) é o que aparece no help. Aí temos que definir os argumentos de linha de comando. O jeito que eu fiz o programa, temos que fornecer o nome de um arquivo e isso é implementado na linha \n",
    "\n",
    "```python\n",
    "parser.add_argument('arquivo', help=\"Nome do arquivo\", type=str, nargs=1)\n",
    "```\n",
    "\n",
    "Teremos um argumento chamado `arquivo` que é do tipo `str` e é composto por apenas um argumento (`nargs=1`).\n",
    "\n",
    "Para dizer em que linha se deve começar a imprimir, usa-se a opção `--inicio` ou `-i` definido na linha \n",
    "\n",
    "```python\n",
    "parser.add_argument(\"-i\", \"--inicio\", help=\"Número da primeira linha para imprimir 0 caso não seja fornecido.\", default=0, type=int)\n",
    "```\n",
    "\n",
    "O argumento especificando a linha inicial que deve ser impressa é opcional tem duas formas: a curta `-i` ou a extensa `--inicio`. O tipo de dado vai ser um `int` e caso este argumento não seja fornecido, o valor usado é 0 (começamos da primeir linha).\n",
    "\n",
    "O argumento especificando a linha final que deve ser impressa é também opcional. Neste caso, se nada for escrito, o valor -1 -e adotado. Este valor sinaliza que queremos imprimir até o final.\n",
    "\n",
    "```python\n",
    "parser.add_argument(\"-f\", \"--fim\", help=\"Número da última que deve ser impressa. -1 para imprimir até o final\", default=-1, type=int)\n",
    "```\n",
    "\n",
    "A linha seguinte:\n",
    "```python\n",
    "args = parser.parse_args()\n",
    "```\n",
    "aplica o parser que definimos aos argumentos de linha de comando (`sys.argv`).\n",
    "\n",
    "Para acessar os argumentos, basta usar os campos de `args`:\n",
    " \n",
    " * `args.arquivo` para o nome do arquivo\n",
    " * `args.inicio`  para o número de linha inicial \n",
    " * `args.fim` para o número de linha final.\n",
    "\n",
    "Esses argumentos são então passados para a função `imprimir_linhas` (vamos destrinchar mais adiante).\n",
    "\n",
    "Vamos ver como funciona:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "photographic-zambia",
   "metadata": {},
   "source": [
    "Se não fornecermos nenhuma opção, ocorre um erro:\n",
    "\n",
    "```shell\n",
    "pjabardo@makhno> ./exercicio02.py \n",
    "usage: exercicio02.py [-h] [-i INICIO] [-f FIM] arquivo\n",
    "exercicio02.py: error: the following arguments are required: arquivo\n",
    "pjabardo@makhno:~/Documents/assipt/pythonassipt/06-aula$ \n",
    "```\n",
    "\n",
    "Fornecendo apenas o nome do arquivo, imprimimos todas as linhas.\n",
    "```shell\n",
    "pjabardo@makhno> ./exercicio02.py arquivo-ex01.txt \n",
    "Primeira linha\n",
    "Segunda\n",
    "Terceira\n",
    "...\n",
    "Última linha\n",
    "```\n",
    "\n",
    "Só a opção `-i`:\n",
    "```shell\n",
    "pjabardo@makhno> ./exercicio02.py -i1 arquivo-ex01.txt \n",
    "Segunda\n",
    "Terceira\n",
    "...\n",
    "Última linha\n",
    "```\n",
    "\n",
    "pode ser também\n",
    "```shell\n",
    "pjabardo@makhno> ./exercicio02.py --inicio 2 arquivo-ex01.txt \n",
    "Terceira\n",
    "...\n",
    "Última linha\n",
    "```\n",
    "\n",
    "Nos exemplos acima, `-f` ou `--fim` fornecem o valor padrão -1 que representa imprimir até o final do arquivo\n",
    "\n",
    "```shell\n",
    "pjabardo@makhno> ./exercicio02.py --inicio 2 --fim 4 arquivo-ex01.txt \n",
    "Terceira\n",
    "...\n",
    "```\n",
    "\n",
    "ou \n",
    "```shell\n",
    " pjabardo@makhno> ./exercicio02.py -i 1 -f 3 arquivo-ex01.txt \n",
    "Segunda\n",
    "Terceira\n",
    "```\n",
    "\n",
    "Observe que o parser vai ver se o tipo é compatível:\n",
    "\n",
    "```shell\n",
    "pjabardo@makhno> ./exercicio02.py -i um\n",
    "usage: exercicio02.py [-h] [-i INICIO] [-f FIM] arquivo\n",
    "exercicio02.py: error: argument -i/--inicio: invalid int value: 'um'\n",
    "```\n",
    "\n",
    "Olha que legal: reconheceu que `um` não é um número e deu erro!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "theoretical-designer",
   "metadata": {},
   "source": [
    "Vamos analisar agora o código em si que tem algumas coisas interessantes.\n",
    "\n",
    "```python\n",
    "def imprimir_linhas(arquivo, linha_inicio=0, linha_fim=-1):\n",
    "    with open(arquivo, \"r\") as arq:\n",
    "        i = 0\n",
    "        for linha in arq:\n",
    "            if i >= linha_inicio and (linha_fim < 0 or i < linha_fim):\n",
    "                print(linha.strip())\n",
    "            i = i + 1\n",
    "            if i == linha_fim:\n",
    "                break\n",
    "```\n",
    "\n",
    "A função tem três argumentos:\n",
    " * `arquivo` uma string com o nome dos arquivos\n",
    " * `linha_inicio` um argumento opcional com valor padrão 0 que indica a primeira linha a ser impressa\n",
    " * `linha_fim` um argumento opcional que indica a última linha a ser impressa. Se for -1, imprime até o final\n",
    "\n",
    "O código usa `with open(arquivo, \"r\") as arq` para abrir o arquivo para leitura, como a maioria dos programas até agora.  \n",
    "\n",
    "Agora que as coisas são um pouco diferentes. Até agora usamos o  método `arq.readlines()` que lê **todas** as linhas de um arquivo. Prático e útil mas e se o arquivo for gigantesco e precisamos só de algumas linhas no começo? Vamos gastar um monte de memória para nada.\n",
    "\n",
    "Uma opção é usar o método `arq.readline()` que lê uma linha de cada vez. Mas existe uma possibilidade mais interessante: **usar o o tipo arquivo como um iterador**. Aí acessamos diretamente no `for` linha a linha. Temos um contador `i` para contar as linhas já lidas e só imprimimos quando `i >= linha_inicio`.\n",
    "\n",
    "Agora temos que ter cuidado para acabar a impressão. Temos dois casos:\n",
    "\n",
    " * `linha_fim < 0`  Vamos até o final do arquivo\n",
    " * `linha_fim >= 0` vamos contar até chegar nesse limite."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "suspected-combat",
   "metadata": {},
   "source": [
    "### Exercício 3\n",
    "Crie um programa que receba o nome de dois arquivos como parâmetros da linha de comando e que gere um arquivo de saída com as linhas do primeiro e do segundo arquivo"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "overhead-palace",
   "metadata": {},
   "source": [
    "Não vou fazer um programa, apenas uma função:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "iraqi-johnston",
   "metadata": {},
   "outputs": [],
   "source": [
    "def imprime_arquivos(arquivos_entrada, arquivo_saída):\n",
    "    \n",
    "    with open(arquivo_saída, \"w\") as fout:\n",
    "        \n",
    "        for arq in arquivos_entrada:\n",
    "            with open(arq, \"r\") as fin:\n",
    "                for linha in fin:\n",
    "                    fout.write(linha)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "dynamic-tomato",
   "metadata": {},
   "outputs": [],
   "source": [
    "imprime_arquivos([\"arquivo-ex01.txt\", \"outro-arquivo.txt\"], \"saida-exercicio-03.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acute-testimony",
   "metadata": {},
   "source": [
    "O resultado pode ser visto a seguir:\n",
    "\n",
    "```\n",
    "Primeira linha\n",
    "Segunda\n",
    "Terceira\n",
    "...\n",
    "Última linha\n",
    "Outra linha\n",
    "Mais outra\n",
    "Mais um montão de linhas\n",
    "A última linha\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "mexican-handy",
   "metadata": {},
   "source": [
    "### Exercício 4\n",
    "Crie um programa que recebe o nome de um arquivo e o nome do arquivo de saída e que inverta as linhas do primeiro arquivo e armazene no segundo."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "heard-trailer",
   "metadata": {},
   "source": [
    "Novamente não vou fazer o programa, apenas uma função."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "assured-wesley",
   "metadata": {},
   "outputs": [],
   "source": [
    "def reverter_arquivo(arquivo_entrada, arquivo_saída):\n",
    "    with open(arquivo_entrada, \"r\") as fin:\n",
    "        linhas = fin.readlines()\n",
    "    linhas.reverse()\n",
    "    with open(arquivo_saída, \"w\") as fout:\n",
    "        for linha in linhas:\n",
    "            fout.write(linha)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "flying-madrid",
   "metadata": {},
   "outputs": [],
   "source": [
    "reverter_arquivo(\"arquivo-ex01.txt\", \"arquivo-reverso.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "annoying-survival",
   "metadata": {},
   "source": [
    "A solução acima é simples mas imagina se você tiver arquivos enormes que não cabem na memória.\n",
    "É possível arranjar soluções optimizadas para estes casos mas não é tão simples assim. Você consegue imaginar por quê?\n",
    "\n",
    "\n",
    "```\n",
    "Última linha\n",
    "...\n",
    "Terceira\n",
    "Segunda\n",
    "Primeira linha\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "amber-madagascar",
   "metadata": {},
   "source": [
    "### Exercício 5\n",
    "Modofique o programa anterior para utilizar o elemento `p` em vez de `h2`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "incorporated-academy",
   "metadata": {},
   "source": [
    "Vou criar uma função que encapsula tudo isso. O tipo de elemento pode ser fornecido pelo usuário."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "anticipated-plastic",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "viral-console",
   "metadata": {},
   "outputs": [],
   "source": [
    "filmes = {\n",
    "    \"drama\" : [\"O Homem Elefante\", \"O Poderoso Chefão\"],\n",
    "    \"comédia\" : [\"Se beber não case\", \"O Auto da Compadecida\", \"American Pie\"],\n",
    "    \"policial\" : [\"Seven\", \"O silêncio dos inocentes\", \"Os Homens que não Amavam as Mulheres\"],\n",
    "    \"guerra\" : [\"Stalingrado\", \"O Resgate do Soldado Ryan\", \"Dunquerque\"],\n",
    "    \"ficção científica\" : [\"O Expresso do Amanhã\", \"Duna\", \"Guerra nas Estrelas\", \"A Ira de Kahn\"]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "portable-harvard",
   "metadata": {},
   "outputs": [],
   "source": [
    "def filmes_html(filmes, arquivo=\"filmes.html\", elemento=\"p\"):\n",
    "    with open(arquivo, \"w\", encoding=\"utf-8\") as página:\n",
    "        página.write(\"\"\"\n",
    "<!DOCTYPE html>\n",
    "<html lang=\"pt-br\">\n",
    "<head>\n",
    "<meta charset=\"utf-8\">\n",
    "<title>Filmes</title>\n",
    "</head>\n",
    "<body>\n",
    "        \"\"\")\n",
    "        for c,v in filmes.items():\n",
    "            página.write(f\"<h1>{c.capitalize()}</h1>\\n\")\n",
    "            for e in v:\n",
    "                página.write(f\"<{elemento}>{e}</{elemento}>\\n\")\n",
    "        página.write(\"\"\"\n",
    "</body>\n",
    "</html>\n",
    "        \"\"\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "measured-doctrine",
   "metadata": {},
   "outputs": [],
   "source": [
    "filmes_html(filmes, \"filmes-p.html\", elemento=\"p\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "supported-essay",
   "metadata": {},
   "source": [
    "```html\n",
    "<!DOCTYPE html>\n",
    "<html lang=\"pt-br\">\n",
    "<head>\n",
    "<meta charset=\"utf-8\">\n",
    "<title>Filmes</title>\n",
    "</head>\n",
    "<body>\n",
    "        <h1>Drama</h1>\n",
    "<p>O Homem Elefante</p>\n",
    "<p>O Poderoso Chefão</p>\n",
    "<h1>Comédia</h1>\n",
    "<p>Se beber não case</p>\n",
    "<p>O Auto da Compadecida</p>\n",
    "<p>American Pie</p>\n",
    "<h1>Policial</h1>\n",
    "<p>Seven</p>\n",
    "<p>O silêncio dos inocentes</p>\n",
    "<p>Os Homens que não Amavam as Mulheres</p>\n",
    "<h1>Guerra</h1>\n",
    "<p>Stalingrado</p>\n",
    "<p>O Resgate do Soldado Ryan</p>\n",
    "<p>Dunquerque</p>\n",
    "<h1>Ficção científica</h1>\n",
    "<p>O Expresso do Amanhã</p>\n",
    "<p>Duna</p>\n",
    "<p>Guerra nas Estrelas</p>\n",
    "<p>A Ira de Kahn</p>\n",
    "\n",
    "</body>\n",
    "</html>\n",
    "        \n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "linear-encyclopedia",
   "metadata": {},
   "outputs": [],
   "source": [
    "filmes_html(filmes, \"filmes-h2.html\", elemento=\"h2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "liable-johnson",
   "metadata": {},
   "source": [
    "```html\n",
    "\n",
    "<!DOCTYPE html>\n",
    "<html lang=\"pt-br\">\n",
    "<head>\n",
    "<meta charset=\"utf-8\">\n",
    "<title>Filmes</title>\n",
    "</head>\n",
    "<body>\n",
    "        <h1>Drama</h1>\n",
    "<h2>O Homem Elefante</h2>\n",
    "<h2>O Poderoso Chefão</h2>\n",
    "<h1>Comédia</h1>\n",
    "<h2>Se beber não case</h2>\n",
    "<h2>O Auto da Compadecida</h2>\n",
    "<h2>American Pie</h2>\n",
    "<h1>Policial</h1>\n",
    "<h2>Seven</h2>\n",
    "<h2>O silêncio dos inocentes</h2>\n",
    "<h2>Os Homens que não Amavam as Mulheres</h2>\n",
    "<h1>Guerra</h1>\n",
    "<h2>Stalingrado</h2>\n",
    "<h2>O Resgate do Soldado Ryan</h2>\n",
    "<h2>Dunquerque</h2>\n",
    "<h1>Ficção científica</h1>\n",
    "<h2>O Expresso do Amanhã</h2>\n",
    "<h2>Duna</h2>\n",
    "<h2>Guerra nas Estrelas</h2>\n",
    "<h2>A Ira de Kahn</h2>\n",
    "\n",
    "</body>\n",
    "</html>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "solar-legend",
   "metadata": {},
   "source": [
    "### Exercício 6\n",
    "Modofique o programa 9.8 para gerar uma lista html usando os elementos `ul` e `li`. Todos os elementos da lista devem estar dentro do elemento `ul` e cada item dentro de um elemento `li`. Exemplo:\n",
    "\n",
    "`<ul><li>Item 1</li><li>Item 2</li><li>Item 3</li></ul>`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "authentic-spokesman",
   "metadata": {},
   "outputs": [],
   "source": [
    "def filmes_html_item(filmes, arquivo=\"filmes.html\"):\n",
    "    with open(arquivo, \"w\", encoding=\"utf-8\") as página:\n",
    "        página.write(\"\"\"\n",
    "<!DOCTYPE html>\n",
    "<html lang=\"pt-br\">\n",
    "<head>\n",
    "<meta charset=\"utf-8\">\n",
    "<title>Filmes</title>\n",
    "</head>\n",
    "<body>\n",
    "        \"\"\")\n",
    "        for c,v in filmes.items():\n",
    "            página.write(f\"<h1>{c.capitalize()}</h1>\\n\")\n",
    "            página.write(f\"<ul>\")\n",
    "            for e in v:\n",
    "                página.write(f\"<li>{e}</li>\\n\")\n",
    "            página.write(f\"</ul>\")\n",
    "        página.write(\"\"\"\n",
    "</body>\n",
    "</html>\n",
    "        \"\"\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "english-metadata",
   "metadata": {},
   "outputs": [],
   "source": [
    "filmes_html_item(filmes, \"filmes-li.html\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "informative-aerospace",
   "metadata": {},
   "source": [
    "```html\n",
    "<!DOCTYPE html>\n",
    "<html lang=\"pt-br\">\n",
    "<head>\n",
    "<meta charset=\"utf-8\">\n",
    "<title>Filmes</title>\n",
    "</head>\n",
    "<body>\n",
    "        <h1>Drama</h1>\n",
    "<ul><li>O Homem Elefante</li>\n",
    "<li>O Poderoso Chefão</li>\n",
    "</ul><h1>Comédia</h1>\n",
    "<ul><li>Se beber não case</li>\n",
    "<li>O Auto da Compadecida</li>\n",
    "<li>American Pie</li>\n",
    "</ul><h1>Policial</h1>\n",
    "<ul><li>Seven</li>\n",
    "<li>O silêncio dos inocentes</li>\n",
    "<li>Os Homens que não Amavam as Mulheres</li>\n",
    "</ul><h1>Guerra</h1>\n",
    "<ul><li>Stalingrado</li>\n",
    "<li>O Resgate do Soldado Ryan</li>\n",
    "<li>Dunquerque</li>\n",
    "</ul><h1>Ficção científica</h1>\n",
    "<ul><li>O Expresso do Amanhã</li>\n",
    "<li>Duna</li>\n",
    "<li>Guerra nas Estrelas</li>\n",
    "<li>A Ira de Kahn</li>\n",
    "</ul>\n",
    "</body>\n",
    "</html>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "clean-professional",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}