CursoPyladies.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introdução"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Intro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "%%pip install emoji"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Este treinamento está sendo útil?\n",
      "      - SIM 😍\n",
      "      - NÃO 😲\n",
      "      \n"
     ]
    }
   ],
   "source": [
    "import emoji\n",
    "\n",
    "print(f\"\"\" Este treinamento está sendo útil?\n",
    "      {emoji.emojize(\"- SIM :heart_eyes:\", language=\"alias\")}\n",
    "      {emoji.emojize(\"- NÃO :astonished:\", language=\"alias\")}\n",
    "      \"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sintaxe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variáveis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Devem ter sido inicializadas (declaradas?) antes de serem usadas, não existe uma criação automática de variáveis (no Python ou em todas as linguagens de programação?)\n",
    "- Tipagem dinâmica: quando você passa o valor da variável sem informar o tipo, e o Python identifica automaticamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10, tipo: <class 'int'>\n",
      "2.0, tipo: <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# Formas de atribuir valores:\n",
    "\n",
    "a, b = 10, 2.0\n",
    "print (f\"{a}, tipo: {type(a)}\")\n",
    "print (f\"{b}, tipo: {type(b)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nesse caso, estou entendendo que type() me diz o tipo que o Python atribuiu à variável, sendo \"a\" uma integral e \"b\", um decimal (float, no Python)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saídas e entradas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- input(): Solicita ao usuário dar um input, que será armazenado naquela variável\n",
    "- print(): Exibe o valor da variável"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "nome = input(\"Qual seu nome? \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pedro\n"
     ]
    }
   ],
   "source": [
    "print(nome)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "sobrenome = input(\"E seu sobrenome?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pinheiro\n"
     ]
    }
   ],
   "source": [
    "print(sobrenome)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função print() pode receber atributos como:\n",
    "- sep: determina como as palavras da variável serão concatenadas, tendo espaço como padrão\n",
    "- end: determina como a frase será finalizada ao ser printada, tendo enter como padrão.\n",
    "\n",
    "Ela também pode ser usada para printar uma string dada na hora, em vez de uma variável."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pedro-Pinheiro\n"
     ]
    }
   ],
   "source": [
    "print(nome,sobrenome,sep=\"-\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A resposta da conta foi 56%\n",
      "A resposta da conta foi 55.56 %\n"
     ]
    }
   ],
   "source": [
    "total = 50/90 * 100\n",
    "print(\"A resposta da conta foi %.f%%\" % (total))\n",
    "print(\"A resposta da conta foi\", round(total,2), \"%\")\n",
    "\n",
    "# "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated.\n"
     ]
    }
   ],
   "source": [
    "texto1 = \"Beautiful is better than ugly.\"\n",
    "texto2 = \"Simple is better than complex.\"\n",
    "\n",
    "print(f\"{texto1} Explicit is better than implicit. {texto2} Complex is better than complicated.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Nesse caso, pelo que estou entendendo, o \"f\" no início é uma F-string, que permite \"interpolar variáveis, objetos e expressões diretamente em strings\".\n",
    "# Mais informações aqui: https://realpython.com/python-f-strings/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Identação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Espaçamento que demarca blocos de código dentro de uma função, classe, condicionais, etc. No caso do Python, identação é obrigatório para o código rodar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eu gosto de bananas.\n",
      "Mas prefiro morangos!\n"
     ]
    }
   ],
   "source": [
    "# Abaixo, tudo o que está identado será rodado caso TRUE:\n",
    "\n",
    "fruta = 'banana'\n",
    "if fruta == 'banana':\n",
    "    print(\"Eu gosto de bananas.\")\n",
    "    print('Mas prefiro morangos!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unindent does not match any outer indentation level (<tokenize>, line 6)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m<tokenize>:6\u001b[1;36m\u001b[0m\n\u001b[1;33m    print('Mas prefiro morangos!')\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m unindent does not match any outer indentation level\n"
     ]
    }
   ],
   "source": [
    "# No caso abaixo, como a identação está errada, o último print não está dentro do if e o código quebra:\n",
    "\n",
    "fruta = 'banana'\n",
    "if fruta == 'banana':\n",
    "    print(\"Eu gosto de bananas.\")\n",
    " print('Mas prefiro morangos!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PEP - Python Enhancement Proposal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Guidelines que orientam o melhor uso da linguagem e funcionalidade. Um compilado de melhores práticas, talvez. Por exemplo: usar espaço ou tabulação?\n",
    "\n",
    "(Segundo a PEP 8, o ideal é usar espaços para identanção. Usar tabs apenas para manter a consistência em códigos que já são identados com tabulação.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O curso das Pyladies traz um apanhado de [PEPs Memoráveis](https://github.com/naiaracerqueira/curso_python/blob/main/1_Intro/4_PEP.md#peps-memoráveis) para manter à mão."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Básico"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variáveis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Tipos-base de variáveis do Python ([documentação](https://docs.python.org/3/library/stdtypes.html)):\n",
    "  - Numérico\n",
    "  - Sequences\n",
    "  - Mappings\n",
    "  - Classes\n",
    "  - Instances\n",
    "  - Exceptions\n",
    "- Da documentação: \"Praticamente todos os objetos podem ser comparados para verificar igualdade, testados para valor TRUE, e convertidos para string\".\n",
    "- Variáveis devem ter nomes em minúsculo e podem ser separados por underscore quando necessário"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tipos numéricos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# int - números inteiros\n",
    "\n",
    "inteiro = 10\n",
    "type(inteiro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# float - números reais (decimais), fora os números inteiros. Observar que, no Python, o separador de decimal é (.), não (,)\n",
    "decimal = 10.5\n",
    "type(decimal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cientifico = 5e-6\n",
    "type(cientifico)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# complex - números complexos. Observar que, no Python, a parte complexa é representada por j, não por i.\n",
    "complexo = 3+5j\n",
    "type(complexo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Operadores aritméticos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com variáveis numéricas, é possível fazer operações aritméticas, entre outras."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Soma:  13\n",
      "Subtração 7\n",
      "Multiplicação:  30\n",
      "Divisão:  3.3333333333333335\n",
      "Divisão inteira:  3\n",
      "Resto da divisão:  1\n",
      "Potência:  1000\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "b = 3\n",
    "\n",
    "print(\"Soma: \", a+b)\n",
    "print(\"Subtração\", a-b)\n",
    "print(\"Multiplicação: \", a*b)\n",
    "print(\"Divisão: \", a/b)\n",
    "print(\"Divisão inteira: \", a//b)\n",
    "print(\"Resto da divisão: \", a%b)\n",
    "print(\"Potência: \", a**b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Raiz:  5.0\n"
     ]
    }
   ],
   "source": [
    "# math é uma das bibliotecas-padrão do Python.\n",
    "# Implementa operações matemáticas que não podem ser usadas com números complexos e que retornam sempre float.\n",
    "\n",
    "import math\n",
    "print(\"Raiz: \", math.sqrt(25))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tipo textual"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Representam textos. Pelo que entendi da [documentação](https://docs.python.org/3/library/stdtypes.html#textseq), é sempre uma string.\n",
    "\n",
    "Strings podem ser escritas de 3 formas: aspas simples, aspas duplas e três aspas simples ou duplas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Aspas duplas:\n",
    "frase = \"texto aqui\"\n",
    "type (frase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Aspas simples:\n",
    "\n",
    "frase = 'texto aqui'\n",
    "type (frase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Três aspas simples ou três aspas duplas:\n",
    "frase = '''texto aqui'''\n",
    "type (frase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para usar uma string que contém aspas ou apóstrofo, é necessário acrescentar um scape (\\) antes do caractere:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (591205289.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[88], line 1\u001b[1;36m\u001b[0m\n\u001b[1;33m    escape = 'I'm an unicorn!''\u001b[0m\n\u001b[1;37m                ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "escape = 'I'm an unicorn!''\n",
    "escape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"I'm an unicorn!\""
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "escape = 'I\\'m an unicorn!'\n",
    "escape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### str methods\n",
    "\n",
    "Tipos textuais/Strings vêm com métodos bult-in, listados na [documentação](https://docs.python.org/3/library/stdtypes.html#string-methods)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python é uma Linguagem de Programação'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# .replace substitui parte da string:\n",
    "\n",
    "frase = 'python éuma Linguagem de Programação'\n",
    "frase = frase.replace('éuma', 'é uma')\n",
    "frase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'PYTHON É UMA LINGUAGEM DE PROGRAMAÇÃO'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# .upper deixa todas as letras maiúsculas. Observar que, para aplicar o método, basta escrever a variável seguida do nome do método.\n",
    "\n",
    "frase.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python é uma Linguagem de Programação'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Observar que, no caso anterior, o método não substituiu o valor da variável, apenas mudou a forma de apresentá-la:\n",
    "frase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'PYTHON É UMA LINGUAGEM DE PROGRAMAÇÃO'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Para substituir o valor, é preciso incluir o frase =:\n",
    "frase = frase.upper()\n",
    "frase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python É Uma Linguagem De Programação'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# .title aplica capitalização de título, deixando a primeira letra de cada palavra em maiúsculo:\n",
    "frase.title()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['python,', 'é', 'uma', 'linguagem', 'de', 'programação']"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# .split divide a frase de acordo com o delimitador indicado. Nesse caso, espaço:\n",
    "\n",
    "frase.split(\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#.count() conta quantas vezes o caractere indicado aparece na string:\n",
    "\n",
    "frase.count(\"m\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#.find(\"é\") funciona como a função LOCALIZA no Excel:\n",
    "\n",
    "frase.find(\"é\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[O curso das Pyladies](https://github.com/naiaracerqueira/curso_python/blob/main/2_Básico/6_Variaveis.ipynb) apresenta uma série de outros métodos padrão do tipo str."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sequências"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- list - listas\n",
    "- tupla - tuplas\n",
    "- range - range (intervalo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Armazenam qualquer tipo de dados\n",
    "- Podem armazenar dados de tipos diferentes\n",
    "- Assim como str, vêm com métodos padrão, disponíveis na [documentação](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "# Listas podem ser indicadas por [], list((iterable)) ou list().\n",
    "# Nesse último caso, coloca-se uma string entre aspas e cada caractere vira um elemento da lista, pelo que entendi da documentação.\n",
    "\n",
    "print(type([]))\n",
    "print(type(list()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista1 = [1,2,3,4,5]\n",
    "print(lista1)\n",
    "type(lista1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "lista2 = list((1,2,3,4,5))\n",
    "print(lista2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', '2', '3', '4', '5']\n"
     ]
    }
   ],
   "source": [
    "lista3 = list(\"12345\")\n",
    "print(lista3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'python', True, 3.1415]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Como mencionado, listas podem ter variáveis de tipos diferentes:\n",
    "\n",
    "lista4 = [1,'python',True,3.1415]\n",
    "print(lista4)\n",
    "type(lista4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Algumas coisa que dá para fazer com listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abacate', 'limão', 10, 'tomate', 'sal', 'alho', 'cebola', 'pimentão']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Alterar valor na posição n. No caso do exemplo, posição 2.\n",
    "# Note que a contagem começa no 0:\n",
    "\n",
    "lista = ['abacate', 'limão', 'maçã', 'tomate', 'sal', 'alho', 'cebola', 'pimentão']\n",
    "lista[2] = 10\n",
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tomate'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Encontrar elemento da lista pelo índice.\n",
    "# Novamente, notar que o primeiro elemento é 0, não 1:\n",
    "\n",
    "lista[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abacate'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para uma lista mais completa, conferir a [documentação](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ranges"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ranges (intervalos?) criam uma sequência inteira a partir de pontos de início e fim. Para ver o range criado, é preciso colocá-lo dentro de uma lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Note que, assim como o índice dos elementos da lista, a contagem começa no 0, não no 1:\n",
    "\n",
    "list(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# É possível criar intervalos a partir de pontos pré-definidos de início e fim.\n",
    "# Note que o número indicado como fim não entra no intervalo:\n",
    "\n",
    "list(range(2,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Também é possível determinar o intervalo entre cada item do range:\n",
    "\n",
    "list(range(2,10, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Conjuntos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Reúne dois tipos de dados: `set` e `frozenset`\n",
    "- `frozenset` precisa ser chamado explicitamente e não sofre alterações"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sets:\n",
    "\n",
    "- Coleção de dados únicos e não ordenados\n",
    "- Mesmo que haja repetição de dados, o `set` salva uma única instância\n",
    "- Permite operações matemáticas como `union`, `intersection`, `difference` e `symmetric difference`\n",
    "- É representado com {}, mas um conjunto vazio (print(type{})) vai ser classificado como dicionário. Dicionários também são indicados por {}."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conjunto = {1,2,3,4,4,4,5,6}\n",
    "print(conjunto)\n",
    "type(conjunto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'frozenset'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "frozenset({1, 2, 3, 4, 5, 6})"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(type(frozenset({1,2,3,4,4,4,4,5,6})))\n",
    "frozenset( {1,2,3,4,4,4,4,5,6})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'r', 'c', 'a', 'b', 'd'}\n",
      "{'z', 'c', 'a', 'l', 'm'}\n",
      "\n",
      "a - b:\n",
      "{'b', 'r', 'd'}\n"
     ]
    }
   ],
   "source": [
    "# É possível fazer operações matemáticas com conjuntos:\n",
    "\n",
    "a = set('abracadabra')\n",
    "b = set('alacazam')\n",
    "\n",
    "print(a)\n",
    "print(b)\n",
    "\n",
    "print(\"\\na - b:\") # Aqui, estamos pedindo ao Python para printar essa string\n",
    "print(a - b) # Aqui, pedimos ao Python para printar as letras do conjunto a que não estão no conjunto b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "a & b:\n",
      "{'a', 'c'}\n"
     ]
    }
   ],
   "source": [
    "print(\"\\na & b:\")\n",
    "print (a & b) # Letras que estão presentes em 'a' ou 'b' (& significa AND)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "a | b:\n",
      "{'z', 'r', 'c', 'a', 'b', 'l', 'm', 'd'}\n"
     ]
    }
   ],
   "source": [
    "print(\"\\na | b:\")\n",
    "print(a | b) # Letras que estão em 'a' ou 'b' (| significa OR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a ^ b:\n",
      "{'z', 'r', 'l', 'b', 'm', 'd'}\n"
     ]
    }
   ],
   "source": [
    "print(\"a ^ b:\")\n",
    "print(a ^ b) # Letras que estão em 'a' ou em 'b', mas não em ambos (^ funciona como o operador XOR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Também é possível verificar se um conjunto contém um determinado elemento:\n",
    "\n",
    "conjunto = {1, 3.14, 'abacate', 'chilli'}\n",
    "'abacate' in conjunto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3.14, 'chilli'}"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ou remover itens:\n",
    "\n",
    "conjunto.remove('abacate')\n",
    "conjunto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Também é possível remover todos os itens de um conjunto de uma vez:\n",
    "\n",
    "conjunto.clear()\n",
    "conjunto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tipos mapeáveis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Dicionários, ou seja, objetos com a estrutura `key:value` (chave:valor)\n",
    "- Sua estrutura lembra `json`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "# Para iniciar um dict vazio:\n",
    "\n",
    "print(type({}))\n",
    "print(type(dict()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'MG': 'Belo Horizonte', 'BA': 'Salvador', 'PE': 'Recife', 'AM': 'Manaus'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Para popular o dicionário, usa-se a estrutura chave:valor:\n",
    "\n",
    "dicionario = {'MG':'Belo Horizonte','BA':'Salvador','PE':'Recife','AM':'Manaus'}\n",
    "print(dicionario)\n",
    "type(dicionario)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Belo Horizonte'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# É possível pedir ao Python para printar um valor a partir da chave:\n",
    "dicionario['MG']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'MG': 'valor5', 'BA': 'Salvador', 'PE': 'Recife', 'AM': 'Manaus'}"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Também é possível alterar o valor de uma determinada chave:\n",
    "\n",
    "dicionario['MG'] = 'valor5'\n",
    "dicionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['MG', 'BA', 'PE', 'AM'])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Mostrar todas as chaves (keys) do dicionário:\n",
    "\n",
    "dicionario.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['valor5', 'Salvador', 'Recife', 'Manaus'])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Mostrar todos os valores do dicionário:\n",
    "\n",
    "dicionario.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('MG', 'valor5'), ('BA', 'Salvador'), ('PE', 'Recife'), ('AM', 'Manaus')])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Mostrar todos os pares de item e valor:\n",
    "\n",
    "dicionario.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'valor5'"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exibir o valor de uma determinada chave, ou o que será retornado se a chave não existir:\n",
    "\n",
    "dicionario.get('MG','Capital não cadastrada')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Capital não cadastrada'"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dicionario.get('SP','Capital não cadastrada')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutabilidade e imutabilidade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variáveis imutáveis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variáveis imutáveis são aquelas instanciadas com um valor único, ou seja, seu valor não pode ser alterado. São elas:\n",
    "\n",
    "- bool\n",
    "- int\n",
    "- float\n",
    "- complex\n",
    "- str\n",
    "- tuple\n",
    "- frozenset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "140723757414472"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Vamos verificar a afirmação acima.\n",
    "# A função id() retorna um id único para o objeto. Esse id é assignado quando o objeto é criado. Cada objeto no Python tem um id único.\n",
    "# Esse id está relacionado ao endereço de memória e, pelo que entendi, afeta a performance do código.\n",
    "\n",
    "x = 42\n",
    "print(type(x))\n",
    "id(x) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43\n",
      "140723757414504\n"
     ]
    }
   ],
   "source": [
    "# Agora, vamos tentar fazer uma operação com a variável e verificar se o id se altera:\n",
    "\n",
    "x = x + 1\n",
    "print(x)\n",
    "print(id(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "# O valor da variável se alterou, mas vemos que o id também.\n",
    "# Ou seja: o que de fato aconteceu é que outra variável substituiu (foi instanciada no lugar de) a anterior."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variáveis mutáveis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diferente das imutáveis, elas têm seu valor alterado. São elas:\n",
    "\n",
    "- list\n",
    "- set\n",
    "- dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2191746888576"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Vamos fazer o mesmo teste anterior com uma variável mutável:\n",
    "\n",
    "x = [22, 44]\n",
    "print(type(x))\n",
    "id(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[22, 44, 66]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2191746888576"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.append(66) # Acrescenta um novo valor ao final da lista\n",
    "print(x)\n",
    "id(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Vemos que o id se manteve o mesmo, ou seja, trata-se da mesma variável e o mesmo endereço de memória."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operadores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadores de atribuição"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `=` - atribuição\n",
    "- `+=` - atribuição incremental, adiciona um valor à variável e atribui o resultado.\n",
    "- `-=` - atribuição decremental, subtrai o valor da variável e atribui o resultado.\n",
    "- `/=` - atribuição com divisão, mesma lógica da anterior\n",
    "- `*=` - atribuição com multiplicação, mesma lógica da anterior\n",
    "- `%=` - atribuição de módulo; terá como resultado o resto da divisão dos números e atribuirá esse valor à variável. Mais informações [aqui](https://realpython.com/python-modulo-operator/#modulo-in-mathematics)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Operador de atribuição incremental:\n",
    "\n",
    "x = 5\n",
    "x += 3\n",
    "print(x)\n",
    "x -= 5\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Me parece que usar +- e \"x = x + y\" dá o mesmo resultado:\n",
    "\n",
    "x = 3\n",
    "x = 3+1\n",
    "print(x)\n",
    "\n",
    "x = 3\n",
    "x += 1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadores booleanos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- x or y\n",
    "- x and y\n",
    "- not x\n",
    "- Até onde eu sei, booleanos são sempre um resultado de TRUE ou FALSE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Operadores lógicos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " A    - B    - or    -and    - not A\n",
      "False - False False - False - True\n",
      "False - True - True - False - True\n",
      "True - False - False - False\n",
      "True - True - True = True - False\n"
     ]
    }
   ],
   "source": [
    "# tabela verdade\n",
    "print(f\" A    - B    - or    -and    - not A\")\n",
    "print(f\"False - False { False or False} - {False and False} - {not False}\")\n",
    "print(f\"False - True - {False or True} - {False and True} - {not False}\")\n",
    "print(f\"True - False - {True and False} - {not True}\")\n",
    "print(f\"True - True - {True or True} = {True and True} - {not True}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadores comparativos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `<` - menor que\n",
    "- `<=` - menor ou igual\n",
    "- `>` - maior que\n",
    "- `>=` - maior ou igual\n",
    "- `==` - igual (apenas um = é usado para atribuição de variável)\n",
    "- `!=` - diferente\n",
    "- `is` - comparação de identidade\n",
    "- `is not` - negação da comparação de identidade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Operadores relacionais"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(4 == 5) # Igual\n",
    "print(4 != 5) # Diferente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(4 < 5)\n",
    "print(4 > 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "x = 4\n",
    "print(4 == x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140723707474824\n",
      "140723707474824\n"
     ]
    }
   ],
   "source": [
    "print (id(4))\n",
    "print(id(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Controle de fluxo e Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### if - else"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A estrutura do `if` é:\n",
    "\n",
    "    if(condition:):\n",
    "        action\n",
    "    elif(condition):\n",
    "        action\n",
    "    else:\n",
    "        action\n",
    "\n",
    "\n",
    "\"Elif\" significa \"else if\". É usado para checar múltiplas condições. Por exemplo, se a primeira condição é falsa, checar a próxima."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá, mundo!\n"
     ]
    }
   ],
   "source": [
    "# Neste caso, vai realizar o print:\n",
    "if(True):\n",
    "    print(\"Olá, mundo!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Neste caso, NÃO vai realizar o print:\n",
    "if(False):\n",
    "    print(\"Olá, mundo!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a > 0\n"
     ]
    }
   ],
   "source": [
    "# No código abaixo, atribuímos o valor 3 à variável `a`.\n",
    "# Depois, checamos se `a` é maior do que 0. Em caso positivo, printamos \"a > 0\"\n",
    "# Se a condição não for atendida, verificamos se `a` é igual à 3. Se for, printamos \"a == 3\".\n",
    "# Se a condição não for atendida, printamos \"N.D.A.\"\n",
    "\n",
    "a = 3\n",
    "\n",
    "if(a > 0):\n",
    "    print(\"a > 0\")\n",
    "elif(a==3):\n",
    "    print(\"a==3\")\n",
    "else:\n",
    "    print(\"N.D.A\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 está em [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# No código abaixo, atribuímos um intervalo de 0 a 9 para `a` e checamos se 3 é parte do invervalo.\n",
    "# Se for, printamos \"3 está em {a}\", em que \"{a}\" é o valor da variável. Se não for, printamos \"falso\".\n",
    "\n",
    "a = list(range(10))\n",
    "\n",
    "if(3 in a):\n",
    "    print(f\"3 está em {a}\")\n",
    "else:\n",
    "    print(\"falso\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existem dois tipos de loop em python:\n",
    "\n",
    "- `for` - faz uma iteração por cada elemento de uma sequência (`list` ou `string`) na ordem em que aparecem.\n",
    "- `while` - executa um loop enquanto uma determinada condição (por exemplo, a < 10) for verdadeira.\n",
    "\n",
    "As estruturas são como se segue:\n",
    "\n",
    "- `for`: for(something in expression) - do something\n",
    "- `while`: while(condition) - do something"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "range(0, 10)\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# No código a seguir, o código executa um print para cada item do intervalo.\n",
    "\n",
    "for i in range(10):\n",
    "    print(i)\n",
    "\n",
    "# Note que o resultado é bastante diferente de simplesmente printar um intervalo ou uma lista:\n",
    "print(range(10))\n",
    "a = [0,1,2,3,4,5,6,7,8,9]\n",
    "print(a)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "banana\n",
      "abacate\n",
      "melancia\n",
      "abacaxi\n"
     ]
    }
   ],
   "source": [
    "lista = ['banana','abacate','melancia','abacaxi']\n",
    "for elemento in lista:\n",
    "    print(elemento)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Aqui, usamos o WHILE para fazer com que a operação pare quando `a` atingir o valor de `b`:\n",
    "\n",
    "a, b = 0, 10\n",
    "while(a < b):\n",
    "    a += 1\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 1 2 3 5 8 13 21 34 55 89 144\n"
     ]
    }
   ],
   "source": [
    "# Na mesma lógica, vamos printar a sequência de Fibonacci até 100:\n",
    "\n",
    "a, b = 0,1 # Damos os valores iniciais das variáveis\n",
    "while b < 100:\n",
    "    print(a, end=' ') # Printamos 0 e acrescentamos o end para substituir o final padrão ENTER por um espaço\n",
    "    a, b = b, a+b # Substituímos os valores das variáveis, para que `a` seja igual a `b` e o número seguinte seja a soma dos dois.\n",
    "\n",
    "print(f\"{a} {b}\") # Printamos a sequência, separada por um espaço, até que `a` atinja o valor de 100."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### break, pass, continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `break` - para a execução do loop\n",
    "- `pass` - faz nada\n",
    "- `continue` - pula próxima execução"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "break\n"
     ]
    }
   ],
   "source": [
    "# break\n",
    "\n",
    "for i in range(10):\n",
    "    print(i)\n",
    "    if i == 3:\n",
    "        print(\"break\")\n",
    "        break\n",
    "        print(\"depois do break\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "pass\n",
      "depois do pass\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# pass\n",
    "\n",
    "for i in range(10):\n",
    "    print(i)\n",
    "    if i == 3:\n",
    "        print(\"pass\")\n",
    "        pass\n",
    "        print(\"depois do pass\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "continue\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# continue\n",
    "\n",
    "for i in range(10):\n",
    "    print(i)\n",
    "    if i == 3:\n",
    "        print(\"continue\")\n",
    "        continue\n",
    "        print(\"depois do continue\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "São maneiras mais simples de criar alguns tipos usando cláusulas `for` e `if`. Podem ser usadas para:\n",
    "\n",
    "- list - [PEP 202](https://peps.python.org/pep-0202/)\n",
    "- dict - [PEP 274](https://peps.python.org/pep-0274/)\n",
    "- set - [PEP 530](https://peps.python.org/pep-0530/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 27, 256, 3125, 46656, 823543, 16777216, 387420489, 10000000000]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Para cada x, no range de 1 a 10\n",
    "# Eleve x por x\n",
    "\n",
    "[ x**x for x in range (1,11)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 27, 3125, 823543, 387420489]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Para cada x, no range de 1 a 10\n",
    "# Eleve x por x, APENAS SE número é impar (divisão por 2 dá resto diferente de zero)\n",
    "\n",
    "[ x**x for x in range (1,11) if x % 2 != 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comp = {x for x in range(1,11)}\n",
    "print(comp)\n",
    "type(comp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dict:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 4, 3: 27, 4: 256, 5: 3125, 6: 46656, 7: 823543, 8: 16777216, 9: 387420489, 10: 10000000000}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comp = {x: x**x for x in range (1,11)}\n",
    "# Pelo que entendi, estamos criando um dicionário em que a chave é um número inteiro e o valor, o número elevado a si mesmo.\n",
    "print(comp)\n",
    "type(comp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tratamento de exceções"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O tratamento de exceções no Python acontece com blocos `try-except` e tem a função de lidar com erros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Não é possível tirar raiz de números negativos.\n"
     ]
    }
   ],
   "source": [
    "# É possível explicitar o tipo de erro com que queremos lidar:\n",
    "\n",
    "import math\n",
    "\n",
    "x = -25\n",
    "\n",
    "try:\n",
    "    print(math.sqrt(x))\n",
    "except ValueError:\n",
    "    print(\"Não é possível tirar raiz de números negativos.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Built-in exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O Python já vem com uma lista de exceções embutidas, descritas na [documentação](https://docs.python.org/3/library/exceptions.html).\n",
    "\n",
    "No exemplo abaixo, ele nos dá um ZeroDivisionError quando chega à divisão por zero e nem continua a rodar o código:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[73], line 4\u001b[0m\n\u001b[0;32m      1\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m100\u001b[39m\n\u001b[0;32m      2\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[1;32m----> 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mx\u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43my\u001b[49m)\n",
      "\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "x = -100\n",
    "y = 0\n",
    "\n",
    "print(x/y)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Não pode dividir por zero!\n"
     ]
    }
   ],
   "source": [
    "# Agora, vamos dizer ao Python o que queremos que ele retorne caso tenha um erro de divisão por zero:\n",
    "\n",
    "x = -100\n",
    "y = 0\n",
    "try:\n",
    "    print(x/y)\n",
    "except ZeroDivisionError:\n",
    "        print(\"Não pode dividir por zero!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ERRO: division by zero\n"
     ]
    }
   ],
   "source": [
    "# Também é possível tratar o erro sem saber qual é ele:\n",
    "\n",
    "x = -100\n",
    "y = 0\n",
    "try:\n",
    "    print(x/y)\n",
    "except Exception as e: # recebe a exceção e salva na variável \"e\"\n",
    "    print(f\"ERRO: {e}\") # inclui o valor da variável (o tipo de erro) na string que será printada"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funções"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funções - Visão geral"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PEPs relacionadas:\n",
    "\n",
    "- [PEP8](https://peps.python.org/pep-0008/) - Style Guide\n",
    "- [PEP257](https://peps.python.org/pep-0257/) - Docstrings\n",
    "- [PEP484](https://peps.python.org/pep-0484/) - Type Hints\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convenção de nomenclaturas PEP8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nomes de funções devem ser em minúsculo, separadas por underscore quando necessário:\n",
    "\n",
    "    # exemplo 1\n",
    "    def Fun(): pass # por convenção, está errado\n",
    "    def fun(): pass # por convenção, está certo\n",
    "\n",
    "    # exemplo 2\n",
    "    def Fun_1(): pass # errado\n",
    "    def fun_1(): pass # certo\n",
    "\n",
    "    # exemplo 3\n",
    "    def Fun1(): pass # errado\n",
    "    def fun1(): pass # \n",
    "\n",
    "Note que é a mesma regra de nomenclatura de variável."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convenção de documentação PEP257\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Usam-se 3 aspas duplas, mesmo que o texto tenha pouco conteúdo\n",
    "- É a primeira informação logo em seguida à declaração da função\n",
    "- A documentação deve começar com um infinitivo afirmativo na 3ª pessoa do singular\n",
    "\n",
    "Exemplo da PEP:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "def kos_root():\n",
    "    \"\"\"Return the pathname of the KOS root directory.\"\"\"\n",
    "    global _kos_root\n",
    "    if _kos_root: return _kos_root"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sintaxe de funções"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    def nome_da_funcao(parametros):\n",
    "        manipulacao\n",
    "        return resultado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Por exemplo:\n",
    "\n",
    "def soma_numeros(a,b,c):\n",
    "    return a+b+c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "406725"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = soma_numeros(131240,150504,124981)\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "406725"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Podemos fazer essa mesma função usando type hints, dizendo ao Python o tipo de cada parâmetro:\n",
    "\n",
    "def soma_numeros(a: int, b: int, c: int):\n",
    "    return a+b+c\n",
    "\n",
    "soma_numeros(131240,150504,124981)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "406725"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Também podemos usar type hints e docstrings\n",
    "def soma_numeros(a: int, b: int, c: int):\n",
    "    \"\"\"Soma números inteiros\"\"\"\n",
    "    return a+b+c\n",
    "\n",
    "soma_numeros(131240,150504,124981)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Soma números inteiros'"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Também podemos verificar qual a documentação de uma determinada função:\n",
    "\n",
    "soma_numeros.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "É par!\n"
     ]
    }
   ],
   "source": [
    "# Outro exemplo de função:\n",
    "\n",
    "def verifica_par(x):\n",
    "    if x %2 == 0:\n",
    "        print(\"É par!\")\n",
    "    else:\n",
    "        print(\"É impar!\")\n",
    "\n",
    "verifica_par(38129204810982)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função só tem conhecimento do que está dentro dela ou de variáveis globais. Se for algo além disso, a função não reconhece."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saída nível 2: Variável nível 2\n",
      "Saída nível 1: Variável no nível 1\n"
     ]
    }
   ],
   "source": [
    "mensagem = \"Variável externa\"\n",
    "def imprimir_nivel1():\n",
    "    #print(f\"entrada nível 1: {mensagem}\")\n",
    "    mensagem = \"Variável no nível 1\"\n",
    "\n",
    "    def imprimir_nivel2():\n",
    "        #print(f\"entrada nivel 2: {mensagem}\")\n",
    "        mensagem = \"Variável nível 2\"\n",
    "        print(f\"Saída nível 2: {mensagem}\")\n",
    "    \n",
    "    imprimir_nivel2()\n",
    "    print(f\"Saída nível 1: {mensagem}\")\n",
    "\n",
    "# Agora sim, vamos imprimir\n",
    "imprimir_nivel1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funções lambda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Também podem aparecer como funções anônimas\n",
    "- Têm uma única instrução e seu resultado é o valor de retorno\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "def funcao_curta(X):\n",
    "    return x **2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Também pode ser escrita como lambda:\n",
    "\n",
    "funcao = lambda x: x ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "lista = [1,2,3,4,5]\n",
    "\n",
    "for x in lista:\n",
    "    print(funcao(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Método importante para a organização do código\n",
    "- Ajuda a usar o paradigma de Orientação a Objetos em Python\n",
    "- PEPs relacionadas:\n",
    "  - [PEP8](https://peps.python.org/pep-0008/) - Style Guide\n",
    "  - [PEP257](https://peps.python.org/pep-0257/) - Docstrings\n",
    "  - [PEP484](https://peps.python.org/pep-0484/) - Type Hints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convenção de nomenclatura PEP8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nome deve ter a primeira letra de cada palavra em maiúsculo e não ter separação (CamelCase):\n",
    "\n",
    "    # Exemplo 1\n",
    "    class Fun(): pass # Certo\n",
    "    class fun(): pass # Errado\n",
    "\n",
    "    # Exemplo 2\n",
    "    class Fun_1(): pass # Errado\n",
    "    class fun_1(): pass # Errado\n",
    "\n",
    "    # Exemplo 3\n",
    "    class Fun1(): pass # Certo\n",
    "    class fun1(): pass # Errado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convenção de documentação PEP257"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Assim como funções, usam-se 3 aspas duplas\n",
    "- É a primeira informação logo em seguida à declaração da class\n",
    "- Começa a documentação com um verbo no infinitivo afirmativo, 3ª pessoa do singular (\"Faz\")\n",
    "- Não deve repetir o que já foi dito na declaração da classe\n",
    "- É boa prática usar type hints nos métodos da classe\n",
    "- É boa prática usar docstrings (documentação) nos métodos da classe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Criando uma classe muito simples\n",
    "\n",
    "class MyClass:\n",
    "    x =5\n",
    "\n",
    "MyClass.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Também é possível criar um objeto\n",
    "\n",
    "numero = MyClass()\n",
    "\n",
    "numero.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name: str, sobrenome: str):\n",
    "        self.name = name\n",
    "        self.sobrenome = sobrenome"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Juliana\n",
      "Guamá\n",
      "Naiara\n",
      "Cerqueira\n"
     ]
    }
   ],
   "source": [
    "p1 = Person(\"Juliana\",\"Guamá\")\n",
    "p2 = Person(\"Naiara\", \"Cerqueira\")\n",
    "\n",
    "print(p1.name)\n",
    "print(p1.sobrenome)\n",
    "\n",
    "print(p2.name)\n",
    "print(p2.sobrenome)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Boa noite, meu nome é Naiara\n"
     ]
    }
   ],
   "source": [
    "# Também é possível criar uma clásse com método:\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name: str, sobrenome: str):\n",
    "        self.name = name\n",
    "        self.sobrenome = sobrenome\n",
    "    \n",
    "    def myfunc(self):\n",
    "        print(\"Boa noite, meu nome é \" + self.name)\n",
    "\n",
    "p1 = Person(\"Naiara\", \"Cerqueira\")\n",
    "p1.myfunc()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manipulação de arquivos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sintaxe da função `open`:\n",
    "\n",
    "    open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)\n",
    "\n",
    "- `mode` possíveis:\n",
    "   - `r` - leitura (read)\n",
    "   - `w` - escrita, que sobrescreve o arquivo (write)\n",
    "   - `x` - criação de arquivo (gera exceção se o arquivo existir)\n",
    "   - `a` - acrescentar no arquivo (add)\n",
    "   - `b` - modo binário\n",
    "   - `t` - modo de texto\n",
    "   - `+` - abre para udpate (leitura e escrita)\n",
    "- [Documentação completa](https://docs.python.org/3/library/functions.html#open)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The \"with\" Statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para não ser necessário abrir e fechar um arquivo, podemos usar o comando `with` para executar operações e não precisar fechar o arquivo novamente"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}