08.Strings, Tuplas e Listas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    },
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\" style=\"margin-top: 1em;\"><ul class=\"toc-item\"><li><span><a href=\"#Seqüências\" data-toc-modified-id=\"Seqüências-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Seqüências</a></span></li><li><span><a href=\"#Strings\" data-toc-modified-id=\"Strings-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Strings</a></span><ul class=\"toc-item\"><li><span><a href=\"#Comprimento-de-Strings\" data-toc-modified-id=\"Comprimento-de-Strings-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Comprimento de Strings</a></span></li><li><span><a href=\"#Acessando-elementos-de-uma-String\" data-toc-modified-id=\"Acessando-elementos-de-uma-String-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Acessando elementos de uma String</a></span></li><li><span><a href=\"#Slices-de-strings\" data-toc-modified-id=\"Slices-de-strings-2.3\"><span class=\"toc-item-num\">2.3&nbsp;&nbsp;</span>Slices de strings</a></span></li><li><span><a href=\"#Operador-in\" data-toc-modified-id=\"Operador-in-2.4\"><span class=\"toc-item-num\">2.4&nbsp;&nbsp;</span>Operador <strong>in</strong></a></span></li><li><span><a href=\"#Método-strip\" data-toc-modified-id=\"Método-strip-2.5\"><span class=\"toc-item-num\">2.5&nbsp;&nbsp;</span>Método <strong>strip</strong></a></span></li><li><span><a href=\"#Método-find\" data-toc-modified-id=\"Método-find-2.6\"><span class=\"toc-item-num\">2.6&nbsp;&nbsp;</span>Método <strong>find</strong></a></span></li><li><span><a href=\"#Método-startswith\" data-toc-modified-id=\"Método-startswith-2.7\"><span class=\"toc-item-num\">2.7&nbsp;&nbsp;</span>Método startswith</a></span></li><li><span><a href=\"#Método-replace\" data-toc-modified-id=\"Método-replace-2.8\"><span class=\"toc-item-num\">2.8&nbsp;&nbsp;</span>Método <strong>replace</strong></a></span></li><li><span><a href=\"#Strings-e-laços\" data-toc-modified-id=\"Strings-e-laços-2.9\"><span class=\"toc-item-num\">2.9&nbsp;&nbsp;</span>Strings e laços</a></span></li><li><span><a href=\"#Exercicios\" data-toc-modified-id=\"Exercicios-2.10\"><span class=\"toc-item-num\">2.10&nbsp;&nbsp;</span>Exercicios</a></span></li></ul></li><li><span><a href=\"#Tuplas\" data-toc-modified-id=\"Tuplas-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Tuplas</a></span><ul class=\"toc-item\"><li><span><a href=\"#Acessando-Valores-em-Tuplas\" data-toc-modified-id=\"Acessando-Valores-em-Tuplas-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Acessando Valores em Tuplas</a></span></li><li><span><a href=\"#Contatenação-de-tuplas\" data-toc-modified-id=\"Contatenação-de-tuplas-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Contatenação de tuplas</a></span></li><li><span><a href=\"#Eliminando-elementos-de-uma-Tupla\" data-toc-modified-id=\"Eliminando-elementos-de-uma-Tupla-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>Eliminando elementos de uma Tupla</a></span></li><li><span><a href=\"#Operações-básicas-em-Tuplas\" data-toc-modified-id=\"Operações-básicas-em-Tuplas-3.4\"><span class=\"toc-item-num\">3.4&nbsp;&nbsp;</span>Operações básicas em Tuplas</a></span><ul class=\"toc-item\"><li><span><a href=\"#Atribuições-com-tuplas\" data-toc-modified-id=\"Atribuições-com-tuplas-3.4.1\"><span class=\"toc-item-num\">3.4.1&nbsp;&nbsp;</span>Atribuições com tuplas</a></span></li><li><span><a href=\"#Tuplas-podem-ser-usadas-para-retornar-mais-de-um-valor-de-uma-função\" data-toc-modified-id=\"Tuplas-podem-ser-usadas-para-retornar-mais-de-um-valor-de-uma-função-3.4.2\"><span class=\"toc-item-num\">3.4.2&nbsp;&nbsp;</span>Tuplas podem ser usadas para retornar mais de um valor de uma função</a></span></li></ul></li><li><span><a href=\"#Tuplas-como-argumentos-de-comprimento-variável-de-funções\" data-toc-modified-id=\"Tuplas-como-argumentos-de-comprimento-variável-de-funções-3.5\"><span class=\"toc-item-num\">3.5&nbsp;&nbsp;</span>Tuplas como argumentos de comprimento variável de funções</a></span></li></ul></li><li><span><a href=\"#Listas\" data-toc-modified-id=\"Listas-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Listas</a></span><ul class=\"toc-item\"><li><span><a href=\"#Operações-básicas:-Pertinencia,-Concatenação-e-Repetição\" data-toc-modified-id=\"Operações-básicas:-Pertinencia,-Concatenação-e-Repetição-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Operações básicas: Pertinencia, Concatenação e Repetição</a></span></li><li><span><a href=\"#Métodos-de-Listas\" data-toc-modified-id=\"Métodos-de-Listas-4.2\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>Métodos de Listas</a></span></li><li><span><a href=\"#Listas-e-Strings\" data-toc-modified-id=\"Listas-e-Strings-4.3\"><span class=\"toc-item-num\">4.3&nbsp;&nbsp;</span>Listas e Strings</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercícios\" data-toc-modified-id=\"Exercícios-4.3.1\"><span class=\"toc-item-num\">4.3.1&nbsp;&nbsp;</span>Exercícios</a></span></li></ul></li><li><span><a href=\"#Referencias-de-Listas\" data-toc-modified-id=\"Referencias-de-Listas-4.4\"><span class=\"toc-item-num\">4.4&nbsp;&nbsp;</span>Referencias de Listas</a></span></li><li><span><a href=\"#Alias-e-clone-de-Listas\" data-toc-modified-id=\"Alias-e-clone-de-Listas-4.5\"><span class=\"toc-item-num\">4.5&nbsp;&nbsp;</span>Alias e clone de Listas</a></span></li><li><span><a href=\"#Listas-como-Parâmetros\" data-toc-modified-id=\"Listas-como-Parâmetros-4.6\"><span class=\"toc-item-num\">4.6&nbsp;&nbsp;</span>Listas como Parâmetros</a></span></li></ul></li><li><span><a href=\"#Processamento-de-Seqüências\" data-toc-modified-id=\"Processamento-de-Seqüências-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Processamento de Seqüências</a></span><ul class=\"toc-item\"><li><span><a href=\"#Compreensão-de-Listas\" data-toc-modified-id=\"Compreensão-de-Listas-5.1\"><span class=\"toc-item-num\">5.1&nbsp;&nbsp;</span>Compreensão de Listas</a></span></li><li><span><a href=\"#Compreensão-de-Listas-Aninhadas\" data-toc-modified-id=\"Compreensão-de-Listas-Aninhadas-5.2\"><span class=\"toc-item-num\">5.2&nbsp;&nbsp;</span>Compreensão de Listas Aninhadas</a></span></li><li><span><a href=\"#Exercícios:\" data-toc-modified-id=\"Exercícios:-5.3\"><span class=\"toc-item-num\">5.3&nbsp;&nbsp;</span>Exercícios:</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Seqüências\n",
    "Uma sequência é uma coleção ordenada de valores. A seqüência é uma abstração\n",
    "poderosa e fundamental em ciência da computação. As seqüências não são\n",
    "instâncias de uma built-int específica ou representação de dados\n",
    "abstratos, mas sim uma coleção de comportamentos que são compartilhados entre\n",
    "vários tipos diferentes de dados. Ou seja, existem muitos tipos de seqüências,\n",
    "mas todos compartilham um comportamento comum. Em particular:\n",
    "\n",
    "**Comprimento** (`len`): Uma sequência tem um comprimento finito. Uma seqüência\n",
    "vazia tem o comprimento 0.\n",
    "\n",
    "**Seleção de elementos**: Uma sequência tem um elemento correspondente a qualquer\n",
    "índice inteiro não negativo inferior ao seu comprimento, começando em 0 para o\n",
    "primeiro elemento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O Python inclui vários tipos de dados nativos que são sequências. Neste curso nós vamos abordar **strings**, **tuplas** e **listas**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Strings\n",
    "Uma string é uma seqüência de caracteres. Um caracter é simplesmente um símbolo. Por exemplo, o idioma inglês tem 26 caracteres. Em Python, string é uma sequência de caracteres \\textit{Unicode}. O Unicode foi introduzido para incluir todos os caracteres em todos os idiomas e trazer uniformidade na codificação. Você pode aprender mais sobre o Unicode [aqui](https://docs.python.org/3.3/howto/unicode.html). Note também que strings são objetos imutáveis, isto é, não podem ser modificados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "s = \"hello\"\n",
    "s[0] = 'y'\n",
    "s = 'y' + s[1:len(s)]\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<img src=\"img/imutable.png\" alt=\"Drawing\" style=\"width: 400px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Comprimento de Strings\n",
    "- **len**( ) é a função usada para se obter o comprimento da cadeia de caracteres. Ex:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "s = \"abc\"\n",
    "len(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Acessando elementos de uma String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Cada um dos caracteres de uma string corresponde a um número de índice, começando com o número de índice $0$ e indice superior igual a $len( ) - 1$. Se tivermos uma string longa e quisermos identificar um item próximo ao fim, também podemos contar de trás para frente, isto é, a partir do final da string, começando pelo índice $-1$ e terminando em $-len( )$.\n",
    "\n",
    "Ao referenciar números de índice, podemos isolar um dos caracteres em uma string. Fazemos isso colocando os índices entre colchetes ( \"[\" & \"]\"). Com isso, pode-se obter o valor/caracter em um determinado índice ou posição. Ex:\n",
    "\n",
    "| $\\Large{s}$ | $=$ | $\\Large{'abc'}$ |\n",
    "| :-: | :-: | :-: |\n",
    "| índice | : | 0 1 2 |\n",
    "| índice | : | -3 -2 -1 |\n",
    "\n",
    " - a indexação sempre começa em $0$ na forma direta.\n",
    " - último elemento sempre tem índice $-1$ na forma reversa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "s = \"abc\"\n",
    "print(s[0])\n",
    "print(s[1])\n",
    "print(s[2])\n",
    "print(s[3])\n",
    "print(s[-1])\n",
    "print(s[-2])\n",
    "print(s[-3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Slices de strings\n",
    "- pode-se fatiar (slice) strings usando [start: stop: step]\n",
    "- pode-se fornecer dois números apenas, [start: stop], sendo que step = 1, por padrão\n",
    "- pode-se também omitir os números e deixar apenas dois pontos ($:$). Neste caso, o valor padrão para start = 0 e para stop = len( )."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "s = \"abcdefgh\"\n",
    "print(s[3:6])\n",
    "print(s[3:6:2])\n",
    "print(s[::])\n",
    "print(s[::-1])\n",
    "print(s[4:1:-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Operador **in**\n",
    "O operador **in** verifica se uma substring é parte de uma outra string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "'tho' in 'Python'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "'thor' in 'Python'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Método **strip**\n",
    "O método **strip** retorna uma string sem os brancos e caracteres de mudança de\n",
    "linha no início e final de uma string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "aa = ' \\n  abcndef   \\n'\n",
    "aa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(\"<\", aa, \">\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "aa.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Método **find**\n",
    "O método **find** retorna onde a substring começa na string. Este retorna $-1$ quando a substring não ocorre na string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "p = 'python'\n",
    "p.find('tho')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "p.find('thor')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Método startswith\n",
    "\n",
    "O método `startswith()` verifica se a string inicia com str, opcionalmente restringindo a correspondência com os índices de início (beg) e fim (end.\n",
    "\n",
    "Sintaxe\n",
    "```\n",
    "str.startswith (str, beg = 0, end = len (string));\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "str = \"this is string example....wow!!!\"\n",
    "print (str.startswith( 'this' ))\n",
    "print (str.startswith( 'string', 8 ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Método **replace**\n",
    "O método **replace** serve para trocar todas as ocorrências de uma\n",
    "substring por outra em uma string. Note que como strings são imutáveis, uma nova string é retornada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "s = \"abcabcdfgabc abc a b c\"\n",
    "s.replace(\"abc\",\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Strings e laços\n",
    "Os dois trechos de código abaixo iteram sobre um string e produzem o mesmo resultado. No entanto, o segundo é considerado mais \"pythonico\", isto é, mais elegante, mais \"clean\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "s = \"abcdefgh\"\n",
    "\n",
    "for index in range(len(s)):\n",
    "    if s[index] == 'i' or s[index] == 'u':\n",
    "        print(\"There is an i or u\")\n",
    "        \n",
    "for char in s:\n",
    "    if char == 'i' or char == 'u':\n",
    "        print(\"There is an i or u\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercicios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**a.** Letras em comum\n",
    "\n",
    "Conte o número de letras em comum entre duas strings. Use a bultin `isalpha` para\n",
    "descobrir se um caracter é letra ou não. Ex.:\n",
    "```python\n",
    "x = \"A\"\n",
    "x.isalpha() == true\n",
    "y = \"3\"\n",
    "y.isaplha() == false\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "s1 = \"Unicamp u rock\"\n",
    "s2 = \"I rule Unicamp\"\n",
    "common = 0\n",
    "for char1 in s1:\n",
    "    if char1.isalpha():\n",
    "        for char2 in s2:\n",
    "            if char2 == char1:\n",
    "                common = common + 1\n",
    "                break\n",
    "print(\"common letters: \", common)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**b.** Escreva uma função que faz a busca de todas as ocorrências de uma palavra em um texto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Tuplas\n",
    "Tuplas são uma sequencia ordenada de elementos separados por virgulas, representados ou não entre parênteses, isto é, os parênteses não são obrigatórios.\n",
    "Pode-se ainda misturar elementos de tipos diferentes. No entanto, tuplas tem a caracteristica de imutabilidade, isto é, seus elementos são\n",
    "imutáveis. Em outras palavras, não é possível alterar os valores dos elementos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Exemplos de tuplas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "tup1 = ('physics', 'chemistry', 1997, 2000)\n",
    "tup2 = (1, 2, 3, 4, 5, 6, 7 )\n",
    "tup3 = \"a\", \"b\", \"c\", \"d\"\n",
    "tup4 = (\"MC102\", )\n",
    "tup5 = ()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- em\n",
    "``` \n",
    "tup4 = (\"MC102\", )\n",
    "``` \n",
    "tup4 representa uma tupla com um único elemento. Note a virgula após o elemento. Ela é necessária para diferenciar de uma expressão entre parenteses. Veja o exemplo abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "t1 = 'A', \n",
    "\n",
    "t2 = ('A')\n",
    "\n",
    "print(type(t1), type(t2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- em \n",
    "```\n",
    "tup5 = ()\n",
    "``` \n",
    "tup5 representa uma tupla vazia. Outra forma de criar uma tupla é com a função integrada tuple. Sem argumentos, cria uma tupla vazia, se os argumentos forem uma sequência (string, lista ou tupla), o resultado é uma tupla com os elementos da sequência:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "t = tuple('Unicamp')\n",
    "print(t, type(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Acessando Valores em Tuplas\n",
    "Como Strings, os índices de tupla começam em $0$ e podem ser cortados (slice), concatenados, e assim por diante. Ainda como Strings, para acessar os valores em uma tupla, use os colchetes para cortar junto com o índice, ou índices, para obter o valor disponível nesse índice. Exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print (\"tup1[0]: \", tup1[0])\n",
    "print (\"tup2[1:5]: \", tup2[1:5])\n",
    "# A sentença abaixa não é valida!\n",
    "tup1[0] = \"calculus\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Contatenação de tuplas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "tupX = (12, 34.56)\n",
    "tupY = ('abc', 'xyz')\n",
    "\n",
    "# So let's create a new tuple as follows\n",
    "tupZ = tupX + tupY\n",
    "print (tupZ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Eliminando elementos de uma Tupla\n",
    "Não é possível remover elementos de uma tupla individualmente. Há, é claro, nada de errado em juntar outra tupla com os elementos indesejados descartados.\n",
    "\n",
    "Para remover explicitamente uma tupla inteira, basta usar a senteça `del`. Exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "tup1 = ('physics', 'chemistry', 1997, 2000);\n",
    "print(type(tup1[3]))\n",
    "tup2 = tup1[0:1] + (tup1[3], )\n",
    "print (tup2)\n",
    "del tup1;\n",
    "print (\"After deleting tup1 : \")\n",
    "print (tup1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Operações básicas em Tuplas\n",
    "As tuplas respondem a todas as operações de seqüência geral que usamos em Strings anteriormente: comprimento (`len`), concatenação (`+`), repetição (`*`), membro (`in`) e iteração. Exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(len((1, 2, 3))) \n",
    "print((1, 2, 3) + (4, 5, 6))\n",
    "print(('Hi!',) * 4)\n",
    "print(3 in (1, 2, 3))\n",
    "for x in (1,2,3) : print (x, end = ' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Atribuições com tuplas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "O Python possui um recurso de atribuição de tupla muito poderoso que permite que uma tupla de variáveis à esquerda de uma atribuição seja atribuída valores de uma tupla à direita da atribuição. (Já vimos isso usado antes, na seção \"Funcões como Argumento\" da aula 07, para pares, mas pode ser generalizada para qualquer número de variáveis.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Uma maneira de pensar sobre a atribuição de tupla é como empacotamento (packing)  / descompactação (unpacking) de tupla.\n",
    "\n",
    "- os valores à esquerda são \"empacotados\" em uma tupla:\n",
    "\n",
    "- os valores em uma tupla à direita são \"descompactados\" nas variáveis / nomes à direita:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "t = (\"Carlos\", 19, \"MC102\")    # tuple packing\n",
    "(name, age, studies) = t       # tuple unpacking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Swap de valores de variáveis:\n",
    "\n",
    "De vez em quando, é útil trocar os valores de duas variáveis. Com declarações de atribuição convencionais, temos que usar uma variável temporária. Por exemplo, para trocar x e y:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 1\n",
    "y = 2\n",
    "# wrong way\n",
    "x = y\n",
    "y = x\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "x = 1\n",
    "y = 2\n",
    "# correct, but needs a temporary variable\n",
    "temp = x\n",
    "x = y\n",
    "y = temp\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "x = 1\n",
    "y = 2\n",
    "#using tuples\n",
    "(x, y) = (y, x)   # or, simple: x, y = y, x\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- O número de variáveis à esquerda e o número de valores à direita precisam \n",
    "ser iguais:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a, b = 1, 2, 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Tuplas podem ser usadas para retornar mais de um valor de uma função"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def quotient_and_remainder(x, y):\n",
    "    q = x // y\n",
    "    r = x % y\n",
    "    return (q, r)\n",
    "\n",
    "(quot, rem) = quotient_and_remainder(7, 4)\n",
    "print(quot, rem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tuplas como argumentos de comprimento variável de funções"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "As funções em Python podem receber um número variável de argumentos.\n",
    "Um nome de parâmetro que comece com `*` reúne vários argumentos em uma tupla. \n",
    "Esses argumentos são chamados de argumentos de comprimento variável e não são nomeados na definição da função, ao contrário dos argumentos necessários e padrão.\n",
    "Esta tupla permanece vazia se nenhum argumento adicional for especificado durante a chamada da função. Vejamos o exemplo a seguir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def printinfo( arg1, *vartuple ):\n",
    "   # This prints variables passed as argument\n",
    "   print(\"Output is: \")\n",
    "   print(arg1)\n",
    "   for var in vartuple:\n",
    "      print(var)\n",
    "   return\n",
    "\n",
    "# Now you can call printinfo function\n",
    "printinfo( 10 )\n",
    "printinfo( 70, 60, 50 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O complemento de reunir é espalhar. Se você tiver uma sequência de valores e quiser passá-la a uma função como argumentos múltiplos, pode usar o operador `*`. Por exemplo, a função `quotient_and_remainder` definida anteriormente recebe exatamente dois argumentos; ele não funciona com uma tupla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "t = 7, 4\n",
    "quot, rem = quotient_and_remainder(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "No entanto, se você espalhar a tupla, aí funciona:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "quot, rem = quotient_and_remainder(*t)\n",
    "print(quot,rem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Uma lista (list) em Python é uma sequência ou coleção ordenada de valores. Cada valor na lista é identificado por um índice. Os valores que formam uma lista são chamados elementos ou itens. Listas são similares a tuplas, no entanto, diferentemente de tuplas, lista são mutáveis, isto é, os itens de uma lista podem ser alterados.\n",
    "\n",
    "A maneira mais simples de se criar uma lista é envolver os elementos da lista por colchetes ( [ e ]):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "frutas = [\"banana\", \"maça\", \"cereja\"]\n",
    "print(frutas)\n",
    "\n",
    "frutas[0] = \"pera\"\n",
    "frutas[-1] = \"laranja\"\n",
    "print(frutas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Também pode-se criar uma lista através da builtin `list`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "digitos = list(range(10))\n",
    "print(digitos, type(digitos))\n",
    "curso = list(\"MC102\")\n",
    "print(curso, type(curso))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Como em tuplas, os elementos de uma lista não precisam ser do mesmo tipo. A lista a seguir contém um string, um float, um inteiro e uma outra lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = [\"oi\", 2.0, 5, [10, 20]]\n",
    "print(len(x))\n",
    "print(len(x[3]))\n",
    "print(x[3][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Um lista em uma outra lista é dita aninhada (nested) e a lista mais interna é chamada frequentemente de sublista (sublist). Finalmente, existe uma lista especial que não contém elemento algum. Ela é chamada de lista vazia e é denotada por []."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "red = \"vermelho\"\n",
    "cores = ['azul', \"amarelo\", 'verde', \"branco\", red]\n",
    "numeros = [123, 5460]\n",
    "vazia = []\n",
    "mista = [1, 1, [2, 3], [5, 8, 13]]\n",
    "print(len(cores), len(numeros), len(vazia), len(mista), len(mista[3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "A sintaxe para acessar um elemento de uma lista é a mesma usada para acessar um caractere de um string ou um elemento de uma tupla. Nós usamos o operador de indexação ($[]$ – não confundir com a lista vazia). A expressão dentro dos conchetes especifica o índice. Lembrar que o índice do primeiro elemento é 0. Qualquer expressão que tenha como resultado um número inteiro pode ser usada como índice. Índices negativos indicarão elementos da direita para a esquerda ao invés de da esquerda para a direita."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Operações básicas: Pertinencia, Concatenação e Repetição"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`in` e `not in` são operadores booleanos ou lógicos que testam a pertinência (membership) em uma sequência. Novamente, como com strings, o operador `+` concatena listas. Analogamente, o operador `*` repete os itens em uma lista um dado número de vezes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "citricas = [\"laranja\", \"abacaxi\"]\n",
    "frutas = [ \"maça\", \"pêra\"] + citricas\n",
    "print(frutas)\n",
    "print(\"pêra\" in frutas)\n",
    "zeros = [0] * 4\n",
    "print(zeros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Métodos de Listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O Python oferece métodos que operam em listas. Estes são alguns exemplos:\n",
    "- `append` adiciona um novo elemento ao fim de uma lista;\n",
    "- `extend` toma uma lista como argumento e adiciona todos os elementos;\n",
    "- `sort` classifica os elementos da lista em ordem ascendente.\n",
    "\n",
    "Há várias formas de excluir elementos de uma lista. Se souber o índice do elemento que procura, você pode usar `pop`. pop altera a lista e retorna o elemento que foi excluído. Se você não incluir um índice, ele exclui e retorna o último elemento. Se não precisar do valor removido, você pode usar a instrução `del`. del também manipula índices negativos e produz um erro de execução se o índice estiver foram do intervalo da lista. Além disso, você pode usar uma fatia como argumento para del. Como é usual, fatias selecionam todos os elementos até, mas não incluindo, o segundo índice. Por fim, se souber o elemento que quer excluir (mas não o índice), você pode usar `remove`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "t1 = ['a', 'b', 'c']\n",
    "t1.append('d')\n",
    "\n",
    "t2 = ['a', 'b', 'c']\n",
    "t3 = ['d', 'e']\n",
    "t2.extend(t3)\n",
    "\n",
    "t4 = ['d', 'c', 'e', 'b', 'a']\n",
    "t4.sort()\n",
    "\n",
    "t5 = ['a', 'b', 'c']\n",
    "x = t5.pop(1)\n",
    "\n",
    "t6 = ['a', 'b', 'c']\n",
    "del t6[1]\n",
    "\n",
    "t7 = ['a', 'b', 'c']\n",
    "t7.remove('b')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Listas e Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Como vimos, a função `list` quebra uma string em letras individuais. Se você quiser quebrar uma string em palavras, você pode usar o método `split`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "s = \"Algoritmos e Programação de Computadores\"\n",
    "t = s.split()\n",
    "print(t)\n",
    "\n",
    "\"Welcome to mc102's lesson on lists & strings\".split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Um argumento opcional chamado `delimiter` especifica quais caracteres podem ser usados para demonstrar os limites das palavras. O valor padrão (default) para `delimiter` são: espaços, tabs e \\textit{newline}. O exemplo seguinte usa um hífen como delimitador:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "s = 'spam-spam-spam'\n",
    "delimiter = '-'\n",
    "t = s.split(delimiter)\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Podem haver substrings vazias no retorno do método **split**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "s = \"1;2;;3\"\n",
    "t = s.split(';')\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "`join` é o contrário de `split`. Ele toma uma lista de strings e concatena os elementos. Por join ser um método de string (função que opera em strings), então é preciso invocá-lo no delimitador e passar a lista como parâmetro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "t = ['The', 'measure', 'of', 'love', 'is', 'to', 'love', 'without', 'measure']\n",
    "delimiter = ' '\n",
    "s = delimiter.join(t)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Nesse caso, o delimitador é um caractere de espaço, então join coloca um espaço entre as palavras. Para concatenar strings sem espaços, você pode usar a string vazia `''`, como delimitador."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercícios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**a.** Escreva uma função que devolve o número de palavras e linhas em um texto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def wc(text):\n",
    "    return text.split(), text.split('\\n')\n",
    "    \n",
    "\n",
    "text = \"Eu estou testando o \\n número de linhas \\n e palavras\"\n",
    "w, c = wc(text)\n",
    "print(w, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Referencias de Listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Como sabemos, objetos Python podem ser identificados usando seus identificadores (nomes, variáveis) que são únicos. Podemos também testar se dois nomes se referem ao mesmo objeto usando o operador `is`. O operador `is` retorna True se as duas referências são ao mesmo objeto. Em outras palavras, as referências são a mesma. vejamos o exemplo abaixo com strings (vamos usar novamente o [Python Tutor](http://www.pythontutor.com/) nestes exemplos):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "%load_ext tutormagic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%tutor -l python3 --link --heapPrimitives\n",
    "a = \"banana\"\n",
    "b = \"banana\"\n",
    "print(a is b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Como strings são imutáveis, Python optimiza recursos fazendo com que duas variáveis que se referem ao mesmo string se referirem ao mesmo objeto.\n",
    "\n",
    "Este não é o caso com listas. Considere o exemplo seguir. Aqui $a$ e $b$ se referem a duas listas diferentes, cada uma por acaso tem os mesmo elementos como valores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%tutor -l python3 --link --heapPrimitives\n",
    "a = [81, 82, 83]\n",
    "b = [81, 82, 83]\n",
    "\n",
    "print(a is b)\n",
    "print(a == b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Existe um ponto importante a ser notado a respeito desse diagrama de referências. O valor $a$ é uma referência a uma coleção de referências. Essas referências na realidade se referem a valores inteiros em uma lista. Em outras palavras, uma lista é uma coleção de referências para objetos. É interessante que apesar de $a$ e $b$ serem duas listas distintas (duas coleções diferentes de referências), o objeto inteiro $81$ é compartilhado por ambos. Como strings, inteiros também são imutáveis, portanto Python optimiza e permite que todos compartilhem o mesmo objeto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Alias e clone de Listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Como variáveis fazem referência a objetos, se atribuimos uma variável a outra, ambas as variáveis passam a fazer referência ao mesmo objeto. No exemplo a seguir, a mesma lista tem dois nomes diferentes, $a$ e $b$. Neste caso,  dizemos que $a$ e $b$ são \"alias\" da lista. Mudanças feitas com um nome afeta o outro. No exemplo a seguir, os ids de $a$ e $b$ são os mesmos depois da execução do comando de atribuição $b = a$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "%%tutor -l python3 --link --textReferences --heapPrimitives\n",
    "a = [81, 82, 83]\n",
    "b = [81, 82, 83]\n",
    "\n",
    "print(a == b)\n",
    "print(a is b)\n",
    "\n",
    "b = a\n",
    "print(a == b)\n",
    "print(a is b)\n",
    "\n",
    "b[0] = 5\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Apesar desse comportamento ser útil, ele é algumas vezes inesperado ou indesejável. Em geral, é mais seguro evitar \\textit{aliasing} quando você está trabalhando com objetos mutáveis. É evidente que com objetos imutáveis não há problema. Por isto, Python é livre para usar alias de strings e inteiros quando surge uma oportunidade para economizar espaço."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Se desejamos modificar uma lista e também manter uma cópia da lista original, temos que ser capazes de fazer uma cópia da lista, não apenas da referência. Este processo é algumas vezes chamado de clonar (cloning), para evitar a ambiguidade da palavra cópia.\n",
    "\n",
    "A maneira mais fácil de clonarmos uma lista é usar o operador de fatiação (slice). Tomar qualquer fatia de $a$, cria uma nova lista. Para clonar uma lista inteira basta tomarmos a fatia como sendo a lista toda:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%tutor -l python3 --link --textReferences --heapPrimitives\n",
    "a = [81, 82, 83, 84, 85]\n",
    "b = a[:]\n",
    "\n",
    "print(a == b)\n",
    "print(a is b)\n",
    "\n",
    "b[0] = 5\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Listas como Parâmetros"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Funções que recebem listas como argumentos e as alteram durante a execução são chamadas de modificadoras (modifiers) e as mudanças que elas realizam são chamadas efeitos colaterais (side effects). Ao passar uma lista como argumento estamos realmente passando para a função uma referência para a lista e não uma cópia (clone) da lista. Como listas são mutáveis, as alterações feitas nos elementos referenciados pelos parâmetros mudarão a lista que o argumento está referenciando. Por exemplo, a função a seguir recebe uma lista como argumento e multiplica cada elemento da lista por 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "%%tutor -l python3 --link --textReferences --heapPrimitives\n",
    "def double_stuff(lista):\n",
    "    \"\"\"Recebe uma lista referenciada por 'lista' e sobreescreve\n",
    "       cada elemento da lista com o dobro do seu valor.\n",
    "    \"\"\"\n",
    "    for posicao in range(len(lista)):\n",
    "        lista[posicao] = 2 * lista[posicao]\n",
    "\n",
    "things = [2, 5, 9]\n",
    "print(things)\n",
    "double_stuff(things)\n",
    "print(things)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Processamento de Seqüências"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "As seqüências são uma forma tão comum de dados compostos que todos os programas são geralmente organizados em torno dessa abstração única. Os componentes modulares que possuem seqüências como entradas e saídas podem ser misturados e combinados para executar o processamento de dados. Os componentes complexos podem ser definidos encadeando um pipeline de operações de processamento de seqüência, cada um dos quais de forma simples e focado."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Compreensão de Listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Muitas operações de processamento de seqüência podem ser expressas avaliando uma expressão fixa para cada elemento em uma seqüência e coletando os valores resultantes em uma seqüência de resultados. Em Python, uma compreensão de lista (**List Comprehensions**) é uma expressão que executa tal computação."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Suponha que você tenha escrito uma função que determina se um número inteiro é primo ou não e eu então peça a você para produzir uma lista com os números primos no intervalo de 0 à 100. Uma solução poderia ser a que segue:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def is_prime(x):\n",
    "    for y in range(2, x):\n",
    "        if x % y == 0:\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "primes = []\n",
    "for x in range(2,100):\n",
    "    if is_prime(x):\n",
    "        primes.append(x)\n",
    "print(primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Porém Python tem uma solução mais elegante:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "primes = [x for x in range(2, 100) if is_prime(x)]\n",
    "print(primes)\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Uma compreensão de lista consiste nas seguintes partes:\n",
    "\n",
    "- Uma seqüência de entrada.\n",
    "- Uma variável representando membros da seqüência de entrada.\n",
    "- Opcionalmente, uma expressão Predicado.\n",
    "- Expansão de saída produzindo elementos da lista de saída dos membros da Seqüência de Entrada que satisfazem o predicado.\n",
    "\n",
    "Outros exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "Celsius = []\n",
    "temp = True\n",
    "while temp:\n",
    "    temp = input(\"Enter a new temperature (Click Return, for finish):\")\n",
    "    if temp != \"\":\n",
    "        Celsius.append(float(temp))\n",
    "\n",
    "print(\"Celsius: \", Celsius)\n",
    "Fahrenheit = [ ((9/5)*x + 32) for x in Celsius ]\n",
    "print(\"Fahrenheit: \", Fahrenheit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "No exemplo a seguir, a compreensão da lista verificará primeiro se o número $x$ é divisível em $3$ e, em seguida, verifique se $x$ é divisível em $5$. Se $x$ satisfizer ambos os requisitos, ele será impresso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "number_list = [x for x in range(100) if (x % 3 == 0) if (x % 5 == 0)]\n",
    "print(number_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Uma tripla pitagórica consiste em três inteiros positivos $a$, $b$ e $c$, tal que $a^2 + b^2 = c^2$.\n",
    "Essa tripla é comumente escrita $(a, b, c)$ e o exemplo mais conhecido é a tripla $(3, 4, 5)$.\n",
    "A compreensão de lista a seguir cria as triplas de Pitágoras no intervalo (1,30):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "[(a,b,c) for a in range(1, 30)\n",
    "         for b in range(a, 30)\n",
    "         for c in range(b, 30) if a**2 + b**2 == c**2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Compreensão de Listas Aninhadas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Uma matriz de identidade de tamanho n é uma matriz quadrada n por n com 1 na diagonal principal e 0 em outro lugar. Em Python podemos representar essa matriz por uma lista de listas, onde cada sub-lista representa uma linha. Uma matriz de 3 por 3 seria representada pela seguinte lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "[ [1, 0, 0],\n",
    "  [0, 1, 0],\n",
    "  [0, 0, 1]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "A matriz no exemplo anterior pode ser gerada pela seguinte compreensão:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "[ [ 1 if col == row else 0 for col in range(0, 3) ] for row in range(0, 3) ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercícios:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Removendo as vogais de uma frase**\n",
    "\n",
    "Objetivo: pegue uma string como entrada e retorne uma string com as vogais removidas. Escreva os códigos de Python com implementações de laços FOR e Compreensão de Listas (LC):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0,
     8
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def sol_for(sentence):\n",
    "    vowels = 'aeiou'\n",
    "    filtered_list = []\n",
    "    for l in sentence:\n",
    "        if l not in vowels:\n",
    "            filtered_list.append(l)\n",
    "    return ''.join(filtered_list)\n",
    "\n",
    "def sol_lc(sentence):\n",
    "    vowels = 'aeiou'\n",
    "    return ''.join([ l for l in sentence if l not in vowels])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# test:\n",
    "sentence = 'My name is Marcio Machado Pereira!'\n",
    "print(\"FOR-loop result: \", sol_for(sentence))\n",
    "print(\"LC result      : \", sol_lc(sentence))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Matriz Transposta**\n",
    "\n",
    "Dada uma matriz $A$ de ordem m x n, a matriz transposta dela será representada por $A^t$ de ordem “invertida” n x m. \n",
    "Essa ordem invertida significa que para transformarmos uma matriz em matriz transposta, basta trocar os elementos das linhas pelo das colunas e vice-versa. \n",
    "\n",
    "Veja o exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "matrix = [[1, 2, 3, 4],\n",
    "          [5, 6, 7, 8],\n",
    "          [9, 10, 11, 12]]\n",
    "rows = len(matrix)\n",
    "cols = len(matrix[0])\n",
    "transposta = [[0 for j in range(rows)] for i in range(cols)]\n",
    "for i in range(cols):\n",
    "    for j in range(rows):\n",
    "        transposta[i][j] = matrix[j][i]\n",
    "print(matrix)\n",
    "print(transposta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O desafio para vocês é gerar a transposta da matrix definida acima, mas usando somente compreensão de listas, isto é, sem usar laços."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# solução:\n",
    "[[row[col] for row in matrix] for col in range(len(matrix[0]))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Findall ocurrences**\n",
    "\n",
    "Usando compreensão de Listas, construa uma função que retorna uma lista com os indices de todas as ocorrências de uma palavra em um texto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def findall(palavra, texto):\n",
    "    return [i for i in range(len(texto)) if texto.startswith(palavra, i)]\n",
    "\n",
    "\n",
    "print(findall(\"spam\", \"spam spam and more spam at the end\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Lançamento de dados**\n",
    "\n",
    "Faça um programa que simule um lançamento de dados. Lance o dado 100 vezes e armazene os resultados em uma lista. Depois, mostre quantas vezes cada valor foi conseguido. Dica: use uma lista para os contadores $(1-6)$ e uma função para gerar numeros aleatórios, simulando os lançamentos dos dados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from random import randint\n",
    "\n",
    "counters = [0 for _ in range(7)]\n",
    "for i in range(100):\n",
    "    r = randint(1, 6)\n",
    "    counters[r] += 1\n",
    "    \n",
    "result = [(i, r) for i, r in zip(range(1, 7), counters[1:])]\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Números inteiros e seus quadrados**\n",
    "\n",
    "(a) Crie uma lista com inteiros de 0 a 9 elevados ao quadrado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "[ x ** 2 for x in range(10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "(b) Crie uma lista com inteiros de 0 a 9, cujo quadrado é maior que 5 e menor que 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[ x ** 2 for x in range(10) if x ** 2 > 5 if x ** 2 < 50]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Combinações de bebidas e comidas**\n",
    "\n",
    "Crie uma lista com todos os possíveis pares de bebida e comida das listas:\n",
    "```\n",
    "[‘água’, ‘chá’, ‘suco’]\n",
    "[‘presunto’, ‘ovos’, ‘queijo’]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "[ (i,j) for i in ['água', 'chá', 'suco'] for j in ['presunto', 'ovos', 'queijo'] ]"
   ]
  }
 ],
 "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.6.4"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "livereveal": {
   "theme": "solarized",
   "transition": "slide"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}