Rudson R.

Alves
Mestre em Física
Prof. na UVV
http://rra.etc.br
25/03/10
Curso de Python
2
Introdução Introdução
Esta apresentação é baseada no material:
Python na Prática: Um curso objetivo de programação
em Python de Christian Robottom Reis:
http://www.async.com.br/projects/python/pnp/
Tutorial Python de Guido van Rossum criador do !ython
3
Cronograma Cronograma
" #ue é Python
!or #ue Python
Python $%sico
Estruturas de Controle
E&ceç'es
(unç'es
Escopo de )ari%veis
(unç'es !ré*de+inidas
Docstrings
,anipulação de -r#uivos
"rientação a "bjetos
.mportando ,/dulos
4
#include <iostream>
using namespace std;
int main ()
{
cout << "Hello World! \n";
return 0;
}
O que é Python: Linguagem interpretada
Classi+icação das lin0ua0ens:
compilada
interpretada
Compiladas:
Fortran C C !isual
"asic ...
$ gcc hello.c -o hello
$ ./hello
Hello World
5
O que é Python: Linguagem interpretada
Interpretadas:
Python Perl "asic tradicional #hell #cript ...
$ python hello.py
Hello World
6
O que é Python: Tipagem dinâmica
Python possui o #ue se chama de tipagem dinâmica ou
seja a tipa0em pode mudar a cada nova entrada de
dados em uma vari%vel.
>>> a = 1
>>> type(a)
<type 'int'>
>>> a = 'abacaxi'
>>> type(a)
<type 'str'>
>>> a = 1.
>>> type(a)
<type '!loat'>
- tipa0em din1mica redu2 a
#uantidade de tempo de
planejamento prévio e é um
mecanismos importante para
0arantir +le&ibilidade e
simplicidade das +unç'es
Python.
7
O que é Python: Delimitação por indentação
Em Python não e&iste um delimitador espec3+ico para
blocos de c/di0o. - delimitação é +eita pela indentação:
print "# $alor de a % "
i! a == &
print "'ero(
a = "'ero(
else&
print a
exit()
.sto 0arante #ue o c/di0o seja sempre le03vel.
8
O que é Python: Tipos de alto n!el
-lém dos tipos b%sicos 4inteiro ponto +lutuante ...5 o
Python possui ainda outros tipos de mais alto n3vel:
Listas "#: como um vetor em outras lin0ua0ens lista é um
conjunto de valores acessados por um 3ndice numérico
inteiro iniciado por 2ero. Em Python uma lista ainda
podem arma2enar todo tipo de valores.
>>> a = )"*(+ ",(+ "-(+ 1+ .+ /+ 0.1
>>> print a)1
*
>>> a)21
0.
>>> a
)'*'+ ','+ '-'+ 1+ .+ /+ 0.1
>>> type(a)21)
<type '!loat'>

O que é Python: Tipos de alto n!el
Tuplas: Tuplas são se#67ncias de elementos arbitr%rios
como listas com a e&ceção de #ue são imut$!eis.
Strings: string em Python é uma se#67ncia imut%vel
alocada dinamicamente e sem restrição de tamanho.
Dicion$rios: dicion%rios são se#67ncias #ue podem utili2ar
3ndices 4imut%veis5 de tipos variados. conhecidos como
arrays associativos.
%rqui!o: Python possui um tipo pré*de+inido para manipular
ar#uivos. Este tipo permite #ue o ar#uivo seja +acilmente
lido alterado e escrito.
Classess e Instâncias: classes são estruturas especiais #ue
servem para apoiar pro0ramação orientada a objetos.
.nst1ncias são e&press'es concretas destas classes.
!"
O que é Python: Orientação a O&'etos
Em Python todos os dados podem ser considerados objetos. !or
e&emplo toda string possui o método upper:
>>> a = 'laran3a'
>>> a.4pper()
'5*6*78*'
>>> 'ca9aleao'.4pper()
'-*:*5;*#'
8a mesma +orma inteiros ponto
+lutuante tuplas dicion%rios
listas ... são todos objetos. "
comando dir4vari%vel5 mostra os
métodos dispon3veis.
>>> dir(<1=<) > 9%todos da string constante "1=(
)'??add??'+ '??class??'+ '??contains??'+ '??delattr??'+ '??doc??'+
'??e@??'+ '??ge??'+ '??getattrib4te??'+ '??getite9??'+
'??getneAargs??'+ '??getslice??'+ '??gt??'+ '??hash??'+ '??init??'+
'??le??'+ '??len??'+ '??lt??'+ '??9od??'+ '??94l??'+ '??ne??'+
'??neA??'+ '??red4ce??'+ '??red4ce?ex??'+ '??repr??'+ '??r9od??'+
'??r94l??'+ '??setattr??'+ '??str??'+ 'capitali'e'+ 'center'+ 'co4nt'+
'decode'+ 'encode'+ 'endsAith'+ 'expandtabs'+ '!ind'+ 'index'+
'isaln49'+ 'isalpha'+ 'isdigit'+ 'isloAer'+ 'isspace'+ 'istitle'+
'is4pper'+ '3oin'+ 'l34st'+ 'loAer'+ 'lstrip'+ 'partition'+ 'replace'+
'r!ind'+ 'rindex'+ 'r34st'+ 'rpartition'+ 'rsplit'+ 'rstrip'+ 'split'+
'splitlines'+ 'startsAith'+ 'strip'+ 'sAapcase'+ 'title'+ 'translate'+
'4pper'+ ''!ill'1
!!
Por que Python
Como e&iste muitas lin0ua0ens di+erentes por #ue
aprender Python9
"s conceitos +undamentais da lin0ua0em são simples de
entender:
- sinta&e do Python é clara e +%cil de aprender:
"s tipos pré*de+inidos em Python são poderosos e simples
de usar:
" interpretador Python permite aprender e testar
rapidamente trechos de c/di0o
Python é e&pressivo com abstraç'es de alto n3vel ;<
c/di0o curto e r%pido desenvolvimento:
!2
Por que Python
Python permite #ue o pro0rama e&ecute em m=ltiplas
plata+ormas sem alteraç'es:
!ossui tratamento de e&ceç'es 4moderno mecanismo de
tratamento de erros5:
Python é livre.
> +%cil escrever e&tens'es para Python em C e C
#uando +or necess%rio desempenho m%&imo ou #uando
necessitar de inter+acear al0uma +erramenta nestas
lin0ua0ens:
E&iste suporte para uma diversidade 0rande de
bibliotecas 4$t %T& 'eb db ...5:
Python é orientado a objetos 4incluindo herança
m=ltiplas5.
!3
Python ($sico
?esta seção ser% abordado aspectos essenciais da
lin0ua0em como tipos operadores e estruturas.
Coment%rios em Python se0uem a mesma estrutura dos
coment%rios em bash script:
>>> > isto 49 co9entBrio
!4
Python ($sico: O interpretador Python
" Python permite e&ecutar comandos diretamente através
de seu interpretador ou uma lista de comandos
arma2enada em um ar#uivo 4pro0rama em Python5
!ara chamar o interpretador Python apenas di0ite @pythonA
no prompt do shell:
$ python
Cython ..=.1 (r.=1&=0D2/+ Eep 0 .F+ 1G&&1G)
)H-- 0.1..1 on lin4x.
Iype <help<+ <copyright<+ <credits< or <license< !or
9ore in!or9ation.
>>>
- mensa0em #ue ir% aparecer deve ser bem parecida com a
mensa0em acima a menos das vers'es do Python e do %CC.
@>>>A e @. . .A são os prompts do Python.
!5
Python ($sico: O interpretador Python
,antendo a tradição vamos +a2er o ()ello *orld+
>>> a = "Hello(
>>> b = "World(
>>> print a+ b
Hello World
"bserve #ue o comando print insere um espaço
automaticamente entre as duas vari%veis. " mesmo poderia
ter sido +eito com os comandos abai&o:
>>> a = "Hello World(
>>> print a
Hello World
>>> print "Hello World(
Hello World
>>> "Hello World(
'Hello World'
!6
Python ($sico: Criando um programa Python
" mesmo pode ser +eito através da criação de um m/dulo
4como são chamados os pro0ramas em Python5. Em um
editor de sua escolha escreva:
> Cri9eiro progra9a Cython& hello.py
a = "Hello(
b = "World(
print a+ b
Balve o pro0rama com o nome hello,py e e&ecute*o
chamando o interpretador:
$ python hello.py
Hello World
$ ?
!7
Python ($sico: Criando um programa Python
" interpretador pode ser chamado automaticamente pelo
sistema. !ara isto acrescente o path dele no in3cio pro0rama
e o torne e&ecut%vel:
>J/4sr/bin/python
> Cri9eiro progra9a Cython& hello.py
a = "Hello(
b = "World(
print a+ b
$ ch9od Kx hello.py
$ ./hello.py
Hello World
$ ?
Be tiver d=vidas #uando a locali2ação do interpretador
Python use o comando: which python
!8
Python ($sico: Criando um programa Python
Cma versão em portu0u7s pode tra2er al0umas surpresas:
>J/4sr/bin/python
> Cri9eiro progra9a Cython& ola.py
a = "#lB(
b = ":4ndo(
print a+ b
$ ./ola.py
Lile <./ola.py<+ line /
Eyntax;rror& 7on-*E-MM character 'Nxe1' in !ile
./ola.py on line /+ b4t no encoding declaredO see
http&//AAA.python.org/peps/pep-.2/.ht9l !or details
$ ?
.sto ocorre por conta do acento no D"l%D passado E vari%vel
a. !ara adicionar suporte aos caracteres acentuados
adicione a linha abai&o ao in3cio do seu pro0rama:
#-*- coding: iso-8859-1 -*-
!
Python ($sico: Criando um programa Python
" pro0rama deve +icar assim:
>J/4sr/bin/python
>-P- coding& iso-DD=G-1 -P-
> Cri9eiro progra9a Cython& ola.py
a = "#lB(
b = ":4ndo(
print a+ b
$ ./ola.py
#lB :4ndo
$ ?
2"
Python ($sico: Tipos numéricos
" Python possui al0uns tipos numéricos pré*de+inidos:
inteiros 4int5 ponto +lutuante 4-loat5 booleanos 4bool5 e
comple&os 4comple.5. Este tipos suportam as operaç'es
matem%ticas b%sicas.
>>> a+ b = 1+ ..= > atrib4i 1 a "a( e ..= a "b(
>>> > 49 inteiro e 49 ponto !l4t4ante
>>> c = Ir4e > booleano
>>> ' = / K 03 > co9plexo
>>>
>>> a K b > res4ltado e9 ponto !l4t4ante
/.=
>>> int(a K b) > res4ltado inteiro
/
>>> b P ' > res4ltado co9plexo
(F.=K13)
>>> type(') > 9ostra a tipage9 da $ariB$el
<type 'co9plex'>
2!
Python ($sico: Tipos numéricos
Python também trabalha com base octal 4FGG5 e
he&adecimal 4F&GG5
>>> a = 1
>>> a
D
>>> xLL
.==
Cm n=mero real deve possuir um ponto @.@
>>> =/. > res4ltado inteiro
.
>>> =/.. > res4ltado ponto !l4t4ante
..=
>>> =P..1/ > res4ltado ponto !l4t4ante
1.20GGGGGGGGGGGG
Especial atenção aos n=meros como H.IJ cujo a
representação decimal no computadores é limitada.
22
Python ($sico: Tipos numéricos
Python como uma calculadora e mais operaç'es:
>>> .=//. > res4ltado ponto !l4t4ante
D.///////////////G
>>> ?K. > adiciona .. ao res4ltado anterior
1.//////////////0
>>> type(?) > $eri!ica o tipo do res4ltado ant.
<type '!loat'>
Kipa0em din1mica:
>>> a = /
>>> type(a)
<type 'int'>
>>> a = /.101=
>>> type(a)
<type '!loat'>
>>> a = "isto e' 49a string(
>>> type(a)
<type 'str'>
>>> a = / K 03
>>> type(a)
<type 'co9plex'>
>>> a.real
/.
>>> a.i9ag
0.
>>> abs(a)
=.
23
Python ($sico: Listas "#
Lista é uma se#67ncia de valores inde&adas por um inteiro.
Cma lista pode conter #ual#uer tipo de valor incluindo
valores de tipos mistos:
>>> n49eros = )1+ .+ /1
>>> no9es = ) 'alberto'+ 'carlos'+ 'si9one' 1
>>> 9isto = ) 1+.+/.+'alberto'+'carlos'+/.=+'si9one' 1
>>> listas = ) n49eros+ no9es+ 9isto 1
>>> print listas
))1+ .+ /1+ )'alberto'+ 'carlos'+ 'si9one'1+ )1+ .+ /.+
'alberto'+ 'carlos'+ /.=+ 'si9one'11
"s elementos da lista podem ser acessados por meio de
3ndices #ue vão de F até o comprimento da lista*I:
>>> len(n49eros)-1
.
>>> n49eros)1
1
>>> n49eros).1
/
>>> listas)1
)1+ .+ /1
>>> listas)11
)'alberto'+ 'carlos'+ 'si9one'1
>>> listas)11)11
'carlos'
24
Python ($sico: Listas "# ) seleç*es
Python também permite acessar uma lista de tr%s para
+rente identi+icando o 3ndice por um sinal de menos:
>>> n49eros)-11 > Qlti9o $alor
/
>>> n49eros)-.1 > o penQlti9o $alor
.
(atias ou slices de uma lista podem ser 0eradas +acilmente
com o @:A
>>> n = ) 1+ .+ /+ 0+ =+ 2+ F+ D+ G+ 1
>>> n).&01
)/+ 01
>>> n)2&1
) F+ D+ G+ 1
>>> n)-=&-11
)2+ F+ D+ G1
25
Python ($sico: Listas "# ) métodos
Como +oi dito anteriormente em Python tudo é um objeto.
)amos ver al0uns métodos de uma lista:
>>> n49eros.append()
>>> n49eros
)1+ .+ /+ 1
>>> n49eros.sort()
>>> n49eros
)+ 1+ .+ /1
>>>
!ara conhecer todos os métodos de um objeto utili2e o
comando dir/objeto0
>>> dir(n49eros)
)'??add??'+ '??class??'+ '??contains??'+ '??delattr??'+
'??delite9??'+ '??delslice??'+ '??doc??'+ '??e@??'+ '??ge??'+
'??getattrib4te??'+ '??getite9??'+ '??getslice??'+ '??gt??'+
'??hash??'+ '??iadd??'+ ... + 'append'+ 'co4nt'+ 'extend'+
'index'+ 'insert'+ 'pop'+ 're9o$e'+ 're$erse'+ 'sort'1
>>> n49eros.re$erse()
>>> n49eros
)/+ .+ 1+ 1
>>> n49eros.pop()

>>> n49eros
)/+ .+ 11
26
Python ($sico: Listas "# ) métodos
"utros métodos de listas:
>>> n = ) 1+ .+ /1
>>> 9 = ) 0+ =+ 21
>>> n.extend(9)O n
)1+ .+ /+ 0+ =+ 21
>>> n.insert(.+'galo')O n
)1+ .+ 'galo'+ /+ 0+ =+ 21
>>> n.re9o$e(0)O n
)1+ .+ 'galo'+ /+ =+ 21
>>> n.append('barco')O n
)1+ .+ 'galo'+ /+ =+ 2+ 'barco'1
>>> n.pop()O n.pop(.)
'barco'
'galo'
>>> n.index(=)
/
>>> n.append(=)
>>> n.extend(9)
>>> n
)1+ .+ /+ =+ =+ 0+ =+ 21
>>> n.co4nt(=)
/
>>> n.sort()O n
)1+ .+ /+ 0+ =+ =+ =+ 21
>>> n.re$erse()O n
)2+ =+ =+ =+ 0+ /+ .+ 11
27
Python ($sico: Tuplas +,
Tuplas são como listas um conjunto de elementos
acess3veis por um 3ndice inteiro.
>>> n = )1+.+/1
>>> n
)1+ .+ /1
>>> n)1='laran3a'O n
)'laran3a'+ .+ /1
Lista
>>> t)1='laran3a'
IracebacR (9ost recent call last)&
Lile <<stdin><+ line 1+ in <9od4le>
Iype;rror& 't4ple' ob3ect does not s4pport ite9
assign9ent
?o entanto tuplas são imut%veis
>>> t = (1+.+/)
>>> t
(1+ .+ /)
>>> t)1
1
Kupla
28
Python ($sico: -trings
#tring é uma se#67ncia imut%vel com o prop/sito especial
de arma2enar cadeias de caracteres.
>>> a = 'abcde!ghi3'
>>> a)1
'a'
>>> a)-11
'3'
>>> a)2&1
'ghi3'
>>> a)11=','
IracebacR (9ost recent call last)&
Lile <<stdin><+ line 1+ in <9od4le>
Iype;rror& 'str' ob3ect does not s4pport ite9
assign9ent
)oc7 não conse0ue alterar um elemento da string
>>> len(a)
1
>>> a.??len??()
1
>>> a.4pper()
'*,-S;LHHM8'
2
Python ($sico: -trings . algumas operaç*es
Colar strin0s 4M5
>>> b = 'Rl9nop@rst'
>>> a K b
'abcde!ghi3Rl9nop@rst'
>>> print a+ b
abcde!ghi3 Rl9nop@rst
>>> c = (a K b).4pper()
>>> print c
*,-S;LHHM8T5:7#CU6EI
3"
Python ($sico: Dicion$rios /0
Cm dicion%rio é uma coleção de elementos onde é poss3vel
utili2ar um 3ndice de #ual#uer tipo imut%vel.
>>> tele!ones = V "pedro( & //.1.1.1+ "patricia( &
/0..+ "!ernanda( & DD....GD W
>>> print tele!ones)"!ernanda(1
DD....GD
-l0uns métodos de dicion%rios:
>>> tele!ones.Reys()
)'pedro'+ 'patricia'+ '!ernanda'1
>>> tele!ones.$al4es()
)//.1.1.1+ /0..+ DD....GD1
>>> tele!ones.ite9s()
)('pedro'+ //.1.1.1)+ ('patricia'+ /0..)+
('!ernanda'+ DD....GD)1
>>> tele!ones.has?Rey('alberto')
Lalse
3!
Python ($sico: Operadores ) aritméticos
>>> F K / > adiXYo
1
>>> F Z / > s4btraXYo
0
>>> D [ / > resto da di$isYo
.
>>> D / / > di$isYo inteira
.
>>> D / /. > di$isYo e9 ponto !l4t4ante
..222222222222222=
>>> D P / > prod4to
.0
>>> D PP . > exponenciaXYo
20
32
Python ($sico: Operadores ) aritméticos
>>> a = 'bits'
>>> a P .
'bitsbits'
>>> print '20 ' K a
20 bits
>>> a = )=+ 2+ F+ D1
>>> b = )G+ 11
>>> print b P .
)G+ 1+ G+ 11
>>> print a K b
)=+ 2+ F+ D+ G+ 11
>>> a = (.+ /+ 0)
>>> print a K (=+ 2)
(.+ /+ 0+ =+ 2)
#trings Listas
Tuplas
33
Python ($sico: Operadores ) &its
>>> a = x1L
>>> b = x1
>>> print a+ b
/1+ 1
>>> a \ b > e
1
>>> a ] b > o4
/1
>>> b << 0 > 0 desloca9entos para a es@4erda
12
>>> a >> 0 > 0 desloca9entos para a direita
1
>>> ^a > in$ersYo e9 co9ple9ento de .
-/.
Cadeias de bits
34
Python ($sico: %tri&uição e condicionais
>>> a = 1
>>> a K= 1
>>> print a
.
>>> a P= 1
>>> print a
.
>>> a /= .
>>> print a
1
>>> a+ b = /+ =
>>> a+ b = b+ aKb
>>> print a+ b
= D
>>> . == 0
Lalse
>>> . J= 0
Ir4e
>>> . > 0
Lalse
>>> . < 0
Ir4e
>>> / <= a
Ir4e
>>> a+ b = =+ /
>>> c = a i! a > b else b
>>> print c
=
-tribuição condicionada *
Python H.N
- =ltima atribuição é o mesmo
#ue +a2er:
<<< b ; aMb
<<< a ; b
Condicionais: "ooleano
35
Python ($sico: Com&inação de operadores
>>> a+ b = =+ /O a+ b
(=+ /)
>>> < a < b > a$aliaXYo % !eita da es@4erda
Lalse
>>> < a > b > para a direita
Ir4e
>>> no9e = 'pedro'
>>> idade = .=
>>> no9e == 'pedro' and idade == .=
Ir4e
>>> len(no9e) < 1 and idade > /
Lalse
>>> len(no9e) < 1 or idade > /
Ir4e
,ais operadores...
36
Python ($sico: Com&inação de operadores
>>> pedro?age = 1=
>>> 3ose?age = .
>>> ("Cedro(+ "8ose() ) pedro?age > 3ose?age 1
'Cedro'
>>> pedro?age = .=
>>> ("Cedro(+ "8ose() ) pedro?age > 3ose?age 1
'8ose'
,ais uma condicional......
( 'string?1'+ 'string?.' ) ) condiXYo 1
Be a condição +or:
verdadeira: Dstrin0OHD
+alsa: Dstrin0OID
> e9 49 progra9a pygtR Z para testar 49 Ioggle,4tton&
print <[s Aas toggled [s< [ (data+ (<#LL<+ <#7<))Aidget.get?acti$e()1)
37
Python ($sico: Operadores . 1
>>> print "Nn7o9e& [s( [ "6oberta(
7o9e& 6oberta
>>> a = "Iotal de itens& [d(
>>> b = "-4sto& [=..!(
>>> print a [ 1O print b [ .=.D/
Iotal de itens& 1
-4sto& ./.D/
>>> print <Nn-liente& [s+ _alor& [=..!< [ (<*lberto<+
.=.0=)
-liente& *lberto+ _alor& .=.0=
Bubstituição em strings: operador P
38
2struturas de Controle: i3
i! condiXYo&
> co9andos
...
eli! condiXYo&
> co9andos
...
else&
> co9andos
...
- estrutura condicional i- usa a sinta&e abai&o:
"bserve #ue #uem
delimita o bloco é a
indentação.
>>> a = =O b = D
>>> i! a > b&
... print "a % 9aior @4e b(
... c = "9aior(
... eli! a == b&
... print "a % ig4al a b(
... c = "ig4al(
... else&
... print "a % 9enor @4e b(
... c = "9enor(
...
a < b
>>> print a+c+b
= 9enor D
3
2struturas de Controle: 3or
!or $ariB$el in se@`ancia&
> co9andos
...
" laço +or do Python é semelhante ao +or do bash. Ele
percorre uma se#67ncia de elementos:
>>> lista = ) "pedra(+ 1.+ =0.=2+ / K =3 1
>>> !or ite9 in lista&
... print ite9
pedra
1.
=0.=2
(/K=3)
>>> !or i in range(1+=)&
... print i+
1 . / 0
4"
2struturas de Controle: 3or
>>> dict = V"batata(& =+ "abbbora(& 1.+ "cebola(& DW
>>> !or e in dict.Reys()&
... print "Mte9& [Ds Ceso& [Ds( [ (e+ dict)e1)
...
Mte9& batata Ceso& =
Mte9& abbbora Ceso& 1.
Mte9& cebola Ceso& D
>>> ani9ais = )"gato(+ "3ag4atirica(+ "sala9andra(+ "ran(1
>>> !or a in ani9ais&
... print "[1.s& [/d( [ ( a+ len(a))
...
gato& 0
3ag4atirica& 11
sala9andra& 1
ran& /
4!
2struturas de Controle: 3or
>>> $ar = ).+ 0+ =+ 2+ F+ -/+ 0+ D+ /1
>>> !or $ in $ar&
... i! $ < &
... print "_alor negati$o encontrado& [d( [ i
... breaR
... else&
... print "7enh49 negati$o encontrado(
...
_alor negati$o encontrado& -/
" laço +or ainda aceita as instruç'es continue e break. Bua
sinta&e completa tem a +orma:
!or $ariB$el in se@`ancia&
> bloco de co9andos
...
else&
> bloco de co9andos na a4sancia de 49 breaR
...
42
2struturas de Controle: 3or
>>> !or n in range(.+ /)&
... !or x in range(.+ n)&
... i! n [ x == &
... breaR
... else&
... > loop !ell thro4gh Aitho4t !inding a !actor
... print <[.d % 49 nQ9ero pri9o< [ n
...
. % 49 nQ9ero pri9o
/ % 49 nQ9ero pri9o
= % 49 nQ9ero pri9o
F % 49 nQ9ero pri9o
11 % 49 nQ9ero pri9o
1/ % 49 nQ9ero pri9o
1F % 49 nQ9ero pri9o
1G % 49 nQ9ero pri9o
./ % 49 nQ9ero pri9o
.G % 49 nQ9ero pri9o
?=meros primos menores #ue JF:
43
2struturas de Controle: 4hile
Ahile condiXYo&
> bloco de co9andos
...
else&
> bloco de co9andos exec4tados na a4sancia de 49 breaR
...
" laço 'hile é =til #uando se é necess%rio +a2er um teste a
cada interação do laço. -ssim como o -or1 aceita as
instruç'es continue e break. Bua sinta&e completa tem a
+orma:
>>> 9 = / P 1GO n = = P 1/
>>> co4nt =
>>> Ahile 9 < n&
... 9 = n / .=
... n = 9 / .=
... co4nt K= 1
...
>>> print "Lora9 [d ineraXces( [ co4nt
Lora9 =1 ineraXces
44
2struturas de Controle: 4hile
>>> a+ b+ n = + 1+ . > o 9es9o @4e& a = O b = 1O c = .
>>> !ib=<<
>>> Ahile b < n&
... !ib = !ib K " K ( K str(b)
... a+ b = b+ aKb > a = bO b = a K b
...
>>> print "* s%rie de Libonacci at% [d+ %&Nn[s( [ ( n+ !ib)
* s%rie de Libonacci at% .+ %&
1 1 . / = D 1/
Bérie de (ibonacci até HF:
45
25ceç*es
>>> a = )1+ .+ /1
>>> print a)=1
IracebacR (9ost recent call last)&
Lile <<stdin><+ line 1+ in <9od4le>
Mndex;rror& list index o4t o! range
Com os laços -or e 'hile e a condicionais i-s todas as
necessidades de controle em um pro0rama podem ser
implementadas. ,as #uando al0o inesperado ocorre Python
o+erece uma +orma adicional de controlar o +lu&o de
e&ecução: a e5ceção
- primeira linha anuncia #ue ocorreu um traceback. -
se0unda linha indica a linha de c/di0o e o ar#uivo onde o
erro ocorreu 4stdin Q entrada padrão modo interativo5. ?a
terceira linha indica o tipo de e&eção levantada *
IndexError.
46
25ceç*es: Tratando e5ceç*es
try&
> co9andos @4e pode9 gerar a exceXYo
...
except tipo?exceXYo )+ $ariB$el1&
> co9andos a sere9 exec4tados para a exceXYo gerada
...
- sinta&e para tratamento de e&ceç'es é apresentada
abai&o:
- linha except também pode conter uma tupla com diversas
e&ceç'es:
except (tipo?exceXYo?1+ tipo?exceXYo?.+ ...) )+ $ariB$el1&
> co9andos a sere9 exec4tados para a exceXYo gerada
...
47
25ceç*es: Tratando e5ceç*es
- e&ceção anterior poderia ser tratada da +orma:
>>> a = )1+ .+ /1
>>> try&
... print a)=1
... except Mndex;rror&
... print "Ientati$a de acessar 49 dndice inexistente.(
...
Ientati$a de acessar 49 dndice inexistente.
>>> a = <tolo<
>>> print a K 1
IracebacR (9ost recent call last)&
Lile <<stdin><+ line 1+ in <9od4le>
Iype;rror& cannot concatenate 'str' and 'int' ob3ects
>>> try&
... print a K 1
... except Iype;rror&
... print "7Yo pode so9ar 49a string a 49 inteiro.(
...
7Yo pode so9ar 49a string a 49 inteiro.
"utro e&emplo:
48
6unç*es
Binta&e 0eral de uma +unção:
de! no9e?!4nXYo(arg?1+ arg?.+ ...+ arg?n)&
> cbdigo da !4nXYo
...
)ret4rn $alor?de?retorno1
>>> de! !ibonacci(n)&
... a+ b = + 1
... Ahile b < n&
... print b+
... a+ b = b+ aKb
...
>>> !ibonacci(1)
1 1 . / = D 1/ .1 /0 == DG
" retorno é opcional. Cma +unção sem retorno pode ser
encarada como um procedimento.
4
6unç*es
>>> de! i9pri9e?cardapio(pratos)&
... "Crocedi9ento para i9pressao do cardapio(
... print "-ardapio do diaNn(
... !or p in pratos&
... i9pri9e?prato(p)
... print "NnIotal de pratos& [d( [ len(pratos)
...
>>> de! i9pri9e?prato(p)&
... "Crocedi9ento para i9pressao do prato(
... print "[.s ........ [2..!( [ (p)"no9e(1+ p)"preco(1)
>>>
>>> p1 = V"no9e( & "*rro' co9 brocolis(+ "preco( & G.GW
>>> p. = V"no9e( & "Eopa de leg49es(+ "preco( & D.FW
>>> p/ = V"no9e( & "5entilhas(+ "preco( & F.DW
>>>
>>> lista?pratos = )p1+ p.+ p/1
"bserve #ue a primeira linha em cada +unção 4procedimento5 é
apenas descritiva não sendo e&ecutada pelo interpretador. Esta
linha é chamada de docstring uma documentação para a +unção.
5"
6unç*es
>>> i9pri9e?cardapio(lista?pratos)
-ardapio do dia
*rro' co9 brocolis ........ G.G
Eopa de leg49es ........ D.F
5entilhas ........ F.D
Iotal de pratos& /
>>>
>>> i9pri9e?cardapio.??doc??
'Crocedi9ento para i9pressao do cardapio'
>>> i9pri9e?prato.??doc??
'Crocedi9ento para i9pressao do prato'
>>> de! !ibonacci(n)&
... a+ b+ ! = + 1+ "(
... Ahile b < n&
... a+ b+ ! = b+ aKb+ !Kstr(b)K( "
... ret4rn !
(ibonacci com retorno
5!
6unç*es: argumento com !alor padrão
>>> de! aplicar?94lta($alor+ taxa=.1=)&
... ret4rn $alorP(1. K taxa)
...
>>> print "_alor a pagar& [=..!( [ aplicar?94lta(1)
11=.
>>> print "_alor a pagar& [=..!( [ aplicar?94lta(1+ ..=)
1.=.
> poss3vel de+inir valores padr'es para os ar0umentos de
entrada:
?ão utili2e como valor padrão listas dicion%rios ou outros
valores mut%veis. " resultado alcançado pode não ser o
desejado.
52
6unç*es: argumento com !alor padrão
>>> !ro9 9ath i9port s@rt
>>> de! segra4(a+ b = .+ c = .)&
... delta = bPP. - 0PaPc
... i! delta > &
... r1 = (-b K s@rt(delta))/(.Pa)
... r. = (-b - s@rt(delta))/(.Pa)
... else&
... r1 = co9plex(-b/(.Pa)+ s@rt(-delta)/(.Pa))
... r. = co9plex(-b/(.Pa)+ -s@rt(-delta)/(.Pa))
... ret4rn ( r1+ r. )
...
)eja outro e&emplo:
>>> segra4(.)
(.+ -.)
>>> segra4(.+ 0)
(.+ -..)
>>> segra4(.+ =+ /)
(-1.+ -1.=)
>>> segra4(.+ c = .)
(13+ -13)
>>> segra4(a=.)
(.+ -.)
>>> segra4(b=0+ a=.)
(.+ -..)
>>> segra4(c=/+ a=.+ b==)
(-1.+ -1.=)
>>> segra4(c=.+ a=.)
(13+ -13)
53
6unç*es: argumento com !alor padrão
Esta +unção também
poderia ser chamada nas
+ormas:
>>> segra4(a=0)
(.+ -.)
>>> segra4(b=.+ c=0)
IracebacR (9ost recent call last)&
Lile <<stdin><+ line 1+ in <9od4le>
Iype;rror& segra4() taRes at least 1 non-ReyAord arg49ent (
gi$en)
>>> segra4(a=.)
(.+ -.)
>>> segra4(b=0+ a=.)
(.+ -..)
>>> segra4(c=/+ a=.+ b==)
(-1.+ -1.=)
>>> segra4(c=.+ a=.)
(13+ -13)
-s vari%veis @bA e @cA possuem valor padrão e por isto são
opcionais j% a vari%vel @aA é obri0at/ria e deve ser passada:
54
6unç*es: con'unto de argumentos
>>> de! 9edia(P$alores)&
... so9a = .
... !or n in $alores&
... so9a K= n
... ret4rn so9a/len($alores)
...
>>> 9edia(1+.+/+0+=+2)
/.=
Cm conjunto de ar0umentos opcionais podem ser passados
com o au&3lio do curin0a @RA:
55
6unç*es: dois con'untos de argumentos
>>> de! teste1(no9e+ PPn49eros)&
... print no9e K <&<
... !or i in n49eros.Reys()&
... print '[1s & [d' [ (i+ n49eros)i1)
...
>>> de! teste.(no9e+ Pstrings+ PPn49eros)&
... print no9e K <&<
... !or i in strings&
... print '> '+ i
... Reys = n49eros.Reys()
... Reys.sort()
... !or i in Reys&
... print '[1s & [d' [ (i+ n49eros)i1)
...
Cm se0undo conjunto de ar0umentos opcionais podem ser
passados usando @RRA para o se0undo conjunto. !elo #ue pude
perceber este se0undo conjunto deve ser um composto de:
$ar?='$alor?'+ $ar?1='$alor?1'+ ...
Be +or usar @RA e @RRA tome o cuidado para #ue @RA sempre
preceda @RRA.
56
6unç*es: dois con'untos de argumentos
>>> teste1('749eros'+ 49=1+ dois=.+ tres=/+ @4atro=0+ cinco==)
749eros&
49 & 1
cinco & =
tres & /
@4atro & 0
dois & .
>>>
>>> teste.('749eros'+ '#s nQ9eros sYo ordenados'+ 'pelos se4s
no9es'+ 49=1+ dois=.+ tres=/+ @4atro=0+ cinco==)
749eros&
> #s nQ9eros sYo ordenados
> pelos se4s no9es
cinco & =
dois & .
@4atro & 0
tres & /
49 & 1
>>>
>>> teste.('749eros'+ 49=1+ dois=.+ tres=/+ @4atro=0+ cinco==)
57
2scopo da 7ari$!el
>>> a = =
>>> b = D
>>> de! so9a(x+y)&
... print 'a ='+a+ 'b ='+ b
... ret4rn xKy
...
>>> so9a(.+ F)
a = = b = D
G
Suanto uma vari%vel é de+inida no bloco principal de um
pro0rama ele estar% presente no escopo de todas as
+unç'es de+inidas a posteriori:
"bserve #ue os valores das vari%veis a e & são impressas
corretamente mesmo elas não tendo sido passadas para a
+unção ou seja estas vari%veis +a2em parte do escopo da
+unção soma.
.nicie uma nova seção do !ython
para as discuss'es a se0uir
58
2scopo da 7ari$!el
>>> de! prod4to(x+y)&
... a+ b = x+ y
... print 'prod4to& a ='+a+ 'b ='+ b
... ret4rn a P b
...
>>> prod4to(.+ F)
prod4to& a = . b = F
10
>>> print 'a ='+a+ 'b ='+ b
a = = b = D
Continuando o e&emplo observe #ue ao atribuirmos valores
a a e & de dentro da +unção produto os valores não são
sobre*escritos aos valores das vari%veis de mesmo nome no
escopo principal:
5
2scopo da 7ari$!el
>>> globals()
V'a'& =+ 'b'& D+ '??b4iltins??'& <9od4le '??b4iltin??' (b4ilt-
in)>+ 'prod4to'& <!4nction prod4to at x.b2.!a0be2>+ 'so9a'&
<!4nction so9a at x.b2.!a0bb1D>+ '??na9e??'& '??9ain??'+
'??doc??'& 7oneW
- +unção globals() retorna um dicion%rio com todo o escopo
0lobal e os seus valores.
- +unção locals() retorna um dicion%rio semelhante ao da
+unção glocals() mas para escopo local.
>>> de! di$isao(x+y)&
... a+ b = x+ y
... print a/b
... ret4rn locals()
...
>>> di$isao(1+/)
/
V'a'& 1+ 'y'& /+ 'b'& /+ 'x'& 1W
>>> print 'a ='+a+ 'b ='+ b
a = = b = D
6"
2scopo da 7ari$!el
>>> de! pot(x+n)&
... global p
... p = n
... ret4rn xPPp+ locals()
...
>>> pot(/+/)
(.F+ V'x'& /+ 'n'& /W)
>>> print p
/
>>> print n
IracebacR (9ost recent call last)&
Lile <<stdin><+ line 1+ in <9od4le>
7a9e;rror& na9e 'n' is not de!ined
- +unção global() permite de+inir uma vari%vel no escopo
0lobal de dentro de uma +unção:
6!
2scopo da 7ari$!el
>>> de! teste.(no9e+ Pstrings+ PPn49eros)&
... print no9e K <&<
... !or i in strings&
... print '> '+ i
... Reys = n49eros.Reys()
... Reys.sort()
... !or i in Reys&
... print '[1s & [d' [ (i+ n49eros)i1)
... ret4rn locals()
...
>>> teste.('749eros'+ '#s nQ9eros sYo ordenados'+ 'pelos se4s
no9es'+ 49=1+ dois=.+ tres=/+ @4atro=0+ cinco==)
749eros&
> #s nQ9eros sYo or...
V'Reys'& )'cinco'+ 'dois'+ '@4atro'+ 'tres'+ '49'1+ 'i'& '49'+
'n49eros'& V'49'& 1+ 'cinco'& =+ 'tres'& /+ '@4atro'& 0+
'dois'& .W+ 'strings'& ('#s nQ9eros sYo ordenados'+ 'pelos
se4s no9es')+ 'no9e'& '749eros'W
)amos testar a +unção locals() na +unção testeJ. "bserve
#ue RRnumeros é passado como um dicion%rio e Rstrin0s
como uma tupla:
62
6unç*es Pré)de3inidas
>>> range(1) > gera 49a lista co9 ele9entos de a G
)+ 1+ .+ /+ 0+ =+ 2+ F+ D+ G1
>>>
>>> range(/+ 1) > gera 49a lista de / a G
)/+ 2+ G+ 1.+ 1=+ 1D+ .1+ .0+ .F1
>>>
>>> range(/+/+ -/) > gera 49a lista de / a 0 co9 step -/
)/+ .F+ .0+ .1+ 1D+ 1=+ 1.+ G+ 21
" !ython possui v%rias +unç'es pré*de+inidas #ue nEo
necessitam de importaç'es e&ternas. )ou passar
rapidamente al0umas destas +unç'es:
range(a[, b[, c]]): retorna uma lista de inteiros de F a a*I
caso somente a seja passado como ar0umento: de a até b caso a
e b sejam passados como ar0umentos: a até b com o incremento
c caso a b e c sejam passados como ar0umentos.
63
6unç*es Pré)de3inidas
>J/4sr/bin/python
> 5oop range.py
!or i in range(1)&
pass
xrange(a[, b[, c]]): o mesmo #ue ran0e mas ao invés de
retornar uma lista retorna um objeto #ue 0era os n=meros
desejados por demanda. !ortando não serão 0erados os
elementos de uma lista. - 0rande utilidade do &ran0e é a sua
aplicação em loops. Com o &ran0e um loop pode +icar até HNP
mais r%pido.
Considere os dois loops de I.FFF.FFF interaç'es abai&o:
>J/4sr/bin/python
> 5oop xrange.py
!or i in xrange(1)&
pass
$ ti9e range.py ] grep 4ser
4ser 9.0=Fs
$ ti9e xrange.py ] grep 4ser
4ser 9.//Fs
64
6unç*es Pré)de3inidas
>>> a = '*lberto Eantos S49ont'
>>> len(a)
.1
>>> a = )1+.+/1
>>> len(a)
/
len(a): retorna o comprimento da vari%vel a. Be a +or uma lista
tupla ou dicion%rio len retorna o seu n=mero de elementos.
>>> ro4nd(=.0D)
=.
>>> ro4nd(=.=0D)
2.
>>> ro4nd(=.=0D+ 1)
=.=
round(a[, n]): arredonda o real DaD com DnD casas decimais. Be
DnD +or omitido ser% considerado n ; F.
65
6unç*es Pré)de3inidas
>>> poA(.+/)
D
>>> poA(..+/./)
G.D0G1==/2F=G/.DF
>>> poA(..+/./3)
(-.2=2D12FGG02G=0K.F=0=.2GDGG==203)
pow(a, n): retorna o valor de aTn onde a e n podem ser
inteiro real ou comple&o. " mesmo #ue aRRn.
>>> !or i in range(1)& print chr(2=Ki)+
...
* , - S ; L H H M 8
chr(a): retorna o caracter ascii correspondente ao c/di0o a. "
valor de a deve ser um inteiro entre F e HNN.
66
6unç*es Pré)de3inidas
>>> !or i in range(1)& print 4nichr(2=Ki)+
...
* , - S ; L H H M 8
unichr(a): como a +unção anterior retorna o caractere Cnicode
correspondente ao inteiro a. " valor de % deve estar entre F e
UNNJN. -té IHV chr4a5 ;; unichr4a5
>>> !or i in range(1)& a = chr(iK2=)O print '[s & [d' [ (a+
ord(a))
...
* & 2=
, & 22
- & 2F
S & 2D
; & 2G
L & F ...
ord(a): retorna o c/di0o ascii do caracter passado pela vari%vel
a. " valor de a deve ser apenas um caracter.
67
6unç*es Pré)de3inidas
>>> 9in(1+2)
1
>>> 9in('a'+ .)
.
>>> 9in('abacate'+ '!lores')
'abacate'
min(a, b): retorna o menor valor entre a e &. (unciona para
#ual#uer tipo de vari%veis. ?o caso de comparação entre tipos
di+erentes a comparação é +eita ap/s converter os ar0umentos
em cadeias de caracteres.
>>> 9ax(1+2)
2
>>> 9ax('a'+ .)
'a'
>>> 9ax('abacate'+ '!lores')
'!lores'
max(a, b): retorna o maior valor entre a e &. (unciona de +oma
a +unção min acima.
68
6unç*es Pré)de3inidas
>>> abs(-/)
/
>>> abs(-/.)
/.
>>> abs(/-03) > 9bd4lo de 49 co9plexo
=.
abs(a): retorna o valor absoluto de a seu m/dulo. Esta +unção
somente trabalha com n=meros inteiros reais e comple&os.
>>> hex(..)
'x12'
>>> oct(..)
'.2'
>>> hex(..)
'x1.'
hex(a) e oct(n): retorna o valor he&adecimal e octal da
vari%vel a.
6
6unç*es Pré)de3inidas: con!ers*es
>>> !loat('=')
=.
>>> !loat('1')
1.
float(a): converte um inteiro ou strin0 em um real.
>>> int(1..2F)
1.
>>> int('1.')
1.
int(a): converte um n=mero real ou strin0 em um inteiro.
>>> str(1..=)
'1..='
>>> str(1.)
'1.'
>>> str(1.K03)
'(1.K03)'
str(a): converte um inteiro comple&o ou real em uma strin0.
7"
6unç*es Pré)de3inidas: con!ers*es
>>> co9plex(.)
(.K3)
>>> co9plex('1.')
(1.K3)
>>> co9plex('1..1')
(1..1K3)
>>> co9plex(2.=)
(2.=K3)
complex(a): converte uma strin0 inteiro ou real em um
comple&o.
>>> list('abacate')
)'a'+ 'b'+ 'a'+ 'c'+ 'a'+ 't'+ 'e'1
>>> t4ple('abacate')
('a'+ 'b'+ 'a'+ 'c'+ 'a'+ 't'+ 'e')
list(a) e tuple(a): converte uma strin0 em uma lista e uma
tupla respectivamente.
7!
6unç*es Pré)de3inidas: leitura do teclado
>>> a = raA?inp4t(<;ntre co9 o se4 no9e& <)
;ntre co9 o se4 no9e& *lberto
>>> a
'*lberto'
raw_input([prompt]): l7 uma strin0 do teclado. Be pro9pt +or
declarado ele ser% impresso sem alimentação de linha.
>>> a = inp4t(<;ntre co9 algo& <)O a
;ntre co9 algo& V 'pai' & '8oYo'+ 'idade' = 2 W
V'idade'& F+ 'pai'& '8oNxe/o'W
>>> a = inp4t(<;ntre co9 algo& <)O a
;ntre algo co9 algo& '*lberto Eantos S49ont'
'*lberto Eantos S49ont'
>>> a = inp4t(<;ntre co9 algo& <)O a
;ntre algo co9 algo& = K 0
G
input([prompt]): l7 #ual#uer coisa do teclado. Btrin0s devem
ser prote0idas com aspas simples ou duplas. " comando inp4t é
o mesmo #ue e$al(raA?inp4t(pro9pt)).
72
Docstring: Documentação
" !ython possui suporte nativo E documentação de c/di0o.
Btrin0s de documentação chamadas de docstrin0s são
adicionados ao in3cio de m/dulos +unç'es e classes para instruir
o +uncionamento e +uncionalidades dos m/dulos +unç'es e
classes.
Estas docstrin0s podem ser escritas entre aspas duplas:
"9ensagens de 49a Qnica linha"
ou tr7s aspas duplas:
"(( 9ensage9 co9 9ais
@4e 49a linha de$e9 ser
escritas entre tras aspas
d4plas "((
73
Docstring: Documentação
>-P- coding& iso-DD=G-1 -P-
> :bd4lo Ee@4ancia de Libonacci& !ibonacci.py
<<< :od4lo Libonacci
L4ncoes&
!ib(n)
!ib.(n)
<<<
de! !ib(n)&
< Write Libonacci series 4p to n <
a+ b = + 1
Ahile b < n&
print b+
a+ b = b+ aKb
de! !ib.(n)&
< 6et4rn Libonacci series 4p to n <
res4lt = )1
a+ b = + 1
Ahile b < n&
res4lt.append(b)
a+ b = b+ aKb
ret4rn res4lt
74
Docstring: Documentação
>>> i9port !ibonacci
>>> print !ibonacci.??doc??
:od4lo Libonacci<
L4ncoes&
!ib(n)
!ib.(n)
>>> print !ibonacci.!ib.??doc??
Write Libonacci series 4p to n
>>> print !ibonacci.!ib..??doc??
6et4rn Libonacci series 4p to n
8ocstrin0s são e&tremamente =teis para documentar m/dulos
+unç'es e classes em seu c/di0o o #ue +acilita consultas +uturas
destes m/dulos e +unç'es. )eja o e&emplo a se0uir:
print open.??doc??
open(na9e)+ 9ode)+ b4!!ering11) -> !ile ob3ect
#pen a !ile 4sing the !ile() type+ ret4rns a !ile ob3ect.
75
8anipulação de %rqui!os: open+,
! = open(</etc/!stab<)
>>> print !
<open !ile '/etc/!stab'+ 9ode 'r' at xF!Db12de>
- +unção open retorna um objeto da classe +ile #ue permite +a2er
a leitura e escrita em ar#uivos das mais diversas +ormas. ?a sua
+orma padrão o ar#uivo é aberto somente para leitura:
>>> dir(!)
)'??class??'+ '??delattr??'+ '??doc??'+ '??enter??'+
'??exit??'+ '??getattrib4te??'+ '??hash??'+ '??init??'+
'??iter??'+ '??neA??'+ '??red4ce??'+ '??red4ce?ex??'+
'??repr??'+ '??setattr??'+ '??str??'+ 'close'+ 'closed'+
'encoding'+ '!ileno'+ '!l4sh'+ 'isatty'+ '9ode'+ 'na9e'+
'neAlines'+ 'next'+ 'read'+ 'readinto'+ 'readline'+
'readlines'+ 'seeR'+ 'so!tspace'+ 'tell'+ 'tr4ncate'+ 'Arite'+
'Aritelines'+ 'xreadlines'1
!ara conhecer todos os métodos do objeto ar#uivo voc7 pode
utili2ar o comando dir(!):
76
8anipulação de %rqui!os: open+, ) uma dica
>>> print !.read.??doc??
read()si'e1) -> read at 9ost si'e bytes+ ret4rned as a string.
M! the si'e arg49ent is negati$e or o9itted+ read 4ntil ;#L is reached.
7otice that Ahen in non-blocRing 9ode+ less data than Ahat Aas re@4ested
9ay be ret4rned+ e$en i! no si'e para9eter Aas gi$en.
- documentação de cada método pode ser muito =til para se
aprender como utili2%*los:
Lendo IF bytes
>>> print '>>[s<<' [ !.read(1)
>>/de$/sda= <<
77
8anipulação de %rqui!os: open+,
-inta5e completa do 3ile:
open4nameW modeW bu++erin0XX5 *< +ile object
-bre um ar#uivo no modo DrD 4leitura Q modo padrão5 DwD
4escrita5 ou DaD 4append5. " ar#uivo ser% criado se não e&istir
#uando aberto no modo DwD ou DaD.
-dicione um DbD para abrir um ar#uivo no modo bin%rio e um DMD
para permitir escrita e leitura simultaneamente.
Be bu++erin0 +or:
F nenhum bu++er ser% alocado para o ar#uivo:
I um bu++er de uma linha ser% alocado:
nn um bu++er de nn bytes ser% alocado para o ar#uivo.
Be um DCD 4universal ne' lin' suport5 +or adicionado ao modo
todo +im de linha ser% visto como um DYnD. DCD não pode ser usado
com os modos DwD ou DMD.
78
8anipulação de %rqui!os: open+, ou 3ile+,
%lguns métodos de open():
>>> !.read()
';9 ./ de o4t4bro de 1G2+ $oo4 cerca de 2 9etros e a 49a
alt4ra de dois a trNxeas 9etros co9 se4 10 ,is+ no -a9po de
,agatelle e9 Caris.Nn:enos de 49 9Nxeas depois+ e9 1. de
no$e9bro+ repeti4 o !eito e+ diante de 49a 94ltidNxe/o de
teste94nhas+ percorre4 .. 9etros a 49a alt4ra de 2 9etros.
Nn# $Nx!0o do 10-,is !oi o pri9eiro $eri!icado pelo
*erocl4be ...Nn'
read([size]): ler size bytes e retorna como uma strin0. Be size
+or ne0ativo ou omitido a leitura ser% +eita até alcançar o +inal
do ar#uivo.
7
8anipulação de %rqui!os: open+,
>>> !.read() > 3B alcanXo4 o !inal do ar@4i$o
''
>>> !.seeR() > alcanXa o indcio do ar@4i$o
>>> !.read(.) > ler . bytes
';9 ./ de o4t4bro de 1G2+ $oo4 cerca de 2 9etros e a 49a
alt4ra de dois a trNxeas 9etros co9 se4 10 ,is+ no -a9po de
,agatelle e9 Caris.Nn:enos de 49 9Nxeas depois+ e9 1. de
no$e9bro+ repeti4 o !eito e+ dia'
>>> !.seeR(+ .) > $ai para o !inal do ar@4i$o
>>> !.read(.)
''
seek(offset[, whence]): move o ponteiro de acesso ao
ar#uivo para uma nova posição. " o!!set é contado em bytes F
para o in3cio do ar#uivo. " ar0umento opcional Ahence pode
assumir tr7s valores:
F * padrão mover para o in3cio do ar#uivo:
I Q +ica no mesmo lu0ar:
H Q move para o +inal do ar#uivo.
8"
8anipulação de %rqui!os: open+,
>>> !.seeR()
>>> !.readline()
';9 ./ de o4t4bro de 1G2+ $oo4 cerca de 2 9etros e a 49a
alt4ra de dois a trNxeas 9etros co9 se4 10 ,is+ no -a9po de
,agatelle e9 Caris.Nn'
>>> !.readline(1)
':enos de 49 9Nxeas depois+ e9 1. de no$e9bro+ repeti4 o !eito
e+ diante de 49a 94ltidNxe/o de teste94nhas+'
>>> !.readline(1)
' percorre4 .. 9etros a 49a alt4ra de 2 9etros. Nn'
>>> !.readline()
'# $Nx!0o do 10-,is !oi o pri9eiro $eri!icado pelo
*erocl4be ...Nn'
readline([size]): ler a pr/&ima linha como uma strin0. Be
si2e +or di+erente de 2ero isto ir% restrin0ir o comprimento de
bytes lidos.
Be não #uiser ver os caracteres de controle use: print
!.readline() ao invés de apenas !.readline().
8!
8anipulação de %rqui!os: open+,
close(): +echa um ar#uivo.
>>> ! = !ile('texto.txt'+ 'rK')
>>> !.seeR(+ .) > a$anXa para o !inal do ar@4i$o
>>> !.Arite('6etirado http&//pt.AiRipedia.org/AiRi/Eantos?S49ontNn')
>>> !.seeR()
>>> print !.read()
;9 ./ de o4t4bro de 1G2+ $oo4 cerca de 2 9etros e a 49a alt4ra de
dois a tras 9etros co9 se4 10 ,is+ no -a9po de ,agatelle e9 Caris.
:enos de 49 9as depois+ e9 1. de no$e9bro+ repeti4 o !eito e+ diante
de 49a 94ltidYo de teste94nhas+ percorre4 .. 9etros a 49a alt4ra de 2
9etros.
# $eo do 10-,is !oi o pri9eiro $eri!icado pelo *erocl4be ...
6etirado http&//pt.AiRipedia.org/AiRi/Eantos?S49ont
write(str): escreve a strin0 str no ar#uivo. 8evido ao
bu++erin0 pode ser necess%rio usar os métodos !l4sh() ou
close() para #ue o ar#uivo no disco re+lita as alteraç'es +eitas.
>>> !.close()
>>> !.readline()
IracebacR (9ost recent call last)&
Lile <<stdin><+ line 1+ in <9od4le>
_al4e;rror& M/# operation on closed !ile
82
8anipulação de %rqui!os: open+,
>>> !.seeR(+ .)O end = !.tell()
>>> !.seeR()O pos = !.tell()
>>> line = 1
>>> Ahile pos J= end&
... print '5inha [d - posiXYo [d' [ (line+ pos)
... line K= 1
... l = !.readline()
... pos = !.tell()
...
5inha 1 - posiXYo
5inha . - posiXYo 1/=
5inha / - posiXYo .D0
5inha 0 - posiXYo /0=
tell(): apresenta a posição corrente para escrita e leitura no
ar#uivo.
83
8anipulação de %rqui!os: open+,
>>> !.!l4sh()
flush(): 0rava as alteraç'es em bu++er no ar#uivo.
>>> !.9ode
'rK'
mode: retorna a strin0 de modo com #ue o ar#uivo +oi aberto.
>>> !.na9e
'texto.txt'
name: retorna uma strin0 com o nome do ar#uivo +oi aberto.
>>> !.closed
Lalse
>>> !.close()
>>> !.closed
Ir4e
closed: retorna Ir4e se o ar#uivo estiver +echado e Lalse se
estiver aberto.
84
8anipulação de %rqui!os: open+,
next(): ler o pr/&imo valor do ar#uivo corrente ou
EtopMteration se o +inal do ar#uivo +or alcançado. - menos do
EtopMteration 0erado ao alcançar o +inal do ar#uivo o método
next() retorna o mesmo #ue o readline().
>>> !.seeR()O !.next()
';9 ./ de o4t4bro de 1G2+ $oo4 cerca de 2 9etros e a 49a
alt4ra de dois a trNxeas 9etros co9 se4 10 ,is+ no -a9po de
,agatelle e9 Caris.Nn'
>>> !.next()
...
>>> !.next()
'6etirado http&//pt.AiRipedia.org/AiRi/Eantos?S49ontNn'
>>> !.next()
IracebacR (9ost recent call last)&
Lile <<stdin><+ line 1+ in <9od4le>
EtopMteration
85
Orientação a O&'etos
(2rientação a objetos1 221 3 um termo 4ue descreve uma s3rie
de t3cnicas para estruturar soluç5es para problemas
computacionais, 3 um paradigma de programação no 4ual um
programa e estruturado em objetos1 e 4ue en-ati6a os aspectos
abstração1 encapsulamento1 polimor7smo e herança,+
"bjetos: Como observamos em seç'es anteriores em !ython tudo
é um objeto com atributos é métodos: valores tipos classes
+unç'es métodos ...
86
Orientação a O&'etos: classes
> Se!ine !or9as
>-P- coding& iso-DD=G-1 -P-
class 6etang4lo&
lado?a = 7one
lado?b = 7one
de! ??init??(sel!+ lado?a+ lado?b)&
sel!.lado?a = lado?a
sel!.lado?b = lado?b
print '-riando 49a no$a instfncia retfng4lo.'
de! calc4la?area(sel!)&
ret4rn sel!.lado?a P sel!.lado?b
de! calc4la?peri9etro(sel!)&
ret4rn . P (sel!.lado?a K sel!.lado?b)
Classes: - estrutura +undamental para de+inir uma objeto é a classe.
Csarei o e&emplo do Christian R. Reis. )amos criar um m/dulo chamado
+ormas.py com a de+inição de uma classe 8et9ngulo.
Esta classe possuir% dois atributos: ladoOa e ladoOb e classe ir% calcular
%rea e per3metro com os métodos calcula:area e calcula:perimetro:
87
Orientação a O&'etos: classes
Esta classe possui tr7s métodos sendo um deles um método
especial ::init::/0. Este é o método construtor padrão do !ython
invocado #uando uma classe é instanciada 4nome dado a criação
de um objeto a partir de uma classe5. Este método é opcional.
"bserve #ue todos os métodos possuem como atributo a vari%vel
sel- #ue é manipulada no interior do método. Em !ython o
primeiro ar0umento é especial sendo seu nome por convenção
sel-.
Instâncias: - inst1ncia é o objeto criado com base em uma classe
deZnida. Cma descrição abstrata da dualidade classe*inst1ncia:
a classe é apenas uma matri2 #ue especi+ica os objetos mas #ue
não pode ser utili2ada diretamente:
a inst1ncia representa o objeto concreti2ado a partir de uma
classe.
88
Orientação a O&'etos: classes
-0ora vamos brincar um pouco com nossa primeira classe do
m/dulo +ormas.py:
>>> !ro9 !or9as i9port P > i9porta apenas 6etang4lo+ por hora
>>> r1 = 6etang4lo(.+ =)
-riando 49a no$a instfncia 6etfng4lo
>>> r. = 6etang4lo(/+ 0)
-riando 49a no$a instfncia 6etfng4lo
de! ??init??(sel!+ lado?a+ lado?b)&
sel!.lado?a = lado?a
sel!.lado?b = lado?b
print '-riando 49a no$a instfncia retfng4lo.'
8
Orientação a O&'etos: classes
>>> r1.calc4la?peri9etro()
10
>>> r..calc4la?area()
1.
-p/s instanciados os objetos rI e rH os métodos calcula:area e
calcula:perimetro são disponibili2ados
de! calc4la?area(sel!)&
ret4rn sel!.lado?a P sel!.lado?b
de! calc4la?peri9etro(sel!)&
ret4rn . P (sel!.lado?a K sel!.lado?b)
>>> r1.lado?a
.
>>> r1.lado?b
=
"
Orientação a O&'etos: classes
>>> class test&
... atr1 = "atrib4to p4blico(
... ?atr. = "atrib4to pri$ado(
...
>>> a = test
>>> a.atr1
'atrib4to p4blico'
>>> a.?atr.
'atrib4to pri$ado'
%tri&utos pri!ados e protegidos: !ython não possui uma
construção sint%tica para de+inir atributos como privados em uma
classe mas e&istem +ormas de se indicar #ue um atributo não
deve ser acessado e&ternamente:
!or convenção atributos iniciados por um sublinhado @OA não
devem ser acessados e&ternamente:
!
Orientação a O&'etos: classes
>>> class test&
... atr1 = "atrib4to p4blico(
... ??atr. = "atrib4to pri$ado(
...
>>> a = test
>>> a.atr1
'atrib4to p4blico'
>>> a.??atr.
IracebacR (9ost recent call last)&
Lile <<stdin><+ line 1+ in <9od4le>
*ttrib4te;rror& class test has no attrib4te '??atr.'
Buporte no pr/prio interpretador: atributos iniciados por dois
sublinhados @OOA são renomeados para prevenir de serem
acessados e&ternamente.
?a verdade o atributo não est% inaccess3vel apenas teve seu
nome alterado para :test::atr;
>>> a.?test??atr.
'atrib4to pri$ado'
2
Orientação a O&'etos: herança
class no9e-classe(base?1+ base?.+...+ base?n)&
atrib4to?1 = $alor?1
...
atrib4to?' = calor?'
de! no9e?9%todo?1(sel!+ arg?1+ arg?.+ ...+ arg?R)&
> bloco de co9andos do 9%todo?1
...
de! no9e?9%todo?9(sel!+ arg?1+ arg?.+ ...+ arg?n)&
> bloco de co9andos do 9%todo?9
...
[erança é uma +orma de derivar classes novas a partir de classes*
bases.
!ython suporta herança simples e herança m=ltiplas. - sinta&e de
uma classe é:
3
Orientação a O&'etos: herança
class U4adrado(6etang4lo)&
de! ??init??(sel!+ lado)&
sel!.lado?a = sel!.lado?b = lado
)amos de+inir a classe $uadrado como derivada de 8etangulo.
-dicione o te&to abai&o ao +ormas.py:
>>> !ro9 !or9as i9port P
>>> r1= U4adrado(1)
>>> dir(r1)
)'??doc??'+ '??init??'+ '??9od4le??'+ 'calc4la?area'+
'calc4la?peri9etro'+ 'lado?a'+ 'lado?b'1
>>> r1.lado?a+ r1.lado?b
(1. 1)
>>> r1.calc4la?area()+ r1.calc4la?peri9etro()
(1+ 0)
Em se0uida vamos criar um #uadrado de aresta IF e ver seus
métodos e atributos
4
Orientação a O&'etos: herança
>>> !ro9 !or9as i9port P
>>> class E@4are(6etang4lo)&
... de! ??init??(sel!+ lado)&
... 6etang4lo.??init??(sel!+ lado+ lado)
...
>>> r1 = E@4are(1)
-riando 49a no$a instfncia retfng4lo.
>>> r1.lado?a+ r1.lado?b
(1+ 1)
>>> r1.calc4la?area()+ r1.calc4la?peri9etro()
(1+ 0)
In!ocando métodos de uma classe)&ase: poder3amos ter
criado a classe $uadrado utili2ando o construtor da classe
8etangulo invocando*o de dentro da classe $uadrado. )amos
+a2er isto para uma classe #4uare:
5
Orientação a O&'etos: herança
>>> class Loo&
... a = )=+ /1
...
>>> h = Loo()
>>> h.a.append(.)O h.a
)=+ /+ .1
>>> g = Loo()
>>> g.a
)=+ /+ .1
9ma 3raque:a; -l0uns cuidados devem ser tomados ao se
alterar atributos em um objeto. "bserve o e&emplo abai&o:
.sto ocorre sempre com atributos
mut%veis como listas e dicion%*
rios. !ara atributos não mut%veis
as atribuiç'es são sempre +eitas
na vari%vel da inst1ncia local e
não da classe como era de se
esperar.
>>> class Loo.&
... a = 1
...
>>> h = Loo.()
>>> h.a = .O h.a
.
>>> g = Loo.()
>>> g.a
1
(<sta particularidade e -re=
4>entemente -onte de bugs
di-?ceis de locali6ar1 e por este
motivo se recomenda -orte=
mente 4ue não se utili6e va=
riáveis de tipos mutáveis em
classes,+ @Christian 8eisA
6
Orientação a O&'etos: herança
>>> 3 = Loo.()
>>> 3.a
=
>>> 3.set?a(D)
>>> R = Loo.()
>>> 3.a+ R.a
(D+ =)
(açamos al0uns testes a0ora:
8esta +orma não h% superposição na de+inição da classe. Este é o
custo da alta +le&ibilidade do !ython.
En#uanto por um lado ele lhe permite alterar a de+inição de um
atributo de uma classe em tempo de e&ecução por outro lado
pode 0erar erros de di+3cil locali2ação.
7
Orientação a O&'etos: 3unç*es <teis
>>> !ro9 !or9as i9port P
>>> !1 = U4adrado(1=)
>>> isinstance(!1+ U4adrado)
Ir4e
>>> isinstance(!1+ 6etang4lo)
Ir4e
)amos ver duas +unç'es importantes para conhecer a hierar#uia
de uma classe e inst1ncias
isinstance+o&'eto= classe,: veri+ica de o objeto passado é uma
inst1ncia da classes
>>> iss4bclass(U4adrado+ 6etang4lo)
Ir4e
>>> iss4bclass(6etang4lo+ U4adrado)
Lalse
issu&class+classe>a= classe>&,: veri+ica se classeOa é uma sub*
classe de classeOb
8
Orientação a O&'etos: 3unç*es <teis
>>> hasattr(!1+ lado?a)
Ir4e
>>> hasattr(!1+ lado)
Lalse
hasattr+o&'eto= atri&uto,: veri+ica se um objeto possui um
atributo.
>>> de! MsLor9a(ob3)&
... ret4rn hasattr(ob3+ 'lado?a') and hasattr(ob3+
'lado?b')
...
>>> MsLor9a(!1)
Ir4e
>>> a = =
>>> MsLor9a(a)
Lalse
Cma +unção para veri+icar se um objeto é uma +orma:

Orientação a O&'etos
Introspecção e re3le5ão: !ython permite obter em tempo de
e&ecução in+ormaç'es a respeito do tipo dos objetos incluindo
in+ormaç'es sobre a hierar#uia de classes.
>>> !ro9 !or9as i9port P
>>> r = U4adrado(1/)
>>> dir(r)
)'??doc??'+ '??init??'+ '??9od4le??'+ 'calc4la?area'+
'calc4la?peri9etro'+ 'lado?a'+ 'lado?b'1
dir+o&'eto,: permite conhecer todos os atributos e métodos de
uma classe ou inst1ncia.
>>class>>: este atributo da inst1ncia arma2ena o seu objeto
classe correspondente.
>>> r.??class??
<class !or9as.U4adrado at x.bF1Fbc0DFF>
!""
Orientação a O&'etos
>>> r.??dict??
V'lado?a'& 1/+ 'lado?b'& 1/W
>>dict>>: apresenta um dicion%rio com todos os atributos de
uma inst1ncia.
>>class>>: este atributo da inst1ncia arma2ena o seu objeto
classe correspondente.
>>> r.??class??
<class !or9as.U4adrado at x.bF1Fbc0DFF>
>>> r.??9od4le??
'!or9as'
>>module>>: apresenta uma strin0 o nome do m/dulo o #ual a
inst1ncia ou a classe +oi importada.
!"!
Orientação a O&'etos
Classe>>&ases>>: apresenta uma tupla com as classes herdadas
por Classe.
>>> U4adrado.??bases??
(<class !or9as.6etang4lo at x.abc1acDaF1>+)
Classe>>name>>: apresenta uma strin0 com o nome da classe.
>>> U4adrado.??na9e??
'U4adrado'
!"2
Importando 8?dulos
?esta =ltima seção do curso vou dedicar a apresentação de
al0uns m/dulos padr'es do !ython.
Estes m/dulos são carre0ados com o comando import
como j% +oi apresentado ao lon0o desta apresentação.
i9port <9bd4lo?1> ) as no9e?1 1 )+ <9bd4lo?.> ) as
no9e?.11 ...
!ro9 <9bd4lo> i9port )<ident?1>+ <ident?.>+ ...1
-s suas sinta&es b%sicas são:
?a se0unda +orma ainda é poss3vel usar R para indicar a
importação de todos os métodos +unç'es ... para a rai2.
!ro9 <9bd4lo> i9port P
!"3
Importando 8?dulos
E&emplos:
>>> i9port !ibonacci
>>> !ibonacci.!ib(1)
1 1 . / = D 1/ .1 /0 == DG 100 .// /FF 21 GDF
>>> dir()
)'??b4iltins??'+ '??doc??'+ '??na9e??'+ '!ibonacci'1
>>> !ro9 !ibonacci i9port P
>>> !ib(1)
1 1 . / = D 1/ .1 /0 == DG 100 .// /FF 21 GDF
>>> dir()
)'??b4iltins??'+ '??doc??'+ '??na9e??'+ '!ib'+ '!ib.'1
.mportando tudo para a rai2:
?as seç'es se0uintes irei apresentar diversos m/dulos padr'es
do !ython. !ara conhecer todos os métodos +unç'es ... de um
m/dulo use o comando: dir(9bd4lo)
?as seç'es se0uintes irei apresentar diversos m/dulos padr'es
do !ython. !ara conhecer todos os métodos +unç'es ... de um
m/dulo use o comando: dir(9bd4lo)
!"4
8?dulo ) sys
>>> i9port sys
>>> sys.ps1 = '> '
> sys.ps. = '. '
> !or i in range(1)
. print i
ps@ e psA: de+inem os prompts do !ython 4A>>>A e A...A5.
sys: Este m/dulo possui v%rias +unç'es #ue permitem
intera0ir com o pr/prio interpretador !ython:
arg!: arma2ena os ar0umentos passados pela linha de comandos
na lista de strin0s ar0vWX onde o primeiro elemento é o nome do
pro0rama chamado se0uido pelos outros ar0umentos. !or
e&emplo considere um m/dulo !ython ar0s.py com o conte=do:
> :od4lo args.py
!ro9 sys i9port arg$
print sys.arg$
!"5
8?dulo ) sys
>>> sys.path
)''+ '/4sr/lib20/python.=.'ip'+ '/4sr/lib20/python..='+
'/4sr/lib20/python..=/plat-lin4x.'+ '/4sr/lib20/python..=/lib-
tR'+ '/4sr/lib20/python..=/lib-dynload'+
'/4sr/lib20/python..=/site-pacRages'+
'/4sr/lib20/python..=/site-pacRages/gtR-..'1
path: apresenta os caminhos utili2ados pelo !ython para buscar
os m/dulos solicitados pelo comando import.
plat3orm= pre3i5= !ersion= BBB: in+ormaç'es sobre o !ython
par1metros de sua instalação.
>>> sys.plat!or9+ sys.pre!ix+ sys.$ersion
('lin4x.'+ '/4sr'+ '..=.1 (r.=1&=0D2/+ Eep 0 .F+
1G&&1G) Nn)H-- 0.1..1')
$ python args.py . = -/
)'args.py'+ '.'+ '='+ '-/'1
!"6
8?dulo ) sys
>>> sys.stdo4t.Arite('Hello World')
Hello World>>>
stdin= stdout= stderr: entrada sa3da e sa3da de erro padr'es.
!ermite redirecionar as entradas e sa3das padr'es do sistema.
>>> sys.exit()
$ ?
e5it: encerra uma seção do !ython mais diretamente
!"7
8?dulo ) re
>>> i9port re
>>> re.!indall(r'Nb!)a-'1P'+ 'Ahich !oot or hand !ell
!astest')
)'!oot'+ '!ell'+ '!astest'1
3indall: permite encontra a ocorr7ncia de uma strin0 +iltrando*a
por uma e&pressão re0ular.
>>> re.s4b(r'Nb*:S'+ r'*4thentic*:S'+ '*:S I4rion(t9) 20 g.
:obile')
'*4thentic*:S I4rion(t9) 20 g. :obile'
su&: substitui uma ocorr7ncia de uma strin0 por outra.
re: 4regular e.pression5 este m/dulo +ornece +erramentas
para +iltrar strin0s através de E&press'es Re0ulares.
!"8
8?dulo ) re
>>> 'cat the the hat'.replace('the the'+ 'the')
'cat the hat'
Bem a mesma e+ici7ncia o mesmo poderia ser +eito com o método
replace de strin0.
>>> re.s4b(r'(Nb)a-'1K) N1'+ r'N1'+ 'cat in the the hat')
'cat in the hat'
Bubstituindo duas ocorr7ncias de uma strin0 por uma.
>>> re.s4b(r'(Nb)a-'1K) N1'+ r'N1'+ 'cat cat the the hat hat+
and 9y 9y shoes')
'cat the hat+ and 9y shoes'
!"
8?dulo ) math
>>> dir(9ath)
)'??doc??'+ '??!ile??'+ '??na9e??'+ 'acos'+ 'asin'+ 'atan'+
'atan.'+ 'ceil'+ 'cos'+ 'cosh'+ 'degrees'+ 'e'+ 'exp'+ '!abs'+
'!loor'+ '!9od'+ '!rexp'+ 'hypot'+ 'ldexp'+ 'log'+ 'log1'+
'9od!'+ 'pi'+ 'poA'+ 'radians'+ 'sin'+ 'sinh'+ 's@rt'+ 'tan'+
'tanh'1
sqrt= cos= sin= BBB : diversas +unç'es matem%ticas. -s +unç'es
ausentes podem ser constru3das a partir destas.
>>> i9port 9ath
>>> de! Ein(a)&
... "-alc4la seno de ang4lo e9 gra4s(
... ang = aP9ath.pi/1D. > 9es9o @4e radians()
... ret4rn 9ath.sin(ang)
...
>>> Ein(/)
.0GGGGGGGGGGGGGGG0
>>> Ein(2)
.D22.=0/FD00/D2
math: este m/dulo +ornece acesso a diversas as +unç'es
matem%ticas e constantes.
!!"
8?dulo ) random
>>> i9port rando9
>>> rando9.choice()'goiaba'+ 'laran3a'+ 'abacate'+ 'pera'1)
'pera'
random: este m/dulo permite 0erar n=meros aleat/rios
sorteios se#67ncias distribuiç'es reais uni+ormes 0amma
... )eja a documentação para mais detalhes:
>>> print rando9.??doc??
choice+lista,: escolhe de +orma aleat/ria um elemento de uma
lista
>>> rando9.randrange(1)
/
randrange+n,: 0era um inteiro aleat/rio entre F e n*I
>>> rando9.randint(/+ 2)
2
randint+n= m,: 0era um inteiro aleat/rio entre n e m incluindo
os e&tremos m e n.
!!!
8?dulo ) random
>>> !ro9 rando9 i9port sa9ple
>>> sa9ple()+ 1+ .+ /1+ 0)
)1+ /+ + .1
>>> de! sena(n = 1)&
... <<<M9pri9e n sorteios para a :egaEena<<<
... print <Eorteios da :egaEena<
... !or i in xrange(n)&
... print str(iK1) K <& < K str(sa9ple(xrange(2)+ 2))
...
>>> sena(=)
Eorteios da :egaEena
1& )/+ /1+ =.+ /+ =D+ 0G1
.& ).+ 02+ 1+ 2+ /+ 1.1
/& )10+ /G+ =0+ =F+ 0.+ 1=1
0& )0D+ /2+ //+ =+ /+ ./1
=& )1/+ =/+ 2+ .=+ /F+ ==1
sample+lista= n,: 0era uma lista com n elementos da lista sem
repetição dos elementos. " n=mero de elementos sorteados m
deve ser menor ou i0ual ao comprimento da lista.
!!2
8?dulos para Internet . urlli&A e smtpli&
>>> i9port 4rllib.
>>> !or line in
4rllib..4rlopen(hhttp&//tycho.4sno.na$y.9il/cgi-
bin/ti9er.plh)&
... i! h;EIh in line& > looR !or ;astern Etandard
Ii9e
... print line
<,6>7o$. .=+ G&0/&/. C: ;EI
urlli&A: este m/dulo permite criar nave0ar pela internet
carre0ar p%0inas pes#uisar ...
!!3
8?dulos para Internet . urlli&A e smtpli&
>>> i9port s9tplib
>>> ser$er = s9tplib.E:IC(hlocalhosth)
>>> ser$er.send9ail(hsoothsayeriexa9ple.orgh+
h3caesariexa9ple.orgh+
<<<Io& 3caesariexa9ple.org
Lro9& soothsayeriexa9ple.org
,eAare the Mdes o! :arch.
<<<)
>>> ser$er.@4it()
smtpli&: com este m/dulo é poss3vel enviar emails através
de um servidor smtp.
!!4
8?dulo ) datetime
>>> !ro9 dateti9e i9port date
>>> ho3e = date.today()
>>> nasci9ento = date(1GD2+ =+ 12)
>>> idade = ho3e Z nasci9ento
>>> print "E4a idade % [d anos( [ int(idade.days//2=)
E4a idade % 11 anos
>>>
>>> dir(date)
)'??add??'+ '??class??'+ '??delattr??'+ '??doc??'+ '??e@??'+
'??ge??'+ '??getattrib4te??'+ '??gt??'+ '??hash??'+
'??init??'+ '??le??'+ '??lt??'+ '??ne??'+ '??neA??'+
'??radd??'+ '??red4ce??'+ '??red4ce?ex??'+ '??repr??'+
'??rs4b??'+ '??setattr??'+ '??str??'+ '??s4b??'+ 'cti9e'+
'day'+ '!ro9ordinal'+ '!ro9ti9esta9p'+ 'isocalendar'+
'iso!or9at'+ 'isoAeeRday'+ '9ax'+ '9in'+ '9onth'+ 'replace'+
'resol4tion'+ 'str!ti9e'+ 'ti9et4ple'+ 'today'+ 'toordinal'+
'AeeRday'+ 'year'1
datetime: este m/dulo +ornece classes para manipulação de
datas e horas nas mais variadas +ormas.
date+ano= mCs= dia,: cria um objeto data.
!!5
8?dulo ) :li&
>>> !ro9 'lib i9port co9press+ deco9press+ crc/=
>>> s = ";9 ./ de o4t4bro de 1G2+ $oo4 cerca de 2 9etros e a
49a alt4ra de dois a tras 9etros co9 se4 10 ,is+ no -a9po de
,agatelle e9 Caris.(
>>> len(s)
1/0
>>> ' = co9press(s)
>>> len(')
11/
:li&: este m/dulo permite trabalhar com dados
comprimidos comprimindo descomprimindo ...
compress+string,= decompress+string,: comprime e
descomprime uma strin0
crcDA+string,: computa o CRC*JH de uma strin0 4chec\sum5
>>> !ro9 'lib i9port crc/=
>>> crc/.(s)
/D1112/D
!!6
8?dulo ) timeit
>>> Ii9er('xrange(1)').ti9eit()
.G/DDGD0F=202GF.F
>>>
>>> Ii9er('range(1)').ti9eit()
..G/==FG22./..GGD
timeit: este m/dulo permite monitorar o desempenho na
e&ecução de comandos !ython
>>> Ii9er('t=aO a=bO b=t'+ 'a=1O b=.').ti9eit()
./DG..2G1/0=.10D00
>>> Ii9er('a+ b = b+ a'+ 'a=1O b=.').ti9eit()
./1.1.GGF0/2=./0/D
"bserve #ue o xrange(1) che0a a ser U]P mais r%pido #ue o
range(1). .sto mostra a vanta0em em se usar o xrange em
loops e outras ocasi'es.
?o swap acima +oi poss3vel conse0uir HFP a menos no
processamento evitando*se uma atribuição em uma vari%vel
tempor%ria.
!!7
Consideraç*es 6inais
E&iste ainda muitos aspectos m/dulos +unç'es objetos
+unç'es ... dispon3veis para o !ython.
(i&liogra3ia:
Kutorial !ython release H.^.H de Guido van Rossum (red
L . 8ra\e _r. editor tradução: !ython $rasil
!ython na !r%tica * Cm curso objetivo de pro0ramação em
!ython http://www.async.com.br/projects/pnp/ de
Christian Robottom Reis -sync "pen Bource
\i\o`async.com.br
8ocumentação do !yton 4dir45 e OOdocOO5