{ "cells": [ { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "## Listas\n", "\n", "### Introdução\n", "\n", "Uma lista é um recurso extremamente poderoso para trabalharmos com coleções de dados em uma linguagem de programação. Este é um recurso que esta presente em praticamente qualquer linguagem de progração existente, embora em algumas linguagens, usualmente a lista terá tamanho fixo e só poderá armazenar um único tipo de dado para todos os valores da mesma. \n", "\n", "Podemos pensar em uma lista como uma variável que, em vez de armazernar um único valor, pode armazenar inúmeros valores dentro dela. Cada um destes valores vai receber um endereço, iremos chamar este enderenço de índice. Portanto se tivermos uma lista com 10 valores, teremos 10 indices diferentes para acessarmos cada um destes valores individualmente. É importante ressaltar que os índices da lista servirão para acessarmos e modificarmos cada um dos valores armazenados dentra lista. Os índices de uma lista são sempre números inteiros e começam em 0 (zero) e vão até N-1, onde N é a quantidade de emelemtnso da lista ou seu tamanho.\n", "\n", "Uma forma interessante de visualizarmos uma lista é uma sequencia de caixinhas na horizontal, assim como uma caixa de correio de um condômínio, embora todas estas caixinhas estejam no mesmo local, cada uma delas vai possuir um número diferente, neste caso chamaremos este número sempre de índice. A a seguir tem uma representação gráfica de uma lista:\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
01234
-404565-66773454
\n", "\n", "Esta lista mostrada tem 5 valores armazenados dentro dela [-404, 565, -66, 7734, 54], observe que estes valores estão representados na segunda linha da figura de cima. Para cada um dos valores armazenados existe um índice, estes valores estão representados na primeira linha. Portanto o valor 565 tem índice 1, mesmo ele sendo o segundo elemento pois a contagem começa em 0. Note que o ultimo elemento sempre vai ter índice igual a N-1. \n", "\n", "Agora você deve estar se perguntando para que vais usar uma lista, bom listas tem ínumeras utilidades justamente por poderem armazenar ínumeros valores em uma única variável. Imagine que você tem que escrever um pograma que leia 100 números e depois da leitura mostre estes números ordenados de forma crescente. Sem o uso de listas fica \n", "praticamente impossível de se escrever um porgrama deste tipo.\n", "\n", "\n", "
\n", "Lembre: O ínidice de uma lista sempre começa em zero e vai até N-1. \n", "
\n", "\n", "### Criando uma lista em python.\n", "\n", "Em python sempre vamos utilizar os colchetes, estes caracteres aqui -> \"[\" \"]\", para trabalharmos com listas. O próprio python imprime as listas utilizando os colchetes. O cochete de abertura [ indica que ali começa a lista e o de fechamento ] que ali termina a mesma. \n", "\n", "Para criarmos uma lista vazia é muito simples, damos um nome de variável e dizemos que a lista abriu e fechou com os colchetes [].\n", "\n", "Exemplo:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[]\n" ] } ], "source": [ "minhaLista = []\n", "print minhaLista" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Acabamos de criar e de imprimir uma lista vazia, voce notou que o python imprimiu os dois colchetes? isso indica uma lista vazia. \n", "\n", "Para criarmos uma lista já com alguns valores utilizamos praticamente a mesma sintaxe, entretanto, passamos os valores em ordem que vão estar dentro da lista separados por , (virgula).\n", "\n", "Exemplo:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[-404, 565, -66, 7734, 54]\n" ] } ], "source": [ "minhaLista = [-404, 565, -66, 7734, 54]\n", "print minhaLista" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Observe que agora, ao imprimir a lista o python mostra os cochetes (onde começa e onde termina a lista) e os valores que colocamos dentro da lista ao cria-la.\n", "\n", "Uma coisa interessante do python é que ele permite que coloquemos vários valores de vários tipos dentro de uma lista.\n", "\n", "Exemplo" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[-404, 'Cachorro Quente', False, 77.0]\n" ] } ], "source": [ "minhaLista = [-404, \"Cachorro Quente\", False, 77.0]\n", "print minhaLista" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mas e esse tal de índice? Porque ele não aparece ali na impressão do python? \n", "\n", "O índice não é impresso pois nós o utilizamos para acessar/modificar cada um dos valroes da lista individualmente. \n", "\n", "### Acesso a um valor individual em lista em python.\n", "\n", "Muitas vezes vamos precisar acessar um valor especifico da lista ou para pegar o valor que está lá ou para modificar. Para isto, novamente utilizaremos os colchetes. A sintaxe é muito simples nome_da_lista[indice] podemos usar essa sintaxe tanto para acessar um valor quanto para modificar um valor da lista.\n", "\n", "Exemplo:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['Listas', 'nao sao', 'legais']\n", "nao sao\n", "sao muito\n", "['Listas', 'sao muito', 'legais']\n" ] } ], "source": [ "lista = ['Listas','nao sao', 'legais']\n", "print lista #observe que este print vai imprimir a lista acima que tem 3 textos dentro dela.\n", "\n", "#se quisermos pegar só um valor (posição) da lista podemos usar o índice\n", "print lista[1] #observe que este print vai imprimir apenas a string q esta na posição de índice 1 da lista\n", "\n", "#podemos usar a mesma ideia para mudar o que está na lista.\n", "lista[1] = 'sao muito'\n", "\n", "#imprimimos agora a posição modificada sozinha e posteriormente toda a lista\n", "print lista[1] \n", "print lista\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Viu que bacana. Então apenas com um nome de variavel conseguimos armazenar ínumeros valores dentro desta lista e com o índice acessar cada un detes valores. \n", "\n", "A lista criada anteriormente tem tamanho 3 e possui os índices 0,1 e 2. O que será que acontece se tentarmos acessar o índice 3?\n", "\n", "Exemplo:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [ { "ename": "IndexError", "evalue": "list index out of range", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mlista\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'Listas'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'nao sao'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'legais'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mprint\u001b[0m \u001b[0mlista\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mIndexError\u001b[0m: list index out of range" ] } ], "source": [ "lista = ['Listas','nao sao', 'legais']\n", "print lista[3]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Como podemos ver, ao tentar acessar um índice que esta fora da lista vai gerar a exceção (erro) de IndexError: list index out of range.\n", "\n", "Mas e se tentarmos inserir algo na posição 3?" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false }, "outputs": [ { "ename": "IndexError", "evalue": "list assignment index out of range", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mlista\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'Listas'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'nao sao'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'legais'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mlista\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"mais alguem\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0;32mprint\u001b[0m \u001b[0mlista\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mIndexError\u001b[0m: list assignment index out of range" ] } ], "source": [ "lista = ['Listas','nao sao', 'legais']\n", "lista[3] = \"mais alguem\"\n", "print lista" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Deu erro novamente... Mas e como inserimos valores na lista?\n", "\n", "### Inserindo novos valores em uma lista\n", "\n", "Em python uma lista tem alguns métodos (funções) associados a ela. Alguns destes métodos são para inserir novos elementos na lista. Sempre que quisermos inserir um valor no final da lista podemos utilizar o método append().\n", "\n", "Exemplo: " ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[6, 7, 33, 3, 5]\n", "[6, 7, 33, 3, 5, 22]\n" ] } ], "source": [ "numerosDaMega = [6, 7, 33, 3, 5]\n", "print numerosDaMega\n", "\n", "#aqui adicionamos mais um valor ao fim\n", "numerosDaMega.append(22)\n", "print numerosDaMega\n", "\n", "#se você jogar estes numeros, quero minha parte do premio =D " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Viu que interessante? Agora podemos ir adicionando números à nossa lista usando o append. Mas e se eu não quiser inserir no fim da lista? \n", "\n", "Existe o método .insert(indice, valor) para inserção baseado em índice, este método recebe o índice de onde vai ser inserido o valor e o valor. \n", "\n", "Exemplo:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[6, 7, 33, 3, 5]\n", "[22, 6, 7, 33, 3, 5]\n", "[22, 4, 6, 7, 33, 3, 5]\n" ] } ], "source": [ "numerosDaMega = [6, 7, 33, 3, 5]\n", "print numerosDaMega\n", "\n", "#aqui adicionamos o 22 no ínicio\n", "numerosDaMega.insert(0,22)\n", "print numerosDaMega\n", "\n", "#aqui adicionamos o 4 na segunda posição.\n", "numerosDaMega.insert(1,4)\n", "print numerosDaMega" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Com o método insert podemos inserir em qualquer posição da lista. Mas e se eu quiser remover alguem da lista?\n", "\n", "### Removendo valores da lista\n", "\n", "Para remover um valor de uma lista usamos o método .remove(valor). Este método remove a primeira ocorrencia do valor que passamos para ele.\n", "\n", "Exemplo:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[33.5, 55.0, 0.05, 55.0]\n", "[33.5, 0.05, 55.0]\n" ] } ], "source": [ "valores = [33.5, 55.0, .05, 55.0]\n", "print valores\n", "valores.remove(55.0)\n", "print valores" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### Listas e laços de repetição\n", "\n", "Como já foi dito antes, listas e laços de repetição combinam muito bem.\n", "\n", "Esta é uma combinação que permite, por exemplo, ler 5 numeros e calcular a média deles só depois de toda a leitura. Pois não perdemos estes números durante a leitura graças a lista.\n", "\n", "Exemplo:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "digite o número 0 da lista:5\n", "digite o número 1 da lista:6\n", "digite o número 2 da lista:9\n", "digite o número 3 da lista:8\n", "digite o número 4 da lista:5\n", "[5, 6, 9, 8, 5]\n", "media dos valores = 6\n" ] } ], "source": [ "lista = [] #criamos uma lista vazia.\n", "\n", "#le os números\n", "for i in range(0,5):\n", " numero = int(raw_input(\"digite o número \" + str(i) + \" da lista:\" ))\n", " lista.append(numero)\n", " \n", "#Depois da leitura, os números estao armazenados na lista\n", "print lista\n", "\n", "#Agora vamos acessar cada valor individualmente e calcular a média\n", "media = 0\n", "for i in range(0,5):\n", " media = media + lista[i] #observe que aqui usamos o contador i do for como indice para pegar cada valor da lista\n", "\n", "media = media / 5 \n", "print \"media dos valores = \" + str(media)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Com listas numca mais perderemos nossos valores e desta forma podemos separar nossa lógica em pequenos pedaços. Mas e se eu quiser ler quantos números o usuário quiser informar, e depois calcular a média?\n", "\n", "Bom, como já sabemos, neste caso é teremos usar um while. \n", "\n", "Exemplo:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "digite sair ou um número1\n", "digite sair ou um número5\n", "digite sair ou um número6\n", "digite sair ou um número2\n", "digite sair ou um número5\n", "digite sair ou um número5\n", "digite sair ou um número5\n", "digite sair ou um número5\n", "digite sair ou um número5\n", "digite sair ou um número54\n", "digite sair ou um número4\n", "digite sair ou um númerosair\n", "[1, 5, 6, 2, 5, 5, 5, 5, 5, 54, 4]\n", "media dos valores = 8\n" ] } ], "source": [ "lista = []\n", "comando = 0\n", "while comando != \"sair\":\n", " comando = raw_input(\"digite sair ou um número\");\n", " if comando == \"sair\":\n", " continue\n", " \n", " numero = int(comando)\n", " lista.append(numero)\n", " \n", "print lista\n", "\n", "media = 0\n", "for i in range(0, len(lista)):\n", " media = media + lista[i] #observe que aqui usamos o contador i do for como indice para pegar cada valor da lista\n", "\n", "media = media / len(lista) \n", "print \"media dos valores = \" + str(media)\n", " " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Com este código o usuário pode informar quantos números quiser e ao digitar sair ele para de ler números para lista. Depois disto, como agora já sabemos a quantidade de elementos da lista... Pera ai, sabemos? Sim, podemos chegar o tamanho de uma lista a qualquer momento usando a função len() do python. Esta função retorna a quantidade de elementos da lista =), dispensando, desta forma, a necessidade de um contador. Observe que no código anterior tem dois usos do len().\n", "\n", "E antes de encerrar esta seção, o for tem uma carta na manga. Você já chamou a função range que usamos no for sozinha?\n", "\n", "Se não, veja o que ele mostra ao imprimirmos o seu resultado" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n" ] } ], "source": [ "print range(0, 20)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "O retorno da função range retorna uma lista. Pasmem! hehe. \n", "\n", "Mas então, será que eu posso passar uma lista ali? e o que acontece com ela?\n", "\n", "Na realidade o for recebe uma lista como entrada, até então estamos dando como entrada uma lista de contagem, e para cada um dos elementos desta lista o seu \"contador\" recebe um novo valor a cada nova iteração. Mas esta lista pode ser de qualquer coisa.\n", "\n", "Exemplo:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "luis\n", "maria\n", "claudia\n", "joão\n", "roberto\n" ] } ], "source": [ "pessoas = [\"luis\", \"maria\", \"claudia\", \"joão\", \"roberto\"]\n", "\n", "for p in pessoas:\n", " print p" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Viu que interessante? Temos uma lista de strings, que guarda em cada posição um nome, e ao passarmos esta lista para o for no lugar da função range() ele itera em cada um dos nomes da lista. \n", "\n", "Mas e se eu quiser mostrar estes nomes ordenados?\n", "\n", "### Ordenando uma lista\n", "\n", "Para ordenar uma lista é só chamarmos seu método .sort() este método ordena, por padrão, de forma crescente. Entretanto pode-se passar para ele uma função explicando como deve ser feita a ordenação. Não iremos cobrir isso neste capítulo.\n", "\n", "Exemplo:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "claudia\n", "joão\n", "luis\n", "maria\n", "roberto\n" ] } ], "source": [ "pessoas = [\"luis\", \"maria\", \"claudia\", \"joão\", \"roberto\"]\n", "\n", "pessoas.sort()\n", "\n", "for p in pessoas:\n", " print p" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Copia de listas\n", "\n", "Em alguns momentos, será necessário copiar uma lista para outra para modificar a nova lista sem perder a original. O comportamento mais instintivo que temos é fazer o seguinte:\n", "\n" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['gato', 'cachorro', 'vaca', 'galinha']\n", "['gato', 'cachorro', 'vaca', 'galinha']\n" ] } ], "source": [ "lista1 = [\"gato\", \"cachorro\", \"vaca\", \"galinha\"]\n", "lista2 = lista1\n", "\n", "print lista1\n", "print lista2\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pareque que a lista foi copiada né? Mas obeserve o que acontece ao modificarmos uma posição da lista2." ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['gato', 'Camelo', 'vaca', 'galinha']\n", "['gato', 'Camelo', 'vaca', 'galinha']\n" ] } ], "source": [ "lista1 = [\"gato\", \"cachorro\", \"vaca\", \"galinha\"]\n", "lista2 = lista1\n", "\n", "lista2[1] = \"Camelo\"\n", "\n", "print lista1\n", "print lista2\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mudou nas duas listas? Mas como, isso não é uma copia!!! Na verdade o que acontece é que ao atribuirmos uma lista a outra, ambas apontam para os mesmos dados, então se mudarmos numa lista vai mudar na outra também.\n", "\n", "Mas eu quero copiar! Como que faz?\n", "\n", "Para realizar a copia é muito parecido com o que fizemos. Mas devemos dizer que queremos fatiar (já vamos falar mais em detalhes disto) a lista em um pedaço inteiro e colocar ele para dentro da lista nova.\n", "\n", "Exemplo:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['gato', 'cachorro', 'vaca', 'galinha']\n", "['gato', 'Camelo', 'vaca', 'galinha']\n" ] } ], "source": [ "lista1 = [\"gato\", \"cachorro\", \"vaca\", \"galinha\"]\n", "lista2 = lista1[:]\n", "\n", "lista2[1] = \"Camelo\"\n", "\n", "print lista1\n", "print lista2\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Agora temos uma cópia. O que mudou? apenas isto -> lista2 = lista1[:]\n", "\n", "Mas o que aqueles dois pontos([:]) dentro dos colchetes significam? Significam que estamos fatiando a lista, porem pegando tudo que esta nela. A seguir isso fica mais claro.\n", "\n", "### Fatiamento de listas\n", "\n", "O fatiamento de listas é uma forma de pegar apenas uma parte de uma determinada lista. Por exemplo, queremos pegar apenas uma parte do ínicio da lista ou do meio. Para realizar o fatiamento utilizamos os dois pontos dentro do colchetes da lista. A sintaxe é a seguinte lista[inicioFatiamento:fimDoFatiamento], observe que tanto o início quanto o fim são indices. \n", "\n", "Exemplo:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[10, 20, 30, 40, 50, 60, 70, 80, 90]\n", "[40, 50, 60]\n" ] } ], "source": [ "lista = range(10,100,10) #cria uma lista com multiplos de 10\n", "\n", "listaFatiada = lista[3:6]\n", "\n", "print lista\n", "print listaFatiada\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Viu que baca, podemos pegar uma sub-lista de qualquer lista usando este recuros. Se não informarmos o início ou o fim do fatiamento por padrão ele vai pegar do início ou fim.\n", "\n", "Exemplo:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[10, 20, 30, 40, 50, 60, 70, 80, 90]\n", "[10, 20, 30, 40, 50, 60]\n", "[30, 40, 50, 60, 70, 80, 90]\n" ] } ], "source": [ "lista = range(10,100,10) #cria uma lista com multiplos de 10\n", "\n", "listaFatiada1 = lista[:6] #vai pegar tudo do inicio até o 6\n", "listaFatiada2 = lista[2:] #vai pegar tudo do 1 até o fim\n", "\n", "print lista\n", "print listaFatiada1\n", "print listaFatiada2\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Se não infromarmos o início nem o fim do fatiamento o resultado é toda a lista. E agora deve fazer mais sentido do pq temos que usar os dois pontos para copiar uma lista.\n", "\n", "\n", "Agora, vamos aos exercícos :)\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 2", "language": "python", "name": "python2" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.13" } }, "nbformat": 4, "nbformat_minor": 2 }