Aula 12 - Boas Práticas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boas Práticas\n",
    "\n",
    "Nesta aula, vou ensinar algumas boas práticas para você aplicar em seu projeto python, sendo eles para você conseguir uma boa performance, um código legivel e outras coisas...\n",
    "\n",
    "Primeiro vamos falar sobre estrutura de projeto.\n",
    "\n",
    "\n",
    "Por \"estrutura\", entendemos as decisões que você toma sobre como o seu projeto melhor atende ao seu objetivo. Precisamos considerar como aproveitar melhor os recursos do Python para criar um código limpo e eficaz. Em termos práticos, \"estrutura\" significa criar código limpo, cuja lógica e dependências são claras, bem como a organização de arquivos e pastas no sistema de arquivos.\n",
    "\n",
    "Quais funções devem ser usadas em quais módulos? Como os dados fluem pelo projeto? Quais recursos e funções podem ser agrupados e isolados? Ao responder a perguntas como essas, você pode começar a planejar, em um sentido amplo, como será o seu produto acabado.\n",
    "\n",
    "Nesta seção, examinaremos mais de perto os módulos e os sistemas de importação do Python, pois eles são os elementos centrais da estrutura suspensa em seu projeto. Em seguida, discutimos várias perspectivas sobre como criar código que pode ser estendido e testado de maneira confiável.\n",
    "\n",
    "## Estrutura do Repositório\n",
    "**É importante.**\n",
    "\n",
    "Assim como o estilo de código, o design da API e a automação são essenciais para um ciclo de desenvolvimento saudável, a estrutura do repositório é uma parte crucial da arquitetura do seu projeto.\n",
    "\n",
    "Quando um usuário ou colaborador em potencial chega à página do seu repositório, ele vê algumas coisas:\n",
    "\n",
    "     Nome do Projeto\n",
    "     Descrição do Projeto\n",
    "     Arquivos do monte O '\n",
    "\n",
    "Somente quando eles rolarem abaixo da dobra, o usuário verá o README do seu projeto.\n",
    "\n",
    "Se o seu repositório for um despejo maciço de arquivos ou uma bagunça aninhada de diretórios, eles poderão procurar em outro lugar antes mesmo de ler sua bela documentação.\n",
    "\n",
    "     Vista-se para o trabalho que você deseja, não para o trabalho que você tem.\n",
    "\n",
    "Obviamente, as primeiras impressões não são tudo. Você e seus colegas passarão inúmeras horas trabalhando com este repositório, eventualmente se familiarizando intimamente com todos os cantos e recantos. O layout é importante.\n",
    "\n",
    "## Suíte de teste\n",
    "\n",
    "Começando, geralmente existe um pequeno conjunto de testes em um único arquivo:\n",
    "```\n",
    "./test_sample.py\n",
    "```\n",
    "Depois que um conjunto de testes cresce, você pode mover seus testes para um diretório, da seguinte maneira:\n",
    "```\n",
    "tests / test_basic.py\n",
    "tests / test_advanced.py\n",
    "```\n",
    "Obviamente, esses módulos de teste devem importar seu módulo empacotado para testá-lo. Você pode fazer isso de algumas maneiras:\n",
    "\n",
    "Espere que o pacote seja instalado nos pacotes do site.\n",
    "Use uma modificação de caminho simples (mas explícita) para resolver o pacote corretamente.\n",
    "\n",
    "Eu recomendo o último. Exigir que um desenvolvedor execute o setup.py develop para testar uma base de código que muda ativamente também exige que eles tenham uma configuração de ambiente isolada para cada instância da base de código.\n",
    "\n",
    "Para fornecer ao contexto de importação de testes individuais, crie um arquivo tests / context.py:\n",
    "```\n",
    "importação os\n",
    "sys de importação\n",
    "sys.path.insert (0, os.path.abspath (os.path.join (os.path.dirname (__ arquivo__), '..'))))\n",
    "```\n",
    "amostra de importação\n",
    "\n",
    "Em seguida, nos módulos de teste individuais, importe o módulo da seguinte maneira:\n",
    "\n",
    "da amostra de importação .context\n",
    "\n",
    "Isso sempre funcionará conforme o esperado, independentemente do método de instalação.\n",
    "\n",
    "Algumas pessoas afirmam que você deve distribuir seus testes dentro do próprio módulo - discordo. Geralmente aumenta a complexidade para seus usuários; muitas suítes de teste geralmente exigem dependências adicionais e contextos de tempo de execução.\n",
    "\n",
    "\n",
    "## Estrutura do código é a chave\n",
    "Graças à maneira como as importações e os módulos são tratados no Python, é relativamente fácil estruturar um projeto Python. Fácil, aqui, significa que você não possui muitas restrições e que o modelo de importação de módulos é fácil de entender. Portanto, você fica com a pura tarefa arquitetônica de criar as diferentes partes do seu projeto e suas interações.\n",
    "\n",
    "A fácil estruturação de um projeto significa que também é fácil fazê-lo mal. Alguns sinais de um projeto mal estruturado incluem:\n",
    "\n",
    "- Dependências circulares múltiplas e confusas: se suas classes Table e Chair no furn.py precisarem importar o Carpenter de workers.py para responder a uma pergunta como table.isdoneby () e, se inversamente, a classe Carpenter precisar importar Table e Chair para responder a questão carpenter.whatdo (), então você tem uma dependência circular. Nesse caso, você terá que recorrer a hacks frágeis, como o uso de instruções de importação dentro de métodos ou funções.\n",
    "- Acoplamento oculto: toda e qualquer alteração na implementação da Tabela quebra 20 testes em casos de teste não relacionados, porque quebra o código de Carpenter, o que requer uma cirurgia muito cuidadosa para adaptar a alteração. Isso significa que você tem muitas suposições sobre a tabela no código do Carpenter ou o contrário.\n",
    "- Uso intenso de estado ou contexto global: em vez de passar explicitamente (altura, largura, tipo, madeira) um para o outro, o Table e o Carpenter dependem de variáveis ​​globais que podem ser modificadas e modificadas rapidamente por diferentes agentes. Você precisa examinar todo o acesso a essas variáveis ​​globais para entender por que uma tabela retangular se tornou um quadrado e descobrir que o código de modelo remoto também está modificando esse contexto, interferindo nas dimensões da tabela.\n",
    "- Código de espaguete: várias páginas de cláusulas aninhadas se e para loops com muito código de procedimento copiado e colado e sem segmentação adequada são conhecidas como código de espaguete. A indentação significativa do Python (um de seus recursos mais controversos) dificulta a manutenção desse tipo de código. Portanto, a boa notícia é que você pode não ver muito disso.\n",
    "- O código Ravioli é mais provável no Python: consiste em centenas de pequenos pedaços de lógica semelhantes, geralmente classes ou objetos, sem estrutura adequada. Se você nunca se lembra se precisa usar FurnitureTable, AssetTable ou Table ou mesmo TableNew para sua tarefa em mãos, talvez esteja nadando em código ravioli.\n",
    "\n",
    "## Modulos\n",
    "\n",
    "Os módulos Python são uma das principais camadas de abstração disponíveis e provavelmente a mais natural. As camadas de abstração permitem separar o código em partes contendo dados e funcionalidades relacionados.\n",
    "\n",
    "Por exemplo, uma camada de um projeto pode manipular a interface com ações do usuário, enquanto outra manipulará a manipulação de dados de baixo nível. A maneira mais natural de separar essas duas camadas é reagrupar toda a funcionalidade de interface em um arquivo e todas as operações de baixo nível em outro arquivo. Nesse caso, o arquivo de interface precisa importar o arquivo de baixo nível. Isso é feito com as instruções import e from ... import.\n",
    "\n",
    "Assim que você usa instruções de importação, você utiliza módulos. Podem ser módulos internos, como os e sys, módulos de terceiros que você instalou em seu ambiente ou módulos internos do seu projeto.\n",
    "\n",
    "Para acompanhar o guia de estilo, mantenha os nomes dos módulos curtos, em minúsculas e evite usar símbolos especiais como o ponto (.) Ou o ponto de interrogação (?). Portanto, um nome de arquivo como my.spam.py é aquele que você deve evitar! Nomear dessa maneira interferirá na maneira como o Python procura por módulos.\n",
    "\n",
    "No caso de my.spam.py, o Python espera encontrar um arquivo spam.py em uma pasta chamada my, que não é o caso. Há um exemplo de como a notação de ponto deve ser usada nos documentos do Python.\n",
    "\n",
    "Se você quiser, poderia nomear seu módulo como my_spam.py, mas mesmo nosso amigo, o sublinhado não deve ser visto com frequência nos nomes dos módulos. No entanto, o uso de outros caracteres (espaços ou hífens) nos nomes dos módulos impedirá a importação (- é o operador de subtração); portanto, tente manter os nomes dos módulos curtos para que não haja necessidade de separar as palavras. E, acima de tudo, não namespace com sublinhados; use submódulos.\n",
    "\n",
    "```\n",
    "# OK\n",
    "import library.plugin.foo\n",
    "# not OK\n",
    "import library.foo_plugin\n",
    "```\n",
    "\n",
    "Além de algumas restrições de nomes, nada de especial é necessário para que um arquivo Python seja um módulo, mas você precisa entender o mecanismo de importação para usar esse conceito corretamente e evitar alguns problemas.\n",
    "\n",
    "Concretamente, a instrução import modu procurará o arquivo adequado, que é modu.py no mesmo diretório que o responsável pela chamada, se existir. Se não for encontrado, o intérprete Python procurará modu.py no “caminho” recursivamente e gerará uma exceção ImportError se não for encontrado.\n",
    "\n",
    "Uma vez encontrado o modu.py, o interpretador Python executará o módulo em um escopo isolado. Qualquer declaração de nível superior no modu.py será executada, incluindo outras importações, se houver. As definições de função e classe são armazenadas no dicionário do módulo.\n",
    "\n",
    "Em seguida, as variáveis, funções e classes do módulo estarão disponíveis para o chamador através do namespace do módulo, um conceito central na programação que é particularmente útil e poderoso no Python.\n",
    "\n",
    "Em muitos idiomas, uma diretiva de arquivo de inclusão é usada pelo pré-processador para pegar todo o código encontrado no arquivo e \"copiá-lo\" no código do chamador. É diferente no Python: o código incluído é isolado em um espaço para nome do módulo, o que significa que você geralmente não precisa se preocupar que o código incluído possa ter efeitos indesejados, por exemplo substituir uma função existente com o mesmo nome.\n",
    "\n",
    "É possível simular o comportamento mais padrão usando uma sintaxe especial da instrução de importação: from modu import *. Isso geralmente é considerado uma má prática. O uso de importação * torna o código mais difícil de ler e torna as dependências menos compartimentadas.\n",
    "\n",
    "O uso do mod import import é uma maneira de identificar a função que você deseja importar e colocá-la no espaço para nome local. Embora seja muito menos prejudicial que a importação *, porque mostra explicitamente o que é importado no espaço para nome local, sua única vantagem sobre um modu de importação mais simples é que ele economizará um pouco de digitação.\n",
    "\n",
    "**MUITO RUIM**\n",
    "```\n",
    "[...]\n",
    "from modu import *\n",
    "[...]\n",
    "x = sqrt(4)  # O sqrt faz parte do modu? Um embutido? Definido acima?\n",
    "```\n",
    "\n",
    "**BOM**\n",
    "```\n",
    "from modu import sqrt\n",
    "[...]\n",
    "x = sqrt(4)  # O sqrt pode fazer parte do modu, se não for redefinido entre\n",
    "```\n",
    "\n",
    "**PERFEITO**\n",
    "```\n",
    "import modu\n",
    "[...]\n",
    "x = modu.sqrt(4)  # sqrt é visivelmente parte do espaço para nome do modu\n",
    "```\n",
    "\n",
    "Conforme mencionado na seção Estilo do código, a legibilidade é um dos principais recursos do Python. Legibilidade significa evitar texto e clichê inúteis; portanto, são envidados alguns esforços na tentativa de atingir um certo nível de brevidade. Mas concisão e obscuridade são os limites onde a brevidade deve parar. Ser capaz de dizer imediatamente de onde vem uma classe ou função, como no idioma modu.func, melhora muito a legibilidade e a compreensão do código em todos os projetos, exceto nos mais simples, de arquivos simples.\n",
    "\n",
    "## Pacotes\n",
    "\n",
    "O Python fornece um sistema de empacotamento muito simples, que é simplesmente uma extensão do mecanismo do módulo para um diretório.\n",
    "\n",
    "Qualquer diretório com um arquivo __init__.py é considerado um pacote Python. Os diferentes módulos no pacote são importados de maneira semelhante aos módulos simples, mas com um comportamento especial para o arquivo __init__.py, que é usado para reunir todas as definições de todo o pacote.\n",
    "\n",
    "Um arquivo modu.py no diretório pack / é importado com a instrução import pack.modu. Esta instrução procurará um arquivo __init__.py no pacote e executará todas as suas instruções de nível superior. Em seguida, ele procurará um arquivo chamado pack / modu.py e executará todas as suas instruções de nível superior. Após essas operações, qualquer variável, função ou classe definida no modu.py estará disponível no espaço para nome pack.modu.\n",
    "\n",
    "Um problema comumente visto é adicionar muito código aos arquivos __init__.py. Quando a complexidade do projeto aumenta, pode haver subpacotes e subpacotes em uma estrutura de diretórios profunda. Nesse caso, a importação de um único item de um subpacote requer a execução de todos os arquivos __init__.py encontrados durante a navegação na árvore.\n",
    "\n",
    "Deixar um arquivo __init__.py vazio é considerado normal e até uma boa prática, se os módulos e subpacotes do pacote não precisarem compartilhar nenhum código.\n",
    "\n",
    "Por fim, uma sintaxe conveniente está disponível para importar pacotes profundamente aninhados: import very.deep.module como mod. Isso permite que você use mod no lugar da repetição detalhada de very.deep.module.\n",
    "\n",
    "\n",
    "## Programação Orientada a Objetos\n",
    "\n",
    "Às vezes, o Python é descrito como uma linguagem de programação orientada a objetos. Isso pode ser um pouco enganador e precisa ser esclarecido.\n",
    "\n",
    "No Python, tudo é um objeto e pode ser tratado como tal. É isso que queremos dizer quando dizemos, por exemplo, que funções são objetos de primeira classe. Funções, classes, strings e até tipos são objetos no Python: como qualquer objeto, eles têm um tipo, podem ser passados ​​como argumentos de função e podem ter métodos e propriedades. Nesse entendimento, Python é uma linguagem orientada a objetos.\n",
    "\n",
    "No entanto, diferentemente do Java, o Python não impõe a programação orientada a objetos como o principal paradigma de programação. É perfeitamente viável que um projeto Python não seja orientado a objetos, ou seja, use nenhuma ou muito poucas definições de classe, herança de classe ou quaisquer outros mecanismos específicos da programação orientada a objetos.\n",
    "\n",
    "Além disso, como visto na seção de módulos, a maneira como o Python lida com módulos e espaços de nome oferece ao desenvolvedor uma maneira natural de garantir o encapsulamento e a separação das camadas de abstração, sendo os dois os motivos mais comuns para usar a orientação a objetos. Portanto, os programadores Python têm mais latitude para não usar a orientação a objetos, quando isso não é exigido pelo modelo de negócios.\n",
    "\n",
    "Existem alguns motivos para evitar a orientação desnecessária a objetos. Definir classes personalizadas é útil quando queremos colar algum estado e alguma funcionalidade. O problema, como apontado pelas discussões sobre programação funcional, vem da parte “estado” da equação.\n",
    "\n",
    "Em algumas arquiteturas, geralmente aplicativos da Web, várias instâncias dos processos Python são geradas para responder a solicitações externas que podem acontecer ao mesmo tempo. Nesse caso, manter algum estado em objetos instanciados, o que significa manter algumas informações estáticas sobre o mundo, é propenso a problemas de simultaneidade ou condições de corrida. Às vezes, entre a inicialização do estado de um objeto (geralmente feito com o método __init __ ()) e o uso real do estado do objeto através de um de seus métodos, o mundo pode ter mudado e o estado retido pode estar desatualizado. Por exemplo, uma solicitação pode carregar um item na memória e marcá-lo como lido por um usuário. Se outra solicitação exigir a exclusão deste item ao mesmo tempo, pode ocorrer que a exclusão realmente ocorra após o primeiro processo carregar o item e, em seguida, precisamos marcar como um objeto excluído como lido.\n",
    "\n",
    "Esse e outros problemas levaram à idéia de que o uso de funções sem estado é um melhor paradigma de programação.\n",
    "\n",
    "Outra maneira de dizer o mesmo é sugerir o uso de funções e procedimentos com o menor número possível de contextos implícitos e efeitos colaterais. O contexto implícito de uma função é constituído por qualquer uma das variáveis ​​ou itens globais na camada de persistência que são acessados ​​de dentro da função. Efeitos colaterais são as alterações que uma função faz em seu contexto implícito. Se uma função salva ou exclui dados em uma variável global ou na camada de persistência, diz-se que ela tem um efeito colateral.\n",
    "\n",
    "Isolar cuidadosamente funções com contexto e efeitos colaterais de funções com lógica (chamadas funções puras) permite os seguintes benefícios:\n",
    "\n",
    "- As funções puras são determinísticas: dada uma entrada fixa, a saída será sempre a mesma.\n",
    "- As funções puras são muito mais fáceis de alterar ou substituir se precisarem ser refatoradas ou otimizadas.\n",
    "- As funções puras são mais fáceis de testar com testes de unidade: há menos necessidade de configuração de contexto complexa e limpeza de dados posteriormente.\n",
    "- As funções puras são mais fáceis de manipular, decorar e distribuir.\n",
    "\n",
    "Em resumo, funções puras são blocos de construção mais eficientes do que classes e objetos para algumas arquiteturas porque não possuem contexto ou efeitos colaterais.\n",
    "\n",
    "Obviamente, a orientação a objetos é útil e até necessária em muitos casos, por exemplo, no desenvolvimento de aplicativos ou jogos gráficos para desktop, onde as coisas manipuladas (janelas, botões, avatares, veículos) têm vida útil relativamente longa no computador.\n",
    "\n",
    "## Decorators\n",
    "\n",
    "A linguagem Python fornece uma sintaxe simples, porém poderosa, chamada \"decoradores\". Um decorador é uma função ou uma classe que agrupa (ou decora) uma função ou um método. A função ou método 'decorado' substituirá a função ou método 'não decorado' original. Como as funções são objetos de primeira classe em Python, isso pode ser feito 'manualmente', mas o uso da sintaxe @decorator é mais claro e, portanto, preferido.\n",
    "\n",
    "```\n",
    "def foo():\n",
    "    # faça algo\n",
    "\n",
    "def decorator(func):\n",
    "    # manipulando a função\n",
    "    return func\n",
    "\n",
    "foo = decorator(foo)  # decorando manualmente\n",
    "\n",
    "@decorator\n",
    "def bar():\n",
    "    # faça algo\n",
    "# bar() é decorado\n",
    "```\n",
    "\n",
    "Esse mecanismo é útil para separar preocupações e evitar a lógica externa não relacionada 'poluindo' a lógica principal da função ou método. Um bom exemplo de uma funcionalidade que é melhor tratada com decoração é a memorização ou o armazenamento em cache: você deseja armazenar os resultados de uma função cara em uma tabela e usá-los diretamente em vez de recalculá-los quando já tiverem sido calculados. Isso claramente não faz parte da lógica da função.\n",
    "\n",
    "\n",
    "## Gerentes de contexto\n",
    "\n",
    "Um gerenciador de contexto é um objeto Python que fornece informações contextuais extras para uma ação. Essas informações extras assumem a forma de executar uma chamada ao iniciar o contexto usando a instrução with, bem como executar uma chamada ao completar todo o código dentro do bloco with. O exemplo mais conhecido de uso de um gerenciador de contexto é mostrado aqui, abrindo em um arquivo:\n",
    "\n",
    "```\n",
    "with open('file.txt') as f:\n",
    "    contents = f.read()\n",
    "```\n",
    "\n",
    "Qualquer pessoa familiarizada com esse padrão sabe que a abertura aberta dessa maneira garante que o método f's close seja chamado em algum momento. Isso reduz a carga cognitiva de um desenvolvedor e facilita a leitura do código.\n",
    "\n",
    "Existem duas maneiras fáceis de implementar essa funcionalidade: usar uma classe ou usar um gerador. Vamos implementar a funcionalidade acima, começando pela abordagem de classe:\n",
    "\n",
    "```\n",
    "class CustomOpen(object):\n",
    "    def __init__(self, filename):\n",
    "        self.file = open(filename)\n",
    "\n",
    "    def __enter__(self):\n",
    "        return self.file\n",
    "\n",
    "    def __exit__(self, ctx_type, ctx_value, ctx_traceback):\n",
    "        self.file.close()\n",
    "\n",
    "with CustomOpen('file') as f:\n",
    "    contents = f.read()\n",
    "```\n",
    "\n",
    "Este é apenas um objeto Python comum com dois métodos extras que são usados pela instrução with. O CustomOpen é instanciado primeiro e, em seguida, seu método __enter__ é chamado e o que __enter__ retorna é atribuído a f na parte f da instrução. Quando o conteúdo do bloco with termina de executar, o método __exit__ é chamado.\n",
    "\n",
    "E agora a abordagem de gerador usando o próprio contextlib do Python:\n",
    "\n",
    "```\n",
    "from contextlib import contextmanager\n",
    "\n",
    "@contextmanager\n",
    "def custom_open(filename):\n",
    "    f = open(filename)\n",
    "    try:\n",
    "        yield f\n",
    "    finally:\n",
    "        f.close()\n",
    "\n",
    "with custom_open('file') as f:\n",
    "    contents = f.read()\n",
    "```\n",
    "\n",
    "Isso funciona exatamente da mesma maneira que o exemplo de classe acima, embora seja mais conciso. A função custom_open é executada até atingir a declaração de rendimento. Em seguida, devolve o controle à instrução with, que atribui o que foi gerado para f na parte as f. A cláusula last garante que close () seja chamado se houve ou não uma exceção dentro do with.\n",
    "\n",
    "Como as duas abordagens parecem iguais, devemos seguir o Zen do Python para decidir quando usar qual. A abordagem de classe pode ser melhor se houver uma quantidade considerável de lógica para encapsular. A abordagem da função pode ser melhor para situações em que estamos lidando com uma ação simples.\n",
    "\n",
    "## Tipagem Dinamica\n",
    "\n",
    "901/5000\n",
    "O Python é digitado dinamicamente, o que significa que as variáveis não têm um tipo fixo. De fato, no Python, as variáveis são muito diferentes do que são em muitas outras linguagens, linguagens especificamente estaticamente tipadas. As variáveis não são um segmento da memória do computador em que algum valor é gravado, são 'tags' ou 'nomes' apontando para objetos. Portanto, é possível que a variável 'a' seja configurada com o valor 1, depois com o valor 'uma string' e, em seguida, com uma função.\n",
    "\n",
    "A tipagem dinâmica do Python é frequentemente considerada uma fraqueza e, de fato, pode levar a complexidades e códigos difíceis de depurar. Algo chamado 'a' pode ser definido para muitas coisas diferentes, e o desenvolvedor ou o mantenedor precisa rastrear esse nome no código para garantir que ele não tenha sido definido para um objeto completamente não relacionado.\n",
    "\n",
    "Algumas diretrizes ajudam a evitar esse problema:\n",
    "\n",
    "- Evite usar o mesmo nome de variável para coisas diferentes.\n",
    "\n",
    "**RUIM**\n",
    "```\n",
    "a = 1\n",
    "a = 'a string'\n",
    "def a():\n",
    "    pass  # Faça algo\n",
    "```\n",
    "\n",
    "**BOM**\n",
    "```\n",
    "count = 1\n",
    "msg = 'a string'\n",
    "def func():\n",
    "    pass  # Faça algo\n",
    "```\n",
    "\n",
    "O uso de funções ou métodos curtos ajuda a reduzir o risco de usar o mesmo nome para duas coisas não relacionadas.\n",
    "\n",
    "É melhor usar nomes diferentes, mesmo para coisas relacionadas, quando elas têm um tipo diferente:\n",
    "\n",
    "**RUIM**\n",
    "```\n",
    "items = 'a b c d'  # Isso é uma string...\n",
    "items = items.split(' ')  # ...tornando uma lista\n",
    "items = set(items)  # ...e então um set()\n",
    "```\n",
    "\n",
    "Não há ganho de eficiência ao reutilizar nomes: as atribuições terão que criar novos objetos de qualquer maneira. No entanto, quando a complexidade aumenta e cada atribuição é separada por outras linhas de código, incluindo ramificações e loops 'if', fica mais difícil determinar qual é o tipo de determinada variável.\n",
    "\n",
    "Algumas práticas de codificação, como programação funcional, recomendam nunca reatribuir uma variável. Em Java, isso é feito com a palavra-chave final. Python não tem uma palavra-chave final e, de qualquer forma, seria contra sua filosofia. No entanto, pode ser uma boa disciplina evitar atribuir a uma variável mais de uma vez e ajuda a entender o conceito de tipos mutáveis e imutáveis.\n",
    "\n",
    "## Tipos mutáveis e imutáveis\n",
    "\n",
    "O Python possui dois tipos de tipos internos ou definidos pelo usuário.\n",
    "\n",
    "Tipos mutáveis são aqueles que permitem a modificação no local do conteúdo. Mutáveis típicos são listas e dicionários: Todas as listas têm métodos de mutação, como list.append () ou list.pop (), e podem ser modificadas no local. O mesmo vale para dicionários.\n",
    "\n",
    "Tipos imutáveis não fornecem método para alterar seu conteúdo. Por exemplo, a variável x definida como o número inteiro 6 não possui um método de \"incremento\". Se você deseja calcular x + 1, é necessário criar outro número inteiro e dar um nome a ele.\n",
    "\n",
    "```\n",
    "my_list = [1, 2, 3]\n",
    "my_list[0] = 4\n",
    "print my_list  # [4, 2, 3] <- A mesma lista mudou\n",
    "\n",
    "x = 6\n",
    "x = x + 1  # O novo x é outro objeto\n",
    "```\n",
    "\n",
    "Uma conseqüência dessa diferença de comportamento é que tipos mutáveis não são \"estáveis\" e, portanto, não podem ser usados como chaves de dicionário.\n",
    "\n",
    "O uso de tipos mutáveis adequadamente para coisas de natureza mutável e tipos imutáveis para coisas de natureza fixa ajuda a esclarecer a intenção do código.\n",
    "\n",
    "Por exemplo, o equivalente imutável de uma lista é a tupla, criada com (1, 2). Essa tupla é um par que não pode ser alterado no local e pode ser usado como chave para um dicionário.\n",
    "\n",
    "Uma peculiaridade do Python que pode surpreender os iniciantes é que as strings são imutáveis. Isso significa que, ao construir uma sequência a partir de suas partes, anexar cada parte à sequência é ineficiente porque a totalidade da sequência é copiada em cada anexo. Em vez disso, é muito mais eficiente acumular as partes em uma lista, que é mutável, e colar (unir) as partes quando a seqüência completa for necessária. A compreensão da lista geralmente é a maneira mais rápida e mais idiomática de fazer isso.\n",
    "\n",
    "**RUIM**\n",
    "```\n",
    "# crie uma sequência concatenada de 0 a 19 (e.g. \"012..1819\")\n",
    "nums = \"\"\n",
    "for n in range(20):\n",
    "    nums += str(n)   # lento e ineficiente\n",
    "print nums\n",
    "```\n",
    "\n",
    "**BOM**\n",
    "```\n",
    "# crie uma sequência concatenada de 0 a 19 (e.g. \"012..1819\")\n",
    "nums = []\n",
    "for n in range(20):\n",
    "    nums.append(str(n))\n",
    "print \"\".join(nums) # Muito mais eficiente\n",
    "```\n",
    "\n",
    "**PERFEITO**\n",
    "```\n",
    "# crie uma sequência concatenada de 0 a 19 (e.g. \"012..1819\")\n",
    "nums = [str(n) for n in range(20)]\n",
    "print \"\".join(nums)\n",
    "```\n",
    "\n",
    "Uma última coisa a mencionar sobre strings é que o uso de join () nem sempre é o melhor. Nos casos em que você está criando uma nova string a partir de um número predeterminado de strings, o uso do operador de adição é realmente mais rápido, mas nos casos como acima ou nos casos em que você está adicionando a uma string existente, o uso de join () deve ser seu método preferido.\n",
    "\n",
    "```\n",
    "foo = 'foo'\n",
    "bar = 'bar'\n",
    "\n",
    "foobar = foo + bar  # Isso é bom\n",
    "foo += 'ooo'  # Isso é ruim, em vez disso, você deve fazer:\n",
    "foo = ''.join([foo, 'ooo'])\n",
    "```\n",
    "\n",
    "    Nota\n",
    "\n",
    "    Você também pode usar o operador de formatação% para concatenar um número predeterminado de strings, além de str.join () e +. No entanto, o PEP 3101 desencoraja o uso do operador% em favor do método str.format ().\n",
    "\n",
    "```\n",
    "foo = 'foo'\n",
    "bar = 'bar'\n",
    "\n",
    "foobar = '%s%s' % (foo, bar) # isso é ok\n",
    "foobar = '{0}{1}'.format(foo, bar) # isso é bom\n",
    "foobar = '{foo}{bar}'.format(foo=foo, bar=bar) # isso é perfeito\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}