Metodos_especiais.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Métodos especiais dunder underscore \\_\\_**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **\\_\\_class__**\r\n",
    "O método interno \\_\\_class__ permite que possamos fazer uma referência a classe atual, permitindo o acesso a informações da mesma.\r\n",
    "\r\n",
    "Utilizando o \\_\\_class__ podemos acessar informações como nome da classe, atributo da classe ou algum método da classe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conta\n",
      "Michael\n",
      "chamando um método\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "class Conta():\n",
    "  nome: str = \"Michael\" # esse é um atributo da classe\n",
    "\n",
    "  def __init__(self, titular: str):\n",
    "    self.titular = titular # esse é um atributo da instância(objeto)\n",
    "\n",
    "  @classmethod\n",
    "  def metodo(cls): # esse é um método da classe\n",
    "    return \"chamando um método\"\n",
    "\n",
    "# acessando nome da classe\n",
    "conta = Conta(\"Erick\")\n",
    "print(conta.__class__.__name__)\n",
    "\n",
    "# acessando o atributo de classe 'nome'\n",
    "print(conta.__class__.nome)\n",
    "\n",
    "# acessando um método da classe\n",
    "print(conta.__class__.metodo())\n",
    "\n",
    "# Também podemos utilizar o __class__ para verificar o tipo de uma instância:\n",
    "print(conta.__class__ == Conta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Porque usarmos \\_\\_class__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "class Pessoa():\n",
    "    tamanho_cpf = 11\n",
    "\n",
    "    def __init__(self, cpf, nome):\n",
    "        self.cpf = cpf\n",
    "        self.nome = nome\n",
    "\n",
    "    def valida_cpf(self):\n",
    "        return True if len(self.cpf) == __class__.tamanho_cpf else False\n",
    "\n",
    "pe = Pessoa('00000000001', 'Ruby')\n",
    "print(pe.valida_cpf())\n",
    "\n",
    "pe = Pessoa('0000000000', 'Cristal')\n",
    "print(pe.valida_cpf())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "12\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "'''O que acontece é que, caso não exista o atributo tamanho_cpf na instância, o Python busca o atributo na classe. Em seguida, adicionamos um atributo tamanho_cpf na instância e quando dizemos que o valor é 12, o atributo da classe não é alterado, já que são atributos diferentes, um da classe e outro só da instância.'''\n",
    "\n",
    "class Pessoa:\n",
    "    tamanho_cpf = 11\n",
    "\n",
    "p = Pessoa()\n",
    "\n",
    "print(p.tamanho_cpf)\n",
    "\n",
    "p.tamanho_cpf = 12\n",
    "\n",
    "print(p.tamanho_cpf)\n",
    "\n",
    "print(Pessoa.tamanho_cpf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **\\_\\_dict__**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'nome': 'João', 'cpf': '123.456.789-00', 'profissão': 'Data Enginear'}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class Cliente():\r\n",
    "    def __init__(self, nome: str, cpf: str, profissão: str) -> None:\r\n",
    "        self.nome = nome\r\n",
    "        self.cpf = cpf\r\n",
    "        self.profissão = profissão\r\n",
    "\r\n",
    "cliente = Cliente('João', '123.456.789-00', 'Data Enginear')\r\n",
    "\r\n",
    "# imprimindo com método dict\r\n",
    "print(f'\\n{cliente.__dict__}\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **\\_\\_eq__**\r\n",
    "\r\n",
    "habilita a comparação entre dois objetos a == a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Filme():\n",
    "    def __init__(self, titulo: str) -> None:\n",
    "        self.titulo = titulo\n",
    "\n",
    "filme1, filme2, filme3 = Filme('A Teoria de Tudo'), Filme('La La Land'), Filme('A Teoria de Tudo')\n",
    "\n",
    "# Testando a igualdade == entre objetos\n",
    "filme1 == filme3\n",
    "# mesmo sabendo que filme1 é igual a filme3, recebemos um false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "class Filme():\n",
    "    def __init__(self, titulo: str) -> None:\n",
    "        self.titulo = titulo\n",
    "    \n",
    "    def __eq__(self, outro_filme) -> bool:\n",
    "        return self.titulo == outro_filme.titulo\n",
    "\n",
    "filme1, filme2, filme3 = Filme('A Teoria de Tudo'), Filme('La La Land'), Filme('A Teoria de Tudo')\n",
    "\n",
    "# Testando a igualdade == entre objetos apos a implementação do __eq__\n",
    "print(filme1 == filme3)\n",
    "print(filme1 == filme2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **\\_\\_getitem__**\r\n",
    "\r\n",
    "Deve ser aplicado a um objeto iteravel. Basicamente seu funcionamento é: objeto\\[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Serie 300\n",
      "Serie 300\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'Lista_programas' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-132d6c1afa52>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     15\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     16\u001b[0m \u001b[1;31m# Se tentarmos acionar diretamente gera um erro:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 17\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfim_de_semana\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'Lista_programas' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "class Lista_programas():\n",
    "    def __init__(self, nome: str, programas: list):\n",
    "        self.nome = nome\n",
    "        self.programas = programas\n",
    "\n",
    "lista = ['Lupin', 'Serie 300', 'Prison Break']\n",
    "\n",
    "fim_de_semana = Lista_programas('Series', lista)\n",
    "\n",
    "# O objeto lista tem o método __getitem__ podemos verificar um item atraves de seu indice\n",
    "print(lista[1])\n",
    "\n",
    "# Para ter o mesmo resultado na class Lista_programas teriamos que acessar nossa lista.\n",
    "print(fim_de_semana.programas[1])\n",
    "\n",
    "# Se tentarmos acionar diretamente gera um erro(TypeError: 'Lista_programas' object is not subscriptable):\n",
    "print(fim_de_semana[1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Serie 300\n"
     ]
    }
   ],
   "source": [
    "class Lista_programas():\n",
    "    def __init__(self, nome: str, programas: list):\n",
    "        self.nome = nome\n",
    "        self.programas = programas\n",
    "   \n",
    "    def __getitem__(self, indice: int):\n",
    "        return self.programas[indice] \n",
    "\n",
    "\n",
    "lista = ['Lupin', 'Serie 300', 'Prison Break']\n",
    "\n",
    "fim_de_semana = Lista_programas('Series', lista)\n",
    "\n",
    "# Agora com o __getitem__ conseguimos acessar nossos objetos passando um indice.  \n",
    "print(fim_de_semana[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **\\_\\_len__**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "object of type 'Lista_programas' has no len()",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-24-e338846b1417>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     15\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     16\u001b[0m \u001b[1;31m# Se tentarmos acionar diretamente gera um erro(TypeError: 'Lista_programas' object is not subscriptable):\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 17\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfim_de_semana\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: object of type 'Lista_programas' has no len()"
     ]
    }
   ],
   "source": [
    "class Lista_programas():\n",
    "    def __init__(self, nome: str, programas: list):\n",
    "        self.nome = nome\n",
    "        self.programas = programas\n",
    "\n",
    "lista = ['Lupin', 'Serie 300', 'Prison Break']\n",
    "\n",
    "fim_de_semana = Lista_programas('Series', lista)\n",
    "\n",
    "# O objeto lista tem o método __len__ podemos verificar a quantidade total de itens na lista\n",
    "print(len(lista))\n",
    "\n",
    "# Para ter o mesmo resultado na class Lista_programas teriamos que acessar nossa lista.\n",
    "print(len(fim_de_semana.programas))\n",
    "\n",
    "# Se tentarmos acionar diretamente gera um erro(TypeError: object of type 'Lista_programas' has no len()):\n",
    "print(len(fim_de_semana))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "class Lista_programas():\n",
    "    def __init__(self, nome: str, programas: list):\n",
    "        self.nome = nome\n",
    "        self.programas = programas\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.programas)\n",
    "\n",
    "lista = ['Lupin', 'Serie 300', 'Prison Break']\n",
    "\n",
    "fim_de_semana = Lista_programas('Series', lista)\n",
    "\n",
    "# Após a implementação de __len__ na class conseguimos agora verificar o tamanho de itens do objeto diretamente:\n",
    "print(len(fim_de_semana))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **\\_\\_lt__**\r\n",
    "habilita o objeto a ser ordenavel, ou seja, usar sorted diretamente pela instancia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "\n",
      "Lista ordenada crescente\n",
      "uno tem 5 litros.\n",
      "gol tem 10 litros.\n",
      "corolla tem 25 litros.\n",
      "opala tem 100 litros.\n",
      "\n",
      "Lista ordenada decrescente\n",
      "opala tem 100 litros.\n",
      "corolla tem 25 litros.\n",
      "gol tem 10 litros.\n",
      "uno tem 5 litros.\n"
     ]
    }
   ],
   "source": [
    "class Veiculo:\n",
    "    \n",
    "    def __init__(self, nome, litros=0):\n",
    "        self.nome = nome\n",
    "        self.litros = litros\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'{self.nome} tem {self.litros} litros.'\n",
    "\n",
    "    def __lt__(self, outro):\n",
    "        return self.litros < outro.litros\n",
    "\n",
    "# Vamos instancia 4 veiculos cada um com uma quantidade de gasolina\n",
    "veiculo1 = Veiculo('gol', 10)\n",
    "veiculo2 = Veiculo('opala', 100)\n",
    "veiculo3 = Veiculo('uno', 5)\n",
    "veiculo4 = Veiculo('corolla', 25)\n",
    "lista_veiculos = [veiculo1, veiculo2, veiculo3, veiculo4]\n",
    "\n",
    "print(veiculo1 < veiculo2)\n",
    "\n",
    "print('\\nLista ordenada crescente')\n",
    "for veiculo in sorted(lista_veiculos):\n",
    "    print(veiculo)\n",
    "\n",
    "print('\\nLista ordenada decrescente')\n",
    "for veiculo in sorted(lista_veiculos, reverse=True):\n",
    "    print(veiculo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **\\_\\_module__**\r\n",
    "guarda o nome do modulo ao qual a classe pertence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__main__\n",
      "math\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "class Circulos:\n",
    "    pass\n",
    "print(Circulos.__module__) # __main__ , pois a classe Circulos foi criada no script corrente cujo __name__ é sempre __main__\n",
    "print(sqrt.__module__) # veja como não criamos a classe sqrt o modulo é de onde ela foi criada (math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **\\_\\_name__ == \\_\\_main__**\r\n",
    "No Python, arquivos .py são chamados de módulos. Cada módulo pode ser executado diretamente, como um programa em si, ou importado por outro módulo.\r\n",
    "\r\n",
    "Precisamos, de alguma maneira, identificar essa diferença. Para isso, temos uma variável nativa que pode nos auxiliar nisso - a \\_\\_name__, que nos indica o nome do contexto em que o módulo está rodando.\r\n",
    "\r\n",
    "Resumindo, a variável \\_\\_name__ representa o nome do módulo. Entretanto, quando o módulo é executado por si só como um programa, \\_\\_name__ é definido para ’\\_\\_main__’, diferente de quando o módulo é importado, no qual o valor fica de fato igual ao nome do módulo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__main__\n",
      "__main__\n"
     ]
    }
   ],
   "source": [
    "print(__name__)\n",
    "\n",
    "# Como estamos com arquivo Metodos_especiais.ipynb aberto o __name__ == '__main__'. É boa pratica usarmos esta logica para testarmos nosso codigo, ou seja quando o arquivo for importado o __name__ dele passara a ser chamado de Metodos_especiais e não executará o codigo indentado no if __name__ == '__main__'\n",
    "if __name__ == '__main__':\n",
    "    print(__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **\\_\\_repr__**\r\n",
    "\r\n",
    "repr () imprime a representação “oficial” de um objeto (significa que usando a representação de string “oficial” podemos reconstruir o objeto). Basicamente repr mostra a linguagem  real da maquina e str mostra a linguagem para o usuário."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-06-17 16:23:45.295182\n",
      "datetime.datetime(2021, 6, 17, 16, 23, 45, 295182)\n",
      "[datetime.datetime(2021, 6, 17, 16, 23, 45, 295182), 'oi']\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "today = datetime.datetime.now()\n",
    "\n",
    "print(str(today))\n",
    "\n",
    "print(repr(today)) \n",
    "\n",
    "lista = [today, 'oi']\n",
    "# em uma lista sempre é mostrato repr\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 + i20\n",
      "Rational 10 - 20\n",
      "[Rational 10 - 20, 'oi']\n"
     ]
    }
   ],
   "source": [
    "class Complex:\n",
    "    def __init__(self, real, imag):\n",
    "       self.real = real\n",
    "       self.imag = imag\n",
    "    \n",
    "    def __str__(self):\n",
    "       return f'{self.real} + i{self.imag}' \n",
    "    \n",
    "    def __repr__(self):\n",
    "       return f'Rational {self.real} - {self.imag}' \n",
    "\n",
    "t = Complex(10, 20)\n",
    "\n",
    "print(str(t))  \n",
    "print(repr(t))\n",
    "\n",
    "lista = [t, 'oi']\n",
    "# em uma lista sempre é mostrato repr\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **\\_\\_setitem__**\r\n",
    "\r\n",
    "Deve ser aplicado a um objeto iteravel. Basicamente seu funcionamento é: objeto\\[1] = 'dados'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista antes:\n",
      "['Lupin', 'Serie 300', 'Prison Break']\n",
      "Lista apos substituição:\n",
      "['Lupin', 'Bruchas', 'Prison Break']\n",
      "\n",
      "['Lupin', 'Bruchas', 'Prison Break']\n",
      "\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'Lista_programas' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-17-d39737f3acf3>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     18\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     19\u001b[0m \u001b[1;31m# Se tentarmos acionar diretamente gera um erro(TypeError: 'Lista_programas' object is not subscriptable):\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 20\u001b[1;33m \u001b[0mfim_de_semana\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'Bruchas'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     21\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfim_de_semana\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mprogramas\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'Lista_programas' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "class Lista_programas():\n",
    "    def __init__(self, nome: str, programas: list):\n",
    "        self.nome = nome\n",
    "        self.programas = programas\n",
    "\n",
    "lista = ['Lupin', 'Serie 300', 'Prison Break']\n",
    "\n",
    "fim_de_semana = Lista_programas('Series', lista)\n",
    "\n",
    "# O objeto lista tem o método __setitem__ podemos substituir um dado dentro de uma lista através de um indice.\n",
    "print(f'Lista antes:\\n{lista}')\n",
    "lista[1] = 'Bruchas'\n",
    "print(f'Lista apos substituição:\\n{lista}\\n')\n",
    "\n",
    "# Para ter o mesmo resultado na class Lista_programas teriamos que acessar nossa lista.\n",
    "fim_de_semana.programas[1]='Bruchas'\n",
    "print(f'{fim_de_semana.programas}\\n')\n",
    "\n",
    "# Se tentarmos acionar diretamente gera um erro(TypeError: 'Lista_programas' object does not support item assignment):\n",
    "fim_de_semana[1] = 'Bruchas'\n",
    "print(fim_de_semana.programas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista antes:\n",
      "['Lupin', 'Serie 300', 'Prison Break']\n",
      "\n",
      "['Lupin', 'Bruchas', 'Prison Break']\n"
     ]
    }
   ],
   "source": [
    "class Lista_programas():\n",
    "    def __init__(self, nome: str, programas: list):\n",
    "        self.nome = nome\n",
    "        self.programas = programas\n",
    "    \n",
    "    def __setitem__(self, indice: int, valor):\n",
    "        self.programas[indice] = valor\n",
    "\n",
    "lista = ['Lupin', 'Serie 300', 'Prison Break']\n",
    "\n",
    "fim_de_semana = Lista_programas('Series', lista)\n",
    "\n",
    "print(f'Lista antes:\\n{fim_de_semana.programas}\\n')\n",
    "\n",
    "# Agora com __setitem__ conseguimos modificar algum dado somente com nossa classe atraves de um indice e um valor.\n",
    "fim_de_semana[1] = 'Bruchas'\n",
    "print(fim_de_semana.programas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **\\_\\_str__**\r\n",
    "\r\n",
    "O método \\_\\_str__()  cria um modo de exibição padrão com print() é usado para retornar uma representação de string de um objeto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## sem \\_\\_srt__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Livro criado\n",
      "\n",
      "<__main__.Livro object at 0x0000012A7A985F40>\n"
     ]
    }
   ],
   "source": [
    "class Livro():\n",
    "    def __init__(self, titulo: str, autor: str, paginas: int):\n",
    "        print (\"Livro criado\\n\")\n",
    "        self.titulo = titulo\n",
    "        self.autor = autor\n",
    "        self.paginas = paginas            \n",
    "    \n",
    "    '''def __str__(self): # chama o print(), ou seja tanto faz um ou outro\n",
    "        return f'Título: {self.titulo} , autor: {self.autor}, páginas: {self.paginas}'''\n",
    "    \n",
    "livro1 = Livro(\"Os Lusíadas\", \"Luis de Camões\", 8816)\n",
    "print(livro1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## com \\_\\_srt__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Livro criado\n",
      "\n",
      "Título: Os Lusíadas , autor: Luis de Camões, páginas: 8816\n"
     ]
    }
   ],
   "source": [
    "class Livro():\n",
    "    def __init__(self, titulo: str, autor: str, paginas: int):\n",
    "        print (\"Livro criado\\n\")\n",
    "        self.titulo = titulo\n",
    "        self.autor = autor\n",
    "        self.paginas = paginas            \n",
    "    \n",
    "    def __str__(self): # chama o print(), ou seja tanto faz um ou outro\n",
    "        return f'Título: {self.titulo} , autor: {self.autor}, páginas: {self.paginas}'\n",
    "    \n",
    "livro1 = Livro(\"Os Lusíadas\", \"Luis de Camões\", 8816)\n",
    "print(livro1)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "325cb660cce599eef17833f9bb0afcb0e3dbe3e8605c570c8e00eb36d04c5df3"
  },
  "kernelspec": {
   "display_name": "Python 3.9.5 64-bit ('venv': venv)",
   "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.5"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}