07 - Strings, codificação e Unicode.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strings\n",
    "\n",
    "Um dos tipos clássicos presente em quase todas as linguagens de programação! Normalmente strings \"simplesmente funcionam\" e não prestamos muita atenção nos detalhes de suas implementações. Nesse caso, Python 2 e Python 3 tem diferenças importantes e caso você precise trabalhar com Python 2, é importante considerá-las!\n",
    "\n",
    "A definição usual de \"string\" é bem simples — uma string é um conjunto de caracteres. No entanto, a definição e os detalhes de implementação do conceito de _caractere_  varia. Se formos pensar do ponto de vista de nós, humanos, um caractere representa um símbolo. Esse símbolo pode ser uma letra, um número, um emoji, etc. Por outro lado, para os computadores, um caractere — assim como absolutamente tudo — é apenas uma sequência de bits.\n",
    "\n",
    "Python 3 trabalha com uma definição de caractere mais pensada para os seres humanos lidando com o código. Porém, nem Python e nem ninguém consegue fazer um computador entender algo além de uma sequência de bits! Portanto, é necessária a existência de entidades que consigam fazer humanos e máquinas se entenderem. É aí que vamos entrar em assuntos como o padrão Unicode e suas diversas codificações.\n",
    "\n",
    "Esse assunto é bastante amplo e você pode apronfundar-se nele o quanto quiser. Nesse texto vou me limitar a apresentar os aspectos gerais de strings em Python e alguns detalhes da forma como as codificações funcionam. Caso você tenha interesse, uma ótima referência para o assunto é o capítulo 4 do livro [Python Fluente](https://www.amazon.com.br/gp/product/857522462X/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=857522462X&linkCode=as2&tag=novatec03-20) — um dos melhores livros que já li sobre Python, escrito pelo genial [Luciano Ramalho](https://twitter.com/ramalhoorg), membro antigo da comunidade Python no Brasil. Recomendo esse livro para programadores Python de nível intermediário ou avançado. Ele vale cada centavo e cada minuto de leitura das suas quase 800 páginas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A atribuição de uma string ocorre do modo usual `nome_da_variável = valor` e strings podem ser delimitadas por aspas simples ou duplas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "nome = \"são paulo\"\n",
    "sigla = 'sp'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O valor de uma string pode ser impresso usualmente com `print`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sp\n"
     ]
    }
   ],
   "source": [
    "print(sigla)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A concatenação de strings ocorre com o operador `+`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "são paulo sp\n"
     ]
    }
   ],
   "source": [
    "print(nome + ' ' + sigla)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O exemplo acima poderia ser feito sem a adição explícita do espaço, graças ao fato de que `print` aceita diversas strings como argumento e coloca um espaço entre elas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "são paulo sp\n"
     ]
    }
   ],
   "source": [
    "print(nome, sigla)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é possível customizar o separador:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "são paulo-sp\n"
     ]
    }
   ],
   "source": [
    "print(nome, sigla, sep=\"-\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Você pode encontrar mais detalhes da função print na [documentação](https://docs.python.org/3/library/functions.html#print)\n",
    "\n",
    "Python também permite que você repita uma string facilmente, usando multiplicação:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "são paulosão paulosão paulosão paulosão paulosão paulosão paulosão paulosão paulosão paulo\n"
     ]
    }
   ],
   "source": [
    "print(nome * 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercício**: O que acontece se você mudar o parâmetro `sep` nesse caso? Pense no que você acha que vai acontecer e teste em seguida!\n",
    "\n",
    "**Exercício**: Use concatenação de strings para que o código acima coloque um ponto e vírgula e um espaço entre cada palavra. Exemplo de saída: `são paulo; são paulo; são paulo;`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Métodos Nativos\n",
    "\n",
    "Strings em Python vem com [diversos métodos embutidos](https://docs.python.org/3.7/library/stdtypes.html#string-methods),  vamos explorar alguns deles agora"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "São paulo\n"
     ]
    }
   ],
   "source": [
    "print(nome.capitalize())   Capitalize retorna a string com inicial maiúscula"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "são paulo\n"
     ]
    }
   ],
   "source": [
    "print(nome)  # Observe que a string não foi alterada! Apenas uma *representação* diferente dela foi apresentada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "São Paulo\n"
     ]
    }
   ],
   "source": [
    "print(nome.title())  # Title coloca maiúsculas depois de espaços"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     são paulo      \n"
     ]
    }
   ],
   "source": [
    "print(nome.center(20))  # Coloca o texto no 'centro' de uma string do tamanho especificado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(nome.endswith('paulo'))  # Determina se uma string termina com outra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(nome.startswith('são'))  # Determina se uma string começa com outra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SÃO PAULO\n"
     ]
    }
   ],
   "source": [
    "print(nome.upper())  # Coloca a string em maiúsculas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercício** Guarde seu nome completo, apenas com letras minúsculas na variável nome"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "meu_nome = 'seu nome'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercicio**: Altere a variável nome pra que ela guarde seu nome com maiúsculas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "meu_nome = ''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Índices\n",
    "\n",
    "Todos os caracteres de uma string são contados a partir do 0. Você pode acessar caracteres individuais usando colchetes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s\n",
      "ã\n",
      "o\n"
     ]
    }
   ],
   "source": [
    "print(nome[0])\n",
    "print(nome[1])\n",
    "print(nome[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É possível também selecionar fatias de caracteres. Um processo conhecido como _slicing_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "são\n"
     ]
    }
   ],
   "source": [
    "print(nome[0:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O _slicing_ de `nome[i:j]` é executado imprimindo desde o i-ésimo caracter até o imediatamente interior de j. Existe um argumento opcional que determina o 'passo', quantos caracteres serão pulados em cada interação:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "são p\n",
      "sop\n"
     ]
    }
   ],
   "source": [
    "print(nome[0:5])\n",
    "print(nome[0:5:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos usá-lo para inverter uma string também:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'oluap oãs'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nome[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que eu deixei os dois primeiros parâmetros em branco. Os três parâmetros são opcionais!:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'são paulo'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nome[::]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'são p'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nome[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sopuo'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nome[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como veremos mais adiante, Python também permite _slicing_ de listas e de outras sequências.\n",
    "\n",
    "## Formatação\n",
    "\n",
    "Python inclui um sistema bem rico de [formatação de strings](https://pyformat.info/) de forma que podemos deixar nosso código mais limpo ao fazer concatenações e conversões de forma mais elegante. Observe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estamos no ano 2018. O mês atual é agosto\n"
     ]
    }
   ],
   "source": [
    "ano = 2018\n",
    "mês = \"agosto\"\n",
    "print(\"Estamos no ano \" + str(ano) + \". O mês atual é \" + mês)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pode ser convertido em:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estamos no ano 2018. O mês atual é agosto\n"
     ]
    }
   ],
   "source": [
    "print(\"Estamos no ano {}. O mês atual é {}\".format(ano, mês))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dessa forma conseguimos _parametrizar_ nossas strings, o que permite construções poderosas.\n",
    "\n",
    "Podemos usar argumentos nomeados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bem vinda Maria! Espero que você goste de aprender Python\n"
     ]
    }
   ],
   "source": [
    "mensagem = \"Bem vinda {nome}! Espero que você goste de aprender {matéria}\"\n",
    "mensagem = mensagem.format(nome=\"Maria\", matéria=\"Python\")\n",
    "print(mensagem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que a função `format` — assim como as outras que vimos — não modifica a string em si, apenas retorna uma nova versão formatada da string. Isso garante que a gente possa usar o mesmo \"modelo\" diversas vezes com argumentos diferentes!\n",
    "\n",
    "Outro uso bastante comum é formatação de números. Podemos cortar casas decimais:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pi é 3.14\n"
     ]
    }
   ],
   "source": [
    "pi = 3.1415\n",
    "print(\"Pi é {:.2f}\".format(pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fazer _padding_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A resposta com 6 dígitos é 000042\n"
     ]
    }
   ],
   "source": [
    "a_resposta = 42\n",
    "print(\"A resposta com 6 dígitos é {:06d}\".format(a_resposta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## F-Strings\n",
    "\n",
    "A partir do Python 3.6 surge o conceito de **f-strings**, que tornam a formatação mais simples e elegante.\n",
    "\n",
    "\n",
    "[Tutorial](https://realpython.com/python-f-strings/)\n",
    "\n",
    "[Documentação Oficial](https://www.python.org/dev/peps/pep-0498/)\n",
    "\n",
    "Para usar uma f-string, basta prefixar sua string com a letra `f`, fora das aspas, e referenciar suas variáveis entre colchetes `{}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bom dia, Unicamp\n"
     ]
    }
   ],
   "source": [
    "mensagem = \"Bom dia\"\n",
    "universidade = \"Unicamp\"\n",
    "\n",
    "print(f\"{mensagem}, {universidade}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n",
      "{pi}\n",
      "3.141592653589793\n",
      "3.14\n",
      "0003.14159\n"
     ]
    }
   ],
   "source": [
    "# Importando pi da biblioteca Math\n",
    "from math import pi\n",
    "\n",
    "# Imprimindo pi de forma crua\n",
    "print(pi)\n",
    "\n",
    "# Tentando usar um f-string sem prefixar com \"f\"\n",
    "print(\"{pi}\")\n",
    "\n",
    "# Usando uma f-string de forma correta\n",
    "print(f\"{pi}\")\n",
    "\n",
    "# Usando uma f-string para formatar o número\n",
    "print(f\"{pi:.2f}\")\n",
    "print(f\"{pi:010.5f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Codificação de Caracteres\n",
    "\n",
    "> Resumo: Antigamente, todo mundo queria ter o seu padrão de codificação até que surgiu o Unicode e o UTF-8. Python3 usa UTF-8 como padrão. Use UTF-8 você também. UTF-8 é legal e todos deveríamos usar UTF-8 a não ser que a gente tenha bons motivos para não usar! Vou repetir UTF-8 mais uma vez só pra deixar bem claro que UTF-8 é 10/10\n",
    "\n",
    "### Introdução\n",
    "\n",
    "Usualmente nós dividimos os arquivos em duas categorias — os arquivos de texto e os binários. Arquivos de texto são mais \"simples\", só contém caracteres textuais, podem ser visualizados diretamente de terminais sem ser necessário usar programas especializados. Códigos-fonte, por exemplo, são arquivos de texto.\n",
    "\n",
    "Arquivos binários, por outro lado, são mais complexos. Neles, informações mais complexas como imagens, vídeos, sons, executáveis, etc são codificados em bits que depois serão lidos por programas específicos. Arquivos JPG, PDF, MP3, EXE e ZIP são exemplos de arquivos binários.\n",
    "\n",
    "Essa distinção, embora bastante útil, pode causar a impressão errada de que arquivos de texto não são compostos por bits. Como se de alguma forma mágica, nossos sistemas computacionais pudessem armazenar de forma direta os caracteres contidos no texto. Isso não é verdade.\n",
    "\n",
    "### Codificações como dicionários\n",
    "\n",
    "Uma forma de vermos as codificações é como se elas fossem dicionários — elas mapeiam os caracteres conforme nós, humanos, conhecemos para uma representação binária que pode ser compreendida por máquinas.\n",
    "\n",
    "Historicamente, diversas codificações foram criadas com propósitos diversos. O [código morse](https://en.wikipedia.org/wiki/Morse_code) é um exemplo disso. Na computação, um dos primeiros exemplos de codificação de caracteres — na época dos cartões perfurados! — foi o [EBCDIC](https://en.wikipedia.org/wiki/EBCDIC).\n",
    "\n",
    "Na computação moderna, um dos primeiros padrões de codificação foi o [ASCII](http://www.asciitable.com/) (pronuncia-se ÉS-qui). Conforme o tempo passou, o número de codificações e extensões de codificações explodiu. Diversas empresas e países criaram padrões diferentes que nem sempre eram compatíveis entre si. No Brasil, por exemplo, dois padrões diferentes foram usados na década de 80, o [BrasCII](https://pt.wikipedia.org/wiki/BRASCII) e o [ABICOMP](https://pt.wikipedia.org/wiki/Tabela_de_caracteres_da_Associa%C3%A7%C3%A3o_Brasileira_de_Ind%C3%BAstria_de_Computadores). Ambos os padrões definiam a codificação de caracteres acentuados do português, algo que não existe no ASCII padrão.\n",
    "\n",
    "\n",
    "### Unicode\n",
    "O problema das diversas codificações é que cada uma delas lida com um conjunto de caracteres que faz sentido para um contexto específico. Caracteres japoneses, por exemplo, não pertenciam aos conjuntos definidos pelos padrões ocidentais. Com o tempo, a ideia de desenvolver um conjunto de caracteres universal foi criando corpo e culminou no consórcio [Unicode](https://en.wikipedia.org/wiki/Unicode).\n",
    "\n",
    "O Unicode define [tabelas](http://unicode.org/charts) de caracteres extremamente extensas. Você pode encontrar desde o [alfabeto latino básico](http://unicode.org/charts/PDF/U0000.pdf) até os [hieróglifos egípcios](https://unicode.org/charts/PDF/U13000.pdf) passando pelos [emojis!](http://www.unicode.org/emoji/). O mesmo consórcio também define diversas codificações que podem ser usadas para mapear os caracteres unicode para bits. Dentre esses, o padrão UTF-8 é um dos mais utilizados no mundo. Segundo dados do Google, mais de 60% da internet em 2012 utilizava UTF-8.\n",
    "\n",
    "### Python e Codificação\n",
    "\n",
    "Python 3 assume que tudo é UTF-8. O seu arquivo de código-fonte, as suas strings, tudo. Ele inclui ferramentas prontas para codificar e decodificar caracteres mas, por padrão, ele assume que tudo é UTF-8 e inclusive permite que você insira nativamente caracteres Unicode:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "❤\n"
     ]
    }
   ],
   "source": [
    "coração = '\\u2764'\n",
    "print(coração)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como vocềs podem ver [aqui](http://graphemica.com/%E2%9D%A4), em UTF-8 o coração é representado pelos bits `11100010:10011101:10100100` ou `e29da4` em hexadecimal. Vamos verificar isso codificando a variável com UTF-8:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'e29da4'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bits = coração.encode('utf-8')\n",
    "bits.hex()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E se nós tentássemos codificar um coração em ASCII? Bem, ASCII não possui o caractere de coração na sua definição, portanto vamos ter problemas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "ename": "UnicodeEncodeError",
     "evalue": "'ascii' codec can't encode character '\\u2764' in position 0: ordinal not in range(128)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mUnicodeEncodeError\u001b[0m                        Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-60-60099d0b2fc8>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mcoração\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mencode\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'ascii'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mUnicodeEncodeError\u001b[0m: 'ascii' codec can't encode character '\\u2764' in position 0: ordinal not in range(128)"
     ]
    }
   ],
   "source": [
    "coração.encode('ascii')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando codificações erradas são usadas, as coisas ficam complicadas e ilegíveis. Vou codificar uma mensagem usando UTF-8 e, em seguida, vou decodificá-la usando CP1252, uma codificação bastante utilizada no Windows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'OlÃ¡, JoÃ£o JosÃ©! Bem vindo Ã\\xa0 SÃ£o Paulo!'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mensagem = \"Olá, João José! Bem vindo à São Paulo!\"\n",
    "mensagem.encode('utf-8').decode('cp1252')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esses problemas acontecem porque, para o UTF-8, o caracter '[ã](http://graphemica.com/%C3%A3)' são os bytes c3a3. Já para o cp1252, esses bytes repersentam dois caracteres, c3 é `Ã` e a3 é `£`, como pode ser visto na [tabela do ISO 8859-1](https://pt.wikipedia.org/wiki/ISO/IEC_8859-1). O padrão cp1252 é um padrão de 'extensão' do ISO 8859-1, o que significa que ele implementa todos os caracteres desse padrão e [adiciona mais alguns](https://marketing.adobe.com/resources/help/en_US/whitepapers/multibyte/multibyte_windows1252.html)\n",
    "\n",
    "### Nomes de variáveis em Python3\n",
    "\n",
    "Python 3 permite que caracteres não-ASCII sejam utilizados. Você pode, por exemplo, ter acentos em variáveis. Mas, você _deveria_ utilizar dessa característica?\n",
    "\n",
    "Em muitas situações, não. Usar apenas caracteres ASCII e programar em inglês é o padrão usado por muitos programadores ao redor do mundo. Isso garante que seu código será mais facilmente compreendido e portado entre máquinas. No entanto, no contexto de ensino, eu particularmente prefiro utilizar códigos em português, com a grafia correta e acentuada.\n",
    "\n",
    "No fim das contas, é uma questão estilística que pode muito bem ser concordada entre você e os colegas que irão trabalhar com você. A comunidade Python define um guia de estilo, o [PEP 8](https://wiki.python.org.br/GuiaDeEstilo) que é uma boa base para essas discussões. Em geral, seguir o PEP 8 é uma boa ideia e mais pra frente veremos seu conteúdo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comentários e strings em múltiplas linhas\n",
    "\n",
    "Em alguns momentos, já usei comentários \"em linha\" usando o caracter `#`. Também é possível montar comentários em múltiplas linhas utilizando um trio de aspas duplas:\n",
    "\n",
    "```python\n",
    "\n",
    "# Esse é um comentário em linha\n",
    "# O caracter # deve ser usado no começo\n",
    "\n",
    "# Podemos comentar logo em seguida do código\n",
    "x = 10  # Nesse caso é recomendado dar 2 espaços entre o código e o comentário\n",
    "\n",
    "\"\"\"\n",
    "Comentários longos podem ser escritos utilizando 3 aspas duplas\n",
    "para delimitar seus limites.\n",
    "\n",
    "Essa sintaxe é útil para escrever documentações mais longas.\n",
    "\"\"\"\n",
    "```\n",
    "\n",
    "A sintaxe de três aspas duplas também serve para definir strings em múltiplas linhas:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lorem ipsum dolor sit amet, consectetur adipiscing elit.\n",
      "Nunc fringilla vulputate dignissim.\n",
      "    Maecenas dignissim commodo porta. Aliquam suscipit, metus non. \n",
      "\n"
     ]
    }
   ],
   "source": [
    "lorem_ipsum = \"\"\"Lorem ipsum dolor sit amet, consectetur adipiscing elit.\n",
    "Nunc fringilla vulputate dignissim.\n",
    "    Maecenas dignissim commodo porta. Aliquam suscipit, metus non. \n",
    "\"\"\"\n",
    "\n",
    "print(lorem_ipsum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que os espaços, quebras de linha e tabulações são mantidos.\n",
    "\n",
    "Caso você não queira que espaços sejam colocados mas também não quer concatenar multiplas strings, pode utilizar de parênteses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lorem ipsum dolor sit amet, consectetur adipiscing elit.Nunc fringilla vulputate dignissim.Maecenas dignissim commodo porta. Aliquam suscipit, metus non.\n"
     ]
    }
   ],
   "source": [
    "lorem_ipsum = (\"Lorem ipsum dolor sit amet, consectetur adipiscing elit.\"\n",
    "               \"Nunc fringilla vulputate dignissim.\"\n",
    "               \"Maecenas dignissim commodo porta. Aliquam suscipit, metus non.\"\n",
    "              )\n",
    "print(lorem_ipsum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que nenhum espaço foi adicionado entre as strings também"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `print()` vs. `repr()`\n",
    "\n",
    "Além da função `print()`, Python possui a função `repr()`. A função do `print()` é exibir mensagens para o usuário em forma de texto. Porém, às vezes utilizamos essa função para inspecionar uma determinada variável:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10 if 3 >= 20 and not 1 == True or 2 < 1 else 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nesse caso, não estamos interessados necessariamente em imprimir x ao usuário, queremos apenas _ver_  o que está acontecendo dentro dele. Nesse caso, Python oferece a função `repr()`.\n",
    "\n",
    "Assim como `print()`, `repr()` lida com strings. No entanto, a string retornada por `repr()` é mais voltada para o desenvolvedor escrevendo códigos do que para o usuário utilizando o software:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = \"João\\nPé\\tde\\tFeijão\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "João\n",
      "Pé\tde\tFeijão\n"
     ]
    }
   ],
   "source": [
    "print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"'João\\\\nPé\\\\tde\\\\tFeijão'\""
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repr(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe como `print` formatou a string, trocando os caracteres especiais `\\n` e `\\t` por quebra de linha e tabulação, respectivamente. `repr`, por outro lado, exibiu a string de maneira crua, como foi escrita no código"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}