{ "cells": [ { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "# Conversões de tipos explícitas" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "É possível fazer conversão explícita entre os tipos." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "int(2)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "int(3.0/2.0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Diferente da divisão inteira (operador `//`), que arredonda os resultados para baixo, a conversão para inteiro descarta a parte fracionária." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "-1" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "int(-3.0/2.0)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "2.0" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "float(2)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "1073741824.0" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "float(2 ** 30)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "1125899906842624.0" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "float(2 ** 50)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "(2+0j)" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "complex(2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A conversão para complexo aceita também dois parâmetros: parte real e parte imaginária." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "(2+4j)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "complex(2, 4)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Mas cuidado com as limitações da precisão ao fazer conversão!" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "717897987691852588770249" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "3 ** 50" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "717897987691852578422784.0\n" ] } ], "source": [ "print('%25.1f' % float(3 ** 50)) # Explico a mágica mais tarde" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "# Variáveis" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Variáveis guardam referências para objetos. Elas não possuem tipos, pois os tipos são associados aos objetos, e portanto podem se referir a objetos de diversos tipos.\n", "\n", "Não é necessária a declaração de variáveis. Elas são criadas quando recebem um objeto por atribuição pela primeira vez durante a execução do código." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a = 1" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a = 2" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a = 3.14" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "3.14" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "É um erro tentar acessar uma variável que ainda não recebeu referência para um objeto, pois ela ainda não existe." ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "ename": "NameError", "evalue": "name 'b' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mNameError\u001b[0m: name 'b' is not defined" ] } ], "source": [ "b" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Diversas variáveis podem se referir ao mesmo objeto." ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "3.14" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "b = a" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "3.14" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a = 2" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "(2, 3.14)" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a, b" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "# Alguns módulos úteis" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Códigos em Python são organizados em módulos. Módulos podem definir novos tipos de dados e novas funções. Para acessar as definições de um módulo em nosso código, precisamos importar o módulo." ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "## O módulo math" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "import math" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "2.0" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "math.sqrt(4)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "0.5403023058681398" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "math.cos(1)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "As funções do módulo math trabalham com número de ponto flutuante." ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "ename": "ValueError", "evalue": "math domain error", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mValueError\u001b[0m: math domain error" ] } ], "source": [ "math.sqrt(-1)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "3.141592653589793" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "math.pi" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "2.718281828459045" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "math.e" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "## O módulo random" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "import random" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Podemos gerar um número de ponto flutuante aleatório na faixa [0,1)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "0.520290112494368" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "random.random()" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Ou um número inteiro aleatório na faixa [a,b] (No exemplo, a=0, b=6.)" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "random.randint(0,6)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Dada uma coleção de elementos, podemos escolher um deles aleatoriamente." ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "23" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "random.choice([12, 23, 34, 45])" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Mais tarde estudaremos outra biblioteca de números aleatórios mais apropriada para simulações científicas." ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "# Cadeias de caracter (o tipo string)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Strings podem ser delimitadas por aspas:" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'Oi, gente!'" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"Oi, gente!\"" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Oi, gente!\n" ] } ], "source": [ "print(\"Oi, gente!\")" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Ou por apóstrofes:" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'Oi, gente!'" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'Oi, gente!'" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Strings são representadas em UTF-8, portanto podemos utilizar caracteres acentuados e não-latinos." ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "cor = 'Coração'" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Para saber o número de caracteres na string temos a função len:" ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "7" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(cor)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Uma string funciona como um array (na verdade lista, veja abaixo) de caracteres, e pode ser indexada para pegar caracteres individuais.\n", "\n", "A indexação começa em 0, como em C." ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'C'" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor[0]" ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'o'" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor[1]" ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'o'" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor[6]" ] }, { "cell_type": "code", "execution_count": 45, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'ã'" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor[5]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "A indexação é verificada: É um erro tentar acessar um índice inexistente." ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "ename": "IndexError", "evalue": "string 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[0;32m----> 1\u001b[0;31m \u001b[0mcor\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mIndexError\u001b[0m: string index out of range" ] } ], "source": [ "cor[7]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "É possível também indexar utilizando \"slices\", que são faixas de índices indicadas pelo caracter ':'\n", "\n", "Como sempre em Python, indicamos o valor inicial da faixa e um após o valor final." ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'ção'" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor[4:7]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Se omitimos o valor final, então pegamos tudo até o final." ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'oração'" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor[1:]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Se omitimos o valor inicial, pegamos desde o início." ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'Cora'" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor[:4]" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'Cor'" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor[:3]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Se omitimos os dois, pegamos todos os elementos." ] }, { "cell_type": "code", "execution_count": 51, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'Coração'" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor[:]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Índices negativos indicam contagem do final para o início: -1 é o último, -2 o penúltimo, etc." ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'o'" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor[-1]" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'ã'" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor[-2]" ] }, { "cell_type": "code", "execution_count": 54, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "'C'" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor[-7]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Índices negativos podem ser usados nos slices:" ] }, { "cell_type": "code", "execution_count": 55, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'ora'" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor[1:-3]" ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'açã'" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor[-4:-1]" ] }, { "cell_type": "code", "execution_count": 57, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "''" ] }, "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor[3:2]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "O operador + é definido entre duas string, fazendo a concatenação." ] }, { "cell_type": "code", "execution_count": 58, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "y = 'bo'" ] }, { "cell_type": "code", "execution_count": 59, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'bobo'" ] }, "execution_count": 59, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y + y" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "O operador * é definido entre string e inteiro, fazendo n cópias da string" ] }, { "cell_type": "code", "execution_count": 60, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'bobobobo'" ] }, "execution_count": 60, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y * 4" ] }, { "cell_type": "code", "execution_count": 61, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "'bobobobo'" ] }, "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], "source": [ "4 * y" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Um fator importante a lembrar é que string são imutáveis. Isto é, uma vez criadas, seu valor não pode ser alterado, nem por mudança de caracteres nem por iserção ou retirada de caracteres." ] }, { "cell_type": "code", "execution_count": 62, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'Coração'" ] }, "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor" ] }, { "cell_type": "code", "execution_count": 63, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "ename": "TypeError", "evalue": "'str' object does not support item assignment", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcor\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'c'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment" ] } ], "source": [ "cor[0] = 'c'" ] }, { "cell_type": "code", "execution_count": 64, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "'coração'" ] }, "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'c' + cor[1:]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "O tipo string possui diversos métodos para realizar operações. Estudaremos métodos quando chegarmos na parte de orientação a objetos, mas já faremos uso de diversos métodos definidos nas bibliotecas.\n", "\n", "O método `find` retorna o índice em que uma subcadeia fornecida pode ser encontrada (primeiro caracter da subcadeia)." ] }, { "cell_type": "code", "execution_count": 65, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 65, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor.find('o')" ] }, { "cell_type": "code", "execution_count": 66, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor.find('ração')" ] }, { "cell_type": "code", "execution_count": 67, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 67, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor.find('raç')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Se a subcadeia não é encontrada, o método retorna -1." ] }, { "cell_type": "code", "execution_count": 68, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "-1" ] }, "execution_count": 68, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor.find('x')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "O método `replace` recebe duas subcadeias s1 e s2 e cria uma nova cadeia a partir da original substituindo s1 por s2 (obviamente sem alterar a cadeia original, que é imutável)." ] }, { "cell_type": "code", "execution_count": 69, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'Corpo'" ] }, "execution_count": 69, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor.replace('ração', 'rpo')" ] }, { "cell_type": "code", "execution_count": 70, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'Coração'" ] }, "execution_count": 70, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Um par de métodos bastante útil é constituído por `split` e `join`.\n", "\n", "O método `split` permite separar uma cadeia em partes delimitadas por uma subcadeia fornecida." ] }, { "cell_type": "code", "execution_count": 71, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "linha = 'aaa bb cccc xxxx'" ] }, { "cell_type": "code", "execution_count": 72, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "['aaa', 'bb', 'cccc', 'xxxx']" ] }, "execution_count": 72, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linha.split(' ')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Espaço em branco é o separador default, então não precisa ser fornecido." ] }, { "cell_type": "code", "execution_count": 73, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "separado = linha.split()" ] }, { "cell_type": "code", "execution_count": 74, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "['aaa', 'bb', 'cccc', 'xxxx']" ] }, "execution_count": 74, "metadata": {}, "output_type": "execute_result" } ], "source": [ "separado" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "O método é bastante sistemático. Se há dois separadores consecutivos, ele retorna uma string vazia entre eles." ] }, { "cell_type": "code", "execution_count": 75, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "['aaa bb ', '', '', '', ' xxxx']" ] }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linha.split('c')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "O método `join` faz a operação contrária, e permite juntar uma lista de cadeias através de um separador." ] }, { "cell_type": "code", "execution_count": 76, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "['aaa', 'bb', 'cccc', 'xxxx']" ] }, "execution_count": 76, "metadata": {}, "output_type": "execute_result" } ], "source": [ "separado" ] }, { "cell_type": "code", "execution_count": 77, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'aaa/bb/cccc/xxxx'" ] }, "execution_count": 77, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'/'.join(separado)" ] }, { "cell_type": "code", "execution_count": 78, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "'aaa,bb,cccc,xxxx'" ] }, "execution_count": 78, "metadata": {}, "output_type": "execute_result" } ], "source": [ "','.join(separado)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Entre outros, temos também métodos para converter para maiúscular, ou minúsculas, para verificar se os caracteres são todos alfanuméricos ou todos dígitos." ] }, { "cell_type": "code", "execution_count": 79, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'CORAÇÃO'" ] }, "execution_count": 79, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor.upper()" ] }, { "cell_type": "code", "execution_count": 80, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'coração'" ] }, "execution_count": 80, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor.lower()" ] }, { "cell_type": "code", "execution_count": 81, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 81, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor.isalpha()" ] }, { "cell_type": "code", "execution_count": 82, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 82, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cor.isdigit()" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Ao ler cadeias de arquivos, é comum que haja espaços em branco adicionais no início e no final da linha. O método `strip` retira esses caracteres em branco." ] }, { "cell_type": "code", "execution_count": 83, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "linha = ' ' + linha + ' '" ] }, { "cell_type": "code", "execution_count": 84, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "' aaa bb cccc xxxx '" ] }, "execution_count": 84, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linha" ] }, { "cell_type": "code", "execution_count": 85, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'aaa bb cccc xxxx'" ] }, "execution_count": 85, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linha.strip()" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Podemos também retirar caracteres em branco só do começo ou só do final." ] }, { "cell_type": "code", "execution_count": 86, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'aaa bb cccc xxxx '" ] }, "execution_count": 86, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linha.lstrip()" ] }, { "cell_type": "code", "execution_count": 87, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "' aaa bb cccc xxxx'" ] }, "execution_count": 87, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linha.rstrip()" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "O método de formatação usado pela função `printf` de C é em certas situações bastante conveniente. Em Python, isso é realizado pelo operador `%` sobre string e uma tupla de valores." ] }, { "cell_type": "code", "execution_count": 88, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'-10 4.325679 2.135'" ] }, "execution_count": 88, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'%d %f %4.3f' % (-10, 4.3256789, 2.1345678)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Algo parecido pode ser conseguido com o método `format`, com uma sintaxe diferente e possibilidade de reordenação dos valores na saída." ] }, { "cell_type": "code", "execution_count": 89, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'-10 4.3256789 2.1345678'" ] }, "execution_count": 89, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'{} {} {}'.format(-10, 4.3256789, 2.1345678)" ] }, { "cell_type": "code", "execution_count": 90, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'4.3256789 2.1345678 -10'" ] }, "execution_count": 90, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'{1} {2} {0}'.format(-10, 4.3256789, 2.1345678)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Podemos inclusive repetir um mesmo valor em vários lugares." ] }, { "cell_type": "code", "execution_count": 91, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "'10 20 10 30'" ] }, "execution_count": 91, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'{0} {1} {0} {2}'.format(10, 20, 30)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Podemos definir cadeias que ocupam múltiplas linhas usando o delimitador `\"\"\"`" ] }, { "cell_type": "code", "execution_count": 92, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "cadeiagrande = \"\"\" Isto é uma cadeia grande\n", "que ocupa diversas linhas.\n", "\n", "Tudo bem, nem tantas assim.\n", "\"\"\"" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Note como as mudanças de linha são representadas pelo caracter `\\n`, que é um caracter normal." ] }, { "cell_type": "code", "execution_count": 93, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "' Isto é uma cadeia grande\\nque ocupa diversas linhas.\\n\\nTudo bem, nem tantas assim.\\n'" ] }, "execution_count": 93, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cadeiagrande" ] }, { "cell_type": "code", "execution_count": 94, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "26" ] }, "execution_count": 94, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cadeiagrande.find('que')" ] }, { "cell_type": "code", "execution_count": 95, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "25" ] }, "execution_count": 95, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cadeiagrande.find('\\n')" ] } ], "metadata": { "kernelspec": { "display_name": "Python [default]", "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.5.2" }, "name": "Aula02.ipynb" }, "nbformat": 4, "nbformat_minor": 0 }