{
"metadata": {
"name": "Capitulo11_Biblioteca_padrao"
},
"nbformat": 3,
"nbformat_minor": 0,
"worksheets": [
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Python para Desenvolvedores](http://ricardoduarte.github.io/python-para-desenvolvedores/#conteudo)\n",
"===================================\n",
"2ª edi\u00e7\u00e3o, revisada e ampliada\n",
"-----------------------------------\n",
"\n",
"Cap\u00edtulo 11: Biblioteca padr\u00e3o\n",
"=============================\n",
"_____________________________\n",
"\u00c9 comum dizer que o Python vem com \u201cbaterias inclusas\u201d, em refer\u00eancia a vasta biblioteca de m\u00f3dulos e pacotes que \u00e9 distribu\u00edda com o interpretador.\n",
"\n",
"Alguns m\u00f3dulos importantes da biblioteca padr\u00e3o:\n",
"\n",
"+ Matem\u00e1tica: math, cmath, decimal e random.\n",
"+ Sistema: os, glob, shutils e subprocess.\n",
"+ Threads: threading.\n",
"+ Persist\u00eancia: pickle e cPickle.\n",
"+ XML: xml.dom, xml.sax e elementTree (a partir da vers\u00e3o 2.5).\n",
"+ Configura\u00e7\u00e3o: ConfigParser e optparse.\n",
"+ Tempo: time e datetime.\n",
"+ Outros: sys, logging, traceback, types e timeit.\n",
"\n",
"Matem\u00e1tica\n",
"----------\n",
"Al\u00e9m dos tipos num\u00e9ricos *builtins* do interpretador, na biblioteca padr\u00e3o do Python existem v\u00e1rios m\u00f3dulos dedicados a implementar outros tipos e opera\u00e7\u00f5es matem\u00e1ticas.\n",
"\n",
"O m\u00f3dulo *math* define fun\u00e7\u00f5es logar\u00edtmicas, de exponencia\u00e7\u00e3o, trigonom\u00e9tricas, hiperb\u00f3licas e convers\u00f5es angulares, entre outras. J\u00e1 o m\u00f3dulo *cmath*, implementa fun\u00e7\u00f5es similares, por\u00e9m feitas para processar n\u00fameros complexos.\n",
"\n",
"Exemplo:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# M\u00f3dulo para matem\u00e1tica\n",
"import math\n",
"\n",
"# M\u00f3dulo para matem\u00e1tica (de complexos)\n",
"import cmath\n",
"\n",
"# Complexos\n",
"for cpx in [3j, 1.5 + 1j, -2 - 2j]:\n",
"\n",
" # Convers\u00e3o para coordenadas polares\n",
" plr = cmath.polar(cpx)\n",
" print 'Complexo:', cpx\n",
" print 'Forma polar:', plr, '(em radianos)'\n",
" print 'Amplitude:', abs(cpx)\n",
" print '\u00c2ngulo:', math.degrees(plr[1]), '(graus)'"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Complexo: 3j\n",
"Forma polar: (3.0, 1.5707963267948966) (em radianos)\n",
"Amplitude: 3.0\n",
"\u00c2ngulo: 90.0 (graus)\n",
"Complexo: (1.5+1j)\n",
"Forma polar: (1.8027756377319946, 0.5880026035475675) (em radianos)\n",
"Amplitude: 1.80277563773\n",
"\u00c2ngulo: 33.690067526 (graus)\n",
"Complexo: (-2-2j)\n",
"Forma polar: (2.8284271247461903, -2.356194490192345) (em radianos)\n",
"Amplitude: 2.82842712475\n",
"\u00c2ngulo: -135.0 (graus)\n"
]
}
],
"prompt_number": 7
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"O m\u00f3dulo *random* traz fun\u00e7\u00f5es para a gera\u00e7\u00e3o de n\u00fameros aleat\u00f3rios.\n",
"\n",
"Exemplos:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import random\n",
"import string\n",
"\n",
"# Escolha uma letra\n",
"print random.choice(string.ascii_uppercase)\n",
"\n",
"# Escolha um n\u00famero de 1 a 10\n",
"print random.randrange(1, 11)\n",
"\n",
"# Escolha um float no intervalo de 0 a 1\n",
"print random.random()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"B\n",
"2\n",
"0.117017323204\n"
]
}
],
"prompt_number": 8
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Na biblioteca padr\u00e3o ainda existe o m\u00f3dulo *decimal*, que define opera\u00e7\u00f5es com n\u00fameros reais com precis\u00e3o fixa.\n",
"\n",
"Exemplo:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from decimal import Decimal\n",
"\n",
"t = 5.\n",
"for i in range(50):\n",
" t = t - 0.1\n",
"\n",
"print 'Float:', t\n",
"\n",
"t = Decimal('5.')\n",
"for i in range(50):\n",
" t = t - Decimal('0.1')\n",
"\n",
"print 'Decimal:', t"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Float: 1.02695629778e-15\n",
"Decimal: 0.0\n"
]
}
],
"prompt_number": 9
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Com este m\u00f3dulo, \u00e9 poss\u00edvel reduzir a introdu\u00e7\u00e3o de erros de arredondamento originados da aritm\u00e9tica de ponto flutuante.\n",
"\n",
"Na vers\u00e3o 2.6, tamb\u00e9m est\u00e1 dispon\u00edvel o m\u00f3dulo *fractions*, que trata de n\u00fameros racionais.\n",
"\n",
"Exemplo:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"from fractions import Fraction\n",
"\n",
"# Tr\u00eas fra\u00e7\u00f5es\n",
"f1 = Fraction('-2/3')\n",
"f2 = Fraction(3, 4)\n",
"f3 = Fraction('.25')\n",
"print \"Fraction('-2/3') =\", f1\n",
"print \"Fraction('3, 4') =\", f2\n",
"print \"Fraction('.25') =\", f3\n",
"\n",
"# Soma\n",
"print f1, '+', f2, '=', f1 + f2\n",
"print f2, '+', f3, '=', f2 + f3"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Fraction('-2/3') = -2/3\n",
"Fraction('3, 4') = 3/4\n",
"Fraction('.25') = 1/4\n",
"-2/3 + 3/4 = 1/12\n",
"3/4 + 1/4 = 1\n"
]
}
],
"prompt_number": 10
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As fra\u00e7\u00f5es podem ser inicializadas de v\u00e1rias formas: como *string*, como um par de inteiros ou como um n\u00famero real. O m\u00f3dulo tamb\u00e9m possui uma fun\u00e7\u00e3o chamada `gcd()`, que calcula o maior divisor comum (MDC) entre dois inteiros.\n",
"\n",
"Arquivos e I/O\n",
"--------------\n",
"Os arquivos no Python s\u00e3o representados por objetos do tipo *file*, que oferecem m\u00e9todos para diversas opera\u00e7\u00f5es de arquivos. Arquivos podem ser abertos para leitura ('r', que \u00e9 o default), grava\u00e7\u00e3o ('w') ou adi\u00e7\u00e3o ('a'), em modo texto ou bin\u00e1rio('b').\n",
"\n",
"Em Python:\n",
"\n",
"+ *sys.stdin* representa a entrada padr\u00e3o.\n",
"+ *sys.stdout* representa a sa\u00edda padr\u00e3o.\n",
"+ *sys.stderr* representa a sa\u00edda de erro padr\u00e3o.\n",
"\n",
"A entrada, sa\u00edda e erro padr\u00f5es s\u00e3o tratados pelo Python como arquivos abertos. A entrada em modo de leitura e os outros em modo de grava\u00e7\u00e3o.\n",
"\n",
"Exemplo de escrita:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import sys\n",
"\n",
"# Criando um objeto do tipo file\n",
"temp = open('temp.txt', 'w')\n",
"\n",
"# Escrevendo no arquivo\n",
"for i in range(20):\n",
" temp.write('%03d\\n' % i)\n",
"\n",
"# Fechando\n",
"temp.close()\n",
"\n",
"temp = open('temp.txt')\n",
"\n",
"# Escrevendo no terminal\n",
"for x in temp:\n",
" # Escrever em sys.stdout envia\n",
" # o texto para a sa\u00edda padr\u00e3o\n",
" sys.stdout.write(x)\n",
"\n",
"temp.close()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"000\n",
"001\n",
"002\n",
"003\n",
"004\n",
"005\n",
"006\n",
"007\n",
"008\n",
"009\n",
"010\n",
"011\n",
"012\n",
"013\n",
"014\n",
"015\n",
"016\n",
"017\n",
"018\n",
"019\n"
]
}
],
"prompt_number": 3
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A cada itera\u00e7\u00e3o no segundo la\u00e7o, o objeto retorna uma linha do arquivo de cada vez.\n",
"\n",
"Exemplo de leitura:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import sys\n",
"import os.path\n",
"\n",
"fn = 'teste.txt'\n",
"\n",
"if not os.path.exists(fn):\n",
" print 'Tente outra vez...'\n",
" sys.exit()\n",
"\n",
"# Numerando as linhas\n",
"for i, s in enumerate(open(fn)):\n",
" print i + 1, s,"
],
"language": "python",
"metadata": {},
"outputs": [
{
"ename": "SystemExit",
"evalue": "",
"output_type": "pyerr",
"traceback": [
"An exception has occurred, use %tb to see the full traceback.\n",
"\u001b[1;31mSystemExit\u001b[0m\n"
]
},
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Tente outra vez...\n"
]
},
{
"output_type": "stream",
"stream": "stderr",
"text": [
"To exit: use 'exit', 'quit', or Ctrl-D."
]
}
],
"prompt_number": 12
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\u00c9 poss\u00edvel ler todas as linhas com o m\u00e9todo `readlines()`:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# Imprime uma lista contendo linhas do arquivo\n",
"print open('temp.txt').readlines()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"['000\\n', '001\\n', '002\\n', '003\\n', '004\\n', '005\\n', '006\\n', '007\\n', '008\\n', '009\\n', '010\\n', '011\\n', '012\\n', '013\\n', '014\\n', '015\\n', '016\\n', '017\\n', '018\\n', '019\\n']\n"
]
}
],
"prompt_number": 4
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Os objetos do tipo arquivo tamb\u00e9m possuem um m\u00e9todo `seek()`, que permite ir para qualquer posi\u00e7\u00e3o no arquivo.\n",
"\n",
"Na vers\u00e3o 2.6, est\u00e1 dispon\u00edvel o m\u00f3dulo *io*, que implementa de forma separada as opera\u00e7\u00f5es de arquivo e as rotinas de manipula\u00e7\u00e3o de texto.\n",
"\n",
"Sistemas de arquivo\n",
"-------------------\n",
"Os sistemas operacionais modernos armazenam os arquivos em estruturas hier\u00e1rquicas chamadas sistemas de arquivo (*file systems*).\n",
"\n",
"V\u00e1rias funcionalidades relacionadas a sistemas de arquivo est\u00e3o implementadas no m\u00f3dulo *os.path*, tais como:\n",
"\n",
"+ `os.path.basename()`: retorna o componente final de um caminho.\n",
"+ `os.path.dirname()`: retorna um caminho sem o componente final.\n",
"+ `os.path.exists()`: retorna *True* se o caminho existe ou *False* em caso contr\u00e1rio.\n",
"+ `os.path.getsize()`: retorna o tamanho do arquivo em *bytes*.\n",
"\n",
"O *glob* \u00e9 outro m\u00f3dulo relacionado ao sistema de arquivo:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import os.path\n",
"import glob\n",
"\n",
"# Mostra uma lista de nomes de arquivos\n",
"# e seus respectivos tamanhos\n",
"for arq in sorted(glob.glob('*.py')):\n",
" print arq, os.path.getsize(arq)"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 2
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A fun\u00e7\u00e3o *glob.glob()* retorna uma lista com os nomes de arquivo que atendem ao crit\u00e9rio passado como par\u00e2metro, de forma semelhante ao comando `ls` dispon\u00edvel nos sistemas UNIX.\n",
"\n",
"Arquivos tempor\u00e1rios\n",
"--------------------\n",
"O m\u00f3dulo os implementa algumas fun\u00e7\u00f5es para facilitar a cria\u00e7\u00e3o de arquivos tempor\u00e1rios, liberando o desenvolvedor de algumas preocupa\u00e7\u00f5es, tais como:\n",
"\n",
"+ Evitar colis\u00f5es com nomes de arquivos que est\u00e3o em uso.\n",
"+ Identificar a \u00e1rea apropriada do sistema de arquivos para tempor\u00e1rios (que varia conforme o sistema operacional).\n",
"+ Expor a aplica\u00e7\u00e3o a riscos (a \u00e1rea de tempor\u00e1rios \u00e9 utilizada por outros processos).\n",
"\n",
"Exemplo:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import os\n",
"\n",
"texto = 'Teste'\n",
"# cria um arquivo tempor\u00e1rio\n",
"temp = os.tmpfile()\n",
"\n",
"# Escreve no arquivo tempor\u00e1rio\n",
"temp.write('Teste')\n",
"\n",
"# Volta para o inicio do arquivo\n",
"temp.seek(0)\n",
"\n",
"# Mostra o conte\u00fado do arquivo\n",
"print temp.read()\n",
"\n",
"# Fecha o arquivo\n",
"temp.close()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Teste\n"
]
}
],
"prompt_number": 3
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Existe tamb\u00e9m a fun\u00e7\u00e3o `tempnam()`, que retorna um nome v\u00e1lido para arquivo tempor\u00e1rio, incluindo um caminho que respeite as conven\u00e7\u00f5es do sistema operacional. Por\u00e9m, fica por conta do desenvolvedor garantir que a rotina seja usada de forma a n\u00e3o comprometer a seguran\u00e7a da aplica\u00e7\u00e3o.\n",
"\n",
"Arquivos compactados\n",
"--------------------\n",
"O Python possui m\u00f3dulos para trabalhar com v\u00e1rios formatos de arquivos compactados.\n",
"\n",
"Exemplo de grava\u00e7\u00e3o de um arquivo \u201c.zip\u201d:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\"\"\"\n",
"Gravando texto em um arquivo compactado\n",
"\"\"\"\n",
"\n",
"import zipfile\n",
"\n",
"texto = \"\"\"\n",
"***************************************\n",
"Esse \u00e9 o texto que ser\u00e1 compactado e...\n",
"... guardado dentro de um arquivo zip.\n",
"***************************************\n",
"\"\"\"\n",
"\n",
"# Cria um zip novo\n",
"zip = zipfile.ZipFile('arq.zip', 'w',\n",
" zipfile.ZIP_DEFLATED)\n",
"\n",
"# Escreve uma string no zip como se fosse um arquivo\n",
"zip.writestr('texto.txt', texto)\n",
"\n",
"# Fecha o zip\n",
"zip.close()"
],
"language": "python",
"metadata": {},
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Exemplo de leitura:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\"\"\"\n",
"Lendo um arquivo compactado\n",
"\"\"\"\n",
"\n",
"import zipfile\n",
"\n",
"# Abre o arquivo zip para leitura\n",
"zip = zipfile.ZipFile('arq.zip')\n",
"\n",
"# Pega a lista dos arquivos compactados\n",
"arqs = zip.namelist()\n",
"\n",
"for arq in arqs:\n",
" # Mostra o nome do arquivo\n",
" print 'Arquivo:', arq\n",
" # Pegando as informa\u00e7\u00f5es do arquivo\n",
" zipinfo = zip.getinfo(arq)\n",
" print 'Tamanho original:', zipinfo.file_size\n",
" print 'Tamanho comprimido:', zipinfo.compress_size\n",
"\n",
" # Mostra o conte\u00fado do arquivo\n",
" print zip.read(arq)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Arquivo: texto.txt\n",
"Tamanho original: 162\n",
"Tamanho comprimido: 85\n",
"\n",
"***************************************\n",
"Esse \u00e9 o texto que ser\u00e1 compactado e...\n",
"... guardado dentro de um arquivo zip.\n",
"***************************************\n",
"\n"
]
}
],
"prompt_number": 4
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"O Python tamb\u00e9m prov\u00ea m\u00f3dulos para os formatos gzip, bzip2 e tar, que s\u00e3o bastante utilizados em ambientes UNIX.\n",
"\n",
"Arquivo de dados\n",
"----------------\n",
"Na biblioteca padr\u00e3o, o Python tamb\u00e9m fornece um m\u00f3dulo para simplificar o processamento de arquivos no formato CSV (*Comma Separated Values*).\n",
"\n",
"No formato CSV, os dados s\u00e3o armazenados em forma de texto, separados por v\u00edrgula, um registro por linha.\n",
"\n",
"Exemplo de escrita:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import csv\n",
"\n",
"# Dados\n",
"dt = (('temperatura', 15.0, 'C', '10:40', '2006-12-31'),\n",
" ('peso', 42.5, 'kg', '10:45', '2006-12-31'))\n",
"\n",
"# A rotina de escrita recebe um objeto do tipo file\n",
"out = csv.writer(file('dt.csv', 'w'))\n",
"\n",
"# Escrevendo as tuplas no arquivo\n",
"out.writerows(dt)"
],
"language": "python",
"metadata": {},
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Exemplo de leitura:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import csv\n",
"\n",
"# A rotina de leitura recebe um objeto arquivo\n",
"dt = csv.reader(file('dt.csv'))\n",
"\n",
"# Para cada registro do arquivo, imprima\n",
"for reg in dt:\n",
" print reg"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"['temperatura', '15.0', 'C', '10:40', '2006-12-31']\n",
"['peso', '42.5', 'kg', '10:45', '2006-12-31']\n"
]
}
],
"prompt_number": 13
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"O formato CSV \u00e9 aceito pela maioria das planilhas e sistemas de banco de dados para importa\u00e7\u00e3o e exporta\u00e7\u00e3o de informa\u00e7\u00f5es.\n",
"\n",
"Sistema operacional\n",
"-------------------\n",
"Al\u00e9m do sistema de arquivos, os m\u00f3dulos da biblioteca padr\u00e3o tamb\u00e9m fornecem acesso a outros servi\u00e7os providos pelo sistema operacional.\n",
"\n",
"Exemplo:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import os\n",
"import sys\n",
"import platform\n",
"\n",
"def uid():\n",
" \"\"\"\n",
" uid() -> retorna a identifica\u00e7\u00e3o do usu\u00e1rio\n",
" corrente ou None se n\u00e3o for poss\u00edvel identificar\n",
" \"\"\"\n",
"\n",
" # Vari\u00e1veis de ambiente para cada\n",
" # sistema operacional\n",
" us = {'Windows': 'USERNAME',\n",
" 'Linux': 'USER'}\n",
"\n",
" u = us.get(platform.system())\n",
" return os.environ.get(u)\n",
"\n",
"print 'Usu\u00e1rio:', uid()\n",
"print 'plataforma:', platform.platform()\n",
"print 'Diret\u00f3rio corrente:', os.path.abspath(os.curdir)\n",
"exep, exef = os.path.split(sys.executable)\n",
"print 'Execut\u00e1vel:', exef\n",
"print 'Diret\u00f3rio do execut\u00e1vel:', exep"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Usu\u00e1rio: lslf\n",
"plataforma: Linux-3.8.0-26-generic-x86_64-with-Ubuntu-13.04-raring\n",
"Diret\u00f3rio corrente: /home/lslf/projetos/github/python-para-desenvolvedores/Capitulo11\n",
"Execut\u00e1vel: python\n",
"Diret\u00f3rio do execut\u00e1vel: /usr/bin\n"
]
}
],
"prompt_number": 5
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Exemplo de execu\u00e7\u00e3o de processo:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import sys\n",
"from subprocess import Popen, PIPE\n",
"\n",
"# ping\n",
"cmd = 'ping -c 1 '\n",
"# No Windows\n",
"if sys.platform == 'win32':\n",
" cmd = 'ping -n 1 '\n",
"\n",
"# Local s\u00f3 para testar\n",
"host = '127.0.0.1'\n",
"\n",
"# Comunica\u00e7\u00e3o com outro processo,\n",
"# um pipe com o stdout do comando\n",
"py = Popen(cmd + host, stdout=PIPE)\n",
"\n",
"# Mostra a sa\u00edda do comando\n",
"print py.stdout.read()"
],
"language": "python",
"metadata": {},
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"O m\u00f3dulo *subprocess* prov\u00ea uma forma gen\u00e9rica de execu\u00e7\u00e3o de processos, na fun\u00e7\u00e3o Popen(), que permite a comunica\u00e7\u00e3o com o processo atrav\u00e9s pipes do sistema operacional.\n",
"\n",
"Tempo\n",
"-----\n",
"O Python possui dois m\u00f3dulos para lidar com tempo:\n",
"\n",
"+ *time*: implementa fun\u00e7\u00f5es que permitem utilizar o tempo gerado pelo sistema.\n",
"+ *datetime*: implementa tipos de alto n\u00edvel para realizar opera\u00e7\u00f5es de data e hora.\n",
"\n",
"Exemplo com time:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import time\n",
"\n",
"# localtime() Retorna a data e hora local no formato\n",
"# de uma estrutura chamada struct_time, que \u00e9 uma\n",
"# cole\u00e7\u00e3o com os itens: ano, m\u00eas, dia, hora, minuto,\n",
"# segundo, dia da semana, dia do ano e hor\u00e1rio de ver\u00e3o\n",
"print time.localtime()\n",
"\n",
"# asctime() retorna a data e hora como string, conforme\n",
"# a configura\u00e7\u00e3o do sistema operacional\n",
"print time.asctime()\n",
"\n",
"# time() retorna o tempo do sistema em segundos\n",
"ts1 = time.time()\n",
"\n",
"# gmtime() converte segundos para struct_time\n",
"tt1 = time.gmtime(ts1)\n",
"print ts1, '->', tt1\n",
"\n",
"# Somando uma hora\n",
"tt2 = time.gmtime(ts1 + 3600.)\n",
"\n",
"# mktime() converte struct_time para segundos\n",
"ts2 = time.mktime(tt2)\n",
"print ts2, '->', tt2\n",
"\n",
"# clock() retorma o tempo desde quando o programa\n",
"# iniciou, em segundos\n",
"print 'O programa levou', time.clock(), \\\n",
" 'segundos at\u00e9 agora...'\n",
"\n",
"# Contando os segundos...\n",
"for i in xrange(5):\n",
"\n",
" # sleep() espera durante o n\u00famero de segundos\n",
" # especificados como par\u00e2metro\n",
" time.sleep(1)\n",
" print i + 1, 'segundo(s)'"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"time.struct_time(tm_year=2013, tm_mon=7, tm_mday=19, tm_hour=14, tm_min=36, tm_sec=13, tm_wday=4, tm_yday=200, tm_isdst=0)\n",
"Fri Jul 19 14:36:13 2013\n",
"1374255373.26 -> time.struct_time(tm_year=2013, tm_mon=7, tm_mday=19, tm_hour=17, tm_min=36, tm_sec=13, tm_wday=4, tm_yday=200, tm_isdst=0)\n",
"1374269773.0 -> time.struct_time(tm_year=2013, tm_mon=7, tm_mday=19, tm_hour=18, tm_min=36, tm_sec=13, tm_wday=4, tm_yday=200, tm_isdst=0)\n",
"O programa levou 0.48 segundos at\u00e9 agora...\n",
"1"
]
},
{
"output_type": "stream",
"stream": "stdout",
"text": [
" segundo(s)\n",
"2"
]
},
{
"output_type": "stream",
"stream": "stdout",
"text": [
" segundo(s)\n",
"3"
]
},
{
"output_type": "stream",
"stream": "stdout",
"text": [
" segundo(s)\n",
"4"
]
},
{
"output_type": "stream",
"stream": "stdout",
"text": [
" segundo(s)\n",
"5"
]
},
{
"output_type": "stream",
"stream": "stdout",
"text": [
" segundo(s)\n"
]
}
],
"prompt_number": 5
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Em *datetime*, est\u00e3o definidos quatro tipos para representar o tempo:\n",
"\n",
"+ *datetime*: data e hora.\n",
"+ *date*: apenas data.\n",
"+ *time*: apenas hora.\n",
"+ *timedelta*: diferen\u00e7a entre tempos.\n",
"\n",
"Exemplo:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import datetime\n",
"\n",
"# datetime() recebe como par\u00e2metros:\n",
"# ano, m\u00eas, dia, hora, minuto, segundo\n",
"# e retorna um objeto do tipo datetime\n",
"dt = datetime.datetime(2020, 12, 31, 23, 59, 59)\n",
"\n",
"# Objetos date e time podem ser criados\n",
"# a partir de um objeto datetime\n",
"data = dt.date()\n",
"hora = dt.time()\n",
"\n",
"# Quanto tempo falta para 31/12/2020\n",
"dd = dt - dt.today()\n",
"\n",
"print 'Data:', data\n",
"print 'Hora:', hora\n",
"print 'Quanto tempo falta para 31/12/2020:', \\\n",
" str(dd).replace('days', 'dias')"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Data: 2020-12-31\n",
"Hora: 23:59:59\n",
"Quanto tempo falta para 31/12/2020: 2722 dias, 9:23:31.736243\n"
]
}
],
"prompt_number": 6
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Os objetos dos tipos *date* e *datetime* retornam datas em formato ISO.\n",
"\n",
"Express\u00f5es regulares\n",
"--------------------\n",
"Express\u00e3o regular \u00e9 uma maneira de identificar padr\u00f5es em sequ\u00eancias de caracteres. No Python, o m\u00f3dulo *re* prov\u00ea um analisador sint\u00e1tico que permite o uso de tais express\u00f5es. Os padr\u00f5es definidos atrav\u00e9s de caracteres que tem significado especial para o analisador.\n",
"\n",
"Principais caracteres:\n",
"\n",
"+ Ponto (`.`): Em modo padr\u00e3o, significa qualquer caractere, menos o de nova linha.\n",
"+ Circunflexo (`^`): Em modo padr\u00e3o, significa inicio da string.\n",
"+ Cifr\u00e3o (`$`): Em modo padr\u00e3o, significa fim da string.\n",
"+ Contra-barra (`\\`): Caractere de escape, permite usar caracteres especiais como se fossem comuns.\n",
"+ Colchetes (`[]`): Qualquer caractere dos listados entre os colchetes.\n",
"+ Asterisco (`*`): Zero ou mais ocorr\u00eancias da express\u00e3o anterior.\n",
"+ Mais (`+`): Uma ou mais ocorr\u00eancias da express\u00e3o anterior.\n",
"+ Interroga\u00e7\u00e3o (`?`): Zero ou uma ocorr\u00eancia da express\u00e3o anterior.\n",
"+ Chaves (`{n}`): n ocorr\u00eancias da express\u00e3o anterior.\n",
"+ Barra vertical (`|`): \u201cou\u201d l\u00f3gico.\n",
"+ Parenteses (`()`): Delimitam um grupo de express\u00f5es.\n",
"+ `\\d`: D\u00edgito. Equivale a `[0-9]`.\n",
"+ `\\D`: N\u00e3o d\u00edgito. Equivale a `[^0-9]`.\n",
"+ `\\s`: Qualquer caractere de espa\u00e7amento (`[ \\t\\n\\r\\f\\v]`).\n",
"+ `\\S`: Qualquer caractere que n\u00e3o seja de espa\u00e7amento.(`[^ \\t\\n\\r\\f\\v]`).\n",
"+ `\\w`: Caractere alfanum\u00e9rico ou sublinhado (`[a-zA-Z0-9_]`).\n",
"+ `\\W`: Caractere que n\u00e3o seja alfanum\u00e9rico ou sublinhado (`[^a-zA-Z0-9_]`).\n",
"\n",
"Exemplos:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import re\n",
"\n",
"# Compilando a express\u00e3o regular\n",
"# Usando compile() a express\u00e3o regular fica compilada\n",
"# e pode ser usada mais de uma vez\n",
"rex = re.compile('\\w+')\n",
"\n",
"# Encontra todas as ocorr\u00eancias que atendam a express\u00e3o\n",
"bandas = 'Yes, Genesis & Camel'\n",
"print bandas, '->', rex.findall(bandas)\n",
"\n",
"# Identifica as ocorr\u00eancias de Bj\u00f6rk (e suas varia\u00e7\u00f5es)\n",
"bjork = re.compile('[Bb]j[\u00f6o]rk')\n",
"for m in ('Bj\u00f6rk', 'bj\u00f6rk', 'Biork', 'Bjork', 'bjork'):\n",
"\n",
" # match() localiza ocorr\u00eancias no inicio da string\n",
" # para localizar em qualquer parte da string, use search()\n",
" print m, '->', bool(bjork.match(m))\n",
"\n",
"# Substituindo texto\n",
"texto = 'A pr\u00f3xima faixa \u00e9 Stairway to Heaven'\n",
"print texto, '->', re. sub('[Ss]tairway [Tt]o [Hh]eaven',\n",
" 'The Rover', texto)\n",
"\n",
"# Dividindo texto\n",
"bandas = 'Tool, Porcupine Tree e NIN'\n",
"print bandas, '->', re.split(',?\\s+e?\\s+', bandas)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Yes, Genesis & Camel -> ['Yes', 'Genesis', 'Camel']\n",
"Bj\u00f6rk -> False\n",
"bj\u00f6rk -> False\n",
"Biork -> False\n",
"Bjork -> True\n",
"bjork -> True\n",
"A pr\u00f3xima faixa \u00e9 Stairway to Heaven -> A pr\u00f3xima faixa \u00e9 The Rover\n",
"Tool, Porcupine Tree e NIN -> ['Tool, Porcupine Tree', 'NIN']\n"
]
}
],
"prompt_number": 7
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"O comportamento das fun\u00e7\u00f5es desse m\u00f3dulo pode ser alterado por op\u00e7\u00f5es, para tratar as strings como *unicode*, por exemplo."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [],
"language": "python",
"metadata": {},
"outputs": [
{
"html": [
"\n",
""
],
"output_type": "pyout",
"prompt_number": 1,
"text": [
""
]
}
],
"prompt_number": 1
}
],
"metadata": {}
}
]
}