Pythondobsicoweb 131028070251 Phpapp02

Antonio Srgio Nogueira
Programando em Python
Do Bsico WEB
1
a
Edio
2012
1
Programando em Python Do Bsico WEB
Nota do Autor
Agradeo a todos os que me cercam e que tem compartilhado
comigo este sonho de fornecer meus conhecimentos e pesquisas
na rea de informtica.
Aos leitores espero que saibam aproveitar este material didtico
escrito com amor, carinho e muito trabalho.
A minha filha anessa !ta "ogueira o meu especial
agradecimento por confeccionar a capa deste material didtico.
Antonio #$rgio "ogueira
2
Sumrio
%ntroduo....................................................................................&
1. ! interpretador '(thon..........................................................10
1.1 #ua hist)ria .........................................................................10
1.2 *icena.................................................................................12
1.+ ,so do %nterpretador '(thon................................................1-
1.+.1 .ual '(thon usar/.............................................................1-
1.+.2 '(thon em 0indo1s.........................................................1-
1.+.2.1 !po 12 %nstalando o Active'(thon.............................13
1.+.2.2 !po 22 %nstalando o '(thon do '(thon.org................14
2. '(thon2 %ntroduo, 5ipos e 6omandos 7sicos...................1&
2.1 %nterpretador........................................................................1&
2.2 'alavras 8eservadas............................................................1&
2.+ 9igitando comandos no %9*E.............................................1&
2.: 5ipos de 9ados....................................................................1;
2.- "<mero ponto flutuante e comple=o...................................20
2.3 #trings..................................................................................22
2.4 #trings ,nicode...................................................................24
2.& *istas....................................................................................+0
2.; 5uplas...................................................................................+2
2.10 9icionrios.........................................................................++
2.11 9oc#tring e comentrio.....................................................+3
2.12 !peradores Aritm$ticos.....................................................+4
2.1+ !peradores de atribuio...................................................+&
2.1: !peradores de condio.....................................................+;
2.1- !peradores l)gicos............................................................:1
2.1-.1 E=press>es boolenas......................................................:1
2.1-.2 !peradores2 in , is , is not...............................................:+
2.13 ariveis............................................................................::
2.14 !perador ?........................................................................:-
+. 6ontrole de @lu=o e Estrutura de 9ados................................:4
+
+.1 6ontrole de @lu=o................................................................:4
+.1.1 %nstruo2 1hile ...............................................................:4
+.1.2 %nstruo2 for ....................................................................:;
+.1.+ 6lusulas breaA, continue e else ......................................-0
+.1.: %nstruo if........................................................................-1
+.1.- 6onstruo pass................................................................-+
+.1.3 5$cnicas de *ao..............................................................-+
+.2.1 ,sando *istas como 'ilhas...............................................--
+.2.2 ,sando *istas como @ilas.................................................--
+.2.+ @un>es sobre listas2 filterBC, mapBC, e reduceBC................-3
+.2.: AbrangDncia de *istasBlist comprehensionsC....................-4
+.2.- ! comando del..................................................................-&
+.2.3 5rabalhando com conEuntos F sets....................................-&
:. @un>es, 8ecurso, E=ceo, Arquivos e G)dulos...............31
:.1 @un>es................................................................................31
:.1.1 Escopo das variveis.........................................................3+
:.1.2 @un>es como parHmetro..................................................3:
:.1.+ @uno com 2 argumentos................................................3-
:.1.: @uno com valores padro ou default.............................3-
:.1.- @uno com argumentos opcionais...................................33
:.1.3 @uno com conEunto de argumentos nomeados .............34
:.1.4 @uno lambda .................................................................3&
:.2 @un>es recursivas...............................................................3&
:.+ @un>es pr$Fdefinidas..........................................................40
:.: G)dulos...............................................................................4+
:.:.1 G)dulos padro................................................................43
:.:.2 'acotes..............................................................................&0
:.:.+ %mportando I de ,m 'acote.............................................&+
:.:.: 8eferDncias em ,m Gesmo 'acote..................................&:
:.:.- 'acotes em m<ltiplos diret)rios........................................&-
:.:.3 G)dulos %mportantes........................................................&-
:.- @un>es de entrada e saJda..................................................&4
:
:.-.1 !pera>es com arquivos...................................................;2
:.-.2 G$todos do obEeto arquivo...............................................;+
:.-.+ %nterao com sistema operacional...................................;3
:.3 @uno varsBC.......................................................................;4
:.4 Erros e e=ce>es..................................................................;&
:.4.1 6omo ler uma mensagem de erro.....................................;&
-. 7iblioteca 'adro.................................................................10+
-.1 %nterface com #istema !peracional ..................................10+
-.2 G)dulo shutil.....................................................................10+
-.+ G)dulo glob......................................................................10:
-.: G)dulo s(s........................................................................10:
-.- G)dulo math......................................................................10-
-.3 G)dulo random.................................................................10-
-.4 G)dulo datetime................................................................103
-.& G)dulo Klib........................................................................104
-.; G)dulo arra(.....................................................................104
-.10 G)dulo collection............................................................10&
-.11 G)dulo decimal...............................................................10&
-.12 G)dulo itime...................................................................10;
3. !rientao a !bEeto.............................................................111
3.1 %ntroduo a 'rogramao !rientada a !bEetosB'!!C......111
3.2 ! que '!!/.......................................................................111
3.+ 9efini>es bsicas de orientao a obEeto.........................112
3.: '!! em '(thon.................................................................11+
3.- 9efinindo 6lasses..............................................................113
3.3 Lerana..............................................................................120
3.4 Atributos 'rivados.............................................................12+
3.& !utros G$todos.................................................................12:
3.; @un>es Mteis....................................................................124
3.10 %ntrospeco e refle=o....................................................12&
4. E=emplos de !rientao a !bEetos e !utros.......................1+0
4.1 9efinio de uma classe....................................................1+0
-
4.2 %nstHncias abertas e classes NvaKias...................................1+1
4.+ Atributos de classe O de instHncia......................................1+1
4.: G$todos de classe O estticos.............................................1+2
4.- Lerana..............................................................................1+2
4.3 Encapsulamento.................................................................1+-
4.4 'assagem de parHmetros....................................................1+3
4.& 'olimorfismo.....................................................................1+4
&. 5Ainter F G)dulo de %nterface Prfica.................................1:0
&.1 %ntroduo..........................................................................1:0
&.2 A classe 5A.........................................................................1:2
&.2.1 %tem 7sico.....................................................................1:2
&.2.2 ,m programa bem simples.............................................1:2
&.2.+ "osso primeiro obEeto P,%............................................1:+
&.2.: 6ontainers e 1idgets.......................................................1:3
&.2.- ,sando classes para estruturar o programa....................1:4
&.2.-.1 Elementos do 5Ainter...................................................1-1
&.2.3 'osicionando os bot>es...................................................1-+
&.2.4 Ganipulando os eventos Bevent handlerC........................1-3
&.2.4.1 Eventos do Gouse.......................................................1-;
&.2.4.2 @oco e eventos do teclado ...........................................130
&.2.& ,sando 6hecA7utton......................................................13:
&.2.; 6riando Genus...............................................................133
&.2.10 7arra de ferramentas.....................................................13&
&.2.11 Alarme com 5Ainter......................................................140
&.2.12 6riar uma Eanela de entrada de dados...........................141
&.2.1+ ,sando o configure.......................................................14-
&.2.1: ,sando a opo fill.......................................................144
&.2.1- 6anvas..........................................................................14&
;. 6P% e #ervidor L55'..........................................................1;1
;.1 ! 6P% B6ommon Pate1a( %nterfaceC...............................1;1
;.2 ! servidor Apache.............................................................1;2
;.+ L55' e L5G*..................................................................1;+
3
;.: 'ginas 9inHmicas.............................................................1;:
;.- #ervidor Apache................................................................1;:
10. 'rogramas 6P%..................................................................201
10.1 %ntroduo........................................................................201
10.2 Gais 'rogramas...............................................................20-
10.2.1 9ados do ambiente.......................................................20-
10.2.2 9ata e Lora do #ervidor atualiKadas............................20-
10.+ G$todos PE5 e '!#5.....................................................204
10.: ,sando 6LE6Q7!R......................................................20;
10.- ,sando 7oto 8adio........................................................211
10.3 ,sando te=to....................................................................212
10.4 ,sando 9rop 9o1nbo=...................................................21+
10.& ,sando o m)dulo cgitab..................................................21-
10.; ,sando arquivos de te=to para armaKenar informa>es. .21&
10.10 ,sando 6ooAies em programao 6P%.........................21;
10.11 @aKendo do1nload de arquivos......................................222
10.12 !utros 'rogramas..........................................................22+
8eferDncias 7ibliogrficas.......................................................22-
4
Introduo
Este te=to no tem a pretenso de ser uma bJblia da
linguagem '(thon, mas ele aborda a linguagem em sua
e=tenso, mostrando os aspectos mais peculiares como2
! interpretador '(thon e o ambiente para edio e
e=ecuo %9*ES
A estrutura bsica da linguagem e seus tipos de
dadosS
A definio de bloco por indentao ao inv$s de
marcadores de inJcio e fim de blocoS
A orientao a obEetosS
A interface grfica 5AinterS
E por fim como desenvolver um programa para
0eb.
*anada por Puido van 8ossum em 1;;1, o '(thon
atualmente possui um modelo de desenvolvimento comunitrio
e aberto, gerenciado pela organiKao sem fins lucrativos
'(thon #oft1are @oundation. '(thon $ simples de usar, e $ uma
verdadeira linguagem de programao que oferece tipos nativos
de alto nJvel como fle=Jveis vetores, matriKes e dicionrios. 'or
ser uma linguagem interpretada de alto nJvel, orientada a
obEetos e de tipagem dinHmica e forte. '(thon $ muito mais fcil
de usar do que as linguagens compiladas e o interpretador pode
ser usado interativamente, o que torna fcil e=perimentar
diversas caracterJsticas da linguagem, escrever e testar
programas e fun>es em um desenvolvimento bottom-up.
! nome da linguagem no tem nada a ver com os
famosos r$pteis e sim com o famoso sho1 da 776 NGont(
'(thonTs @l(ing 6ircusU. Gas neste e=ato momento se vocD
&
ainda no se convenceu com a linguagem '(thon, saiba que a
"asa e a %ndustrial *ight V Gagic, a companhia de efeito visual
que criou #tar 0ars, usa '(thon. Agora que vocD E se
convenceu, que tal continuar a e=aminar o te=to com maior
detalhe e testar o interpretador '(thon com os e=emplos
mostrados no te=to.
! '(thon e sua e=tensa biblioteca padro esto
disponJveis na forma de c)digo fonte ou binrio para a maioria
das plataformas a partir do site, http2OO111.p(thon.orgO, e deve
ser distribuJdos livremente. "o mesmo sJtio esto disponJveis
distribui>es e referDncias para diversos m)dulos, programas,
ferramentas e documentao adicional contribuJdos por
terceiros. Acesse as documenta>es atrav$s de
http2OOp(thon.orgOdocO onde vocD vai encontrar2 '(thon *ibrar(
8eference, '(thon 8eference Ganual, E=tending and
Embedding the '(thon %nterpreter, '(thonO6 A'% 8eference.
;
1. inter!retador Python
1.1 "ua hist#ria
"o final de 1;&; Puido van 8ossum criou o '(thon no
%nstituto de 'esquisa nacional para Gatemtica e 6iDncia da
6omputao B60%C, nos 'aJses 7ai=os, um sucessor da
linguagem chamada de A76. 5endo como foco principal o
aumento de produtividade do programador, em 1;;1, Puido
publicou o c)digo B verso 0.;.0C no grupo de discusso
alt.sources. Em 1;;: formouFse o principal f)rum de discusso
do '(thon, comp.lang.python, isto foi o marco para o
crescimento de usurios da linguagem. A verso 1.0 foi lanada
em Eaneiro de 1;;:. Al$m das funcionalidades que E estavam
presentes como classes com herana, tratamento de e=ce>es,
fun>es e os tipos de dados nativos, lista, dicionrios e strings,
sistema de m)dulos e assim por diante, esta nova verso incluJa
ferramentas para programao funcional como lambda, map,
filter e reduce. A ltima verso que Puido
lanou enquanto estava na 60% foi o '(thon 1.2. Puido
continuou o trabalho, em 1;;-, no 6"8% em 8eston, ,#A, de
onde lanou diversas vers>es. "a verso 1.: a linguagem
ganhou parHmetros nomeados
1
e suporte nativo a n<meros
comple=os, assim como uma forma de encapsulamento Berso
1.3 <ltima verso lanada no 6"8%C
A partir de 2000, o de desenvolvimento da linguagem se
mudou para a 7e!pen afim de formar o time '(thon*abs. !
<nico lanamento na 7e!pen foi o '(thon 2.0, e ap)s o
lanamento o grupo de desenvolvedores da '(thon*abs
agrupouFse na 9igital 6reations. ! '(thon 2.0 implementou list
1 A capacidade de passar parHmetro pelo nome e no pela posio na lista de
parHmetros.
10
comprehension, uma relevante funcionalidade de linguagens
funcionais como #E5* e LasAell, e essa verso 2.0 tamb$m
introduKiu um sistema coletor de li=o capaK de identificar e
tratar ciclos de referDncias. ! lanamento incluiu a mudana na
especificao para suportar escopo aninhado, assim como outras
linguagens com escopo esttico. ,ma grande inovao da
verso 2.2 foi a unificao dos tipos '(thon Bescritos em N6UC e
classes Bescritas em '(thonC em somente uma hierarquia, com
isto o modelo de obEetos do '(thon tornaFse consistentemente
orientado a obEeto e foi adicionado generator, inspirado em %con.
! incremento da biblioteca padro e as escolhas sintticas foram
fortemente influenciadas por Wava em alguns casos2 o pacote
logging introduKido na verso 2.+, o analisador sinttico
#AR, introduKido na verso 2.0 e a sinta=e de decoradores que
usa @, adicionadas na verso 2.:. Em 1 de outubro de 200& foi
lanada a verso 2.3, E visando a transio para a verso +.0 da
linguagem. Entre outras modifica>es, foram incluJdas
bibliotecas para multiprocessamento, W#!", EO#, al$m de uma
nova forma de formatao de cadeia de caracteres.
Atualmente a linguagem $ usada em diversas reas, como
servidores de aplicao e computao grfica. Est disponJvel
como linguagem script em aplica>es como !pen !ffice
B'(thon ,"! 7ridgeC e pode ser utiliKada em procedimentos
armaKenados no sistema gerenciador de banco de dados
'ostgre#.*B'*O'(thonC. X0%Q%'E9%A Y 24O11O200Z.
E=istem diversas implementa>es do '[5!" so elas2
$!ython Y esta $ a verso original escrita em N6U.
Acti%ePython F $ um padro industrial do '(thon, disponJvel
para 0indo1s, *inu=, Gac !# R, #olaris, A%R e L'F,R.
11
&ython Y esta $ a verso escrita em Wava e pode ser usada em
implementa>es que usam a biblioteca de classes Wava. eEa o
0ebsite do W(thon.
Python 'or .NE( Y usa a implementao 6p(thon, mas $
gerenciada por uma aplicao ."E5 e disponibiliKa as
bibliotecas ."E5. eEa '(thon for ."E5
IronPython Y 9iferente do '(thon ."et , ela $ uma
implementao completa de '(thon que gera a *inguagem
%ntermediria, e compila o c)digo '(thon diretamente para o
assembler ."E5.
PyPy F ,ma implementao do p(thon escrita em '(thon, at$ o
interpretador de b(tecode $ escrito em '(thon. Ela $ e=ecutada
usando o 6p(thon como um interpretador subEacente. ,m dos
obEetivos do proEeto $ incentivar a e=perimentao com a
linguagem pr)pria, tornandoFa mais fcil de modificar o
interpretador Buma veK que $ escrito em '(thonC. %nformao
adicional est disponJvel na pgina inicial do proEeto '('( .
1.) *icena
"o que tange as licenas de uso a verso 1.3.1 do '(thon
passou a ser compatJvel com a P'*, e na verso 2.1 a licena
foi renomeada para '(thon @oundation *icense, em 2001. 5odos
os direitos de propriedade intelectual adicionados deste ponto
em diante, comeando com '(thon 2.1 e suas vers>es alfa e
beta, so de titularidade da '(thon #oft1are @oundation B'#@C,
uma associao sem fins lucrativos organiKada sob inspirao da
12
Apache #oft1are @oundation BA#@C. eEa
http2OO111.p(thon.orgOpsfO para mais informa>es sobre '#@.
5E8G!# E 6!"9%\]E# 'A8A A6E##A8 !, 9E !,58A
@!8GA ,5%*%Â8 '[5L!"
_____________________________________________
6!"58A5! 9E *%6E"\A '#@
_____________________________________________
1. Este 6!"58A5! 9E *%6E"\A realiKaFse entre
'(thon #oft1are @oundation BN'#@UC e o %ndivJduo
ou !rganiKao BN*icenciadoUC acessando ou de
outra forma utiliKando o programa de computador
'(thon 2.1.1 em forma binria ou c)digoFfonte e
sua documentao associada.
2. "os termos e condi>es deste 6ontrato de
*icena, '#@ outorga ao *icenciado, por este
instrumento, uma *icena no e=clusiva, sem
encargos patrimoniais Bro(altiesC, de abrangDncia
mundial para reproduKir, analisar, testar, e=ecutar
ou e=por publicamente, preparar obras derivadas,
distribuir e de outra forma utiliKar '(thon 2.1.1,
isolado ou em qualquer verso derivada, contanto
que, por$m, este 6ontrato de *icena '#@ e o aviso
de direitos autorais '#@, i.e., N6op(right ` 2001
'(thon #oft1are @oundation, All 8ights 8eservedU
seEam incluJdos em '(thon 2.1.1, isolado ou em
qualquer verso derivada preparada pelo
*icenciado.
+. 6aso o *icenciado prepare uma obra derivada
baseada em '(thon 2.1.1 ou que o incorpore por
1+
inteiro ou qualquer trecho seu, e deseEe tornar esta
obra derivada disponJvel a outrem como aqui
previsto, ento o *icenciado concorda em incluir
em tal obra um breve sumrio das mudanas feitas
sobre '(thon 2.1.1.
:. '#@ torna '(thon 2.1.1 disponJvel ao *icenciado
N6!G! E#5aU. '#@ "b! !@E8E6E
.,A%#.,E8 PA8A"5%A# !,
9E6*A8A\]E#, ER'8E##A# !, 5a6%5A#.
6!G! EREG'*!, GA# "b! *%G%5A\b!,
'#@ "b! !@E8E6E E #E %#E"5A 9E
.,A%#.,E8 PA8A"5%A# !,
9E6*A8A\]E# 9E 6!GE86%A7%*%9A9E
!, A9E.,A\b! A @%"A*%9A9E#
E#'E6c@%6A#, !, 9E .,E ! ,#! 9E
'[5L!" 2.1.1 "b! %!*A8a .,A%#.,E8
9%8E%5!# 9E 5E86E%8!#.
-. '#@ "b! #E8a 8E#'!"#aE* 'E8A"5E
! *%6E"6%A9! !, .,A%#.,E8 !,58!#
,#,a8%!# 9E '[5L!" 2.1.1 '!8 'E89A# E
9A"!#, #EWAG %"6%9E"5A%#, E#'E6%A%#
!, 6!"#E.,E"5E#, 6!G! 8E#,*5A9! 9E
G!9%@%6A\b!, 9%#58%7,%\b!, ! !,58A
@!8GA 9E ,5%*%Â\b! 9E '[5L!" 2.1.1,
!, .,A*.,E8 9E #,A# !78A#
9E8%A9A#, GE#G! .,E L!,E##E #%9!
A%#A9A 9E#5A '!##%7%*%9A9E.
3. Este 6ontrato de *icena ser automaticamente
rescindido em caso de violao material de seus
termos e condi>es.
4. "ada neste 6ontrato de *icena pode ser
interpretado de forma a criar qualquer relao de
1:
agDncia, parceria ou EointFventure entre '#@ e o
*icenciado. Este 6ontrato de *icena no outorga
permisso para usar marcas ou nomes comerciais
de '#@ como conEunto distintivo para endossar ou
promover produtos ou servios do *icenciado ou
de qualquer terceiro.
&. Ao copiar, instalar ou de outra forma
utiliKar '(thon 2.1.1, o *icenciado obrigaFse aos
termos e condi>es deste 6ontrato de *icena.
_____________________________________________
1.+ ,so do Inter!retador Python
1.+.1 -ua. Python usar/
! 0indo1s no vem com '(thon. Gas no se preocuped
L diversas formas fceis de entrar no mundo '(thon usando
0indo1s. 6omo vocD pode ver, '(thon roda em muitos
sistemas operacionais. A lista completa inclui 0indo1s, o Gac
!#, o Gac !# R e todos os sistemas gratuitos compatJvel com
,"%R como o pr)prio *inu=. L tamb$m vers>es que rodam no
#un #olaris, A#O:00, Amiga, !#O2, 7e!# e muitas outras
plataformas que vocD provavelmente nunca ouviu falar.
1.+.) Python em Windo0s
"o 0indo1s, vocD tem diversas escolhas para instalar o
'(thon. A Active#tate tem um instalador '(thon para 0indo1s
que inclui a verso completa do '(thon, um %9E com um editor
de c)digo e e=tens>es 0indo1s para o '(thon que permitem
acesso a servios especJficos do 0indo1s, suas A'%s e o
1-
registro. ! Active'(thon pode ser bai=ado gratuitamente, mas
no $ open source. #e vocD realmente precisa da <ltima verso
do '(thon pule para a opo 2. A segunda opo $ usar o
instalador '(thon NoficialU, distribuJdo pelos pr)prios
desenvolvedores do '(thon. Esse instalador pode ser bai=ado
gratuitamente, tem c)digo fonte aberto e est sempre atualiKado.
1.+.).1 !o 11 Insta.ando o Acti%ePython
1. 7ai=e o Active'(thon em
http2OO111.activestate.comO'roductsOActive'(thonO.
2. #e vocD usa 0indo1s ;-, 0indo1s ;& ou 0indo1s GE, deve
instalar o 0indo1s %nstaller 2.0 antes de continuar.
+. 9D um clique duplo no arquivo Active'(thonF2.3.1.1F1in+2F
i=&3.msi.
:. #iga as instru>es na tela.
-. #e seu espao em disco for limitado, $ possJvel faKer uma
instalao personaliKada BecustomeC e dei=ar de instalar a
documentao, mas isso no $ recomendado.
3. Ap)s o t$rmino da instalao, feche o instalador e abra
%niciarFf'rogramasFfActive#tate Active'(thon 2.2Ff'(thon0in
%9E.
E2am!.e IDE Acti%ePython
'(thon0in 2.2.2 Bg+4, "ov 23 2002, 1022:2+4C XG#6 +2 bit
B%ntelCZ on 1in+2.
'ortions 6op(right 1;;:F2001 GarA Lammond
BmhammondhsAippinet.com.auC F
see iLelpOAbout '(thon0ini for further cop(right information.
fff
13
1.+.).) !o )1 Insta.ando o Python do Python.org
1. 7ai=e o instalador 0indo1s do '(thon em
http2OO111.p(thon.orgOdo1nloadOreleasesO2.4.2O
2. E=ecute o arquivo '(thonF2.4.2
+. #iga as instru>es na tela.
:. Ap)s o t$rmino da instalao, feche o instalador e abra
%niciarFf'rogramasFf'(thon 2.4Ff%9*E
B'(thon P,%C.

14
Figura 1: IDLE (Python GUI
). Python1 Introduo3 (i!os e $omandos Bsicos
).1 Inter!retador
'(thon $ uma linguagem interpretada, o que significa
que o c)digo no precisa ser compilado para que seEa e=ecutado.
Assim, o interpretador lD e e=ecuta o c)digo diretamente.
*inguagens interpretadas, normalmente, funcionam atrav$s de
i6ompilao WustF %nF5imei ou i%nterpretao pura ou em
7(tecodei. ocD pode criar seu arquivo '(thon e salvFlo com a
e=tenso N.p(U ou ainda pode e=ecutar no modo shell, ou seEa,
vocD digita o c)digo diretamente no interpretador. '(thon $
multi plataforma, roda em 0indo1s, *inu=, ,ni=, Gacintosh,
etc. 'ode ser utiliKado um ambiente para edio e e=ecuo
como o %9*E, que $ nativo da linguagem e para acessFlo em
0indo1s basta ir em %"%6%A8f'8!P8AGA#f'[5L!"
2.4f%9*E. Em computadores com 0indo1s, '(thon $ instalado
geralmente em j62k'(thon24T, apesar de vocD poder mudar isso
enquanto est e=ecutando o instalador. 'ara adicionar esse
diret)rio ao path, vocD pode digitar o seguinte comando no
9!#2 set path_?path?S62kp(thon24
).) Pa.a%ras 4eser%adas
#o palavras que no podem ser usadas para dar nomes
aos obEetos. #o2 and3 assert3 5rea63 c.ass3 continue3 de.3 de'3
e.i'3 e.se3 e2ce!t3 e2ec3 'ina..y3 'or3 'rom3 g.o5a.3 i'3 im!ort3 in3
is3 .am5da3 not3 or3 !ass3 !rint3 raise3 return3 try3 0hi.e.
).+ Digitando comandos no ID*E
'odemos usar o %9*E como uma calculadora,
1&
visualiKando resultados e usando os resultados em clculos
futuros.
fff a_1
fff b_2
fff alb
fff aOb
fff aIb
).7 (i!os de Dados
#o categorias de valores que so processados de forma
semelhante. 'or e=emplo, n<meros inteiros so processados de
forma diferente dos n<meros de ponto flutuanteBdecimaisC e dos
n<meros comple=os.
5ipos primitivos2 so aqueles E embutidos no n<cleo da
linguagem
#imples2 n<meros Bint, long, float, comple=C e cadeias de
caracteres BstringsC
Int2 n<meros inteiros de precis!o "i#a
1 , 2 , 1- , 1;
*ong1 n<meros inteiros de precis!o arbitr$ria
1* , 10000* , F;;;;;;;*
8.oats1 n<meros racionais de preciso %ari$%el.
1.0 , 10.- , F1;000.0000- , 1-eF-
$om!.e21 n<meros comple=os.
1l1E , 20E , 1000l100W
1;
$om!ostos1 listas, dicionrios, tuplas e conEuntos.
(i!os de'inidos !e.o usurio1 so correspondentes a classes
Borientao obEetoC.
).9 N:mero !onto '.utuante e com!.e2o
L total suporte para ponto flutuanteS operadores com
operandos de diferentes tipos convertem o inteiro para ponto
flutuante2
fff + I +.4- O 1.-
4.-
fff 4.0 O 2
+.-
"<meros comple=os tamb$m so suportadosS n<meros
imaginrios so escritos com o sufi=o jET ou jWT. "<meros
comple=os com parte real no nula so escritos como
jBreallimagECT, ou podem ser criados pela chamada de
funo jcomple=Breal, imagCT.
fff 1E I 1W
BF1l0EC
fff 1E I comple=B0,1C
BF1l0EC
fff +l1EI+
B+l+EC
fff B+l1ECI+
B;l+EC
20
fff B1l2ECOB1l1EC
B1.-l0.-EC
"<meros comple=os so sempre representados por dois
n<meros ponto flutuante, a parte real e a parte imaginria. 'ara
e=trair as partes de um n<mero &, utiliKe &.real e &.imag.
fff a_1.-l0.-E
fff a.real
1.-
fff a.imag
0.-
As fun>es de converso para ponto flutuante e inteiro,
floatBC, intBC e longBC no funcionam para n<meros comple=os,
pois no e=iste maneira correta de converter um n<mero
comple=o para um n<mero real. ,tiliKe absB&C para obter sua
magnitude Bcomo ponto flutuanteC ou K.real para obter sua parte
real.
fff a_+.0l:.0E
fff floatBaC
5racebacA Bmost recent call lastC2
@ile emstdinfe, line 1, in /
5(peError2 canTt convert comple= to floatS use absBKC
fff a.real
+.0
fff a.imag
:.0
fff absBaC
-.0
21
"o modo interativo, a <ltima e=presso a ser impressa $
atribuJda a varivel
2
N;< . %sso significa que ao utiliKar '(thon
como uma calculadora, $ muitas veKes mais fcil prosseguir com
os clculos da seguinte forma2
fff ta=a _ 12.- O 100
fff preco _ 100.-0
fff precoI ta=a
12.-32-
fff preco l n
11+.032-
fff roundBn, 2C
11+.03
Essa varivel especial deve ser tratada somente para
leitura pelo usurio. "unca lhe atribua e=plicitamente um valor,
do contrrio estaria criando uma outra varivel BhomonimaC
independente, que mascararia o comportamento mgico da
varivel especial.
).= "trings
Al$m de n<meros, '(thon tamb$m pode manipular
strings
+
. ! %9*E no est preparado para trabalhar com
caracteres acentuados. 9urante a e=ecuo de um programa em
'(thon, use este comando na primeira linha para acentuar os
caracteres2 > ?@? coding1 c!1)9) ?@?
2 *ocal de mem)ria usado para guardar valores.
+ #trings so sequDncias de caracteres entre aspas ou ap)strofo,
modificveis apenas com atribuio de novos valores.
22
fff Tmais menosT
Tmais menosT
fff NvidaisU
evidaise
fff TU!*AU, 7!G 9%A.T
TU!*AU, 7!G 9%A.T
fff eke!*A,ke 7!G 9%A.e
Te!*A,e 7!G 9%A.T
#trings que cont$m mais de uma linha podem ser
construJdas de diversas maneiras. 5erminadores de linha podem
ser embutidos na string com barras invertidas.
g FIF coding2 cp12-2 FIF
g'rograma que imprime oi
oi _ eEsta $ uma string longa contendoknk
diversas linhas de te=to assim como vocD faria em 6.knk
!bserve que os espaos em branco no inicio da linha so k
significativos.e
print oi
8esultado da e=ecuo2
Esta ' uma string longa conten(o
(i%ersas linhas (e te#to assim como %oc) "aria em *.
+bser%e ,ue os espa-os em branco no inicio (a linha s!o
signi"icati%os.
2+
!bserve que terminadores de linha ainda precisam ser
embutidos na string usando knS a quebra de linha ap)s a <ltima
barra de escape seria ignorada.
"o entanto, se a tornarmos uma string NcruaU Bra.C, as
sequDncias de kn no so convertidas para quebras de linha.
5anto a barra invertida quanto a quebra de linha no c)digoFfonte
so incluJdos na string como dados. 'ortanto, o e=emplo2
fffoi _ reEsta eh uma string longa contendoknk
diversas linhas de te=to assim como voce faria em 6.knk
!bserve que os espaos em branco no inicio da linha so k
significativos.e
fffprint oi
8esultado2
Esta eh uma string longa conten(o/n/
(i%ersas linhas (e te#to assim como %oce "aria em *./n/
+bser%e ,ue os espa-os em branco no inicio (a linha s!o /
signi"icati%os.
As strings tamb$m podem ser delimitadas por pares de
aspas ou ap)strofos trJplices2 <<<ou AAA. "este caso no $
necessrio embutir terminadores de linha, pois o te=to da string
ser tratado fielmente como o original.
fff print eee ola
tudo bem e ai como
vai.eee
8esultado2
2:
ola
tu(o bem e ai como
%ai.
! interpretador imprime o resultado de opera>es sobre
strings da mesma forma que as strings so formatadas na
digitao2 dentro de aspas, e com caracteres especiais embutidos
em escape se,uences
0
, para mostrar seu valor com preciso a
string ser delimitada por aspas duplas se ela cont$m um <nico
caractere de aspas simples e nenhum de aspas duplas, caso
contrrio a string ser delimitada por aspas simples
-
. #trings
podem ser concatenadas BcoladasC com o operador l, e repetidas
com I2
fff palavra_ipalavra iliAi
fff palavra
ipalavra Ai
fff imilpalavra I - l ifi
impalavra Apalavra Apalavra Apalavra Apalavra Afi
fffprint eoie ividai
oi vida
fff print ioii ividai g 9uas strings literais Eustapostas so
automaticamente concatenadas.
oivida
fff
: *aractere especial como /n 1 no%a linha
- ! comando print, descrito posteriormente, pode ser utiliKado para escrever
strings sem aspas ou escape se,uences 2/n3.
2-
#trings podem ser inde=adasS como em 6, o primeiro
Jndice da string $ o 0. "o e=iste um tipo separado para
caracteresS um caractere $ simplesmente uma string unitria.
Assim como na linguagem %con, substrings
3
podem ser
especificadas atrav$s da notao slice
4
2 dois Jndices separados
por dois pontos.
fff palavraX:Z
ivi
fff palavraX022Z
ipai
fff palavraX22:Z
ilai
cndices de fatias seguem uma padroniKao <tilS a
omisso do primeiro Jndice equivale a Kero, a omisso do
segundo Jndice equivale ao tamanho da string que est sendo
fatiada.
fff palavraX22Z g os dois primeiros caracteres
ipai
fff palavraX22Z g todos menos os 2 primeiros
ilavra Ai
fff palavraXF1Z g <ltimo caractere
iAi
fff palavraX2F2Z g todos menos os 2 <ltimos
ipalavrai
3 ,ma pedao da string.
4 @atiar.
23
fff palavraXF122F1Z g imprime ao contrrio a palavra
iA arvalapi
!s principais m$todos das strings so2
capitaliKe F transforma o primeiro caractere em mai<scula.
count F conta o n<mero de ocorrDncias da substring.
upper F transforma string em mai<scula.
fff a_esergioe
fff a.capitaliKeBC
i#ergioi
fff a.countBieiC
1
fff a.upperBC
i#E8P%!i
).B "trings ,nicode
A partir de '(thon 2.0 um novo tipo foi introduKido2 o
obEeto ,nicode. Ele pode ser usado para armaKenar e manipular
dados ,nicode BveEa http2OO111.unicode.orgOC e se integra bem
aos demais obEetos strings pr$ e=istentes, de forma a realiKar
auto convers>es quando necessrio. ,nicode tem a vantagem de
prover um <nico n<mero ordinal para cada caractere usado em
te=tos modernos ou antigos. 6riar strings ,nicode em '(thon $
to simples quanto criar strings normais2
24
fff uU!la ida dU
uT!la ida dT
! juT antes das aspas ou ap)strofo indica a criao de
uma string ,nicode. #e vocD deseEar incluir caracteres especiais
na string, vocD pode faKDFlo atrav$s da codificao '(thon
Unico(e-Escape.
fff uT!laku0020ida dT
uT!la ida dT
! c)digo de escape ku0020 indica a insero do caracter
,nicode com valor ordinal 0=0020
&
na posio determinada.
Al$m dessa codificao padro, '(thon oferece um outro
conEunto de maneiras de se criar strings ,nicode.
A funo interna unicodeBC provD acesso a todos os
,nicode codecs
;
registrados. Alguns dos mais conhecidos
codecs so 2 Latin-1, 56*II, U7F-8, and U7F-19. !s dois
<ltimos so codifica>es de tamanho varivel para armaKenar
cada caractere ,nicode em um ou mais b(tes. A codificao
padro $ A#6%%, que trata normalmente de caracteres no
intervalo de 0 a 124 mas reEeita qualquer outro com um erro.
.uando uma string ,nicode $ impressa, escrita em arquivo ou
convertida por strBC, a codificao padro $ utiliKada.
fff ueabce
uTabcT
& Espao em branco.
; 6oders and 9ecoders Y 6odificadores e decodificadores.
2&
fff strBueabceC
TabcT
fff uepqre
uTk=e:k=f3k=fcT
fff strBuepqreC
@ile emp(shellg1fe, line 1, in mmodulef
strBuepqreC
,nicodeEncodeError2 iasciii codec canit encode characters in
position 0F22 ordinal not in rangeB12&C
Erro ? caractere no C !adro A"$II
'ara se converter uma string ,nicode em uma string &F
bits, usando uma codificao especJfica, basta invocar o m$todo
encodeBC de obEetos ,nicode, passando como parHmetro o nome
da codificao destino. s preferJvel utiliKar nomes de
codificao em letras min<sculas.
fff uepqre.encodeBiutfF&iC
ik=c+k=a:k=c+k=b3k=c+k=bci
5amb$m pode ser utiliKada a funo unicodeBC para
efetuar a converso de uma string em outra codificao. "este
caso, o primeiro parHmetro $ a string a ser convertida e o
segundo o nome da codificao almeEada. ! valor de retorno da
funo $ a string na nova codificao.
fff unicodeBik=c+k=a:k=c+k=b3k=c+k=bci, iutfF&iC
uik=e:k=f3k=fci
2;
).D *istas
A mais verstil estrutura de dados do '(thon $ a lista
BlistC, que pode ser escrita como uma lista de valores separados
por vJrgula e entre colchetes. Gais importante, os valores
contidos na lista no precisam ser do mesmo tipo e podem ter
seus elementos modificados.
fff lista _ X1,eume,1.0Z
fff lista.insertB+,ehumeC
fff print lista
X1, iumi, 1.0, ihumiZ
,ma varivel chamada lista retorna uma lista com um
valor inteiro, uma string e um valor float. Em seguida, foi
inserida no final da lista Bo n<mero i+i indica a posio trDs
comeando do KeroC uma outra string. *istas possuem alguns
m$todos2
appen(( F adiciona um elemento ao fim da lista.
count( F retorna o n<mero de veKes que um determinado
elemento aparece na lista.
e#ten(( F estende a lista com novos elementos passados.
in(e#( F retorna o Jndice Bou posioC de um determinado
elemento da lista.
insert( F insere um determinado elemento numa especificada
posio.
pop( F remove o elemento da posio indicada e o retorna.
remo%e( F remove o primeiro elemento da lista.
re%erse( F inverte a ordem dos elementos da lista.
+0
sort( F ordena os elementos da lista.
fff l _ X10,-3,+2,&;,2-,1:Z
fff l.appendB;0C gappend
fff l
X10, -3, +2, &;, 2-, 1:, ;0Z
fff l.insertB+,-0C ginsert
fff l
X10, -3, +2, -0, &;, 2-, 1:, ;0Z
fff l.popB4C gpop
;0
fff l
X10, -3, +2, -0, &;, 2-, 1:Z
fff l.inde=B&;C ginde=
:
fff a _ X1-,;0,3&Z
fff a.e=tendBlC ge=tend
fff a
X1-, ;0, 3&, 10, -3, +2, -0, &;, 2-, 1:, i-i, i-iZ
fff a.sortBC gsort
fff a
X10, 1:, 1-, 2-, +2, -0, -3, 3&, &;, ;0, i-i, i-iZ
9a mesma forma que Jndices de string, Jndices de lista
comeam do 0, listas tamb$m podem ser concatenadas e sofrer o
operado>es de slice(cortes.
+1
Este e=emplo $ para entender o slice.
fffAX02+Z
X10,1:,1-Z
).E (u!.as
#o obEetos como as listas, com a diferena de que tuplas
so imutveis como strings. ,ma veK criadas, no podem ser
modificadas. ,saFse ou no BC como delimitador.
fff tupla _ BeGariae, e'edroe, eWos$eC
fff tuplaX0Z
iGariai
fff tuplaX0Z_e@timae
@ile emp(shellg2-fe, line 1, in mmodulef
tuplaX0Z_e@timae
5(peError2 ituplei obEect does not support item assignment
Erro ? na tentati%a de atri5uir um no%o %a.or.
fff tupla_ 1,2,+
ffftupla
B1,2,+C
,m problema especial $ a criao de tuplas contendo 0
+2
ou 1 itens2 a sinta=e tem certos truques para acomodar estes
casos. 5uplas vaKias so construJdas por uma par de parDnteses
vaKios. E uma tupla unitria $ construJda por um <nico valor e
uma vJrgula ou isto entre parDnteses Bsem a vJrgula a tupla no
ser geradadC. @eio, mas efetivo2
fff vaKio _ BC
fff unica _ ToiT,
fff lenBvaKioC
0
fff lenBunicaC
1
fff unica
BToiT,C
! comando t _ 12+,ioii $ um e=emplo de empacotamento
em tupla
10
2 os valores 12+ e ToiT so empacotados Euntos em uma
tupla. A operao inversa tamb$m $ possJvel desempacotamento
de sequDncia
11
2
fff t_12+,ioii
fff =,(_t
fff =
12+
fff (
ioii
).1F Dicionrios
10 5uple pacAing.
11 #equence unpacAing.
++
9icionrios so conEuntos no ordenados de pares, onde
o primeiro elemento do par $ o Jndice chamado de chave e o
segundo de valor. ,m dicionrio, em '(thon, suporta qualquer
tipo de obEeto, seEa ele uma lista ou at$ mesmo outros
dicionrios e pode ser modificado. 'ara criar um dicionrio
basta declarar pares Nchave2valorU separados por vJrgula e
delimitados por chaves.
fff dic _ t12iumi, 22idoisi, +2itrDsiu
fff dicX1Z
iumi
fff dicX:Z_iquatroi
fff dic
t12 iumi, 22 idoisi, +2 itrk=easi, :2 iquatroiu
!s dicionrios possuem alguns m$todos, entre eles2
itemsGH F esse m$todo retorna uma lista de tuplas, ou seEa, todos
os pares chave2valor na forma de tuplasS
fff dic.itemsBC
XB1, iumiC, B2, idoisiC, B+, itrk=easiC, B:, iquatroiCZ
6eysGH F esse m$todo retorna somente as chavesS
fff dic.Ae(sBC
X1, 2, +, :Z
%a.uesGH F esse m$todo retorna somente os valoresS
+:
fff dic.valuesBC
Xiumi, idoisi, itrk=easi, iquatroiZ
getGcha%eH F retorna o valor da chave passada como parHmetroS
fff dic.getB2C
idoisi
fff print dic.getB-C
"one
has;6eyGcha%eH F verifica se e=iste a chave passada como
parHmetro, retornando true ou falseS
fff dic.hasnAe(B-C
@alse
fff dic.hasnAe(B2C
5rue
u!dateGdicionrioH F atualiKa um dicionrio com base em outro
passado como parHmetro. 6aso elementos do primeiro
dicionrio e=istam tamb$m no segundo, esse sobrescreve o
primeiro, ou se o segundo conter elementos e=clusivos, sero
adicionados ao primeiro dicionrio.
fff dic _ t12iumi, 22idoisi, +2itrDsiu
fff dic2 _ t12ionei, 22it1oi, -2ifiveiu
fff dic.updateBdic2C
fff dic
t12 ionei, 22 it1oi, +2 itrk=easi, -2 ifiveiu
+-
dictBC F produK dicionrios diretamente a partir de uma lista de
chavesFvalores, armaKenadas como tuplas.
fff dictBXBisapoi, :1+;C, Bipatoi, :124C, Bigatoi, :0;&CZC
tisapoi2 :1+;, igatoi2 :0;&, ipatoi2 :124u
fff dictBXB=, =II2C for = in B2, :, 3CZC g usando construtor de
gprocessamento de lista
t22 :, :2 13, 32 +3u
fffdictBsapo_10,lua_-,cidade_+C
tiluai2 -, icidadei2 +, isapoi2 10u
).11 Doc"tring e comentrio
Docstring F #o strings que servem para documentar c)digo.
7asta criar a string entre sequDncias de trDs aspas.
fff def mBC2
eee
Autor 2 "ogueira
9ata 2 2+O0+O200;
ersao2 0.0
eee
print eGinha funoe
ffm.nndocnn gmostra documentao da funo
Autor 2 "ogueira
9ata 2 2+O0+O200;
+3
ersao2 0.0
$omentrioG>H F usado para faKer comentrio em '(thon, tudo
ap)s este simbolo $ considerado como comentrio na linha.
g primeiro comentrio
#'AG _ 1 g e esse $ o segundo comentrio
g ... e ainda um terceiro d
#58%"P _ eg Este no $ um comentrio.e
).1) !eradores AritmCticos
l adio
F subtrao
I multiplicao
O diviso
? m)dulo
II e=ponenciao
!s operadores : e ; faKem concatenao de strings, listas e
tuplas.
fff 2II+ g s o mesmo que dois ao cubo
&
+4
fff 2IIB+l3C g 9ois elevado a nove
-12
fff 4 ? 2 g ! resto da diviso entre 4 e 2
1
! sinal de igual Bj_TC $ utiliKado para atribuio de um
valor a uma varivel.
fff largura _ 20
fff altura _ -I;
fff largura I altura
;00
,m valor pode ser atribuJdo a diversas variveis
simultaneamente2
fff = _ ( _ K _ 0 g 0 $ atribuJdo a =, ( e K
fff =
0
fff (
0
fff K
0
).1+ !eradores de atri5uio
l_ #oma com valor atribuJdo
F_ #ubtrai o valor atribuJdo
O_ 9ivide pelo valor atribuJdo
+&
I_ Gultiplica pelo valor atribuJdo
fff a_-
fff b_3
fff al_b g a_alb
fff a
11
fff b
3
fff aF_b g a_aFb
fff a
-
fff a_10
fff b_-
fff aO_b g a_aOb inteiro
fff a
2
fff aI_b g a_aIb
fff a
10
).17 !eradores de condio
_ _ %gual
d _ 9iferente
f Gaior
m Genor
f_ Gaior ou igual
+;
m_ Genor ou igual
in Est dentro da sequDncia ou do
dicionrio
fff - in B2,+,-C
5rue
fff eme in eWorgee
@alse
fff a_1
fff b_2
fff a __ b g __ testa se a $ igual a b
@alse
fff a d_ b g d_ testa se a $ diferente de b
5rue
fff a mf b g mf tamb$m testa se a $ diferente de b
5rue
fff a f b g f testa se a $ maior que b
@alse
fff a m b g m testa se a $ menor que b
5rue
fff 2Ia f_ b g testa se o dobro de a $ maior ou igual a b
5rue
Em '(thon, a sinta=e a seguir $ vlida2
fff i' FI2I1F1
print =
:0
).19 !eradores .#gicos
and e
or ou
not no
is $
%s not no $
).19.1 E2!ressJes 5oo.enas

5amb$m chamadas e=press>es l)gicas. 8esultam em
verdadeiro B5rueC ou falso B@alseC. #o usadas em comandos
condicionais e de repetio. #ervem para analisar o estado de
uma processamento e permitir escolher o pr)=imo passo. A
e=presso $ avaliada da esquerda para a direita. #e o resultado
Bverdadeiro ou falsoC puder ser determinado sem avaliar o
restante, este $ retornado imediatamente.
fff 1_ _1
5rue
fff 1_ _2
@alse
fff 1_ _1 or 1_ _2
5rue
fff 1_ _1 and 1_ _2
@alse
fff 1m2 and 2m+
5rue
fff not 1m2
:1
@alse
fff not 1m2 or 2m+
5rue
fff not B1m2 or 2m+C
@alse
fff ealoe and 1
1
fff ealoe or 1
ialoi
fff 0 or 100
100
fff @alse or 100
100
fff eabce or 1
iabci
fff 1 and 2
2
fff 0 and +
0
ff @alse and +
@alse
fff 1 and 2 or +
2
fff 0 or 2 and +
+
fff 1 and not 0
5rue
:2
).19.) !eradores1 in 3 is 3 is not
fffa_-
fffb_a
fffa is b
5rue
fffa_-
fffb_3
fffa is b
@alse
fffa is not b
5rue
fffa_X1,2,+Z
fff1 in a
5rue
fffa_@alse
fffb_5rue
fffc_ a and b garmaKenar em c o resultado de uma e=presso
booleana
fffc
@alse
$om!arando o5Ketos seLuMncias de mesmo ti!o1
fffB1,2,+C m B1,2,:C
5rue
fffiA76imi6imi'(thoni
5rue
:+
s permitido comparar obEetos de diferentes tipos. !
resultado $ determinJstico, por$m, arbitrrio2 os tipos so
ordenados pelos seus nomes. Ento, uma lista $ sempre menor
do que uma string, uma string $ sempre menor do que uma
tupla, etc. 5ipos num$ricos mistos so comparados de acordo
com seus valores num$ricos, logo 0 $ igual a 0.0, etc Besta
comparao no $ confivel podendo mudar com a versoC
).1= Nari%eis
#o nomes dados a reas de mem)ria2 "omes podem ser
compostos de algarismos, letras ou n. ! primeiro caractere no
pode ser um algarismo. 'alavras reservadas Bif, 1hile, etcC so
proibidas. As variveis servem para guardar valores
intermedirios, construir estruturas de dados,etc... ,ma varivel
$ modificada usando o comando de atribuio2
%ar _ e#press!o
s possJvel tamb$m atribuir a vrias variveis
simultaneamente2
%ar1<%ar=<...<%ar> ? e#pr1<e#pr=<...<e#pr>
'(thon $ uma linguagem dinamicamente tipada, ou seEa,
suporta uma varivel que pode ter diferentes tipos durante a
e=ecuo do programa. Embora no seEa e=plJcita, ela assume
um <nico tipo no momento em que se atribui um valor a ela.
fff var _ +
fff t(peBvarC
mt(pe iintif
fff var _ e+e
fff t(peBvarC
::
mt(pe istrif
fff var _ +.0
fff t(peBvarC
mt(pe ifloatif
'ara descobrir o tipo da varivel, basta usar a funo
type(. 6om linguagem dinHmica, vocD garante a simplicidade e
fle=ibilidade da funo. Em '(thon, tudo $ obEeto, que possui
atributos e m$todos e pode ser atribuJdo a uma varivel ou
passado como argumento de uma funo. 'or e=emplo, uma
varivel que cont$m uma string $ um obEeto, pois qualquer
string possui um m$todo chamado upper que converte a string
para mai<sculo.
fff a _ ealoe
fff a.upperBC
iA*!i
!s principais tipos de obEetos em '(thon so inteiros,
floatsBreaisC, stringsBte=toC, listas, tuplas, dicionrios. 'odeFse
transformar o tipo original de um obEeto para inteiro, float e
string por meio de fun>es int, float e string.
).1B !erador O
Esse operador $ muito <til para formatao de te=to.
E=istem trDs tipos de formatao2
Os Y substitui strings
Od Y substitui inteiros
O' Y substitui floats
:-
fff nome _ eElianee
fff print eGeu nome $ ?se ? nome
Geu nome $ Eliane
fff =_eabaca=ie
fff (_eamareloe
fff print i! ?s $ ?s.e ?B=, (C
! abaca=i $ amarelo.
fff num%nt _ 1;
fff print eEu tenho ?d anose ? num%nt
Eu tenho 1; anos
fff num@loat _ 1.3
fff print eAltura2 ?.2f me ? num@loat
Altura2 1.30 m
fff num@loat _ -:.&0
fff print e'eso2 ?10.1f Age ? num@loat
'eso2 -:.& Ag
N?.2fU corresponde a duas casas decimais e N?10.1U, a deK
espaos, uma casa decimal.
:3
+. $ontro.e de 8.u2o e Estrutura de Dados
+.1 $ontro.e de 8.u2o
Assim como nas outras linguagens, '(thon possui
estruturas de controle de flu=o Bcondio e laoC tamb$m.
+.1.1 Instruo1 0hi.e
8epete uma sequDncia de comandos enquanto uma dada
e=presso booleana $ avaliada como verdadeira. Em '(thon,
como em 6, qualquer valor inteiro no nulo $ considerado
verdadeiro BtrueC, Kero tem valor falso B"alse. A condio pode
ser ainda uma lista ou string, na verdade qualquer sequDnciaS
qualquer coisa com comprimento no nulo tem valor true e
sequDncias vaKias tem valor "alse. !s operadores padro para
comparao so os mesmos de 62 m Bmenor queC, f Bmaior queC,
__BigualC, m_ Bmenor ou igualC, f_ Bmaior ou igualC and d_
BdiferenteC.
8ormato1 0hi.e e#press!o1 > no se esLuea da indentao
coman(o
...
coman(o
fff a_10
fff 1hile af&2
aF_1
print a
;
&
fff
:4
E2em!.o sCrie de 8i5onacci1
fff g #erie de @ibonacci 2
... g A soma de dois elementos define o pr)=imo
fff a,b_0,1
fff 1hile bm10002
print b,
a,b_b,alb
1 1 2 + - & 1+ 21 +: -- &; 1:: 2++ +44 310 ;&4
! corpo do lao $ indentado
12
. '(thon BaindadC no
possui facilidades automticas de edio de linha. "a prtica
vocD ir preparar scripts '(thon comple=os em um editor de
te=toS a maioria dos editores de te=to possui facilidades de
indentao automtica. .uando comandos compostos forem
alimentados ao interpretador interativamente, devem ser
encerrados por uma linha em branco BE que o parser no tem
como adivinhar qual $ a <ltima linha do comandoC. !bserve que
toda linha de um mesmo bloco de comandos deve possuir a
mesma indentao.
6omo em todo comando de repetio, $ importante evitar os
chamados Nlaos infinitosU
fff a _ 10
fff 1hile af&2
print a,
a _ al1
122 %ndentao em '(thon $ a maneira de agrupar comandos.
:&
10 11 12 1+ 1: 1- 13 14 1& 1; 20 21 22 2+ 2: 2- 23
24 2& 2; +0 +1 +2 ++ ...
6trlF6 aborta comando %9*E.
+.1.) Instruo1 'or
A instruo 'or interage com uma sequDncia, ou seEa, requer um
obEeto lista ou qualquer outro de sequDncia.
'or i in se,u)ncia1
coman(o
@..
coman(o
fff a _ XiWooi, i8afaeli, i9ouglasiZ
fff a
XiWok=e+oi, i8afaeli, i9ouglasiZ
fff for i in a2
print i
Woo
8afael
9ouglas
fff g Gedindo algumas strings2
fff a _ XTgatoT, TEanelaT, TvivendoTZ
fff for = in a2
print =, lenB=C
gato :
Eanela 3
vivendo 4
:;
A construo for em '(thon difere um pouco, do que se
est acostumado, do 6 ou 'ascal. Ao inv$s de se iterar sobre
progress>es aritm$ticas Bcomo em 'ascalC, ou fornecer ao
usurio a habilidade de definir tanto o passo da iterao quanto a
condio de parada Bcomo em 6C, o 'or de '(thon itera sobre os
itens de uma sequDncia Buma lista ou uma stringC na ordem em
que aparecem.
8uno rangeGPinicio3Q'imP3!assoQH2 #e vocD precisar iterar
sobre sequDncias num$ricas, a funo interna rangeBC $ a
resposta. Ela gera listas contendo progress>es aritm$ticas.
fff rangeB;C
X0, 1, 2, +, :, -, 3, 4, &Z
! ponto de parada fornecido nunca $ gerado na listaS
rangeB;C gera uma lista com ; valores, e=atamente os Jndices
vlidos para uma sequDncia de comprimento ;. s possJvel
iniciar o intervalo em outro n<mero, ou alterar a raKo da
progresso Binclusive com passo negativoC2
fff rangeB-, 10C
X-, 3, 4, &, ;Z
fff rangeB0, 10, +C
X0, +, 3, ;Z
fff rangeBF10, F100, F+0C
XF10, F:0, F40Z
+.1.+ $.usu.as break, continue e else
-0
! breaA, suspende o lao mais interno de um for ou
1hile. ! continue, continua o programa no pr)=imo comando
situado fora do lao mais interno. *aos podem ter uma clusula
else, que $ e=ecutada sempre que o lao se encerra por e=austo
da lista Bno caso do forC ou quando a condio se torna falsa Bno
caso do 1hileC, mas nunca quando o lao $ encerrado por um
breaA.
fff for n in rangeB2, 10C2
for = in rangeB2, nC2
if n ? = __ 02
print n, iiguali, =, iIi, nO=
breaA
else2
g encontrou numero primo
print n, ieh um numero primoi
fff
2 eh um numero primo
+ eh um numero primo
: igual 2 I 2
- eh um numero primo
3 igual 2 I +
4 eh um numero primo
& igual 2 I :
; igual + I +
+.1.7 Instruo i'
Em '(thon, no $ permitido faKer atribui>es em um i",
ento $ necessrio usar o operador N_ _U quando fiKer
-1
compara>es. A palavra eli" $ a abreviao de Nelse ifU.
fff if = m 02
print e"egativoe
elif = _ _ 02
print eêroe
elif = m_ 102
print eEntre 1 e 10e
elif = m_ 202
print eEntre 11 e 20e
elif = m_ +02
print eEntre 21 e +0e
else2
print eAcima de +0e
E=emplos2
a _ inputBeEntre com um numero2eC
if a m 02
print a,e $ negativoe
elif a_ _02
print a,e $ Keroe
else2
print a,e $ positivoe
print e!brigadode
E=ecuo 12
Entre com um numero20
0 $ Kero
!brigadod
E=ecuo 22
-2
Entre com um numero22
2 $ positivo
!brigadod
+.1.9 $onstruo !ass
A construo pass no faK nada. Ela pode ser usada
quando a sinta=e e=ige um comando mas a semHntica do
programa no requer nenhuma ao. 'or e=emplo2
fff 1hile 5rue2
pass g 7us(F1ait Bespera ocupadaCF para com
g a interrupo de teclado
+.1.= (Ccnicas de *ao
mCtodo iteritemsGH F para obter chaveOvalor ao percorrer um
dicionrio com lao.
fffdicionario_t12iumi, 22idoisi, +2itresiu
ffffor i, E in dicionario.iteritensBC2
print i, E
1 um
2 dois
'uno enumerateGH F obtem o Jndice e o valor correspondente
em uma lista.
ffflista_Xiumi, idoisi, itresiZ
ffffor i,E in enumerateBlistaC2
-+
print i, E
0 um
1 dois
2 tres
'uno Ri!GH F percorrer duas sequDncias simultaneamente com
lao e agrupFlos.
fff questao _ XTnomeT, TconviteT, Tsapato favoritoTZ
fff resposta _ XTEoseT, TespecialT, TmarromTZ
fff for q, a in KipBquestao, respostaC2
print T.ual seu ?s/ Eh ?s.T ? Bq, aC
.ual seu nome/ Eh sergio.
.ual seu convite/ Eh especial.
.ual seu sapato favorito/ Eh marrom.
'uno re%ersedGH F percorrer uma lista em ordem reversa.
ffflista_X1,2,+Z
ffffor i in reversedBlistaC2
print i
+
2
1
'uno sortedGH F retorna lista na forma ordenada.
ffflista_Xiai,ibi,iei,iciZ
ffffor i in sortedBlistaC2
print i,
-:
a b c e
+.2 Estrutura de 9ados
+.).1 ,sando *istas como Pi.has
! <ltimo elemento a entrar $ o primeiro a sair.
fff pilha _ X+, :, -Z
fff pilha.appendB3C
fff pilha.appendB4C
fff pilha
X+, :, -, 3, 4Z
fff pilha.popBC
4
fff pilha
X+, :, -, 3Z
fff pilha.popBC
3
fff pilha.popBC
-
fff pilha
X+, :Z
+.).) ,sando *istas como 8i.as
! primeiro elemento que entra $ o primeiro que sai.
fff fila _ XeEricae, eWoe, eGigueleZ
fff fila.appendBe5ereKaeC g entra 5eresa
fff fila.appendBePilsoneC g entra Pilson
fff fila.popB0C
TEricaT
--
fff fila.popB0C
TWoT
fff fila
XTGiguelT, T5eresaT, TPilsonTZ
+.).+ 8unJes so5re .istas1 'i.terGH3 ma!GH3 e reduceGH
S'i.terGfuno3 sequnciaHA F retorna uma sequDncia consistindo
dos itens pertencentes a sequDncia para os quais "un-!oBitemC $
verdadeiro. #e a sequDncia for string ou tuple, o resultado ser
sempre do mesmo tipoS caso contrrio, ser sempre uma lista.
'or e=emplo, para computar n<meros primos2
fff def fB=C2 return = ? 2 d_ 0 and = ? + d_ 0
fff filterBf, rangeB2, 2-CC gvlido s) nessa fai=a de dados
X-, 4, 11, 1+, 14, 1;, 2+Z
Sma!Gfuno3 sequnciaHA F aplica funoBitemC para cada item
da sequDncia e retorna a lista de valores retornados a cada
aplicao. 'or e=emplo, para computar quadrados2
fff def .,A98A9!B=C2 return =I=
...
fff mapB.,A98A9!, rangeB1, 10CC
X1, :, ;, 13, 2-, +3, :;, 3:, &1Z
E=emplo soma de 2 sequDncias2
fff seq _ rangeB&C
fff def somaB=, (C2 return =l(
-3
...
fff mapBsomaBseq, seqCC
X0, 2, :, 3, &, 10, 12, 1:Z
SreduceGfuno3 sequnciaHA F esta funo pega dois primeiros
itens da sequDncia e passa para a funo e depois pega o retorno
da funo e o pr)=imo item e passa para a funo, faKendo isso
at$ acabar a sequDncia. 'or e=emplo, para computar a soma dos
102 primeiros n<meros inteiros2
fff def somaB=,(C2 return =l(
fff reduceBsoma, rangeB1, 11CC
--
,m terceiro argumento pode ser passado para indicar o
valor inicial. "este caso, reduo de sequDncias vaKias retornar
o valor inicial. #e a sequDncia no for vaKia, a reduo se
iniciar a partir do valor inicial.
+.).7 A5rangMncia de *istasGlist comprehensions)
6ada abrangDncia de lista consiste numa e=presso
seguida da clusula "or, e ento &ero ou mais clusulas "or ou i".
! resultado ser uma lista proveniente da avaliao da
e=presso no conte=to das clusulas "or e i" subsequentes. #e a
e=presso gerar uma tupla, a mesma deve ser inserida entre
parDnteses.
fff vec _ X2, :, 3Z
fff X+I= for = in vecZ
X3, 12, 1&Z
-4
fff X+I= for = in vec if = f +Z
X12, 1&Z
fff X+I= for = in vec if = m 2Z
XZ
fff XB=, =II2C for = in vecZ
XB2, :C, B:, 13C, B3, +3CZ
fff vec1 _ X2, :, 3Z
fff vec2 _ X:, +, F;Z
fff X=I( for = in vec1 for ( in vec2Z
X&, 3, F1&, 13, 12, F+3, 2:, 1&, F-:Z
fff X=l( for = in vec1 for ( in vec2Z
X3, -, F4, &, 4, F-, 10, ;, F+Z
fff Xvec1XiZIvec2XiZ for i in rangeBlenBvec1CCZ
X&, 12, F-:Z
+.).9 comando de.
8emove item da lista a partir de um Jndice. 'ermite
tamb$m fatiar a lista BsliceC. 5amb$m apaga variveis.
fff a _ XF1, 1, 33.2-, +++, +++, 12+:.-Z
fff del aX0Z
fff a
X1, 33.2-, +++, +++, 12+:.-Z
fff del aX22:Z
fff a
X1, 33.2-, 12+:.-Z
fff del a g apagando variveis
+.).= (ra5a.hando com conKuntos ? sets
-&
'(thon tamb$m inclui um tipo de dados chamado
conEunto BsetC. ,m conEunto $ uma coleo desordenada de
dados, sem elementos duplicados. ,sos comuns para isso
incluem verifica>es da e=istDncia de obEetos em outras
sequDncias e eliminao de itens duplicados. 6onEuntos tamb$m
suportam opera>es matemticas como unio, interseo,
diferena e diferena sim$trica.
fff cesta@rutas _ XTabacateT, TlaranEaT, TlaranEaT, TperaT,
TbananaTZ
fff frutas _ setBcesta@rutasC g cria conEunto sem duplicao
fff frutas
setBXTabacateT, TlaranEaT, TperaT, TbananaTZC
fff TbananaT in frutas g teste rpido
5rue
fff TEaboticabaT in frutas
@alse
fff g 9emonstrao de opera>es de conEuntos
...
fff a _ setBTabracadabraTC
fff a
setBXTaT, TrT, TbT, TcT, TdTZC g set dei=a apenas uma letra de
cada sem repetio
fff b _ setBTalacaKamTC
fff b
setBXTaT, Tli,ici,iKi,imiZC
fff a F b g letras em a e no em b
setBXTrT, TdT, TbTZC
fff a v b g letras em a e em b
setBXTaT, TcT, TrT, TdT, TbT, TmT, TKT, TlTZC
-;
fff a V b g letras em ambos a e b
setBXTaT, TcTZC
fff a w b gletras em a ou b e no em ambos
setBXTrT, TdT, TbT, TmT, TKT, TlTZC
30
7. 8unJes3 4ecurso3 E2ceo3 ArLui%os e T#du.os
7.1 8unJes
@un>es so blocos de c)digo com um nomeS recebem
um conEunto de parHmetros Bou argumentosC e retornam um
valor. '(thon possui, como seria esperado de uma linguagem de
programao completa, suporte a fun>es. E=istem diversas
fun>es pr$Fdefinidas pelo interpretador. A sinta=e geral para
definir uma funo $2
de' nomenfuncaoBargn1, argn2, ..., argnnC1
g
g bloco de c)digo contendo corpo da funo
g
return valorndenretorno g retornar $ opcional
!s argumentos so valores fornecidos na chamada da funo, e
que ficam disponJveis por meio de variveis locais no corpo da
funo. Ao encontrar o comando return, a funo termina
imediatamente e o controle do programa volta ao ponto onde a
funo foi chamada. #e uma funo chega a seu fim sem
nenhum valor de retorno ter sido especificado, o valor de
retorno $ "one.
! corpo da funo deve comear na linha seguinte e deve ser
indentado. !pcionalmente, a primeira linha do corpo da funo
pode ser uma string, cuEo prop)sito $ documentar a funo. #e
presente, essa string chamaFse docstring.
fff def fBC2 gdocstring
iii funcao f
31
do sergioiii
return
fff print fBC
"one
ffff gendereo da funo na mem)ria
mfunction f at 0R00e20+40f
ffff.nndocnn gdocumentao da funo
ifuncao fknktdo sergioi
fff def fBC2
return e!ie
fff print fBC
!i
fff def fBnomeC2
return e!i, elnomelede
fff print fBeWoaoeC
!i, Woaod
E2em!.o de !rograma com 'uno1
def imprimencardapio BpratosC2
print e6ardapio para hoEekne
for p in pratos2
imprimenpratoBpC
print ekn5otal de pratos2 ?de ? lenBpratosC
32
def imprimenpratoBpC2
print e?s ........ ?10.2fe ? BpXenomeeZ, pXeprecoeZC
g defino dicionrios descrevendo os pratos
p1 _ tenomee2 eArroK com brocolise, eprecoe2 ;.;0u
p2 _ tenomee2 e#oEa com legumese, eprecoe2 4.&0u
p+ _ tenomee2 e*entilhase, eprecoe2 :.&0u
listanpratos _ Xp1, p2, p+Z
g e chamo uma funo, passando os pratos como argumento
imprimencardapioBlistanpratosC
gFFFFFFFFFFFFFFFFFfim programaFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
7.1.1 Esco!o das %ari%eis
A e=ecuo da funo gera uma nova tabela de sJmbolos
utiliKada para as variveis locais da funo,
mais precisamente, toda atribuio a varivel dentro da
funo armaKena o valor na tabela de sJmbolos local.
8eferDncias a variveis so buscadas
primeiramente na tabela local, ento na
tabela de smbolos global e finalmente na
tabela de sJmbolos interna Bbuilt-inC. 'ortanto, deveFse
declarar que a varivel $ global antes de atribuir um valor para
3+
ela, se vocD deseEa acessar a varivel e=terna, se fiKer o contrrio
da erro. ! uso de uma varivel e=terna $ possJvel, sem definir
ela globalmente, s) no $ possJvel faKer atribuio a ela, pois a
linguagem gera uma varivel local.
fffv _ 0
fffdef processaBC2
global v
v _ 1
fffv_0
fffdef pBC2
=_1
v_+
print =,v
fffpBC
1 +
ffv g veEa usamos a varivel v internamente e a v e=terna no
foi alterada
0
7.1.) 8unJes como !arUmetro
"omes de fun>es podem ser manipulados como
variveis e mesmo como argumentos de fun>es. 'ara saber se
um nome se refere a uma funo, use o predicado callableBC.
fff def fBgC2
3:
return gB-C
fff def hB=C2
return =I=
fff fBhC
2-
fff m _ h
fff callableBmC
5rue
fff fBmC
2-
4.1.3 Funo com 2 argumentos
>>> def c(,!"#
return $!
>>>c(%,&"
'
>>>c((a(,(b(" )mudana do tipo de varivel
durante a eecuo
(ab(
4.1.4 Funo com valores padro ou default
fff def aplicanmultaBvalor, ta=a_0.1C2
return valor l valor I ta=a
fffaplicanmultaB10C
11.0
3-
fffaplicanmultaB10,0.-C
1-.0
9ica2 "o utiliKe como valor padro listas, dicionrios e outros
valores mutveisS os valores padr>es so avaliados apenas uma
veK e o resultado obtido no $ o que intuitivamente se esperaria.
4.1.5 Funo com argumentos opcionais
fff def somatoriaBIargumentosC2
soma _ 0
for i in argumentos2
somal_i g s igual a soma_somali
return soma
fff somatoriaB1,2,+,:,-C
1-
A funo pode receber quantos os argumentos o usurio
deseEar. #e o argumento no for compatJvel retorna um erro.
fff somatoriaB1,2,+,:,itesteiC
somatoriaB1,2,+,:,itesteiC
@ile emp(shellg110fe, line :, in somatoria
somal_i
5(peError2 unsupported operand t(peBsC for l_2 iinti and istri
fff def testanprimoBnC2
33
teste_1
for i in rangeB2,nC2
if n ? i __ 02
teste_testel1
if teste d_ 12
print i"<mero no primoi
else2
print i"<mero primoi
fff testanprimoB2&C
"<mero no primo
fff testanprimoB4C
"<mero primo
7.1.= 8uno com conKunto de argumentos nomeados
*stes par+metros especiais devem
necessariamente ser os ltimos definidos na
lista de par+metros da funo.
def equipeBdiretor, produtor, IIatoresC2
for personagem in atores.Ae(sBC2
print e?s2 ?se ? Bpersonagem, atoresXpersonagemZC
print eFe I 20 grepete o sinal de Y 20 veKes
print e9iretor2 ?se ? diretor
print e'rodutor2 ?se ? produtor
equipeBdiretor_e7arretoe,
produtor_e'aulo 7ondadee,
@ranA_e5om 7eloe, Edmundo_e'atricia Galdonadoe,
*inda_eWuliana @onsecaeC
34
7.1.B 8uno .am5da
6om a palavraFchave lambda, fun>es curtas e anonimas
podem ser criadas. Aqui est uma funo que devolve a
soma de seus dois argumentos2
j.am5da a3 51 aV5T. @un>es *ambda podem ser utiliKadas em
qualquer lugar que e=igiria uma funo tradicional.
#intaticamente, fun>es *ambda esto restritas a uma <nica
e=presso. #emanticamente, ela so apenas a<car sinttico para
a definio de fun>es normais. Assim como defini>es de
fun>es aninhadas, fun>es lambda no podem referenciar
variveis de um escopo mais e=terno.
fff def maAenincrementorBnC2
return lambda =2 = l n
fff f _ maAenincrementorB:2C
fff fB0C
:2
fff fB1C
:+
7.) 8unJes recursi%as
@un>es recursivas so fun>es que chamam a si mesma,
de forma que para resolver um problema maior utiliKa a recurso
para chegar as unidades bsicas do problema em questo e ento
calcular o resultado final.
8i5onacci recursi%o1
3&
gcoding2 utfF&
g fibnrecursivo.p(
def fibonacciBindiceC2
if indice __ 12 return 0
elif indice __ 22 return 1
else2 return fibonacciBindice F 1C l fibonacciBindice F 2C g
chamada recursiva

for i in rangeB1,11C2
print fibonacciBiC,
Busca Binria 4ecursi%a1
def testaBlista,valorC2
def buscanbinariaBimin,ima=C2
if imin__ima=2 return imin
else2
meio_Bima=liminCO2
if valorflistaXmeioZ2
return buscanbinariaBmeiol1,ima=C
else2
return buscanbinariaBimin,meioC
i _ buscanbinariaB0,lenBlistaCF1C
if listaXiZ__valor2
print valor,eencontrado na posicaoe,i
else2
print valor,enao encontradoe
testaBX1,2,-,3,;,12Z,-C
3;
fff
- encontrado na posicao 2
.uando uma funo $ chamada, um pouco de mem)ria $
usado para guardar o ponto de retorno, os argumentos e
variveis locais. Assim, solu>es iterativas so normalmente
mais eficientes do que solu>es recursivas equivalentes. %sto no
quer diKer que solu>es iterativas sempre seEam preferJveis a
solu>es recursivas. #e o problema $ recursivo por natureKa,
uma soluo recursiva $ mais clara, mais fcil de programar e,
frequentemente, mais eficiente.
7.+ 8unJes !rC?de'inidas
,!t-on possui uma s.rie de fun/es
pr.0definidas, que 1 esto disponveis
quando eecutamos o interpretador, sem ter
que recorrer a bibliotecas eternas.
Algumas fun/es importantes que ainda foram
ou no apresentadas no teto seguem#
range(a,b"2 recebe dois inteiros, retorna uma lista de
inteiros entre a e b, no incluindo b. Esta funo $
frequentemente utiliKada para iterar laos for.
fff print rangeB1,10C
X1, 2, +, :, -, 3, 4, &, ;Z
len(a"2 retorna o comprimento da varivel a. ,ara
listas, tuplas e dicionrios, retorna o n<mero de
elementosS para strings, o n<mero de caracteres.
fff print lenBX1,2,+ZC
40
+
round(a, n"2 recebe um float e um n<meroS retorna o
float arredondado com este n<mero de casas decimais.
fff print roundB1.2+:-,2C
1.2+
po2(a, n"2 recebe dois inteirosS retorna o resultado da
e=ponenciao de a x ordem n. s equivalente x sinta=e a
33 n.
fffpo1B2,&C
2-3

c-r(a"2 recebe um inteiro Bentre 0 e 2--C como
parHmetro, retornando o caractere correspondente da
tabela A#6%%.
fff print chrB;4C
a

unic-r(a"2 como c-r(", recebe um inteiro Baqui
variando entre 0 e 3--+-C, retornando o caracter ,nicode
correspondente.
fff print unichrB;4C
a
ord(a"2 recebe um <nico caractere como parHmetro,
retornando o seu c)digo A#6%%.
fff print ordBeaeC
41
;4

min(a, b"2 retorna o menor entre a e b, sendo
aplicvel a valores de qualquer tipo.
fff print minB-,3C
-
ma(a, b"2 retorna o maior entre a e b.
fff print ma=B-,3C
3
abs(n"2 retorna o valor absoluto de um n<mero.
fff print absBF1l1EC
1.:1:21+-32+4

-e(n" e oct(n"2 retornam uma string contendo a
representao em he=adecimal e octal, respectivamente,
de um inteiro.
fff print he=B2-3C
0R100
fff print octB2-3C
0:00
L tamb$m fun>es de converso e=plJcita de tipoS as
mais frequentemente utiliKadas incluem2
float(n"2 converte um inteiro em um float.
fff print floatB1C
42
1.0

int(n"2 converte um float em inteiro.
fff print intB-.-C
-
str(n"2 converte qualquer tipo em uma string. 5ipos
sequDncias so convertidos de forma literal,
peculiarmente.
fff print strBX1,2,+ZC, strBteae2 1uC
X1, 2, +Z tiai2 1u
list(l" e tuple(l"2 convertem uma sequDncia em
uma lista ou tupla, respectivamente.
fff print listBebacoeC
Xii, ibi, iai, ici, ioiZ

7.7 T#du.os
A medida que seus programas crescem, pode ser
deseEvel dividiFlos em vrios arquivos para facilitar a
manuteno. 5alveK vocD at$ queira reutiliKar uma funo sem
copiar sua definio a cada novo programa. 'ara permitir isto,
'(thon possui uma maneira de depositar defini>es em um
arquivo e posteriormente reutiliKFlas em um script ou seo
interativa do interpretador. Esse arquivo $ denominado m)dulo.
9efini>es de um m)dulo podem ser importadas por outros
4+
m)dulos ou no m)dulo principal. ,m m)dulo $ um arquivo
contendo defini>es e comandos '(thon. ! nome do arquivo
recebe o sufi=o j.p(T . 9entro de um m)dulo, seu nome Buma
stringC est disponJvel na varivel global nnnamenn. ! comando
re.oadGm#du.oH recarrega m)dulo.
! procedimento para criar um m)dulo $ o mesmo para
escrever um programa completo. Abra uma Eanela nova em
%9*EB@ilef"e1 0indo1C, ou digite 6rtlF". Agora digite as
fun>es e salve com a e=tenso .p(, este programa deve estar no
diret)rio que esteEa no path. E=emplo2
9escobrindo diret)rio2
fffimport s(s g
fffs(s.path
Gostra todos os diret)rios do path2 X i62p(thon2-i ,
i62kk'(thon2-kk*ibkkidlelibi,.....Z
Escreveremos o m)dulo funcoes.p( e armaKenaremos num
arquivo de nome funcoes.p(.
gfuncoes.p(
def perimetroBrC2
eeeesta funcao calcula perimetro de um
circulo de raio reee
tr(2
r_floatBrC
return 2I+.1:Ir
e=cept2
4:
print iErro argumentoi
def areaBrC2
r_floatBrC
eeecalcula areaeee
tr(2
r_floatBrC
return +.1:IBrII2C
e=cept2
print iargumento e numeroi
def nadaBC2
eeefaK nada so para mostrar
doc stringseee
pass
"o shell importaremos o m)dulo e veremos o funcionamento,
quando o m)dulo $ importado o '(thon gera o arquivo
compilado '(thon Bfuncoes.p(cC2
fffimport funcoes
fffdir BfuncoesC
mostra atributos e m$todos
fffprint funcoes.nndocnn
"one gno tem documentao
fffprint funcoes.nada.nndocnn
faK nada so para mostrar
doc strings
fffprint funcoes.perimetroB:C
4-
2-.12
"a hora de e=ecuo devemos informar
m)dulo.funoBparHmetrosC.
!utra forma de usar fun>es $ importFlas diretamente2
'rom m)dulo im!ort funcao1, funcao2,.....
fffform funcoes import area
fffprint areaB:C guse s) o nome da funo
-0.2:
7.7.1 T#du.os !adro
'(thon possui um biblioteca padro de m)dulos, descrita
em um documento em separado, a Python Library Ae"erence
Bdoravante N*ibrar( 8eferenceUC. Alguns m)dulos esto
embutidos no interpretadorS estes possibilitam acesso a
opera>es que no so parte do n<cleo da linguagem, seEa por
eficiDncia ou para permitir o acesso a chamadas de sistema. !
conEunto presente destes m)dulos $ configurvel, por e=emplo,
o m)dulo amoeba s) est disponJvel em sistemas que suportam
as primitivas do Amoeba. E=iste um m)dulo que requer especial
ateno2 s(s, que $ embutido em qualquer interpretador '(thon.
As variveis s(s.ps1 e s(s.ps2 definem as strings utiliKadas
como prompt primrio e secundrio2
fff import s(s
fff s(s.ps1
Tfff T
43
fff s(s.ps2
T... T
fff s(s.ps1 _ T6f T
6f print T[ucAdT
[ucAd
6f
Essas variveis s) esto definidas se o interpretador est em
modo interativo.
A varivel s(s.path cont$m uma lista de strings que
determina os caminhos de busca de m)dulos conhecidos pelo
interpretador. Ela $ inicialiKada para um caminho default
determinado pela varivel de ambiente '[5L!"'A5L ou por
um valor default interno se a varivel no estiver definida. ocD
pode modificFla utiliKando as opera>es tJpicas de lista, por
e=emplo2
fff import s(s
fff s(s.path.appendBTOufsOguidoOlibOp(thonTC
A funo interna dirBC $ utiliKada para se descobrir que nomes
so definidos por um m)dulo. Ela retorna uma
lista ordenada de strings2
fff import fibo, s(s
fff dirBfiboC
XTnnnamennT, TfibT, Tfib2TZ
fff dirBs(sC
XTnndispla(hooAnnT, TnndocnnT, Tnne=cepthooAnnT,
TnnnamennT, TnnstderrnnT,
44
TnnstdinnnT, TnnstdoutnnT, TngetframeT, TapinversionT, TargvT,
TbuiltinnmodulennamesT, Tb(teorderT, TcallstatsT, Tcop(rightT,
Tdispla(hooAT, Te=cnclearT, Te=cninfoT, Te=cnt(peT,
Te=cepthooAT,
Te=ecnprefi=T, Te=ecutableT, Te=itT, TgetdefaultencodingT,
TgetdlopenflagsT,
TgetrecursionlimitT, TgetrefcountT, The=versionT, Tma=intT,
Tma=unicodeT,
TmetanpathT, TmodulesT, TpathT, TpathnhooAsT,
TpathnimporterncacheT,
TplatformT, Tprefi=T, Tps1T, Tps2T, TsetchecAintervalT,
TsetdlopenflagsT,
TsetprofileT, TsetrecursionlimitT, TsettraceT, TstderrT, TstdinT,
TstdoutT,
TversionT, TversionninfoT, T1arnoptionsTZ
#em nenhum argumento, dirBC lista os nomes atualmente
definidos.
fff a _ X1, 2, +, :, -Z
fff import fibo
fff fib _ fibo.fib
fff dirBC
XTnnbuiltinsnnT, TnndocnnT, TnnfilennT, TnnnamennT, TaT, TfibT,
TfiboT, Ts(sTZ
!bserve que ela lista nomes dos mais diversos tipos2 variveis,
m)dulos, fun>es, etc.
dirBC no lista nomes de fun>es ou variveis internas. #e vocD
deseEar conhecDFlos, eles esto definidos no m)dulo padro
nnbuiltinnn2
4&
fff import nnbuiltinnn
fff dirBnnbuiltinnnC
XTArithmeticErrorT, TAssertionErrorT, TAttributeErrorT,
T9eprecation0arningT,
TE!@ErrorT, TEllipsisT, TEnvironmentErrorT, TE=ceptionT,
T@alseT,
T@loating'ointErrorT, T@uture0arningT, T%!ErrorT,
T%mportErrorT,
T%ndentationErrorT, T%nde=ErrorT, TQe(ErrorT,
TQe(board%nterruptT,
T*ooAupErrorT, TGemor(ErrorT, T"ameErrorT, T"oneT,
T"ot%mplementedT,
T"ot%mplementedErrorT, T!#ErrorT, T!verflo1ErrorT,
T!verflo10arningT,
T'ending9eprecation0arningT, T8eferenceErrorT,
T8untimeErrorT,
T8untime0arningT, T#tandardErrorT, T#top%terationT,
T#(nta=ErrorT,
T#(nta=0arningT, T#(stemErrorT, T#(stemE=itT, T5abErrorT,
T5rueT,
T5(peErrorT, T,nbound*ocalErrorT, T,nicode9ecodeErrorT,
T,nicodeEncodeErrorT, T,nicodeErrorT,
T,nicode5ranslateErrorT,
T,ser0arningT, TalueErrorT, T0arningT, T0indo1sErrorT,
Têro9ivisionErrorT, TnT, TnndebugnnT, TnndocnnT,
TnnimportnnT,
TnnnamennT, TabsT, Tappl(T, TbasestringT, TboolT, TbufferT,
TcallableT, TchrT, TclassmethodT, TcmpT, TcoerceT, TcompileT,
Tcomple=T, Tcop(rightT, TcreditsT, TdelattrT, TdictT, TdirT,
TdivmodT,
TenumerateT, TevalT, Te=ecfileT, Te=itT, TfileT, TfilterT, TfloatT,
4;
TfroKensetT, TgetattrT, TglobalsT, ThasattrT, ThashT, ThelpT, The=T,
TidT, TinputT, TintT, TinternT, TisinstanceT, TissubclassT, TiterT,
TlenT, TlicenseT, TlistT, TlocalsT, TlongT, TmapT, Tma=T, TminT,
TobEectT, ToctT, TopenT, TordT, Tpo1T, Tpropert(T, TquitT, TrangeT,
Tra1ninputT, TreduceT, TreloadT, TreprT, TreversedT, TroundT, TsetT,
TsetattrT, TsliceT, TsortedT, TstaticmethodT, TstrT, TsumT, TsuperT,
TtupleT, Tt(peT, TunichrT, TunicodeT, TvarsT, T=rangeT, TKipTZ
X'[5Z
7.7.) Pacotes
'acotes so uma maneira de estruturar espaos de nomes
para m)dulos utiliKando a sinta=e de Nseparao por pontoU.
6omo e=emplo, o m)dulo A.7 designa um subm)dulo chamado
j7T num pacote denominado jAT. ! uso de pacotes permite que
autores de grupos de m)dulos Bcomo "um'( ou '%*C no se
preocupem com a coliso entre os nomes de seus m)dulos e os
nomes de m)dulos de outros autores. #uponha que vocD deseEe
proEetar uma coleo de m)dulos Bum NpacoteUC para o
gerenciamento uniforme de arquivos de som. E=istem muitos
formatos diferentes Bnormalmente identificados pela e=tenso do
nome de arquivo, por e=emplo. j.1avT, j.aiffT, j.auTC, de forma
que vocD pode precisar criar e manter uma crescente coleo de
m)dulos de converso entre formatos. Ainda podem e=istir
muitas opera>es diferentes passJveis de aplicao sobre os
arquivos de som Bmi=agem, eco, equaliKao, efeito est$reo
artificialC. *ogo, possivelmente vocD tamb$m estar escrevendo
uma interminvel coleo de m)dulos para aplicar estas
opera>es. Aqui est uma possJvel estrutura para o seu pacote
Be=pressa em termos de um sistema hierrquico de arquivosC2
&0
#oundO 'acote de mais alto nJvel
nninitnn.p( %nicialiKa pacote de som
@ormatsO #ub pacote para arquivos de
converso de formato
nninitnn.p(
1avread.p(
1av1rite.p(
aiffread.p(
...
EffectsO #ub pacote de efeito de sons
nninitnn.p(
echo.p(
surround.p(
reverse.p(
...
@iltersO #ub pacote para filtros
nninitnn.p(
equaliKer.p(
vocoder.p(
AaraoAe.p(
...
Ao importar esse pacote o '(thon busca pelo
subdiret)rio com mesmo nome nos diret)rios listados em
s(s.path. !s arquivos jnninitnn.p(T so necessrios para que
'(thon trate os diret)rios como um conEunto de m)dulos. %sso
foi feito para evitar diret)rios com nomes comuns, como
jstringT, de inadvertidamente pode esconder m)dulos vlidos
que ocorram a posteriori no caminho de busca. "o caso mais
simples, jnninitnn.p(T pode ser um arquivo vaKio. 'or$m, ele
pode conter c)digo de inicialiKao para o pacote ou gerar a
varivel nnallnn, que ser descrita depois. ,surios do pacote
podem importar m)dulos individuais, por e=emplo2
&1
import #ound.Effects.echo
Assim se carrega um subm)dulo #ound.Effects.echo. Ele deve
ser referenciado com seu nome completo, como em2
#ound.Effects.echo.echofilterBinput, output, dela(_0.4, atten_:C
,ma alternativa para a importao $2
from #ound.Effects import echo
Assim se carrega o m)dulo sem necessidade de prefi=ao na
hora do uso. *ogo, pode ser utiliKado como se segue2
echo.echofilterBinput, output, dela(_0.4, atten_:C
5amb$m $ possJvel importar diretamente uma <nica varivel ou
funo, como em2
from #ound.Effects.echo import echofilter
"ovamente, h carga do subm)dulo echo, mas a funo
echofilterBC est acessJvel diretamente sem prefi=ao2
echofilterBinput, output, dela(_0.4, atten_:C
!bserve que ao utiliKar from pacBage import item, o item pode
ser um sub pacote, subm)dulo, classe, funo ou varivel. !
comando import primeiro testa se o item est definido no
pacote, seno assume que $ um m)dulo e tenta carregFlo. #e
falhar em encontrar o m)dulo uma e=ceo %mportError $
levantada. Em oposio, na construo import
item.subitem.subsubitem, cada item, com e=ceo do <ltimo,
deve ser um pacote. ! <ltimo pode ser tamb$m um pacote ou
m)dulo, mas nunca uma entidade contida em um m)dulo.
&2

7.7.+ Im!ortando @ de ,m Pacote
Agora, o que acontece quando um usurio escreve2 from
#ound.Effects import I / %dealmente, poderia se esperar que
todos subm)dulos presentes no pacote fossem importados.
%nfeliKmente, essa operao no funciona muito bem nas
plataformas Gac ou 0indo1s, onde no e=iste distino entre
mai<sculas ou min<sculas nos sistema de arquivos. "estas
plataformas no h como saber como importar o arquivo
jE6L!.'[T, deveria ser com o nome echo, Echo ou E6L!. A
restrio de nomes de arquivo em 9!# com o formato &l+
adiciona um outro problema na hora de se utiliKar arquivos com
nomes longos. A <nica soluo $ o autor do pacote fornecer um
Jndice e=plJcito do pacote. ! comando de importao utiliKa a
seguinte conveno2 se o arquivo jnninitnn.p(T do pacote define
a lista chamada nnallnn, ento esta lista indica os nomes dos
m)dulos a serem importados quando o comando from pacBage
import I $ encontrado. @ica a cargo do autor do pacote manter
esta lista atualiKada, inclusive fica a seu crit$rio e=cluir
inteiramente o suporte a importao direta de todo o pacote
atrav$s do from pacBage import I. 'or e=emplo, o arquivo
j#oundsOEffectsOnninitnn.p(T poderia conter apenas2nnallnn _
Xeechoe, esurrounde, ereverseeZ
%sso significaria que from #ound.Effects import I iria importar
apenas os trDs subFm)dulos especificados no pacote #ound. #e
nnallnn no estiver definido, o comando from #ound.Effects
import I no importar todos os subm)dulos do pacote
#ound.Effects no espao de nomes corrente. L apenas garantia
que o pacote #ound.Effects foi importado Bpossivelmente
e=ecutando qualquer c)digo de inicialiKao em jnninitnn.p(TC
Euntamente com os nomes definidos no pacote. %sso inclui todo
&+
nome definido em jnninitnn.p(T bem como em qualquer
subm)dulo importado a partir deste. 6onsidere o c)digo abai=o2
import #ound.Effects.echo
import #ound.Effects.surround
from #ound.Effects import I
"este e=emplo, os m)dulos echo e surroun( so importados no
espao de nomes corrente, pois esto definidos no pacote
#ound.Effects. ! que tamb$m funciona quando nnallnn estiver
definida. Em geral, a prtica de importar I de um dado m)dulo $
desaconselhada, principalmente por preEudicar a legibilidade do
c)digo. 6ontudo, $ recomendada em sess>es interativas para
evitar e=cesso de digitao. *embreFse que no h nada de
errado em utiliKar from 'acAage import specificnsubmoduled 9e
fato, essa $ a notao recomendada a menos que o m)dulo que
efetua a importao precise utiliKar subm)dulos homonimos em
diferentes pacotes. B5utorial '(thonC
7.7.7 4e'erMncias em ,m Tesmo Pacote
!s subm)dulos frequentemente precisam referenciar uns
aos outros. 'or e=emplo, o m)dulo surround talveK precise
utiliKar o m)dulo echo. 9e fato, tais referDncias so to comuns
que o comando import primeiro busca m)dulos dentro do pacote
antes de utiliKar o caminho de busca padro. 'ortanto, o m)dulo
surround pode usar simplesmente import echo ou from echo
import echofilter. #e o m)dulo importado no for encontrado no
pacote corrente Bo pacote do qual o m)dulo corrente $
subm)duloC, ento o comando import procura por um m)dulo
de mesmo nome no escopo global. .uando pacotes so
estruturados em sub pacotes Bcomo no e=emplo #oundC, no
&:
e=iste atalho para referenciar subm)dulos de pacotes irmos,
ento o nome completo do pacote deve ser utiliKado. 'or
e=emplo, se o m)dulo #ound.@ilters.vocoder precisa utiliKar o
m)dulo echo no pacote #ound.Effects, $ preciso importFlo
como from #ound.Effects import echo. B5utorial '(thonC.
7.7.9 Pacotes em m:.ti!.os diret#rios
'acotes suportam mais um atributo especial, nnpathnn.
Este $ inicialiKado como uma lista contendo o nome do diret)rio
com o arquivo jnninitnn.p(T do pacote, antes do c)digo naquele
arquivo ser e=ecutado. Esta varivel pode ser modificadaS isso
afeta a busca futura de m)dulos e sub pacotes contidos no
pacote. Apesar de no ser muito usado, pode ser usado para
estender o conEunto de m)dulos usado num pacote. B5utorial
'(thonC
7.7.= T#du.os Im!ortantes
4 um grande con1unto de m5dulos que
se instalam 1untamente com o interpretador
,!t-on6 so descritos nesta seo alguns
dos mais interessantes.
s!s2 oferece vrias opera>es referentes ao pr)prio
interpretador. %nclui2 pat-, uma lista dos diret)rios de
busca de m)dulos do p(thon, argv, a lista de
parHmetros passados na linha de comando e eit(",
uma funo que termina o programa.
time2 oferece fun>es para manipular valores de tempo.
%nclui2 time(", uma funo que retorna o timestamp
Bdata e hora atualCS sleep(n", que pausa a e=ecuo
&-
por n segundosS e strftime(n", que formata a data e
hora atual em uma string de acordo com um formato
fornecido.
os2 oferece fun>es relacionadas ao ambiente de
e=ecuo do sistema. %nclui2 m7dir(", que cria
diret)riosS rename(", que altera nomes e caminhos de
arquivosS e s!stem, que e=ecuta comandos do sistema.
os.pat-2 oferece fun>es de manipulao do caminho
independente de plataforma. %nclui2 isdir(p", que
testa se d $ um diret)rioS eists(p", que testa se p
e=isteS 1oin(p,m", que retorna uma string com os dois
caminhos p e m concatenados.
string2 oferece fun>es de manipulao de string Bque
tamb$m esto disponJveis como m$todos da stringC.
%nclui2 split(c, s, p", que divide a string c em at$
p parti>es separadas pelo sJmbolo s, retornandoFas em
uma listaS lo2er(c", que retorna a string c convertida
em min<sculasS e strip(c", que retorna c removendo
espaos e quebras de linha do seu inJcio e fim.
mat-2 fun>es matemticas gerais. %nclui fun>es como
cos(", que retorna o cosseno de S -!pot(, !"S
que retorna a distHncia euclidiana entre e !S e
ep("S que retorna o e=ponencial de .
random2 gerao de n<meros randomicos. %nclui2
random(", que retorna um n<mero randomico entre 0 e
1S randrange(m,n", que retorna um randomico entre
m e nS c-oice(s", que retorna um elemento
randomico de uma sequDncia s.
&3
getopt2 processamento de argumentos de comando de
linhaS ou seEa, os parHmetros que passamos para o
interpretador na linha de e=ecuo. %nclui2 getopt(",
que retorna duas listas, uma com argumentos e outra com
op>es da linha de comando.
87inter2 um m)dulo que permite a criao de
programas com interface grfica, incluindo Eanelas,
bot>es e campos te=to.
A documentao do ,!t-on inclui uma
descrio detal-ada (e muito boa" de cada
um destes m5dulos e de seus membros.
7.9 8unJes de entrada e saWda
Entrada e saJda so opera>es de comunicao de um
programa com o mundo e=terno. Essa comunicao se d
usualmente atrav$s de arquivos. Arquivos esto associados a
dispositivos. 'or e=emplo, disco, impressora, teclado. Em
'(thon, um arquivo pode ser lidoOescrito atrav$s de um obEeto
da classe file.
#empre que um comando print $ e=ecutado, o resultado
vai para um arquivo chamado s(s.stdout. #empre que lemos um
dado atrav$s do comando input ou ra1ninput, na verdade
estamos lendo de um arquivo chamado s(s.stdin. Gensagens de
erro ou de rastreamento de e=ce>es so enviadas para um
arquivo chamado s(s.stderr.
fff import s(s
fff s(s.stdout.1riteBealoeC
alo
fff print ealoe
&4
alo
fff s(s.stdin.readlineBC
sfadfas
isfadfaskni
fff ra1ninputBC
fasdfadsf
ifasdfadsfi
!s arquivos s(s.stdin, s(s.stdout e s(s.stderr
normalmente esto associados ao teclado e ao displa( do
terminal que est sendo usado, mas podem ser associados a
outros dispositivos.
Em ,ni=O*inu= e 0indo1s2
!rograma X arLui%o
E=ecuta programa redirecionando stdout para arquivo
!rograma I arLui%o
E=ecuta programa redirecionando stdin de arquivo
!rograma1 Y !rograma)
E=ecuta programa1 e programa2 sendo que a saJda de
programa1 $ redirecionada para a entrada de programa2
ra1ninputBC F funo que retorna sempre uma string2
fff = _ ra1ninputBi%nforme a fase2 iC
%nforme a fase2 vapor
fff =
ivapori
&&

8etornando um inteiro ou float2
fff r _ floatBra1ninputBi8aio2 iCC
8aio2 :.-
fff t(peBrC
mt(pe ifloatif
fff a _ intBra1ninputBi5amanho do lado do quadrado2 iC
5amanho do lado do quadrado2 2+
fff t(peBaC
mt(pe iintif
inputBC F funo que retorna n<mero2
fff=_inputBi"o.iC
"o. 12
fff=
12
print F comando que imprime dados, imprimindo dados com
print2
fff b _ 1
fff 1hile b m :2
if b__12
print i?i d)lar vale ?.2f reaisi ?Bb,bI2.;&C
gformatacao ?.2f B2 casas dec.C
else2
print i?i d)lares valem ?.2f reaisi ?Bb,bI2.;&C
bl_1
&;
1 d)lar vale 2.;& reais
2 d)lares valem -.;3 reais
+ d)lares valem &.;: reais
fff a _ XiWooi, i8afaeli, i9ouglasiZ
fff a
XiWok=e+oi, i8afaeli, i9ouglasiZ
fff for i in a2
print i
Woo
8afael
9ouglas
fff for = in a2
print i?s tem ?i letrasi ?B=,lenB=CC
Woo tem : letras
8afael tem 3 letras
9ouglas tem 4 letras
fff a_X1,2,+Z
fff for i in rangeBlenBaCC2
print i
1
2
+
fff a_X1,2,+Z
fff for i in rangeBlenBaCC2
print i,
1 2 +
;0
!utros e=emplos e fun>es2
fff s _ T!i, Gundo.T
fff strBsC
T!i, Gundo.i
fff reprBsC g coloca NU
eT!i, Gundo.Te
fff strB0.1C g numero y string
T0.1T
fff reprB0.1C
T0.10000000000000001T g string com limite m=imo da
representao
ffffor i in rangeB10C2
print reprBiC.rEustB1C, reprBiI2C.rEustB-C gatua em cima da
string
0 0
1 1
2 :
z......
ffffor i in rangeB-C2 ge=ecuta e veEa o
que acontece
print strBiC.lEustB1C,strBiI2C,lEustB2C
print strBiC.centerB1C,strBiI2C.centerB2C
;1
z.
z.
fffi12i.KfillB-C gstring com Kero a esquerda
i0001-i
fff tabela _ ti#ergioi2 :124, iWosei2 :0;&, i9inoi2 434&u
fff for nome, fone in tabela.itemsBC2
print i?F10s __f ?10di ? Bnome, foneC
9ino __f 434&
Wose __f :0;&
#ergio __f :124
fff
7.9.1 !eraJes com arLui%os
Em '(thon, assim como em outras linguagens, $ possJvel
manipular arquivos. 9esse modo, o usurio consegue abrir, ler,
alterar, gravar e fechar um arquivo. 5udo o que vocD precisa
para manipular, corretamente, um arquivo $ conhecer os
m$todos responsveis por cada coisa. A funo
open(nomeCar,ui%o<mo(o<bu""er retorna um obEeto arquivo, em
outras palavras, abre o arquivo que vocD especificar.
fff arq _ openBic2kteste.t=tiC
ocD, ainda, tem a opo de passar como parHmetro o
modo como vai abrir o arquivo. 6aso passe um NrU, seu arquivo
ser somente de leituraS se passar NaU, poder adicionar
;2
conte<do ao final do arquivoS caso passe N1U, o arquivo ser
apagado e aberto para escrita, no entanto, se ele no e=istir ser
automaticamente criado, etc. A opo TrlT abre o arquivo tanto
para leitura como para escrita. 6aso o usurio no passe o
segundo parHmetro, '(thon assume o NrU."o 0indo1s e no
Gacintosh, TbT adicionado a string de modo indica que o arquivo
ser aberto no formato binrio. #endo assim, e=istem os modos
compostos 2 TrbT, T1bT, e TrlbT. ! 0indo1s faK distino entre
arquivos te=to e binrios2 os caracteres terminadores de linha em
arquivos te=to so levemente alterados em leituras e escritas.
Essa mudana Npor trs do panoU $ <til em arquivos te=to
A#6%%, mas ir corromper um arquivo binrio como no caso de
arquivos jW'EPT ou jERET. Aopo 7uffer indica se vai usar
uma mem)ria de buffer para entrada e saJdaB0Fsem buffer O 1F
buffer BdefaultC O 2 ou mais F n<mero de b(tes do bufferC.
fff t _ openBi62kmeuarquivo.t=ti,i1i,0C
fff print t
mopen file i62kmeuarquivo.t=ti, mode i1i at 0=00A&-A:0f
7.9.) TCtodos do o5Keto arLui%o
t.readGsiReH1 'ara ler o conte<do de um arquivo chame
t.readBtamanhoC, que lD um punhado de dados retornandoFos
como string. ! argumento num$rico tamanho $ opcional.
.uando tamanho for omitido ou negativo, todo o conte<do do
arquivo ser lido e retornado.
"ota2 t $ o obEeto gerado quando e=ecutamos o comando open.

fff t_openBic2kmeu.t=ti,iri,0C
;+
fff t.readBC
TEsse $ todo o conte<do do arquivo.knT
fff
fff t.readBC gfinal do arquivo atingido
TT
t.read.ineGH1 lD uma <nica linha do arquivo. ! caractere de
retorno de linha BknC $ dei=ado ao final da string, s) sendo
omitido na <ltima linha do arquivo se ele E no estiver presente
l. %sso elimina a ambiguidade no valor de retorno. #e
f.readlineBC retornar uma string vaKia, ento o arquivo acabou.
*inhas em branco so representadas por TknT, uma string
contendo unicamente o terminador de linha.
fff t.readlineBC
TEssa $ a primeira linha do arquivo.knT
fff t.readlineBC
T#egunda linha do arquivoknT
fff t.readlineBC
TT
t.read.inesGH1 retorna uma lista contendo todas as linhas do
arquivo. #e for fornecido o parHmetro opcional tamanho, ser
lida a quantidade especificada de b(tes e mais o suficiente para
completar uma linha.
fff for linha in t2 g le diretamente as linhas do arquivo
print linha,
Esta $ a primeira linha do arquivo.
#egunda linha do arquivo.
;:
t.0riteGstringH2 escreve o conte<do da string para o arquivo,
retornando "one.
fff t.1riteBT%sso $ um teste.knTC
Ao escrever algo que no seEa uma string, $ necessrio convertDF
lo antes2
fff valores _ BTa respostaT, :2C
fff s _ strBvaloresC
fff t.1riteBsC
t.0rite.inesGsequDnciaH1 Escreve a lista Bou qualquer sequDnciaC
de strings, uma ap)s a outra no arquivo.
fff =_openBetestee,e1leC
fff lista_e1e,e2e
fff =.1ritelinesBlistaC
fff =.closeBC
t.te..GH1 retorna um inteiro que indica a posio corrente de
leitura ou escrita no arquivo, medida em b(tes desde o inJcio do
arquivo. 'ara mudar a posio utiliKe jf.seeAB(eslocamento,
posi-!oCT. A nova posio $ computada pela soma do
(eslocamento a um ponto de referDncia, que por sua veK $
definido pelo argumento posi-!o. ! argumento posi-!o pode
assumir o valor 0 para indicar o inJcio do arquivo, 1 para indicar
a posio corrente e 2 para indicar o fim do arquivo. Este
parHmetro pode ser omitido, quando $ assumido o valor default
0 Bvalor default Y valor assumido quando no tem o parHmetroC.
;-
t _ openBTtestearquivoT, TrlTC g o arquivo deve e=istir
t.1riteBT012+:-34&;abcdefTC
t.seeAB-C g ai para o se=to b(te
print t.readB1C
t.seeABF+, 2C g ai para o terceiro b(te antes do fim
print t.readB1C
print t.tellBC
t.closeBC gfecha arquivo
-
d
1:
t.c.oseGH1 fecha arquivo.
7.9.+ Interao com sistema o!eraciona.
!pera>es de entrada e saJda so na verdade realiKadas
pelo sistema operacional. ! m)dulo Nos< possui diversas
variveis e fun>es que aEudam um programa '(thon a se
adequar ao sistema operacional, por e=emplo2
im!ort os F importa m)dulo NosU.
os.getc0dGH F retorna o diret)rio corrente.
os.chdirGdirH F muda o diret)rio corrente para (ir.
os.se! F $ uma string com o caractere que separa componentes
de um caminho BiOi para Uni#, ikki para Din(o.sC.
;3
os.!ath.e2istsGZcaminhoH F informa se e=iste o caminho.
os.systemGZstring<H F e=ecuta uma string como se fosse uma
linha de comando.
a_os.s(stem
aBiformat c2iC > cuidado 'ormata o disco
os.start'i.eG[arLui%o[H ? e=ecuta um arquivo se ele for do
tipo .bat ou .e=e.
fffos.startfileBic.batiC
E=emplo de um programa instalador, que cria um
diret)rio na linha 3, copia o programa para o diret)rio e abre
um arquivo de te=to com o bloco de notas.
ginstalar.p(
import os
comando_os.s(stem
comandoBicop( a2kmeumodulo.p( c2k'(thon24iC
"!GE_ra1ninputBi#eu nome2 iC g *inha :
"!GE_i'(thonFil"!GE
comandoBimd c2kiil"!GEC g *inha 3
comandoBicop( a2kmeuprograma.p( c2kiil"!GEC
abrir_os.startfile
abrirBia2Oleiame.t=tiC
7.= 8uno %arsGH
! dicionrio obtido com a funo varsBC pode ser usado
para ter acesso a todas as variveis definidas num escopo.
;4
fff varsBC
tinnbuiltinsnni2 mmodule innbuiltinnni BbuiltFinCf,
innnamenni2 innmainnni, inndocnni2 "oneu
fff def fBC2
= _ 1
print varsBC
fff varsBC
tifi2 mfunction f at 0=b3e4f-3cf, innbuiltinsnni2
mmodule innbuiltinnni BbuiltFinCf, innnamenni2
innmainnni, inndocnni2 "oneu
fff fBC
ti=i2 1u
7.B Erros e e2ceJes
#o os dois tipos de erro mais comuns. ,m erro de
sinta=e ocorre quando vocD no respeita a sinta=e, digitando
errado ou esquecendo de algo, como N2U.
fff if = m 10
#(nta=Error2 invalid s(nta=
"esse caso, est faltando N2U no final da condio.
7.B.1 $omo .er uma mensagem de erro
A dura realidade $ que um programador profissional
passa boa parte de sua vida caando erros, e por isso $
fundamental saber e=trair o m=imo de informa>es das
mensagens resultantes. A essa altura vocD talveK E tenha
;&
provocado um erro para ver o que acontece. amos faKer isso
agora, e aprender a ler as mensagens resultantes. 'ode parecer
perda de tempo, mas $ importantJssimo saber interpretar as
mensagens de erro porque a melhor forma de aprender a
programar $ e=perimentando, e ao e=perimentar vocD
certamente vai provocar muitos erros. 6omo e=emplo, vamos
digitar um programa com uma e=presso aritm$tica sem sentido.
c_1
print c
a_4l2
print 4O0
@ile e62O'(thon24Oteste.p(e, line :, in mmodulef
print 4O0
êro9ivisionError2 integer division or modulo b( Kero
fff
A primeira linha da mensagem de erro informa o arquivo
onde ocorreu o erro2
8i.e \$1]Python)B]teste.!y\3 .ine 73 in Imodu.eX.
.uando vocD est usando o interpretador em modo
interativo essa informao $ in<til, mas ao trabalhar com
programas e=tensos ela se torna indispensvel. As pr)=imas
duas linhas indicam onde ocorreu o erro e qual $ o erro2
!rint B]F
êroDi%isionError1 integer di%ision or modu.o 5y Rero
"o '(thon #hellB%9*EC, tente agora este comando e veEa
o que ocorre.
;;
fff 4lO2
#(nta=Error2 invalid s(nta=
fff
"ote que o sJmbolo O foi sinaliKado, indicando que est
neste ponto o erro. @oi a partir desse ponto que a e=presso
dei=ou de faKer sentido para o interpretador.
7.B.) (ratamento de Erros
.uando e=ce>es ocorrem, o programa para e o
interpretador gera uma mensagem de erro. "o entanto, $
possJvel resolver esse problema. 'ara este fim, basta usar duas
instru>es2 try e e#cept. Enquanto a instruo try cont$m
comandos que sero e=ecutados, a instruo e#cept e=ecuta o
tratamento nas possJveis e=ce>es desses comandos, ou seEa, na
instruo e#cept vocD diK o que $ para ser feito caso um erro
ocorra durante a e=ecuo dos comandos.
fff n _ intBra1ninputBeEscolha uma chave2 eCC
Escolha uma chave2 3
fff dic _ t12iumi,22idoisi,+2itresiu
fff tr(2
print dicXnZ
e=cept2
print e6have no e=istee
6have no e=iste
#e no houver e=ce>es nos comandos, a instruo
e#cept $ ignorada. s possJvel numa <nica instruo try criar
100
diversas e#cept com diferentes tipos de e=ce>es, entre eles2
ValueError3 IndeError3 !"peError.
E=istem, ainda, duas outras instru>es2 raise e "inally. "o
primeiro caso, fora a ocorrDncia de um determinado tipo de
e=ceo. .uando e=istir a instruo "inally, seus comandos sero
e=ecutados independentemente de e=istir ou no e=ce>es, e
sero e=ecutados antes das e=ce>es. A instruo try nunca
permite que o usurio use e#cept e "inally, simultaneamente.
Al$m de e=istir diversos tipos pr$Fdefinidos de e=ce>es no
'(thon, o usurio tem a liberdade de criar seus pr)prios tipos de
e=ce>es atrav$s de classes.
fff 1hile 5rue2
tr(2
= _ intBra1ninputBeEntre com um n<mero2 eCC
breaA
e=cept alueError2
print e!pad Esse n<mero no $ vlido. 5ente de
novo...e
A construo try . . . e2ce!t possui uma clusula e.se
opcional, que quando presente, deve ser colocada depois de
todas as outras clusulas. s <til para um c)digo que precisa ser
e=ecutado se nenhuma e=ceo foi levantada.
for arg in s(s.argvX12Z2
tr(2
f _ openBarg, TrTC
e=cept %!Error2
print T"ao consegui abrir2T, arg
else2
101
print arg, T tem T, lenBf.readlinesBCC, Tlinhas.T
f.closeBC
'ina..y1 $ e=ecutada sempre, ocorrendo ou no uma
e=ceo. .uando ocorre a e=ceo, $ como se a e=ceo fosse
sempre levantada ap)s a e=ecuo do c)digo na clusula "inally.
Gesmo que haEa um breaA ou return dentro do tr(, ainda assim o
finall( ser e=ecutado. ! c)digo na clusula "inally $ <til para
liberar recursos e=ternos Bcomo arquivos e cone=>es de redeC,
no importando se o uso deles foi bem sucedido. A construo
tr( pode ser seguida da clusula finall( ou de um conEunto de
clusulas e=cept, mas nunca ambas Bno ficaria muito claro qual
deve ser e=ecutada primeiroC.
fff tr(2
raise Qe(board%nterrupt
finall(2
print TAte logo, mundodT
Ate logo, mundod
raise Qe(board%nterrupt
Qe(board%nterrupt
9iversos tipos de e=ce>es vDm pr$Fdefinidas pelo
interpretador '(thonS o guia de referDncia do '(thon cont$m
uma lista completa e os casos onde so levantadas. "ote
tamb$m que esta introduo a e=ce>es no cobre a sua sinta=e
completaS consulte a seo Errors and E=ceptions do tutorial
'(thon para maiores detalhes.
102
9. Bi5.ioteca Padro
9.1 Inter'ace com "istema !eraciona.
! m)dulo os oferece interfaceamento com o sistema
operacional e possui vrias fun>es. 'ara carregFlo digite2
im!ort os, veEa os comandos dirGosH e he.!GosH.
os.getc0dGH F retorna o diret)rio corrente.
fffos.getc1dBC
i62kk'(thon2-i
os.chdirGIdiret#rioXH F muda o diret)rio corrente.
fffos.chdirBiOiC
fffos.getc1dBC
i62kki
,se import os ao inv$s de from os import I, que pode ocultar
fun>es como os.openBC
que funcionam diferente.
renameGI%e.hoX3Ino%oarLui%oXH F renomeia arquivo.
eEa documentao atrav$s do helpBosC.
9.) T#du.o shuti.
,tilitrio com fun>es para copiar arquivos e rvore de
diret)rios.
10+
fff import shutil g importa m)dulo
fff shutil.cop(fileBTdata.dbT, Tarchive.dbTC g copia arquivo
fff shutil.moveBTObuildOe=ecutablesT, TinstalldirTC g move
arquivo ou diret)rio para outro local
9.+ T#du.o g.o5
8etorna uma lista de arquivos de diret)rio, usando
caracteres coringa.
fffglob.glob BI.p(C g retorna todos os arquivos de e=tenso
.p( do diret)rio.
Xiteste.p(iZ
9.7 T#du.o sys
'rovD acesso a alguns obEetos usados ou mantidos pelo
interpretador que interage diretamente com o interpretador.
fffs(s.path Y lista os diret)rios do path.
Xi62O'(thon24i, i62kk'(thon24kk*ibkkidlelibi,
i62kk0%"9!0#kks(stem+2kkp(thon24.Kipi,
i62kk'(thon24kk9**si, i62kk'(thon24kklibi,
i62kk'(thon24kklibkkplatF1ini, i62kk'(thon24kklibkklibFtAi,
i62kk'(thon24i, i62kk'(thon24kklibkksiteFpacAagesiZ
fff
#cripts geralmente precisam processar argumentos
passados na linha de comando. Esses argumentos so
armaKenados como uma lista no atributo arg% do m)dulo s(s.
10:
'or e=emplo, terJamos a seguinte saJda e=ecutando S!ython
demo.!y um dois tresA na linha de comando2
fff import s(s
fff print s(s.argv
XTdemo.p(T, TumT, TdoisT, TtresTZ
s(s.e=itBC F encerra um script.
9.9 T #du.o math
!ferece acesso xs fun>es da biblioteca 6 para
matemtica e ponto flutuante.
fff import math
fff math.cosBmath.pi O :.0C
0.4041034&11&3-:4-4
fff math.logB102:, 2C
10.0
9.= T#du.o random
@ornece ferramentas para gerar sele>es aleat)rias.
fff import random
fff random.choiceBXTappleT, TpearT, TbananaTZC
TappleT
fff random.sampleB=rangeB100C, 10C g e=emplo sem
substituicao
X+0, &+, 13, :, &, &1, :1, -0, 1&, ++Z
10-
fff random.randomBC g randomico float
0.14;40;&43;+4031&3
fff random.randrangeB3C g escolhendo randomico de uma
fai=a de 3
:
9.B T#du.o datetime
@ornece classes para manipulao de datas e horas nas
mais variadas formas.
6alendrios so facilmente formatados e construJdos
fff from datetime import date
fff no1 _ date.toda(BC
fff no1
datetime.dateB200+, 12, 2C
fff no1.strftimeBe?mF?dF?(. ?d ?b ?[ is a ?A on the
?d da( of ?7.eC
T12F02F0+. 02 9ec 200+ is a 5uesda( on the 02 da( of
9ecember.T
#uporte a operao aritm$ticas entre datas
fff birthda( _ dateB1;3:, 4, +1C
fff age _ no1 F birthda(
fff age.da(s
1:+3&
103
9.D T#du.o R.i5
6ompresso de dados.

fffimport Klib
fff =_i! rato roeu a roupa rasgada do rei de 8omai
ffflenB=C
:2
ffft_Klib.compressB=C
ffflenBtC
:2
fffa_Klib.decompressBtC
fffprint t
! rato roeu a roupa rasgada do rei de 8oma
9.E T#du.o array

@ornece obEeto arrayGH, para trabalhar com listas.
#omando uma lista com : elementos num$ricos todos com
tamanho de 2 b(tes em veK de 13 b(tes da representao
normal.
fff from arra( import arra(
fff a _ arra(BTLT, X:000, 10, 400, 22222ZC
fff sumBaC
23;+2
fff aX12+Z
arra(BTLT, X10, 400ZC
104
9.1F T#du.o co..ection
!bEeto deLue para ane=ar e remover rapidamente
elementos em listas.
fff from collections import deque
fff d_dequeBXetar1e,etar2e,etar+eZC
fff d.appendBetar:eC
fff print eGanipulandoe,d.popleftBC
Ganipulando tar1
fff
9.11 T#du.o decima.
'ara trabalhar com n<meros de ponto flutuante em
opera>es financeiras.
fff from decimal import I
fff 9ecimalBT0.44TC I 9ecimalBT1.03TC
9ecimalBe0.&132eC
fff getconte=tBC.prec _ +3
fff 9ecimalB1C O 9ecimalB4C
9ecimalBe0.1:2&-41:2&-41:2&-41:2&-41:2&-41:2&-4eC
fff getconte=tBC.prec_-:
fff 9ecimalB1CO9ecimalB4C
9ecimalBi0.1:2&-41:2&-41:2&-41:2&-41:2&-41:2&-41:2&-
41:2&-41:2&-4iC
10&
9.1) T#du.o itime
'ara medi>es de tempo.
fff from timeit import 5imer
fff 5imerBTt_aS a_bS b_tT, Ta_1S b_2TC.timeitBC
0.1-2;24:3;--:124+&-
fff 5imerBTa,b _ b,aT, Ta_1S b_2TC.timeitBC
0.0;;:3-;:+1+:+3204&
9.1+ T#du.o doctest
'ara e=ecutar testes automticos com o docstring. 8etorna erro
se o resultado no for o esperado.
g gere este arquivo teste.p(
def mediaBvaluesC2
eee6alcula a media aritmetica de uma lista
fff print mediaBX20, +0, 40ZC
-0.0
eee
return sumBvalues, 0.0C O lenBvaluesC
import doctest
doctest.testmodBC
10;
No she.. a!arecer mensagem de erro1
IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
@ile ennmainnne, line +, in nnmainnn.media
@ailed e=ample2
print mediaBX20, +0, 40ZC
E=pected2
-0.0
Pot2
:0.0
IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
1 items had failures2
1 of 1 in nnmainnn.media
III5est @ailedIII 1 failures.
"u5stitua o %a.or 9F !or 7F e a 'uno no retorna nenhum
resu.tado.
110
=. rientao a 5Keto
=.1 Introduo a Programao rientada a 5KetosGPH
Este termo foi criado por Alan 6urtis Qa(, autor da
linguagem de programao #malltalA. Antes da criao do
#malltalA, algumas das ideias da '!! E eram aplicadas, sendo
que a primeira linguagem a realmente utiliKar estas ideias foi a
linguagem #imula 34, criada por !le Wohan 9ahl e Qristen
"(gaard em 1;34. Este paradigma de programao E $ bastante
antigo e hoEe vem sendo aceito nas grandes empresas de
desenvolvimento de #oft1are. E=emplos de linguagens
modernas que utiliKam '!!2 Wava, 6g, 6ll, !bEect 'ascal
B9elphiC, 8ub(, '(thon, *isp, ...
=.) Lue P/

6om o obEetivo de apro=imar o mundo real do mundo
virtual, a programao orientada a obEeto tenta simular o mundo
real dentro do computador. 'ara isso, nada mais natural do que
utiliKar obEetos, afinal, nosso mundo $ composto de obEetos,
certo/ 6om isto, o programador $ responsvel por moldar o
mundo dos obEetos, e e=plicar para estes obEetos como eles
devem interagir entre si. !s obEetos econversame uns com os
outros atrav$s do en%io de mensagens, e o papel principal do
programador $ especificar quais sero as mensagens que cada
obEeto pode receber, e tamb$m qual a ao que aquele obEeto
deve realiKar ao receber aquela mensagem especJfica. ,ma
mensagem $ um pequeno te=to que os obEetos conseguem
entender e, por quest>es t$cnicas, no pode conter espaos.
Wunto com algumas dessas mensagens ainda $ possJvel passar
algumas informa>es para o obEeto BparHmetrosC, dessa forma,
111
dois obEetos conseguem trocar informa>es entre si facilmente.
'or e=emplo num sistema de controle de clientes podemos
afirmar que um dos obEetos so os clientes.
=.+ De'iniJes 5sicas de orientao a o5Keto
! obEeto $ um tipo abstrato que cont$m dados mais os
procedimentos que manipulam esses dados, ou $ uma unidade
de soft1are que encapsula algoritmos e os dados sobre o qual os
algoritmos atuam.
Tensagens1 s uma informao enviada ao obEeto para que ele
se comporte de uma determinada maneira. ,m programa
orientado a obEetos em e=ecuo consiste em envios,
interpreta>es e respostas xs mensagens.
TCtodos1 #o procedimentos ou fun>es residentes nos obEetos
que determinam como eles iro atuar ao receber as mensagens.
Nari%eis de InstUncia1 #o variveis que armaKenam
informa>es ou dados do pr)prio obEeto. 'odem tamb$m ser
chamadas de propriedades do obEeto.
$.asse1 *strutura fundamental para definir
novos ob1etos. 9ma classe . definida em
c5digo0fonte, e possui nome, um con1unto de
atributos e m.todos.
"u5c.asse1 ,ma nova classe originada de uma classe maior
Bclasse paiC.
InstUncia1 #o os obEetos de uma classe. 6ada obEeto utiliKado
em uma aplicao pertencente a uma classe, e $ uma instHncia
112
dessa classeBdiKFse que o obEeto fabricado por uma classe $ uma
instEncia da classeC.
_ereditariedade1 s um mecanismo que permite o
compartilhamento de m$todos e dados entre classes, subclasses
e obEetos. A hereditariedade permite a criao de novas classes
programando somente as diferenas entre a nova classe e a
classe pai.
Enca!su.amento ou a5strao1 s um mecanismo que permite
o acesso aos dados do obEeto somente atrav$s dos m$todos desse
obEeto. "enhuma outra parte do programa pode operar sobre os
dados de nenhum obEeto. A comunicao entre os obEetos $ feita
apenas atrav$s de mensagens.
Po.imor'ismo1 ,ma mesma mensagem pode provocar respostas
diferentes quando recebidas por obEetos diferentes. 6om o
polimorfismo, podeFse enviar uma mensagem gen$rica e dei=ar
a implementao a cargo do obEeto receptor da mensagem.
PersistMncia1 s a permanDncia de um obEeto na mem)ria.
.uando um obEeto $ necessrio, ele $ criado na mem)ria
Bm$todos construtoresC. .uando ele no for mais necessrio, $
destruJdo da mem)ria Bm$todos destrutoresC. .uando um obEeto
$ destruJdo, seu espao na mem)ria $ liberado automaticamente.
Este processo recebe o nome de Ncoleta de li=oU Bgarbage
collectorC.
=.7 P em Python
Em '(thon todos os tipos de dados so obEetos. 6om o
obEetivo de entender classes, $ preciso falar das regras de escopo
11+
em '(thon. ! que h de importante para saber $ que no e=iste
nenhuma relao entre nomes em espaos distintos. 'or
e=emplo, dois m)dulos podem definir uma funo de nome
Nma=imiKeU sem confuso Y usurios dos m)dulos devem
prefi=ar a funo com o nome do m)dulo para evitar coliso. s
normal utiliKar a palavra atributo para qualquer nome depois de
um ponto. "a e=presso K.real, por e=emplo, real $ um atributo
do obEeto K. Estritamente falando, referDncias para nomes em
m)dulos so atributos2 na e=presso mo(ulo.atrib, mo(ulo $ um
obEeto m)dulo e atrib $ seu atributo. "este caso, e=iste um
mapeamento direto entre os os atributos de um m)dulo e os
nomes globais definidos no m)dulo2 eles compartilham o
mesmo espao de nomes. Atributos de m)dulos so passJveis de
atribuio, vocD pode escrever jmodulo.resposta _ :2T, e
remoo pelo comando del Bjdel modulo.respostaTC.
Espaos de nomes so criados em momentos diferentes e
possuem diferentes longevidades. ! espao de nomes que
cont$m os nomes pr$Fdefinidos $ criado quando o interpretador
inicialiKa e nunca $ removido. ! espao de nomes global $
criado quando uma definio de m)dulo $ lida, e normalmente
duram at$ a saJda do interpretador. !s comandos e=ecutados
pela invocao do interpretador, ou pela leitura de um script, ou
interativamente so parte do m)dulo chamado nnmainnn, e
portanto possuem seu pr)prio espao de nomes Bos nomes pr$F
definidos possuem seu pr)prio espao de nomes no m)dulo
chamado nnbuiltinnnC. ! espao de nomes local para uma
funo $ criado quando a funo $ chamada, e removido quando
a funo retorna ou levanta uma e=ceo que no $ tratada na
pr)pria funo. "aturalmente, chamadas recursivas de uma
funo possuem seus pr)prios espaos de nomes. ,m escopo $
uma regio te=tual de um programa '(thon onde um espao de
nomes $ diretamente acessJvel. !nde Ndiretamente acessJvelU
11:
significa que uma referDncia sem qualificador especial permite o
acesso ao nome. Ainda que escopos seEam determinados
estaticamente, eles so usados dinamicamente. A qualquer
momento durante a e=ecuo, e=istem no mJnimo trDs escopos
diretamente acessJveis2 o escopo interno Bque $ procurado
primeiroC contendo nomes locais, o escopo intermedirio Bcom
os nomes globais do m)duloC e o escopo e=terno Bprocurado por
<ltimoC contendo os nomes pr$Fdefinidos. #e um nome $
declarado como global, ento todas as referDncias e atribui>es
de valores vo diretamente para o escopo intermedirio que
cont$m os nomes do m)dulo. 6aso contrrio, todas as variveis
encontradas fora do escopo interno so apenas para leitura Ba
tentativa de atribuir valores a essas variveis ir simplesmente
criar uma varivel local, no escopo interno, no alterando nada
na varivel de nome idDntico fora deleC. "ormalmente, o escopo
local referencia os nomes locais da funo corrente. @ora de
fun>es, o escopo local referencia os nomes do escopo global
Bespao de nomes do m)duloC. 9efini>es de classes adicionam
um espao de nomes ao escopo local.
,m detalhe especial $ que atribui>es so sempre
vinculadas ao escopo interno. Atribui>es no copiam dados,
simplesmente vinculam obEetos a nomes. ! mesmo $ verdade
para remo>es. ! comando jdel =T remove o vJnculo de = do
espao de nomes referenciado pelo escopo local. 9e fato, todas
opera>es que introduKem novos nomes usam o escopo local.
Em particular, comandos import e defini>es de funo
vinculam o m)dulo ou a funo ao escopo local Ba palavraF
reservada g.o5a. pode ser usada para indicar que certas
variveis residem no escopo global ao inv$s do localC.
+bser%a-!o: +bFetos possuem um atributo (e leitura escon(i(o
chama(o CC(ictCC ,ue retorna o (icion$rio utili&a(o para
implementar o espa-o (e nomes (o mG(ulo. + nome CC(ictCC '
11-
um atributo< por'm n!o ' um nome global. G(utoria. Python
ùido %an 4ossumH
=.9 De'inindo $.asses
A maneira mais simples de definir uma classe $ dada
abai=o.
c.ass nome#
%ar ? %alor
...
%ar ? %alor
def meto(o Bself< ... argC2
...
def meto(o Bself< ... argC2
...
As variveis e os m$todos so escritos precedidos pelo
nome da classe e por um ponto B.C Assim, uma %ari%e. $
de'inida numa c.asse c C escrita c.$ . !s m$todos sempre tDm
self como primeiro argumento, self se refere a uma instHncia da
classe. 'ara criar uma instHncia utiliKaFse a e=presso2
nome;da;c.asseGH. !s obEetos de classe suportam dois tipos de
opera>es2 referDncias a atributos e instanciao. Atributos
vlidos so todos os nomes presentes no espao de nomes da
classe quando o obEeto classe foi criado. 'ortanto, se a definio
da classe era2
class Ginha6lasse2
e,m e=emplo simples de classee
i _ 12+:-
113
def fBselfC2
return T!la mundoT
Ento Tinha$.asse.i e Tinha$.asse.' so referDncias a
atributos vlidos, retornando um inteiro e um obEeto funo,
respectivamente. Atributos de classe podem receber atribui>es,
logo vocD pode mudar o valor de Ginha6lasse.i por atribuio.
nndocnn $ tamb$m um atributo vlido, que retorna a docstring
pertencente a classe2 e,m e=emplo simples de classee.

Instanciao de $.asse1 = _ Ginha6lasseBC g cria um
obEeto vaKio
A operao de instanciao cria um obEeto vaKio. Guitas classes
preferem criar um novo obEeto em um estado inicial pr$F
determinado. 'ara tanto, e=iste um m$todo especial nninitnn.
def nninitnnBselfC2
self.data _ XZ
! m$todo nninitnnBC pode ter argumentos para aumentar sua
fle=ibilidade. "este caso, os argumentos passados para a
instanciao de classe sero delegados para o m$todo nninitnnBC.
fff class 6omple=2
def nninitnnBself, realpart, imagpartC2
self.r _ realpart
self.i _ imagpart
=_comple=BC g veEa o m$todo nninitnn em ao, obrigando a
fornecer os argumentos para
instanciar o obEeto com um estado inicial pr$Fdeterminado.
114
@ile Nmp(shellg;fU, line1, inmmodulef
=_comple=BC
5(peError2nninitnnBC taAes e=actl( + arguments B1 givenC
fff = _ 6omple=B+.0, F:.-C
fff =.r, =.i
B+.0, F:.-C
Acessando atri5utos de dados e mCtodos nas instUncias2
fff=_Ginha6lasseBC
fff=.i_1
fff1hile =.im102
=.i_=.iI2
print =.i
2
:
&
13
fff1hile =.im102 galterou atributo de dados sem dei=ar
rastro
=.i_=.iI2
print =.i
del =.i
fff=.i
13
fff del =.i gapaga =.i e retorna valor inicial
fff=.i
11&
12+:-
,m m$todo $ uma funo que Npertence aU uma
instHncia Bem '(thon, o termo m$todo no $ aplicado
e=clusivamente a instHncias de classes definidas pelo usurio2
outros tipos de obEetos tamb$m podem ter m$todosS por
e=emplo, obEetos listas possuem os m$todos2 append, insert,
remove,sort, etcC. "omes de m$todos vlidos de uma instHncia
dependem de sua classe. 'or definio, todos atributos de uma
classe que so fun>es equivalem a um m$todo presente nas
instHncias. "o nosso e=emplo, =.f $ uma referDncia de m$todo
vlida E que Ginha6lasse.f $ uma funo, enquanto =.i no $, E
que Ginha6lasse.i no $ funo. Entretanto =.f no $ o mesmo
que Ginha6lasse.f, o primeiro $ um m$todo de obEeto e o
segundo $ um obEeto funo. ! m$todo em um obEeto $
chamado da forma 2.'GH BobEeto =C, porque um m$todo $ uma
funo, neste caso o parHmetro deste obEeto foi
Ginha6lasse.fB=C, com isto podemos diKer que um m$todo com
n argumentos o 1o. Argumento sem!re ser a instUncia da
c.asse.
$omo nomear atri5utos de dados e mCtodos1 Algumas ideias
incluem colocar nomes de m$todos com inicial mai<scula,
prefi=ar atributos de dados com uma string <nica Bquem sabe
NnUC, ou simplesmente utiliKar substantivos para atributos e
verbos para m$todos. %sto evita erros difJceis de encontrar. !
argumento se.' $ s) uma conveno usada por desenvolvedores
'(thon, mas podeFse usar qualquer nome.
Atri5uir um o5Keto 'uno a uma %ari%e. .oca. da c.asse C
%.ido.
11;
g @uno definida fora da classe
def f1Bself, =, (C2
return minB=, =l(C
class 62
f _ f1
def gBselfC2
return Thello 1orldT
h _g
f,g,h agora so atributos de 6. Gas esta soluo no $ uma boa
prtica.
$hamada de TCtodos !or outros mCtodos uti.iRando o
argumento se.' 1
class #omas2
def nninitnnBselfC2
self.dado _ XZ
def somaBself, =C2
self.dado.appendB=C
def somaduplaBself, =C2
self.somaB=C
self.somaB=C
=.= _erana
,m mecanismo fundamental em sistemas orientados a
obEetos modernos $ herana2 uma maneira de derivar classes
novas a partir da definio de classes e=istentes, denominadas
neste conte=to classes base. As classes derivadas possuem
acesso transparente aos atributos e m$todos das classes base, e
podem redefinir estes conforme conveniente.
120
Lerana $ uma forma simples de promover reuso atrav$s de uma
generaliKao2 desenvolveFse uma classe base com
funcionalidade gen$rica, aplicvel em diversas situa>es, e
definemFse subclasses concretas, que atendam a situa>es
especJficas.
6lasses '(thon suportam herana simples e herana m<ltipla2
class nomeFclasseBbase1, base2, ..., basenC2 g
Bmod.base1...base definida em m)duloC
varF1 _ valorF1
.
.
varFn _ valorFn
def nomeFm$todoF1Bself, arg1, arg2, ..., argnC2
g bloco de c)digo do m$todo
.
.
def nomeFm$todoFnBself, arg1, arg2, ..., argnC2
g bloco de c)digo do m$todo
6omo pode ser observado acima, classes base so especificadas
entre parDnteses ap)s o nome da classe sendo definida. "a sua
forma mais simples.
fff class 72
n _ 2
def fBself,=C2 return 7.nI=
fff class 6B7C2 g chamada
def fBself,=C2 return 7.fBself,=CII2
121
def gBself,=C2 return self.fB=Cl1
fff b _ 7BC
fff c _ 6BC
fff b.fB+C
3
fff c.fB+C
+3
fff c.gB+C
+4
fff 7.n _ -
fff c.fB+C
22-
s atri5utos es!eciais ;;doc;; 3 ;;modu.e;; e 'uno he.! 1
class 5apecaria2
eee8eforma e servico de
qualidade em veiculos.eee
def revisaoBselfC2
eee
Este metodo responde com a avaliacao dos servicos
eee
print i,m servico e=cepcionali
print 5apecaria.nndocnn gdocumentacao da classe
print 5apecariaBC.nndocnn gdocumentacao da instancia
print 5apecariaBC.revisao.nndocnn gdocumentacao da funcao
da instancia
resultado2
122
,m servico e=cepcional
8eforma e servico de
qualidade em veiculos
Este metodo responde com a avaliacao dos
servicos
comando1 he.!G(a!ecariaH
Lelp on class 5apecaria in module nnmainnn
class 5apecaria
v 8eforma e servcio de
v qualidade em veiculos.
v
v Gethods defined here2
v
v revisaoBselfC
v Este metodo responde com a avaliacao dos servicos
@erramenta de introspeco a ser comentada adiante. A primeira
linha mostra o m)dulo a que pertence a classe e todos os
m$todos e as docstrings.
fff 5apecaria.nnmodulenn gmostra o m)dulo da classe
innmainnni
=.B Atri5utos Pri%ados
Em princJpio, todos os atributos de um obEeto podem
sera acessados tanto dentro de m$todos da classe como de fora.
12+
.uando um determinado atributo deve ser acessado apenas para
implementao da classe, ele no deveria ser acessJvel de fora.
Em princJpio tais atributos no faKem parte da interface
Np<blicaU da classe. Atributos assim so ditos pri%a(os. Em
'(thon, atributos privados tDm nomes iniciados por dois
caracteres NsublinhadoU, isto $, nn .
fff class 62
def nninitnnBself,=C2 self.nn= _ =
def incrBselfC2 self.nn= l_ 1
def =BselfC2 return self.nn=
fff a _ 6B-C
fff a.=BC
-
fff a.incrBC
fff a.=BC
3
fff a.nn=
@ile emp(shellg1+fe, line 1, in Ftoplevela.nn
=
AttributeError2 6 instance has no attribute inn=i
=.D utros TCtodos
W vimos um m$todo desses2 o construtor nninitnn .
Alguns outros so2
Adio2 nnaddnn
6hamado usando ili
#ubtrao2 nnsubnn
6hamado usando iFi
12:
8epresentao2 nnreprnn
6hamado quando obEeto $ impresso
6onverso para string2 nnstrnn
6hamado quando o obEeto $ argumento do construtor da
classe str . #e no especificado, a funo nnreprnn $ usada
Gultiplicao2nnmulnn
6hamado usando iIi
fff class vetor2
def nninitnnBself,=,(C2
self.=, self.( _ =,(
def nnaddnnBself,vC2
return vetorBself.=lv.=, self.(lv.(C
def nnsubnnBself,vC2
return vetorBself.=Fv.=, self.(Fv.(C
def nnreprnnBselfC2
return evetorBelstrBself.=Cle,elstrBself.(CleCe
fff a_vetorB1,2C
fff a l_ vetorB+,-C
fff aFvetorB2,2C
vetorB2,-C
fff print a
vetorB:,4C
fff class !pn7asicas2
def nninitnnBself, entradaC2
self.valor _ entrada
def nnaddnnBself, otherC2 g m$todo especiald
return self.valor l other.valor
def nnmulnnBself, otherC2 g m$todo espeiald
return self.valor I other.valor
12-
fff a _ !pn7asicasB-3C
fff b _ !pn7asicasBF2+C
fff a l b
++
fff a I b
F12&&
fff str1 _ !pn7asicasBi-3iC
fff str2 _ !pnbasicasBiF2+iC
fff str1 l str2
i-3F2+i
fff str1 I str2 g vai dar erro porque no definimos operao
soma multipilicao de strings
E88!
"ote a sobrecarga de operadores, que antes s) eram
usados para inteiros, float...e passa agora a ser utiliKado em
instHncias.
fffstr2_-
fffstr1Istr2
i-3-3-3-3-3i goperao de string por inteiro E $ assumida pelo
operador I.
5Ketos $a..a5.e1 so todos os obEetos que so capaKes
de carregar um n<mero indeterminado de argumentos.
@un>es, m$todos e classes so sempre callableBchamveisC.
'ara sabermos se um obEeto $ callable usamos a operao
boolena ca..a5.eGo5KH .
123
fff callableBstr1C g str1 $ uma instHncia da classe
!pn7asicas...
@alse
fff callableB!pn7asicasC
5rue
fff callableBd.quadradoC
5rue
fff callableBiabaca=iiC
@alse
!bs2 instncias no so obEetos callable.
fff class !pn7asicas2
def nninitnnBself, entradaC2
self.valor _ entrada
def nnaddnnBself, otherC2
return self.valor l other.valor
def nnmulnnBself, otherC2
return self.valor I other.valor
def nncallnnBself, qualquerncoisaC2 g m$todo especiald
return qualquerncoisa
fff a_!pn7asicasB-3C
fff callableBaC g com o m$todo nncallnn a instHncia passa a
ser callable
5rue
=.E 8unJes ateis
4 duas fun/es particularmente teis
124
para estudar uma -ierarquia de classes e
inst+ncias#
isinstance(objeto, classe1 retorna
verdadeiro se o obEeto for uma instHncia da classe
especificada, ou de alguma de suas subclasses.
issubclass(classe!a, classe!b1 retorna
verdadeiro se a classe especificada como classe:a for
uma subclasse da classe:b, ou se for a pr)pria
classe:b.
fffisinstanceBa,!pn7asicasC
5rue
=.1F Intros!eco e re'.e2o
#o propriedades de sistemas orientados a obEetos que
qualificam a e=istDncia de mecanismos para descobrir e alterar,
em tempo de e=ecuo, informa>es estruturais sobre
um programa e ob1etos eistentes neste.
,!t-on possui tanto caractersticas
introspectivas quanto refleivas. ,ermite
obter em tempo de eecuo informa/es a
respeito do tipo dos ob1etos, incluindo
informa/es sobre a -ierarquia de classes.
,reserva, tamb.m, metadados que descrevem a
estrutura do programa sendo eecutado, e
permitindo que se estude como ele est
organi;ado sem a necessidade de ler o seu
c5digo0fonte.
Algumas fun/es e atributos so
12&
particularmente importantes neste sentido,
e so apresentadas nesta seo#
dir(ob1"2 esta funo pr$Fdefinida lista todos os
nomes de variveis definidos em um determinado obEetoS
foi apresentada anteriormente como uma forma de obter
as variveis definidas em um m)dulo, e aqui pode ser
descrita em sua gl)ria completa2 descreve o conte<do de
qualquer obEeto '(thon, incluindo classes e instHncias.
ob1.::class::2 este atributo da instHncia armaKena
o seu obEeto classe correspondente.
ob1.::dict::2 este atributo de instHncias e classes
oferece acesso ao seu estado local.
ob1.::module::2 este atributo de instHncias e classes
armaKena uma string com o nome do m)dulo do qual foi
importado.
classe.::bases::2 esta atributo da classe armaKena
em uma tupla as classes das quais herda.
classe.::name::2 este atributo da classe armaKena
uma string com o nome da classe.
12;
B. E2em!.os de rientao a 5Ketos e utros
B.1 De'inio de uma c.asse
{ uma classe com trDs m$todos
c.ass $ontadorBobEectC2
de' nninitnnBselfC2
self.dic _ tu
de' incluirBself, itemC2
qtd _ self.dic.getBitem, 0C l 1
self.dicXitemZ _ qtd
de' contarBself, itemC2
return self.dicXitemZ
nninitnn $ invocado automaticamente na instanciao
"ote que a referDncia ao obEeto onde estamos operando $
e=plJcita BselfC.
fffa_6ontadorBC
fffa
mnnmainnn.6ontador obEect at 0=00E1AE70f
fffa.incluirBiaiC
fff print a.contarBiaiC
1
fffa.incluirBibiC
fffprint a.contarBibiC
1
fffa.incluirBibiC
fffprint a.contarBibiC
2
1+0
"as chamadas de m$todos, o self $ implJcito pois a
sinta=e $ instancia.metodoBC.
5odos os m$todos de instHncia recebem como primeiro
argumento uma referDncia e=plJcita x pr)pria instHncia.
'or conveno, usaFse o nome self.
s obrigat)rio faKer referDncia e=plJcita a self para
acessar atributos da instHncia.
,samos nninitnn para inicialiKar os atributos da
instHncia.

B.) InstUncias a5ertas e c.asses Z%aRias<
instHncias podem receber atributos dinamicamente
fff class AnimalBobEectC2
Tum animal qualquerT
fff baleia _ AnimalBC
fff baleia.nome _ TGob( 9icAT
fff print baleia.nome
B.+ Atri5utos de c.asse ] de instUncia
instHncias adquirem atributos da classe
fff class AnimalBobEectC2
nome _ TmailoT g atributo da classe
fff cao _ AnimalBC
fff cao.nome g atributo adquirido da classe
TmailoT
fff cao.nome _ TdinoT g criado na instHncia
fff cao.nome
1+1
TdinoT
fff Animal.nome g na classe, nada mudou
TmailoT
B.7 TCtodos de c.asse ] estticos
indicados por meio de decorators
class E=emploBobEectC2
hclassmethod
def danclasseBcls, arg1C2
return Bcls, arg1C
hstaticmethod
def estaticoBarg1C2
return arg1
XXX E=emplo.danclasseBTfuTC
Bmclass Tnnmainnn.E=emploTf, TfuTC
XXX E=emplo.estaticoBTbarTC
TbarT
B.9 _erana
class 6ontadorBobEectC2
def nninitnnBselfC2
self.dic _ tu
def incluirBself, itemC2
qtd _ self.dic.getBitem, 0C l 1
self.dicXitemZ _ qtd
1+2
def contarBself, itemC2
return self.dicXitemZ
_erana
class 6ontador5oleranteB$ontadorC2
def contarBself, itemC2
return self.dic.getBitem, 0C
A 'orma mais sim!.es
class 6ontador5otaliKadorB$ontadorC2
def nninitnnBselfC2
6ontador.nninitnnBselfC
self.total _ 0
6ontador.incluirBself, itemC
self.total l_ 1
A 'orma mais correta
class 6ontador5otaliKadorB$ontadorC2 g superB...C acesso a
classe pai
def nninitnnBselfC2
superB6ontador5otaliKador,selfC.nninitnnBC
self.total _ 0
superB6ontador5otaliKador,selfC.incluirBitemC
self.total l_ 1
1++
herana m:.ti!.a
c.ass $ontador((B6ontador5otaliKador, 6ontador5oleranteC2
!ass
{ G8! _ ordem de resoluo de m$todos2
XXX 6ontador55.nnmronn
Bmclass Tnnmainnn.6ontador55Tf,
mclass Tnnmainnn.6ontador5otaliKadorTf,
mclass Tnnmainnn.6ontador5oleranteTf,
mclass Tnnmainnn.6ontadorTf,
mt(pe TobEectTfC
E2em!.o de uso
fffclass 6ontador55B6ontador5otaliKador,
6ontador5oleranteC2
pass
fffct_6ontador55BC
ffffor = in iabobrinhai2
ct.incluirB=C
fffct.total
;
fffct.contarBiaiC
2
fffct.contarBi=iC
0
1+:
B.= Enca!su.amento
fffclass 6BC2
pass
fffa_6BC
fffa.=_10 gpode alterar atributo
fffprint a.=
10
fffa.=_11
fffprint a.=
11
{ apenas para leitura, via decorator2
class 6BobEectC2
def nninitnnBself, =C2
self.nn= _ =
hpropert(
def =BselfC2
return self.nn=
{ a notao nn= protege este atributo contra acessos acidentais
fffa_6B10C
fffprint a.=
10
fffa.=_11
Error can|t set attribute
1+-
{ para leitura e escrita2
class 6BobEectC2
def nninitnnBself, =_0C2
self.nn= _ =
def get=BselfC2
return self.nn=
def set=Bself, =C2
if = m 02 = _ 0
self.nn= _ =
= _ propert(Bget=, set=C
fffa_6B10C
fffa.=_10
fffa.(_11
fffprint a.=
11
fffa.=_10
fffprint a.=
10
fffb_6BC
fffprint a.=
10
fffprint b.=
0
B.B Passagem de !arUmetros
def fBa, b_1, c_"oneC2
return a, b, c
fff fBC
1+3
@ile emstdinfe, line 1, in mmodulef
5(peError2 fBC taAes at least 1 argument B0 givenC
fff fB;C
B;, 1, "oneC
fff fB-,3,4C
B-, 3, 4C
fff fB+, c_:C
B+, 1, :C
def fBIargs, II=argsC2
return args, =args
fff fBC
BBC, tuC
fff fB1C
BB1,C, tuC
fff fBcor_TaKulTC
BBC, tTcorT2 TaKulTuC
fff fB10,20,+0,sabor_TuvaT,cor_TvinhoTC
BB10, 20, +0C, tTcorT2 TvinhoT, TsaborT2 TuvaTuC
B.D Po.imor'ismo
{ polimorfismo com fatiamento e len
fff l _ X1, 2, +Z
fff lX22Z
1+4
X1, 2Z
fff TcasaTX22Z
TcaT
fff lenBlC, lenBTcasaTC
B+, :C
{ Ntipagem patoU BducA t(pingC $ polimorfismo dinHmico.
fff def dobroB=C2
... return = I 2
...
fff dobroB10C
20
fff dobroBX1, 2, +ZC
X1, 2, +, 1, 2, +Z
fff dobroBTcasaTC
Tcasacasai
{ 7aralho 'olif)rmico2 classe simples
class 6artaBobEectC2
def nninitnnBself, valor, naipeC2
self.valor _ valor
self.naipe _ naipe
def nnreprnnBselfC2
return Tm?s de ?sfT ? Bself.valor, self.naipeC
1+&
{ m$todos especiais2 nnlennn, nngetitemnn
{ com esses m$todos o 7aralho implementa o protocolo das
sequDncias
class 7aralhoBobEectC2
naipes _ Tcopas ouros espadas pausT.splitBC
valores _ TA 2 + : - 3 4 & ; 10 W . QT.splitBC
def nninitnnBselfC2
self.cartas _ X
6artaBv, nC for n in self.naipes for v in
self.valores
Z
def nnlennnBselfC2
return lenBself.cartasC
def nngetitemnnBself, posC2
return self.cartasXposZ
def nnsetitemnnBself, pos, itemC2
self.cartasXposZ _ item
fffa_7aralhoBC
fffa.cartas
ffflenBaC
-2
fff from random import shuffle
fff shuffleBaC
fffaXF+2Z
XmQ de espadasf, m10 de copasf, mQ de copasfZ
1+;
D. (6inter ? T#du.o de Inter'ace `r'ica
D.1 Introduo
! 5Ainter $ um conEunto de elementos B1idgetsC, na
linguagem '(thon, para a construo de interface grfica com o
usurioBP,%C. Esse m)dulo grfico vem Eunto com o '(thon.
rios elementos esto disponJveis neste m)dulo como boto,
cai=a de te=to, Eanela etc.., al$m disso temos vrios
manipuladores de eventos Bevent handlersCcomo abrir e fechar
Eanela e eventos de loop
1+
, na maioria das veKes $ necessrio
atribuir ao elemento um evento
1:
, mas e=istem casos em que
assim que adicionamos o elemento ele E tem associado um
evento e seu manipuladorBEanela2 E vem com boto de abrir e
fecharC.

1+ Evento que fica em espera aguardando at$ que um manipulador seEa
acionado, ou que uma entrada de dados seEa feita
1: 8otina que e=ecuta alguma tarefa como2 armaKenar dados, fechar Eanela
1:0
Figura =: E%entos e Hanipula(ores
eEa este caso acima2 o mouse ficou parado em cima do
menu @ileBEventC e o manipulador de eventoBEvent LandlerC
automaticamente modificou este boto destacandoFo. eEa que
para este caso no foi necessrio faKer um ligao ou
atribuioBbindingC, uma veK que este tipo de binding E $
automtico.
6omo todo bom manual nosso primeiro programa $ o NAlo
GundodU.
g FIF coding2 cp12-2 FIF g caracteres acentuados
g @ile2 alo1.p(
from 5Ainter import I g importa o modulo 5Ainter
raiK _ 5ABC g cria uma Eanela de mais alto nJvel
g chamada de raiK BrootC
1 _ *abelBraiK, te=t_eAlo GundodeC g insere 1idgets na
g Eanela
1.pacABC g m$todo que faK o
g te=to caber na Eanela
raiK.mainloopBC g mostra a Eanela raiK e e=ecuta o event
gloop, aguarda um evento ou fechamento da
g Eanela atrav$s de um evento destruidor
E=ecute este programa no prompt do sistema atrav$s do
comando2 p(thon alomundo.p(. Ao e=ecutar um programa em
%9*E este poder entrar em conflito com o mainloop da %9*E
1:1
uma veK que esta interface P,% $ uma aplicao 5Ainter.
D.) A c.asse (6
D.).1 Item Bsico
'ara trabalharmos com a classe tA devemos primeiro
disponibiliKFla atrav$s do comando import, depois importar a
classe tA que cria a Eanela principal com os 1idgets minimiKar,
ma=imiKar e fechar a Eanela, e depois visualiKFla atrav$s do
event loop mainloop.
D.).) ,m !rograma 5em sim!.es
ffffrom 5Ainter import I
fffraiK_5ABC
fffraiK.mainloopBC
1:2
Fig I: Programa 5lJ Hun(o na Fanela
(o 7Binter
Fig 0: 7ela (o programa
simples.
Este $ um programa muito simples, inclusive os comandos
podem ser digitados no %9*E.
D.).+ Nosso !rimeiro o5Keto `,I
"empre que trabalhamos com o 5Ainter devemos importar todo
conte<do do m)dulo, quando faKemos isto importamos a classe
5A que tem todos o elementosB1idgetsC. "ossa interface deve
ser estruturada em forma de classes a partir da classe raiK, uma
instHncia da classe 5A. 'ara programarmos com interfaces P,%
5Ainter devemos citar trDs conceitos2
A criao de um obEeto P,% e a associao a raiK.
! m$todo pacA.
! conceito containers
1-
versus 1idgets
s importante dividirmos os elementos ou componentes
grficosB1idgetsC em containers e 0idgets. !s
elementosB1idgetsC sero os componentes grficos
visJveisBgeralmenteC da P,% e tem uma funo voltada ao
usurio, E os containers so componentes que agregam vrios
1idgets, ou seEa um recipiente onde colocamos os 1idgets. !
5Ainter oferece vrios tipos de containers. N6anvasU $ um
container para aplica>es de desenho, e o container mais
frequentemente utiliKado $ o N@rameU
13
. @rames so oferecidos
pelo 5Ainter como uma classe chamada N@rameU.
eEamos isto2
from 5Ainter import I
root _ 5ABC
1- #o componentes que agregam vrios elementosB1idgetsC.
13 s uma regio retangular da tela.
1:+
container1 _ @rameBrootC
container1.pacABC
root.mainloopBC
"o programa acima importamos o m)dulo 5A criamos
um obEeto raiK instHncia de 5A e dentro deste obEeto colocamos
um obEeto container do tipo @rame, este tipo de estrutura gera
uma relao de pai e filho ou mestreFescravo de tal forma que ao
fecharmos a instHncia pai ou mestre automaticamente
fecharemos a Eanela. ! obEeto container1 $ uma instHncia de
@rame e esta conectado logicamente ao obEeto raiK, uma
instHncia de 5A. "a pr)=ima linha temos um m$todo
simplesmente designado, NpacAU $ um m$todo que transforma
em visuais as rela>es entre os componentes P,% e seus
mestres. #e vocD no definir o componente pacA ou outro
gerenciador de geometria, nunca ver a P,%. ,m gerenciador de
geometria $ essencialmente um A'%
14
Y um meio de diKer ao
5Ainter como vocD quer que containers e 1idgets se apresentem
visualmente. 5Ainter oferece trDs gerenciadores para esta
finalidade2 pacA, grid e place. 'acA e grid so os mais usados
por serem mais simples.
I #ubstitua o comando container1.pacABC por2 container1.gridBC
e depois por container1.placeBC e veEa o que acontece.
6omparando dois e=emplos2 "o programa anterior, por no
termos colocado nada dentro dela, a raiK mostrou a si mesma na
14 Application 'rogramming %nterface
1::
tela com seu tamanho padro, mas neste programa, n)s
preenchemos sua cavidade com o container1. Agora, a raiK se
estica para acomodar o tamanho de container1, mas como no
colocamos nenhum 1idget neste frame, nem especificamos um
tamanho mJnimo para ele, a cavidade da root se encolhe at$ o
limite, podemos diKer que esta frame $ elstica. 'or isso no h
nada para ser visto abai=o da barra de tJtulo desse programa.
D.).7 $ontainers e 0idgets
A estrutura de containers pode ser bastante sofisticada e
pode conter um dentro do outro e dentro destes os 1idgets.

1:-
Fig. K: E#emplo 5nterior
Fig. 9: E#emplo
eEa a estrutura acima onde temos a Eanela raiK dentro dela os
obEetos containers frame 1 e frame 2 e dentro destas Eanelas os
1idgets. 5emos agora que usar um gerenciador de geometria
para posicionar 1idgets dentro das Eanelas.
'ara e=emplificar criaremos uma Eanela raiK com dois container
e dentro deles os bot>es como acima.
g FIF coding2 cp12-2 FIF gpara colocar caracteres acentuados
root _ 5ABC
6ontainer1 _ @rameBrootC
6ontainer2_ @rameBrootC
6ontainer1.pacABC
6ontainer2.pacABC
botao _ 7uttonB6ontainer1C gcria boto
botaoXete=teZ_ eA*! G,"9!1de gte=to do boto
botaoXebacAgroundeZ _ egra(e gcor do boto
botao.pacABC gvisualiKa e posiciona boto
1:3
Figura 4: *ontainers com .i(gets(botLes
botao _ 7uttonB6ontainer2C g boto 2
botaoXete=teZ_ eA*! G,"9!2de
botaoXebacAgroundeZ _ egra(e
botao.pacABC
botao _ 7uttonB6ontainer2C g boto +
botaoXete=teZ_ eA*! G,"9!2de
botaoXebacAgroundeZ _ egra(e
botao.pacABC
root.mainloopBC
E=perimente mudar a cor do boto de Ngra(U para NblueU.

D.).9 ,sando c.asses !ara estruturar o !rograma
Ao escrever grandes programas $ uma boa ideia dividir
os c)digos em classes. Esta estruturao em classes $ muito
importante e vai aEudFlo a controlar melhor seu
desenvolvimento. ,m programa estruturado em classes $
provavelmente Y especialmente se seu programa for muito
grande Y muito mais fcil de ser entendido. ,ma considerao
muito importante $ que estruturar sua aplicao como uma
classe aEudar vocD a evitar o uso de variveis globais.
Eventualmente, conforme seu programa for crescendo, vocD
provavelmente ir querer que alguns de seus event handler
consigam compartilhar informa>es entre si. ,ma maneira $
usar variveis globais, mas no $ uma t$cnica muito
recomendada. ,m caminho muito melhor $ usar instHncias Bisto
$ obEetos gerados pela chamada da classeC, e para isso vocD
precisa estruturar sua aplicao como classes.
amos estruturar em classe parte do e=emplo anterior, primeiro
criamos uma classe chamada Aplic e depois transcreveremos
alguns dos c)digos do programas anteriores para dentro do seu
1:4
m$todo construtor BnninitnnC. "esta verso ento teremos uma
classe chamada Aplic e nela definiremos a forma da interface
P,%. 5odo esse c)digo $ inserido dentro do m$todo construtor
dessa classeBclass AplicC. .uando o programa $ e=ecutado, uma
instHncia da classe $ criada atrav$s do comando
a!.icbA!.icGraiRH, veEa que a instHncia tem a letra inicial do
nome min<sculo e a classe mai<scula BconvenoC e perceba que
passamos para esta classe como argumento a NraiKU.
class Aplic2
def nninitnnBself, paiC2
self.6ontainer1 _ @rameBpaiC
self.6ontainer1.pacABC
self.botao1_ 7uttonBself.6ontainer1C
self.botao1Xete=teZ_ eAplicaoe
self.botao1XebacAgroundeZ _ erede
self.botao1.pacABC
raiK _ 5ABC
aplic _ AplicBraiKC
raiK.mainloopBC
amos inserir agora mais um elementoB1idgetC nesta classe,
para ficar assim a aplicao2
1:&
class Aplic2
self.label1_*abelBself.6ontainer1C
self.label1Xete=teZ_eAperte o botoe
self.label1.pacABC
self.botao1XebacAgroundeZ _ erede
self.botao1.pacABC
raiK _ 5ABC
aplic _ AplicBraiKC
raiK.mainloopBC
!s elementosB1idgetsC tem outras configura>es como2
height Y altura em n<mero de linhas de te=to
1idth Y largura em n<mero de n<mero de caracteres de
te=to
1:;
Fig. 8: Dois elementos(.i(get na
classe 5plic.
font Y configura a fonte de te=to.
fg Y cor de frenteBforegroundC
bg Y cor de fundoBbacAgroundC
!utro e=emplo com boto e suas configura>es2
class Aplic2
self.label1_*abelBself.6ontainer1C
self.label1Xete=teZ_eAperte o botoe
self.label1XefgeZ _ ec(ane
self.label1.pacABC
self.botao1XebgeZ _ e(ello1e
self.botao1XeheighteZ_:
self.botao1XefonteZ_Bi1ide latini,i1:i,iitalici,iboldiC
self.botao1.pacABC
raiK _ 5ABC
aplic _ AplicBraiKC
raiK.mainloopBC
1-0
D.).9.1 E.ementos do (6inter
7utton
7oto simplesF usado para e=ecutar um comando
ou outra operao.
6anvas Prficos estruturados. 'ode ser usado para plotar
e desenhar grficos, criar editores grficos e para
implementar 1idgets customiKados.
6hecAbutto
n
8epresenta uma varivel que pode ter dois
valores distintos. 6licando no boto o valor $
trocado.
Entr( ,m campo para entrada de te=to.
@rame ,m 1idget tipo container. A @rame pode ter
borda e fundo e $ usado para agrupar 1idgets
quando criamos uma aplicao ou dilogo.
*abel Gostra um te=to ou imagem.
1-1
Figura M: Not!o com algumas
con"igura-Les mo(i"ica(as.
*istbo= Gostra uma lista de alternativas. A listbo= pode
ser configurada para comportarFse como
radiobutton ou checAlist.
Genu ,m painel de menu. ,sado para implementar
menus pullFdo1n e popFup.
Genu7utton ,m boto de menu. ,sado para implementar
menus pullFdo1n.
Gessage Gostra um te=to. #imilar ao label, mas podemos
automaticamente aEustar te=to ao tamanho e
proporo
8adiobutton 8epresenta um valor de varivel que pode ter
vrios valores. 6licando o boto, o valor da
varivel $ posicionado para aquele valor e os
outros valores so apagados.
#cale 'ermite posicionar um valor num$rico arrastando
um ponteiro.
#crollbar 7arra de rolamento padro usada com 1idgets
canvas, entr(, listbo= e te=t.
5e=t @ormata um te=to. 'ermite a vocD mostrar e
editar te=tos com vrios estilos e atributos.
5amb$m suporta incorporar imagens e Eanelas.
5oplevel Wanela de mais alto nJvel.
5odos os 1idgtes tem a mesma hierarquia.
,m 1idgtes tJpico possui cerca de 1-0 m$todos. A classe
5oplevel fornece o gerenciador de interfaces. Al$m disso temos
1-2
os gestores de geometria que permite criar la(Fouts, so eles2grid
1&
, pacA
1;
e place
20
.
D.).= Posicionando os 5otJes
W verificamos que o m$todo pacA $ quem cuida da parte
visual do 1idget e ele possue um argumento chamado side que
pode assumir os valores2 left, right, top, bottom.
class Aplic2
frame _ @rameBC
frame.pacABC
self.botaoE_ 7uttonBframe, te=t_e#aie, fg_erede,
command_frame.quitC
self.botaoE.pacABside_*E@5C
self.botao9 _ 7uttonBframe, te=t_e!ide,
command_self.diga!iC
self.botao9.pacABside_8%PL5C
def diga!iBselfC2
1& *a(Fout em uma grade biFdimensional.
1; *a(Fout em blocos retangulares.
20 'ermite definir o la(Fout do local que colocaremos o 1idget.
1-+
print e!i Goadade
root _ 5ABC
app _ AplicBrootC
root.mainloopBC
!bserve em botaoE e botao9 do programa anterior os
comandos que foram associados aos bot>es.

'osicionamento superior e inferior.
class Aplic2
frame _ @rameBC
frame.pacABC
1-:
Figura 1O: Posicionamento
(os NotLes
self.botaoA_ 7uttonBframe, te=t_eAcimae, fg_erede,
command_self.diga!i
21
C
self.botaoA.pacABside_5!'C
self.botao7 _ 7uttonBframe, te=t_eAbai=ode,
self.botao7.pacABside_7!55!GC
self.botaoE_ 7uttonBframe, te=t_e#aie, fg_erede,
command_frame.quitC
self.botaoE.pacABside_*E@5C
self.botao9 _ 7uttonBframe, te=t_e!ide,
self.botao9.pacABside_8%PL5C
def diga!iBselfC2
print e!ie
root _ 5ABC
app _ AplicBrootC
root.mainloopBC
21 6ommand 7inding Y ligao do evento a uma rotina de comando.
1--
eEa nesta figura que ap)s colocarmos um boto no container,
ele $ preenchido pelo boto e dei=a a rea restante para os
pr)=imos 1idgets, quando no colocamos o parHmetro side o
boto $ colocado no topo do container dei=ando a rea logo
abai=o para vocD colocar os outros 1idgets. "o devemos dar
vrios posicionamentos aos 1idgets numa frame uma veK que
isto pode causar efeitos indeseEados quando alterarmos o
tamanho dela. 'ara melhor posicionar os 1idgets podemos
colocar vrios containers.
D.).B Tani!u.ando os e%entos Ge%ent hand.erH
Agora iremos detalhar como vocD pode associar um
e%ent hand.er a um e%ent como clicar um boto. !s events
handlers so a>es e=ecutadas em resposta a um event, para que
isso ocorra precisamos associar este evento ao event handler
atrav$s de m$todo chamado event binding
22
cuEa sinta=e $
1idget.bindBenvent, event handlerC. !utra forma de ligar um
manipulador de eventos a um 1idget $ chamado Ncommand
22 *igao do evento a uma rotina de resposta.
1-3
Figura 11: P$rios
botLes
posiciona(os.
bindingU
2+
, E citada anteriormente. 'or ora, veEamos melhor o
event binding, e tendo entendido este, ser moleKa e=plicar o
command binding. Antes de comearmos, vamos esclarecer uma
coisa2 a palavra NbotoU pode ser usada para designar duas
coisas inteiramente diferentes2
F um 1idget 7utton Y um elemento visual que $ mostrado no
monitor do computador.
F um boto no seu mouse Y aquele que vocD pressiona com o
dedo.
class Wanela2
def nninitnnBself,principalC2
g define o container principal
self.frame_@rameBprincipalC
self.frame.pacABC
g coloca no container mensagem de te=to
self.te=to_*abelBself.frame, te=t_i6lique para ficar amareloiC
self.te=toXi1idthiZ_23
self.te=toXiheightiZ_+
self.te=to.pacABC
g coloca no container um botao com verde inicialmente
self.botaoverde_7uttonBself.frame,te=t_i6liqueiC
self.botaoverdeXibacAgroundiZ_igreeni
self.botaoverde.bindBem7uttonF1fe,self.mudancorC
self.botaoverde.pacABC
g funcao que muda a cor do botao
def mudancorBself, eventC2
g Guda a cor do botaod
if self.botaoverdeXibgiZ__igreeni2
self.botaoverdeXibgiZ_i(ello1i
2+ *igao do evento a um comandoBrotina de tratamento do eventoC.
1-4
self.te=toXite=tiZ_i6lique para ficar verdei
else2
self.botaoverdeXibgiZ_igreeni
self.te=toXite=tiZ_i6lique para ficar amareloi

raiK_5ABC
WanelaBraiKC
raiK.mainloopBC
"o programa acima inserimos um 1idget do tipo *a5e.
que serve para colocarmos r)tulos ou melhor te=tos na Eanela.
erifique que quando criamos 1idget ele est associado a um
Eanela principal ou container principal, que $ o local onde ele
ser encai=ado.
Ainda no programa acima temos a associao do evento apertar
o boto 1 do mouse com a e=ecuo da funo mudar de cor,
veEa nesta linha Bself.botaoverde.bindBem7uttonF
1fe,self.mudancorCC que temos a string Nm7uttonF1fU que $
passada como argumento que representa apertar o boto 1 do
mouse, por e=emplo se fosse apertar o boto enter a string seria
Nm8eturnfU.
1-&
Fig 1=: 7ela (o programa na con(i-!o %er(e e
amarela.
D.).B.1 E%entos do Touse
imos no e=emplo acima que ao acionarmos o boto 1
do mouse o boto muda de cor, podemos tamb$m verificar no
e=emplo acima que na linha com o r)tulo Nm7uttonF1fU na
passagem de parHmetro temos um obEeto evento sendo passado
como argumento, em 5Ainter sempre que um evento ocorre um
obEeto $ passado contendo todas as informa>es necessrias do
evento. ,m o5Keto e%ento $ um tipo especial de obEeto
contendo todas as informa>es necessrias a manipulao do
evento. .uando quisermos passar uma sequDncia de teclas que
deve ser acionadas, isto $ possJvel atrav$s de uma tupla veEa
e=emplo2
class Wanela2
def nninitnnBself,toplevelC2
self.frame_@rameBtoplevelC
self.frame.pacABC
self.te=to_*abelBself.frame, te=t_i6lique para ficar amareloiC
self.te=toXi1idthiZ_23
self.te=toXiheightiZ_+
self.te=to.pacABC
self.botaoverde_7uttonBself.frame,te=t_i6liqueiC
self.botaoverdeXibacAgroundiZ_igreeni
self.botaoverde.bindBBem7uttonF1fe,em7uttonF
+feC,self.mudancorC
self.botaoverde.pacABC
def mudancorBself, eventC2
g Guda a cor do botaod
if self.botaoverdeXibgiZ__igreeni2
1-;
self.botaoverdeXibgiZ_i(ello1i
self.te=toXite=tiZ_i6lique para ficar verdei
else2
self.botaoverdeXibgiZ_igreeni
self.te=toXite=tiZ_i6lique para ficar amareloi
raiK_5ABC
WanelaBraiKC
raiK.mainloopBC
g ateno acione boto 1 e depois o boto 2
E=perimente ainda as strings NmGotionfU Bmovimentao do
mouseC, Nm*eavefUBsai do botoC e Nm7utton8elaseFRfU Bboto
do meio e R pode ser 1, 2 ou +C.
D.).B.) 8oco e e%entos do tec.ado
! foco $ um mecanismo que serve para indicar que
elemento grfico B1idgetC est respondendo aos eventos. ,m
m$todo importante quando falamos em foco $ o m$todo
1idg1.focusnforceBC que coloca o foco no 1idget 0idg1. "a
tabela abai=o vemos as strings associadas aos eventos quando
desenvolvemos um programa.
(a5e.a de E%entos
E%ento "tring
Apertar tecla Enter Nm8eturnfU
Apertar tecla 9elete Nm9eletefU
Apertar tecla 7acAspace Nm7acA#pacefU
Apertar tecla Escape NmEscapefU
130
Apertar #eta para Esquerda Nm*eftfU
Apertar #eta para 9ireita Nm8ightfU
Apertar #eta para 7ai=o Nm9o1nfU
Apertar #eta para 6ima Nm,pfU
5irar o foco do 1idget Nm@ocus!utfU
6olocar o foco no 1idget Nm@ocus%nfU
Apertando qualquer tecla
alfanum$rica
NmQe('ressFAlfafU ou
NmAlfafU
#oltando tecla Alfa NmQe(8eleaseFAlfafU
Apertando duas veKes
boto 1 mouse
Nm9ouble7uttonF1fU
Apertando + veKes tecla ' Nm5ripleFQe('ressF'fU
Apertando qualquer boto
mouse
NmAn(F7uttonfU
Apertando qualquer tecla NmAn(FQe('ressAfU
E=emplo de programa com eventos2
g FIF coding2 cp12-2 FIF g usar caracteres acentuados
class Wanela2
self.frame_@rameBprincipalC
self.frame.pacABC
self.frame2_@rameBprincipalC
self.frame2.pacABC
gcoloca em container te=to @!6! e A'E85E...
131
self.titulo_*abelBself.frame,te=t_i@!6! kn Aperte 5A7
para @ocoi,
font_Bierdanai,i1+i,iboldiCC
self.titulo.pacABC
self.msg_*abelBself.frame,1idth_:0,height_3,
te=t _ i5este @ocodiC
self.msg.focusnforceBC
self.msg.pacABC
g 9efinindo o boto 1
self.b01_7uttonBself.frame2,te=t_i7oto 1iC
self.b01XibgiZ_ibluei
g definindo eventos FFFFFFFF
g se for acionado mouse ou tecla enter
self.b01.bindBem8eturnfe,self.aperta01C
self.b01.bindBemAn(F7uttonfe,self.botao01C
g se tab for acionado foca e aperta boto
self.b01.bindBem@ocus%nfe,self.fin01C
self.b01.bindBem@ocus!utfe,self.fout01C
self.b01XireliefiZ_8A%#E9
self.b01.pacABside_*E@5C
g FFFFFFFFFFFFFFFFFFFFFFFFFF
g 9efinindo o boto 2
self.b02XibgiZ_i(ello1i
self.b02.bindBem8eturnfe,self.aperta02C
self.b02.bindBemAn(F7uttonfe,self.botao02C
self.b02.bindBem@ocus%nfe,self.fin02C
self.b02.bindBem@ocus!utfe,self.fout02C
self.b02.pacABside_*E@5C

def aperta01Bself,eventC2
132
self.msgXite=tiZ_iE"5E8 sobre o 7oto 1i

def aperta02Bself,eventC2
self.msgXite=tiZ_iE"5E8 sobre o 7oto 2i
def botao01Bself,eventC2
self.msgXite=tiZ_i6lique sobre o 7oto 1i

def botao02Bself,eventC2
self.msgXite=tiZ_i6lique sobre o 7oto 2i
def fin01Bself,eventC2
self.b01XireliefiZ_#,"QE"
def fin02Bself,eventC2
self.b02XireliefiZ_#,"QE"
def fout01Bself,eventC2
self.b01XireliefiZ_8A%#E9 gdesaperta boto 1
def fout02Bself,eventC2
raiK_5ABC
WanelaBraiKC
raiK.mainloopBC
13+
D.).D ,sando $hec6Button
Este tipo de elementoB1idgetC $ usado quando queremos
faKer escolha entre valores distintos.
,ara usar um <-ec7button, criaFse uma varivel
5Ainter2
var _ %ntarBC
c _ 6hecAbuttonBmaster, te=t_eE=pande, variable_varC
6omo padro esta varivel $ posicionada em 1 quando o boto $
selecionado e 0 quando no. ocD pode mudar estes valores
usando as op>es onvalue e offvalue. Esta varivel no precisa
ser um n<mero inteiro.
var _ #tringarBC
c _ 6hecAbuttonB
master, te=t_e6olor imagee, variable_var,
13:
Figura 1I: 7ela (o programa
onvalue_e*igadoe, offvalue_e9esligadoe
C
E=emplo2
class botaoescolha2
def nninitnnBself, masterC2
self.frame_@rameBmaster,1idth_-00,height_100C
master.titleBe6hecA 7uttoneC
self.frame.pacABC
self.var _ %ntarBC
self.msg_*abelBself.frame,te=t_i7oto 6hecAiC
self.msg.pacABC
c _ 6hecAbuttonBmaster, te=t_eEscolhae,
variable_self.var,height_& , 1idth_20C
c.bindBem1fe,self.cbC
c.pacABC
def cbBself,eventC2
print self.var
if self.var__12
print edesligadoe
self.var_0
else2
print eligadoe
self.var_1
raiK_5ABC
13-
botaoescolhaBraiKC
raiK.mainloopBC
D.).E $riando Tenus
'ara criar um menu vocD deve instanciar a classe Genu e
usar o m$todo add para adicionar entradas.
add;commandG.a5e.bstring3 commandbca..5ac6H F
adiciona uma entrada ao menu.
add;se!aratorGH F adiciona um separador de linha.
,sado para agrupar entradas.
add;cascadeG.a5e.bstring3 menubmenu instanceH F
adiciona um submenu.
def mostraBC2
file1in _ 5oplevelBrootC
button _ 7uttonBfile1in, te=t_eGostra 7otaoeC
133
Fig. 10: 7ela (o programa
button.pacABC

root _ 5ABC
menubar _ GenuBrootC
filemenu _ GenuBmenubar, tearoff_0C
filemenu.addncommandBlabel_e"ovoe, command_mostraC
filemenu.addncommandBlabel_eAbrire, command_mostraC
filemenu.addncommandBlabel_e#alvare, command_mostraC
filemenu.addncommandBlabel_e@echare, command_mostraC
filemenu.addnseparatorBC
filemenu.addncommandBlabel_e#aie, command_root.quitC
menubar.addncascadeBlabel_eArquivoe, menu_filemenuC
editmenu _ GenuBmenubar, tearoff_0C
editmenu.addncommandBlabel_e9esfaKe, command_mostraC
editmenu.addnseparatorBC
editmenu.addncommandBlabel_eApagse, command_mostraC
editmenu.addncommandBlabel_e#eleciona 5odose,
command_mostraC
menubar.addncascadeBlabel_eEditare, menu_editmenuC
helpmenu _ GenuBmenubar, tearoff_0C
helpmenu.addncommandBlabel_eAEudae, command_mostraC
helpmenu.addncommandBlabel_e#obre...e, command_mostraC
menubar.addncascadeBlabel_eAEudae, menu_helpmenuC
root.configBmenu_menubarC
root.mainloopBC
134
D.).1F Barra de 'erramentas
rios programas colocam abai=o da barra de menu uma
barra de ferramentas, normalmente esta barra cont$m vrios
bot>es como abrir arquivo, imprimir, etc...
E=emplo de barra de ferramentas e uma frame com vrios
bot>es.
garquivo 5Aintertoolbar.p(
root _ 5ABC
def chamadaBC2
print eAvisoe
g create a menu
menu _ GenuBrootC
13&
Fig. 1K: 7ela (o Programa
filemenu _ GenuBmenuC
menu.addncascadeBlabel_eArquivoe, menu_filemenuC
filemenu.addncommandBlabel_e"ovoe, command_chamadaC
filemenu.addncommandBlabel_eAbrir...e, command_chamadaC
filemenu.addnseparatorBC
filemenu.addncommandBlabel_e#aire, command_chamadaC
helpmenu _ GenuBmenuC
menu.addncascadeBlabel_eAEudae, menu_helpmenuC
helpmenu.addncommandBlabel_e#obre...e,
command_chamadaC
g criar barra de ferramentas
toolbar _ @rameBrootC
b _ 7uttonBtoolbar, te=t_enovoe, 1idth_3,
command_chamadaC
b.pacABside_*E@5, pad=_2, pad(_2C
b _ 7uttonBtoolbar, te=t_eabree, 1idth_3, command_chamadaC
b.pacABside_*E@5, pad=_2, pad(_2C
toolbar.pacABside_5!', fill_RC
root.configBmenu_menuC
root.mainloopBC
13;
Figura 19: 7ela (o
Programa
D.).11 A.arme com (6inter
eEamos como gerar um sinal sonoro.
class AlarmB@rameC2
def repeteBselfC2
self.bellBC
self.afterBself.msecs, self.repeteC
def nninitnnBselfC2
@rame.nninitnnBselfC
self.msecs _ 100
self.pacABC
parar _ 7uttonBself, te=t_i'arar sonsdi,
command_self.quitC
parar.pacABC
parar.configBbg_inav(i, fg_i1hitei, bd_&C
self.parar _ parar
self.repeteBC
if nnnamenn __ innmainnni2
AlarmBC.mainloopBC
140
Fig. 14: 7ela (o
Programa
D.).1) $riar uma Kane.a de entrada de dados
Este e=emplo cria um elemento Eanela de alto nJvel e
adiciona alguns alguns elementos, um r)tulo e uma cai=a de
te=to.
root _ 5ABC
root.titleBiEntradaiC
*abelBroot, te=t_e9ados2eC.pacABside_*E@5, pad=_-, pad(_10C
e _ #tringarBC
Entr(Broot, 1idth_:0, te=tvariable_eC.pacABside_*E@5C
e.setBei9igite aquidieC
root.mainloopBC
! 1idget Entry $ uma forma de entrada de dados. !s
dados informados pelo usurio neste campo esto na forma de
strings, como a funo ra1ninput. Atrav$s do m$todo get,
fornecido pelo Entry podemos utiliKar os dados entrados em
nosso c)digo. Este 1idget possui as mesmas configura>es que
bot>es e labels e=ceto a altura height que neste caso $ de uma
linha. 'ara entrada de senhas podemos utiliKar a opo sho1_iIi
que mostra asteriscos em veK dos dados teclados.
!utro e=emplo2
141
Figura 18: 7ela (o Programa
class entradadedados2
def nninitnnBself,'aiC2
self.pai_@rameB'aiC
self.pai.pacABC
*abelBself.pai,te=t_e"omee,fg_eblacAeC.gridBro1_0C
*abelBself.pai,te=t_eEnderecoeC.gridBro1_1C
self.e1_Entr(Bself.paiC
self.e2_Entr(Bself.paiC
self.e1.gridBro1_0, column_1C
self.e2.gridBro1_1,column_1C
root_5ABC
8aiK_entradadedadosBrootC
8aiK.pai.mainloopBC
Gais um e=emplo e neste usamos uma uma opo
chamada de !ad para dar um espao e=tra entre bordas e
1idgets dentro da frame.
self.b02Xipad=iZ,self.b02Xipad(iZ _ 10, -
142
Fig. 1M: 7ela (o Programa
class #enhas2
self.frame1_@rameBprincipalC
self.frame1.pacABC
*abelBself.frame1,te=t_i#E"LA#i, fg_idarAbluei,
font_Bierdanai,i1:i,iboldiC, height_+C.gridBro1_0C
fonte1_Bierdanai,i10i,iboldiC
*abelBself.frame1,te=t_i"ome2 i,
font_fonte1,1idth_&C.gridBro1_1,column_0C
self.nome_Entr(Bself.frame1,1idth_10,
font_fonte1C
self.nome.focusnforceBC
self.nome.gridBro1_1,column_1C
*abelBself.frame1,te=t_i#enha2 i,
font_fonte1,1idth_&C.gridBro1_2,column_0C
self.senha_Entr(Bself.frame1,1idth_10,sho1_iIi,
14+
Figura =O: pa(y e pa(# em um
elemento (o tipo bot!o< aumentan(o
as bor(as.
font_fonte1C
self.senha.gridBro1_2,column_1C
self.confere_7uttonBself.frame1, font_fonte1,
te=t_iEnviai,
bg_ipinAi, command_self.conferir,pad=_10,pad(_10C
self.confere.gridBro1_+,column_0C
self.msg_*abelBself.frame1,font_fonte1,
height_+,te=t_iAP,A89A"9!...iC
self.msg.gridBro1_:,column_0C
def conferirBselfC2
"!GE_self.nome.getBC
#E"LA_self.senha.getBC
if "!GE __ #E"LA2
self.msgXite=tiZ_iA6E##! 'E8G%5%9!i
self.msgXifgiZ_idarAgreeni
else2
self.msgXite=tiZ_iA6E##! "EPA9!i
self.msgXifgiZ_iredi
self.nome.focusnforceBC
instancia_5ABC
#enhasBinstanciaC
instancia.mainloopBC
14:
D.).1+ ,sando o con'igure
principal _ @rameBC
principal.pacABC
rotulo _ *abel Bprincipal, te=t_e8)tulo E=emploe,
foreground_eblueeC
rotulo.pacA BC
rotulo.configureBrelief_eridgee, font_eArial 2: bolde,
border_-, bacAground_e(ello1eC
principal.mainloopBC
6om configure2
14-
Fig. =1: 7ela (o Programa
#em configure2
!utro e=emplo do configure2
principal _ @rameBC S principal.pacABC
a _ *abel Bprincipal, te=t_e1eC S a.pacA Bside_elefteC
b _ *abel Bprincipal, te=t_e2eC S b.pacA Bside_ebottomeC
c _ *abel Bprincipal, te=t_e+eC S c.pacA Bside_erighteC
d _ *abel Bprincipal, te=t_e:eC S d.pacA Bside_etopeC
e _ *abel Bprincipal, te=t_e-eC S e.pacA Bside_etopeC
for 1idget in Ba,b,c,d,eC2
1idget.configureBrelief_egroovee, border_10,
font_e5imes 2: boldeC
143
Figura =I: 6em o
coman(o con"igure
Figura ==: 7ela (o Programa
D.).17 ,sando a o!o 'i..
'i.. G[none[3 [2[3 [y[ ou [5oth[H

%ndica como o desenho do elemento ir preencher o
espao alocado
i=i e i(i indica que ir preencher a largura e altura
ibothi indica preenchimento de todo o espao
inonei indica que apenas o espao necessrio ser
ocupado BdefaultC
principal _ @rameBC S principal.pacABC
a _ *abel Bprincipal, te=t_e1eC S a.pacA Bside_elefteC
b _ *abel Bprincipal, te=t_e2eC S b.pacA
Bside_ebottome,fill_e=eC
c _ *abel Bprincipal, te=t_e+eC S c.pacA Bside_erighte,fill_e(eC
144
Figura =0: 7ela (o
Programa
d _ *abel Bprincipal, te=t_e:eC S d.pacA Bside_etopeC
e _ *abel Bprincipal, te=t_e-eC S e.pacA Bside_etopeC
for 1idget in Ba,b,c,d,eC2
1idget.configureBrelief_egroovee, border_10,
font_e5imes 2: boldeC
D.).19 $an%as
! 1idget canvas fornece uma facilidade de estrutura grfica
para o 5Ainter. Ele $ altamente verstil e $ usado para desenhar
e plotar grficos, criar editor grfico e criar 1idgets
padroniKados, at$ anima>es so possJveis. 'or default, novos
itens so desenhados acima dos itens que E esto no 6anvas. !
5Ainter fornece um conEunto de m$todos permitindo a vocD
14&
Figura =K: Usan(o
a op-!o "ill
manipular os itens de vrias formas e adicionar eventos e
retorno deles individualmente.
ocD deve usar o 1idget 6anvas para mostrar e editar
grficos e outros desenhos e ainda implementar vrios tipos de
1idgets padroniKados. 'or e=emplo2 vocD pode usar um 6anvas
como uma barra de concluso atualiKando um obEeto retHngulo.
! 6anvas suporta os seguintes itens2
arcos Y arco de cJrculo
bitmap Y imagem binria
imagem Y imagem colorida
linha Y linha poligonal
oval Y cJrculos e elipses
polJgonos
retHngulo
te=to
Eanela Y um 1idget tA
9efineFse um 6anvas da mesma forma que um outro
1idget qualquer, al$m de possuir as op>es de configurao de
bot>es e labels, ele possui as op>es 5d e cursor.
A opo 5d especifica a espessura da borda do 1idget em pi=els
e a opo cursor define de que forma o cursor aparece quando
est posicionado no 1idget. E=istem muitas op>es de cursor
vlidas para qualquer 1idget. amos ao nosso primeiro
e=emplo.
class Qanvas2
def nninitnnBself,raiKC2
self.canvas1 _ 6anvasBraiK, 1idth_100, height_200,
cursor_istari, bd_1-,
bg_irediC
14;
self.canvas1.pacABside_*E@5C
self.canvas2 _ 6anvasBraiK, 1idth_100, height_200,
cursor_istari, bd_-,
bg_i(ello1iC
self.canvas2.pacABside_*E@5C
instancia_5ABC
QanvasBinstanciaC
eEa que no programa anterior criamos os canvas diretamente na
Eanela topFlevelBprincipalC.
1&0

"istema de $oordenadas $an%as
NeKa Lue a coordenada F3F est situada a esLuerda e no a.to e
o ei2o y est in%ertido.
$riando .inha em $an%as1 a sinta=e do comando para
desenhar uma linha num canvas
$2se.'.nome;do;can%as.create;.ineG213y13....32n3ynH Y a linha
comea em =1,(1 e segue a =2,(2 e depois =+, (+ at$ =n,(n.
'odemos definir a opo 0idthbn:mero que serve para definir
espessura da linha.
class Qanvas2
self.canvas1 _ 6anvasBraiK, 1idth_:00, height_:00,
cursor_ifleuri, bd_10,
bg_irediC
1&1
Fig. =9: 6istema (e coor(ena(as *an%as
self.canvas1.createnlineB200,200,2+0,2+0,100,1-0,fill_ibla
cAi,1idth_:C
self.canvas1.pacABC
instancia_5ABC
QanvasBinstanciaC
1&2
Figura =4: Desenhan(o uma linha
(e2to e $Wrcu.o no $an%as1
g@ile2 canvas:.p(
class Qanvas2
bg_irediC
=( _ 20, 20, +00, 1&0
self.canvas1.createnarcB=(, start_0, e=tent_240, fill_eredeC
self.canvas1.createnarcB=(, start_240, e=tent_30,
fill_eblueeC
self.canvas1.createnarcB=(, start_++0, e=tent_+0,
fill_egreeneC
self.canvas1.creatente=tB200,+00,te=t_ePrb}ficoe,font_Bi
Ariali,i23i,iboldiCC
self.canvas1.pacABC
self.frame_@rameBinstanciaC
self.label_*abelBte=t_e9esenhando linhaseC
self.frame.pacABC
self.label.pacABC
instancia_5ABC
QanvasBinstanciaC
1&+
1&:
Figura =8: Desenhan(o te#to e cQrculos no 7Binter
Desenhando retUngu.o e !o.Wgono1
class Qanvas2
bg_irediC
=( _ 20, 20, +00, 1&0
self.canvas1.createnarcB=(, start_0, e=tent_240, fill_eredeC
self.canvas1.createnarcB=(, start_240, e=tent_30,
fill_eblueeC
self.canvas1.createnarcB=(, start_++0, e=tent_+0,
fill_egreeneC
self.canvas1.creatente=tB200,+-0,te=t_ePrb}ficoe,font_Bi
Ariali,i23i,iboldiCC
self.canvas1.createnpol(gonB200,200,200,+00,+00,+00,20
0,200, fill_i(ello1iC
self.canvas1.createnrectangleB200,1-0,2-0,200,fill_iblueiC
self.canvas1.pacABC
self.frame_@rameBinstanciaC
self.label_*abelBte=t_e9esenhando linhaseC
self.frame.pacABC
self.label.pacABC
instancia_5ABC
QanvasBinstanciaC
1&-
1&3
Figura =M: Desenhan(o no 7Binter
Tais comando do $an%as do (6inter1
class 'alheta2
raiK.titleBe'alhetaeC
self.canvas_6anvasBraiK, 1idth_200, height_200C
self.canvas.pacABC
self.frame_@rameBraiKC
self.frame.pacABC
self.canvas.createnovalB1-, 1-, 1&-, 1&-,
fill_i1hitei, tag_ibolaiC
*abelBself.frame,te=t_iermelho2 iC.pacABside_*E@5C
self.vermelho_Entr(Bself.frame, 1idth_:C
self.vermelho.focusnforceBC
self.vermelho.pacABside_*E@5C
*abelBself.frame,te=t_ierde2 iC.pacABside_*E@5C
self.verde_Entr(Bself.frame, 1idth_:C
self.verde.pacABside_*E@5C
*abelBself.frame,te=t_iAKul2 iC.pacABside_*E@5C
self.aKul_Entr(Bself.frame, 1idth_:C
self.aKul.pacABside_*E@5C
7uttonBself.frame, te=t_iGostrari,
command_self.misturarC.pacABside_*E@5C
self.rgb_*abelBself.frame, te=t_ii, 1idth_&,
font_Bierdanai,i10i,iboldiCC
self.rgb.pacABC
def misturarBselfC2
cor_eg?02=?02=?02=e ?BintBself.vermelho.getBCC,
intBself.verde.getBCC,
intBself.aKul.getBCCC
self.canvas.deleteBibolaiC
1&4
self.canvas.createnovalB1-, 1-, 1&-, 1&-,
fill_cor, tag_ibolaiC
self.rgbXite=tiZ _ cor
self.vermelho.focusnforceBC
inst _ 5ABC
'alhetaBinstC
inst.mainloopBC
1&&
Figura IO: Palheta (e cores.
E. $Ì e "er%idor _((P
E.1 $Ì G$ommon àte0ay Inter'aceH
s uma padroniKao para troca de informa>es com
servidores de aplica>es e=ternas, tais como o L55' ou
servidores 0eb. Essas especifica>es so mantidas pela
"6#A
2:
. ,m documento L5G* $ esttico, ou seEa $ um
arquivo tipo te=to imutvel, por outro lado um programa 6P%
gera uma informao dinHmica, E que ele $ e=ecutado em
tempo real. 'or e=emplo, digamos que vocD queria permitir que
as pessoas acessem seu banco de dados atrav$s da 0E7.
7asicamente vocD precisa criar um programa 6P%, que o
servidor 0eb ir e=ecutar, para transmitir as informa>es para o
motor do banco de dados, receber os resultados e e=ibiFlos de
volta para o cliente. Este $ um e=emplo de um gate1a(
2-
, e este
$ o lugar onde 6P%, verso 1.1, tem as suas origens. ! e=emplo
de banco de dados $ uma ideia simples, mas na maioria das
veKes $ bastante difJcil de implementar. 8ealmente no h
nenhum limite quanto ao que vocD pode se conectar pela 0eb. A
<nica coisa que vocD precisa lembrar $ que qualquer que seEa o
seu programa 6P% seu tempo de processamento deve ser o
menor possJvel, caso contrrio, o usurio vai apenas ficar
olhando para seu navegador a espera que alguma coisa acontea.
6omo os programas 6P% so e=ecutveis, e=istem algumas
precau>es de segurana que precisam ser implementadas. !
que mais afeta o usurio tJpico da 0E7 $ o fato de que
programas 6P% necessitam residir em um diret)rio especial, de
modo que o servidor 0eb saiba que $ para e=ecutar o programa
e no apenas apresentFlo ao navegador. Este diret)rio esta
2: "6#A F "ational 6enter for #upercomputing Applications
2- Pate1a( F$ uma ponte entre duas redes, permitindo a cone=o entre elas.
1&;
geralmente sob controle do 1ebmaster
23
que proJbe
determinados usurios de criar programas 6P%. ! programa
6P% fica aloEado no diret)rio chamado de cgiFbin um diret)rio
especial que residem todos programas 6P%. ,m programa 6P%
pode ser escrito em2 6, @ortran, 'erl, isual 7asic. '(thon, etc..
#) depende do que vocD tem disponJvel em seu sistema. #e vocD
usar uma linguagem de programao como 6 ou @ortran, vocD
sabe que vocD tem que compilar o programa para que ele seEa
e=ecutado, no entanto, usar se um dos scripts em veK linguagem,
tais como '(tthon, 'erl, 5cl, ou um shell ,ni=, o script em si s)
tamb$m tem de residir no cgiFbin. Guitas pessoas preferem
escrever scripts 6P%, em veK de programas, uma veK que eles
so mais fceis de depurar, modificar e manter do que um tJpico
programa compilado.
E.) ser%idor A!ache
s o mais bem sucedido servidor L55' livre, criado em
1;;- por 8ob Gc6oll, funcionrio do "6#A. Este servidor
atualmente est sob os cuidados da Apache #oft1are
@oundation, que tem uma deKena de proEetos para 0E7, e ele $
compatJvel com o protocolo L55' verso 1.1. ! Apache #erver,
como $ conhecido, $ um soft1are livre, o que significa que
qualquer um pode estudar ou alterar seu c)digoFfonte, al$m de
poder utiliKFlo gratuitamente. Praas ao trabalho muitas veKes
voluntrio de vrios desenvolvedores, o Apache continua sendo
o servidor 0eb mais usado no mundo. Al$m de estar disponJvel
para o *inu= Be para outros sistemas operacionais baseados no
,ni=C, o Apache tamb$m conta com vers>es para o 0indo1s,
para o "ovell "et1are e para o !#O2, o que o torna uma )tima
opo para rodar em computadores obsoletos Bdesde que este
23 0ebmaster Y responsvel pela manuteno e administrao de um site.
1;0
atenda aos requisitos mJnimos de hard1areC. ! servidor Apache
$ capaK de e=ecutar c)digo em 6, 6g, 6ll, Wava, 'erl, 'L'
'(thon, 8ub(, #cala, #P #calable ector Praphics, 5cl e at$
em A#' e pode atuar como servidor @5', L55', entre outros.
#ua utiliKao mais conhecida $ a que combina o Apache com a
linguagem 'L' e o banco de dados G(#.*.
E.+ _((P e _(T*
A 1eb $ construJda a partir de duas tecnologias
fundamentais2 a linguagem L5G* e o protocolo L55'. !
L5G*
24
$ a codificao usada para criar as pginas da 0eb,
usaremos esta linguagem em nosso e=emplos. ! segundo pilar
da 0eb $ o L55'
2&
, protocolo de transporte de hiperte=to. Esse
$ o conEunto de comandos e regras que define como deve ser a
comunicao entre um bro1ser
2;
Bcomo o GoKilla C e um
servidor L55' como o Apache ou o %%#
+0
. A e=presso
eservidor L55'e pode significar duas coisas2 o soft1are que
serve pginas via L55', ou o computador onde esse soft1are
est instalado. "o mundo ,ni=, soft1ares servidores so
chamados de edaemonse, e a sigla L55'd descreve um eL55'
daemone gen$rico. Esta relao entre o bro1ser e o servidor $
chamada clienteFservidor, desta forma quando vocD digita uma
,8*
+1
como2 111.capotasprudentina.com.brOinde=.html, o seu
bro1ser localiKa e conectaFse ao servidor
111.capotasprudentina.com.br e enviaFlhe o comando
PE5Oinde=.html, o servidor lD o arquivo inde=.html e transmite
24 L5G* F L(perte=t GarAup *anguage
2& L55' F L(perte=t 5ransport 'rotocol
2; 7ro1ser F navegador
+0 %%# Y %nternet %nformation #ervices Y servidor 1eb da Gicrosoft
+1 ,8* Y ,niform 8esource *ocator ou Locali&a(or-Pa(r!o (e Aecursos
1;1
o conte<do para o cliente e encerra a cone=o, desta forma
temos os seguintes passos na comunicao2 cone=o,
solicitao, resposta e encerramento da cone=o. A pgina
inde=.html $ o que chamamos de pgina esttica.
E.7 Pginas DinUmicas
Este tipo de soluo apresentada acima atende algumas
necessidades, mas com o advento do com$rcio eletronico, chats
e outras transa>es, tornouFse necessrio novas tecnologias. A
mais antiga tecnologia de pginas dinHmicas $ o 6P% um
protocolo bsico para interao entre um L55'd e um programa
gerador de pginas dinHmicas
+2
, $ com ele que trabalharemos.
!utras tecnologias de pginas dinHmicas so2 ôpeBescrito em
'(thonC, A#'BGicrosoftC, 6old@usionBAllaire C, 'L' etc..
E.9 "er%idor A!ache
'ara testarmos os nossos scripts 6P%, sugiro que
instalemos o #ervidor Apache.
%nstalando o Apache2
7ai=e o Apache para 0indo1s em2
http2OO111.apache.orgOdistOhttpdObinariesO1in+2
,tiliKe a <ltima verso msiBneste caso 2.2.11C que $ um
pacote compactado do 0indo1s %nstaller para vers>es
recentes do 1indo1s.
Bhttp2OO111.apache.orgOdistOhttpdObinariesO1in+2Oapache
+2 F ! nome pginas dinHmicas vem do mecanismo de montagem das
pginas na hora da solicitao da mesma.
1;2
n2.2.11F1in+2F=&3FopensslF0.;.&i.msiC
Im!ortante2 instale o soft1are usando uma conta com
direitos administrativos no 0indo1s.
Ao bai=Flo, inicie a instalao, como vocD faria com
qualquer programa para 0indo1s com um bom
instalador. 9urante a instalao ele pedir o domJnio da
rede B"et1orA 9omainC, o nome do servidor B#erver
"ameC e o eFmail do administrador do sistema. 6omo a
instalao $ para um servidor local, para
desenvolvimento, preencha com elocaldomaine no
campo e"et1orA 9omaine, elocalhoste no campo
e#erver "amee e seu eFmail no <ltimo campo.
@inaliKada a instalao, o apache dever estar
funcionando. "o 0indo1s 2000OR' ele $ instalado
como um servio que pode ser
inicialiKadoOdesativadoOreiniciado usando o console de
1;+
servios, o eservices.msce. 'or padro, ele se configura
para ser iniciado sempre Eunto com o 0indo1s BveEa na
imagem de tela acima a opo na instalao para mudar
isso, al$m de mudar a porta para &0&0C. Ao faKer alguma
alterao num arquivo de configurao do Apache ou ao
instalar um m)dulo, por e=emplo, deveFse reiniciar o
servidor Bno o computador, mas sim o servio do
ApacheC. %sso pode ser feito com o eApache #ervice
Gonitore, que ficar ativo na rea de notificao
BbandeEa do sistema, pr)=imo ao rel)gioC2
6om ele instalado, abra qualquer navegador e digite o
nome do seu computador, ou, de preferDncia, o nome
elocalhoste, que sempre se refere ao computador local.
1;:
Fig. I1: *om esta inter"ace po(e-se iniciar< reiniciar ou parar o
ser%i(or 5pache no Din(o.s.
#e preferir, acesse http2OO124.0.0.1, o %' da mquina
local. #e tudo deu certo at$ aqui, vocD dever ver uma
mensagem e%t 1orAse BeEle trabalhae, eEle funcionaeC.
As pginas ficam por padro na pasta ehtdocse, dentro da
pasta onde o Apache foi instalado. "o meu caso, seria
e62kApache2.2khtdocse. 7asta substituir o conte<do do
arquivo einde=.htmle pelo do seu site, e colocar suas
pginas e subpastas aJ. ocD poder acessar as subpastas
da pasta ehtdocse digitando http2OOlocalhostOpasta, em
qualquer navegador no micro local, o nome do arquivo
tem que se inde=.html. #e ao digitar localhost o apache
no mostrar a pgina acima desinstale o Apache e instale
novamente.
1;-
%nstalado o Apache, ele lD basicamente L5G* puro. !
acesso ao arquivo inde=.html, no navegador, pode ser
feito de duas formas2ehttp2OOlocalhostOinde=.htmle ou
e62kmeu sitekinde=.htmle. "o primeiro caso, o navegador
solicita a pgina ao computador elocalhoste Bque $ o seu
computadordC, recebeFa do servidor, armaKenaFa no
cache, para depois e=ibiFla. Ele trata como se fosse um
site da %nternetS como o servidor do site est na rede
local Bou mesmo no seu pr)prio '6, um computador s)C,
trataFse de uma %ntranet. "o segundo caso, vocD est
acessando o arquivo diretamente no seu L9. !
navegador pode at$ armaKenar algum dado no cache,
mas no h nenhuma comunicao com nenhum
servidor. Ele lD o arquivo como qualquer programa leria
qualquer arquivo.
A configurao do Apache est em alguns arquivos de
te=to puro, no estilo dos arquivos e.inie, e fica na pasta
econfe, dentro da pasta do Apache. Ao editFlos e salvF
los, reinicie o servidor do apache para que as altera>es
entrem em vigor Busando o Jcone do Apache na rea de
notificao, ou o services.msc, ou ainda o comando net
stop apache2, e net start apache2, num prompt de
comandoC. !s arquivos de configurao usados na
verso 0indo1s do Apache so o ehttpd.confe e o
emime.t(pese.
! ehttpd.confe $ o principal, abordando diversas
caracterJsticas do Apache. ! emime.t(pese define os
tipos mime, tipos de arquivos e suas e=tens>es, para que
o Apache saiba como tratFlos. 'or e=emplo, ele deve
saber que deve enviar arquivos L5G* diretamente, sem
processFlos, mas deve processar os arquivos 'L', antes
1;3
de entregar o resultado ao bro1ser. s importante que
vocD faa bacAup destes arquivos, para restaurFlos, se
vocD editar algo e der errado. Em ambos as linhas
iniciadas com o caractere g so comentrios, e so
ignoradas. 'ara desativar um item ou colocar
e=plica>es, basta iniciar a linha com g.
s possJvel aparecer um erro na inicialiKao do Apache,
se vocD tiver um outro servidor 1eb ativo na mquina. A
provvel causa pode ser o uso da porta &0, se vocD
mant$m o %%# ativo, E que ele normalmente $ iniciado
antes e ocupa a porta &0 Bpraticamente qualquer servidor
1eb se configura para usar a porta &0, que $ dada como
padroC. 'ara contornar isso e manter os dois servidores
ativos, vocD deve trocar a porta de pelo menos um deles.
"o arquivo ehttpd.confe do Apache, localiKe o item
e*isten &0e, e troque o valor &0 por outro n<mero que
no esteEa sendo usado por nenhuma outra porta. 'or
e=emplo, &0&0, &0&1, etc. *ocaliKe mais para frente
e#erver"ame localhost2&0e, e troque o &0 daJ tamb$m.
#alve o arquivo e reinicie o servidor. Agora, vocD deve
acessar os sites digitando e2&0&0e ap)s o edomJnioe.
6omo $ local, vocD dever digitar2
ehttp2OOlocalhost2&0&0e, trocando $ claro, &0&0 pela porta
escolhida por vocD. #e entrar sem definir a porta, o
navegador muito provavelmente ir usar a &0, o que
resultar que o site aberto ser o do outro servidor Bcomo
o %%#, por e=emploC. #empre use o n<mero da porta
separado por dois pontos do nome do domJnio. ! certo $
ehttp2OOlocalhost2&0&0Oteste.htme, e no
ehttp2OOlocalhostOteste.htm2&0&0e. 'reocupeFse com isso
apenas se vocD possuir mais de um servidor 1eb na
1;4
mesma mquina. eEa este tutorial na internet.PPI$Q
1;&
1F. Programas $Ì
1F.1 Introduo
"osso primeiro programa $ o !l.
gdkp(thon2-kp(thon
print i6ontentFt(pe2te=tOhtmli
print
print imL5G*fm7!9[fi
print emL1f!*AimOL1fe
print imO7!9[fmOL5G*fi
6omentando o programa2
Em primeiro lugar devemos salvar o script em um
diret)rio chamado2 62kApache2.2kcgiFbin. ! nome do
arquivo ser2 ola.p(
A primeira linha $ um comentrio especial marcado
pelos caracteres igdi. !s sinais igdi devem estar
encostados na margem esquerda da pgina, e o restante
deve conter o caminho at$ o programa que e=ecutar o
script.Bkp(thon2-kp(thon ou Op(thon2-Op(thon
representao ,"%RC.
"a linha + encontramos o comando print i6onte=tF
t(pe2te=t2htmli produK a parte obrigat)ria do cabealho
da pgina, e=igida pelo 6P%. Este cabealho define o
documento a ser transmitido de acordo com o esquema
1;;
de classificao chamado G%GE
++
B! G%GE define uma
coleo de cabealhos do eFmail para especificar
atributos adicionais de uma mensagem incluindo o tipo
de caractere do te=to e dos arquivos de transferDncia. !
G%GE $ e=tensivo, as suas defini>es incluem m$todos
para registrar novos conte<dos e valores. ! ite=tOhtmli $
um tipo G%GE padro de documentos L5G*. Embora
originalmente definido por G%GE eFmail, o cabealho
conteR(o-tipo e o tipo G%GE de registro $ reutiliKado
em outros protocolos de %nternet, como L55'. ! tipo de
registro G%GE $ administrado por %A"A
+:
. C. ,m
arquivo tipo ascii $ definido com o G%GE t(pe
ite=tOplaini, um arquivo do tipo Epeg com iimageOEpegi.
"a linha : temos um print vaKio, que gera uma linha em
branco, que marca o fim do cabealho.
E por fim temos um c)digo L5G*.
'ara e=ecutar o programa digite2 localhostOcgiFbinOola.p(
ou 124.0.1.0OcgiFbinOola.p(
Gensagens como2 "ot @ound Y erro na digitao do
caminho ou e%nternal #erver Errore erro quando o
script 6P% no gera um cabealho mJnimo, so comuns e
fique atento.
$omentrio 'ina.1 #e ao rodar o script a partir do prompt ou do
%9*E vocD est vendo um tracebacA do interpretador '(thon, o
problema est mesmo dentro do seu programa. .uando ocorre
um erro de sinta=e B#(nta=ErrorC o interpretador apenas leu, mas
no chegou a e=ecutar nenhuma linha do seu script. Assim, o
++ G%GE Y Gultipurpose %nternet Gail E=tension2 especificao para o
formato de ane=os de eFmail que no so te=tos.
+: %A"A F %nternet Assigned "umber Authorit(
200
famoso cabealho e6ontentFt(pe2 ...e e a linha em branco no
so enviados para o servidor, e o tracebacA que o aEudaria a
detectar o problema no chega ao seu bro1ser, mas vai para um
arquivo onde o Apache registra mensagens de erro. Este arquivo
chamaFse error.log e fica em OapacheOlogsO. ocD pode
inspecionFlo com qualquer editor de te=to. !utras veKes, o erro
pode acontecer durante a e=ecuo e ap)s o envio do cabealho.
"este caso, o tracebacA $ perdido para sempre. s por isso que
programadores de 6P% e=perientes procuram testar
e=austivamente seus scripts a partir da linha de comando antes
de tentar acionFlo pelo bro1ser.
9e sempre um nome significativo ao programa em '(thon.
gd62kk'(thon24kkp(thon.e=e
gFIF coding2 %#!F&&-;F1 FIF

print e6ontentFt(pe2 te=tOhtmlS %#!F&&-;F1e
print

201
Fig. I=: + na%ega(or acessan(o um site ,ue
possui uma base (e (a(os(e#: site (e banco
print iii
mhtmlf
mheadf
mtitlef 'rogramando em '(thon para 0E7 22 5utorial 1mOtitlef
mheadf
mbod(f
!l
mObod(f
mhtmlf
iii
A 2a. *inha $ usada para o uso de caracteres acentuados, veEa
tamb$m no bro1ser o efeito da linha do tJtulo mtitlef. 8etire a
linha 2 e veEa o erro, entre no diret)rio de logs do apache e veEa
o erro dentro do arquivo de te=to error. 'ara e=ecutar o
programa entre no navegador e digite2 http2OOlocalhostOcgiF
binOola2.p(
8etirando a linha 2.
Interna. "er%er Error
5he server encountered an internal error or misconfiguration
and 1as unable to complete (our request.
'lease contact the server administrator, adminhsF
abecf-&:1b;::.ap and inform them of the time the error
occurred, and an(thing (ou might have done that ma( have
caused the error.
Gore information about this error ma( be available in the
server error log.
202
1F.) Tais Programas
1F.).1 Dados do am5iente
gdOp(thon24Op(thon
import os
print e6ontentFt(pe2 te=tOhtmleS
print
print emfont siKe_l1fEnvironmentmOfontfe
for param in os.environ.Ae(sBC2
print emfont siKe_l1f?20smOfontf2 ?se ? Bparam,os.environXparamZC
1F.).) Data e _ora do "er%idor atua.iRadas
gdOp(thon24Op(thon
g hora.p( F 6P% que e=ibe a hora local do servidor
from time import time, localtime
print i6ontentFt(pe2 te=tOhtmli
print i8efresh2 0.3i
print
a, ms, d, h, m, s _ localtimeBtimeBCCX023Z
print imL5G*fm7!9[fi
print imL1f9ata2 ?02dO?02dO?02d Lora2 ?02d2?02d2?02dmOL1fi ? Bd,ms,a,h, m, sC
print im'fI de acordo com o relogio interno deste
servidormO'fi
20+
6omentando o programa2
"a linha + so importados do m)dulo time as fun>es
time e localtime.
"a linha 3 o sistema pede um refresh da pgina a cada
0,3s de tal forma que a hora $ atualiKada, este tempo de
0,3s $ para que o sistema mostre sempre os segundos
corretamente. Gude para 1.0s e veEa o que acontece.
"a linha temos a impresso da data e hora.
eEa neste programa que o ideal seria que o servidor
enviaFse a informao a cada segundo, mas com o protocolo
L55' clienteFservidor no h como o servidor enviar a
informao uma veK que isto s) $ feito por iniciativa do cliente,
isto $, quando o cliente requisita a informao. Esta $ uma
limitao importante na hora de implementarmos nossos
programas 6P%. 'ara solucionar este problemas os navegadores
modernos tem um cabealho especial chamado 8efresh, cuEa
20:
Figura II: 7ela (e e#ecu-!o (o programa
presena instrui o bro1ser a solicitar a pgina ap)s algum
tempo.
1F.+ TCtodos È( e P"(
Em determinadas situa>es n)s precisamos passar
informa>es de nosso bro1ser para o servidor e por fim para o
programa 6P%, nestes casos a maioria dos bro1sers usam dois
m$todos que so os m$todos2 get e post.
Passando in'ormao atra%Cs do mCtodo get1 o
m$todo get adiciona a informao na string de requisio da
pgina, e pode ter no m=imo 102: caracteres, por este m$todo
no devemos passar senhas e informa>es importantes.
'assagem de parHmetro2
http2OOlocalhostOcgiFbinOget1.p(/firstnname_sVlastnname_a
6hamou o script get1.p( para tratar a informa>es passadas
firstnname e lastnname.
'ara testarmos este m$todo digitaremos dois arquivos2
1o. 8ormu.rio em _(T*1 armaKenaremos ele no arquivo
%"9ER.L5G* e no diret)rio c2kApache2.2khtdocs,
automaticamente quando digitarmos localhost o formulrio
aparecer.
mform action_eOcgiFbinOget1.p(e method_egetef
"ome2 minput t(pe_ete=te name_enomeefmbr Of
#obrenome2 minput t(pe_ete=te name_esobrenomee Of
minput t(pe_esubmite value_eEnviare Of
20-
mOformf
A primeira linha passa os parHmetros para nosso programa 6P%.
A pen<ltima linha gera um boto que quando acionado envia os
dados.
)o. Programa $Ì Python1 armaKenaremos o nosso arquivo
PE51.'[ no diret)rio c2kApache2.2kcgiFbin, ele $ quem
responder ao m$todo '!#5.
gdOp(thon24Op(thon
g %mporta modulos para trabalhar com 6P%
import cgi, cgitb
g 6ria a instancia de armaKenamento de campos
form _ cgi.@ield#torageBC
g Pet data from fields
nome _ form.getvalueBinomeiC
sobrenome _ form.getvalueBisobrenomeiC
print e6ontentFt(pe2te=tOhtmlkrknkrkne
print emhtmlfe
print emheadfe
print emtitlef!lai F #egundo 'rograma 6P% mOtitlefe
print emOheadfe
print embod(fe
print emh2f!lai ?s ?smOh2fe ? Bnome, sobrenomeC
print emObod(fe
print emOhtmlfe
203
! programa recebe os dados atrav$s do m$todo getvalue.
5este o programa e verifique ele sendo e=ecutado
automaticamente assim que o boto Enviar for clicado.
TCtodo P"(1 $ um m$todo mais seguro de passagem
de informao para programas 6P%. Esta informao em veK de
ser passada em uma string ap)s o sinal de / , ela $ enviada como
uma mensagem separada, um script 6P%.
mform action_eOcgiFbinOget1.p(e method_epostef
"ome 2 minput t(pe_ete=te name_enomeefmbr Of
#obrenome2 minput t(pe_ete=te name_esobrenomee Of
mOformf
eEa s) o m$todo foi substituJdo.
5este o programa faKendo apenas essa modificao e veEa que
no aparece na ,8* os dados. Ateno2 deveFse dar um restart
no Apache, para ele atualiKar o cache.
1F.7 ,sando $_E$cBd
,sados quando temos a necessidade de selecionar uma
ou mais op>es. Abai=o temos um e=emplo, com o formulrio e
o programa 6P%, que devem ser e=ecutados da mesma forma
que o e=emplo anterior.
@ormulrio L5G*2
204
mform action_eOcgiFbinOchecAbo=.p(e method_e'!#5e
target_enblanAef
minput t(pe_echecAbo=e name_eAKule value_eone Of AKul
minput t(pe_echecAbo=e name_eermelhoe value_eone Of ermelho
minput t(pe_esubmite value_e#elecione a 6ore Of
mOformf
'rograma 6P%2
gdkp(thon24kp(thon
g %mporta modulos de manipulacao do 6P%
import cgi, cgitb
g 6ria instancia de armaKenamento dos campos
g 'ega dado dos campos
if form.getvalueBiAKuliC2
aKulnflag _ e*igadoe
else2
aKulnflag _ e9esligadoe
if form.getvalueBiermelhoiC2
vermelhonflag _ e*igadoe
else2
vermelhonflag _ e9esligadoe
print emhtmlfe
print emheadfe
20&
print emtitlef'rograma 6hecAbo=mOtitlefe
print emOheadfe
print embod(fe
print emh2f 6hecA7o= Aûl estai 2 ?smOh2fe ? aKulnflag
print emh2f 6hecA7o= ermelho estai 2 ?smOh2fe ? vermelhonflag
print emObod(fe
print emOhtmlfe
1F.9 ,sando Boto 4adio
,tiliKamos quando devemos selecionar apenas uma
opo entre vrias disponJvel.
@ormulrio L5G*2
mform action_eOcgiFbinOradio.p(e method_eposte target_enblanAef
minput t(pe_eradioe name_eescolhae value_eaKule Of AKul
minput t(pe_eradioe name_eescolhae value_evermelhoe Of ermelho
minput t(pe_esubmite value_e#elecione 6ore Of
mOformf
'rograma 6P%2
gdkp(thon24kp(thon
g %mportando modulos para tratar 6P%
import cgi, cgitb
g 6ria instancia de armaKenamento dos campos
20;
g 'ega dado dos campos
if form.getvalueBiescolhaiC2
escolha _ form.getvalueBiescolhaiC
else2
escolha _ e"ao escolheue
print emhtmlfe
print emheadfe
print emtitlef'rograma 8adio 6P%mOtitlefe
print emOheadfe
print embod(fe
print emh2f A cor selecionada ei ?smOh2fe ? escolha
print emObod(fe
print emOhtmlfe
#iga as recomenda>es anteriores para e=ecutar o programa.
1F.= ,sando te2to
Guitas veKes precisamos passar vrias linhas de dados
para o servidor, o e=emplo abai=o mostra como isto $ feito.
@ormulrio2 diret)rio htdocs O nome do arquivo inde2.htm.
mform action_eOcgiFbinOte=to.p(e method_eposte target_enblanAef
mte=tarea name_ete=tcontente cols_e:0e ro1s_e:ef
9igite o te=to aqui...
mOte=tareaf
mOformf
210
'rograma 6P%2 para e=ecutFlo no se esquea de armaKenar seu
programa no diret)rio do apache cgi?5in.
gdkp(thon24kp(thon

g %mportando modulos para 6P%
import cgi, cgitb
g 6riando instancia de armaKenamento dos campos
g !btendo os dados do campo
if form.getvalueBite=tcontentiC2
te=tncontent _ form.getvalueBite=tcontentiC
else2
te=tncontent _ e"ao digitadoe
print emhtmlfe
print emheadfeS
print emtitlef5e=to 6P% mOtitlefe
print emOheadfe
print embod(fe
print emh2f ! 6onte<do do te=to $2 ?smOh2fe ? te=tncontent
print emObod(fe
"o esquea2 ! formulrio de entrada est em ]htdocs e tem o
nome inde2.htm. e o programa que atende a solicitao est em
]cgi?5in.
211
1F.B ,sando Dro! Do0n5o2
"ormalmente usado para selecionar um valor de uma
lista com vrios valores.
@ormulrio2
mform action_eOcgiFbinOdropdo1n.p(e method_eposte target_enblanAef
mselect name_edropdo1nef
moption value_eGatemticae selectedfGatemticamOoptionf
moption value_e@Jsicae f@JsicamOoptionf
mOselectf
minput t(pe_esubmite value_eEnviareOf
mOformf
'rograma 6P%2
gdkp(thon24kp(thon
g %mportando modulos para 6P%
import cgi, cgitb
g 6ria instancia de armaKenamento de campos
g !btem dados
if form.getvalueBidropdo1niC2
escolha _ form.getvalueBidropdo1niC
else2
escolha _ e"o definidae
212
print emhtmlfe
print emheadfe
print emtitlef'rograma 9ropdo1n 7o= mOtitlefe
print emOheadfe
print embod(fe
print emh2f ! selecionado ei ?smOh2fe ? escolha
print emObod(fe
print emOhtmlfe
1F.D ,sando o m#du.o cgita5
Este m)dulo $ um debugger e tornarFseF <til quando iniciarmos
um grande script com muitas linhas, E que este c)digo permiteF
nos visualiKar os erros contidos no script.
5este este c)digo e veEa o que acontece, depois retire os
caracteres g das linhas + e : e veEa o erro aparecer no bro1ser.
'ara e=ecutar este programa armaKene ele no diret)rio cgiFbin e
digite no bro1ser2 http2OOlocalhostOcgiFbinOtestadorcgi.p(
gdOp(thon24Op(thon
import cgi
gimport cgitb
gcgitb.enableBC
print e6ontentFt(pe2 te=tOhtmle
print
laptops _ form.getvalueBilaptopsi,i0iC
desAtops _ form.getvalueBidesAtopsi,i0iC
21+
print eee
mhtmlf
mbod(f
mform action_isecond.p(if
.uantos laptops voce tem/VnbspS
minput t(pe_iradioi checAed name_ilaptopsi value_i0i
Of0VnbspS
minput t(pe_iradioi name_ilaptopsi value_i1i Of1VnbspS
minput t(pe_iradioi name_ilaptopsi value_i2i Of2
mpf
.uantos desAtop voce tem/VnbspS
minput t(pe_iradioi checAed name_idesAtopsi value_i0i
Of0VnbspS
minput t(pe_iradioi name_idesAtopsi value_i1i Of1VnbspS
minput t(pe_iradioi name_idesAtopsi value_i2i Of2
mpf
minput t(pe_isubmiti Of
mpf
oce tem ?d computadores.
mOformf
mObod(f
mOhtmlfeee ? BintBlaptopsClBdesAtopsCC
A informao abai=o aparece no bro1ser e vocD consegue
visualiKar o erro.
@ile e62OArquivos de programasOApache #oft1are
@oundationOApache2.2OcgiFbinOtestadorcg1e, line 2;, in
mmodulef
mOhtmlfeee ? BintBlaptopsClBdesAtopsCC
21:
5(peError2 unsupported operand t(peBsC for l2 iinti and istri
fff
Agora corriEa o erro e veEa o que acontece.
gdOp(thon24Op(thon
import cgi
import cgitb
cgitb.enableBC
print e6ontentFt(pe2 te=tOhtmle
print
laptops _ form.getvalueBilaptopsi,i0iC
desAtops _ form.getvalueBidesAtopsi,i0iC
print eee
mhtmlf
mbod(f
mform action_isecond.p(if
.uantos laptops voce tem/VnbspS
minput t(pe_iradioi checAed name_ilaptopsi value_i0i
Of0VnbspS
minput t(pe_iradioi name_ilaptopsi value_i1i Of1VnbspS
minput t(pe_iradioi name_ilaptopsi value_i2i Of2
mpf
.uantos desAtop voce tem/VnbspS
minput t(pe_iradioi checAed name_idesAtopsi value_i0i
Of0VnbspS
minput t(pe_iradioi name_idesAtopsi value_i1i Of1VnbspS
minput t(pe_iradioi name_idesAtopsi value_i2i Of2
mpf
minput t(pe_isubmiti Of
21-
mpf
oce tem ?d computadores.
mOformf
mObod(f
mOhtmlfeee ? BintBlaptopsClintBdesAtopsCC
1F.E ,sando arLui%os de te2to !ara armaRenar in'ormaJes
E=ecute no navegador2 localhostOcgiFbinOcontador.p(
gdkp(thon24kp(thon
g FIF coding2cp12-2 FIF
ggggggggg 6P% header gggggggggggggggggggggggggggggg
import cgi
print e6ontentF5(pe2 te=tOhtmlkne
tr(2counter _ openBecounter.t=te,ereC
e=cept2counter _ openBecounter.t=te,eaeC
line _ counter.readlineBC
counter.closeBC
if line __ ee2
number _ 1
else2
number _ intBlineC l 1
counter _ openBecounter.t=te,e1eC
counter.1riteBstrBnumberCC
counter.closeBC
gggggggggg L5G* content ggggggggggggggggggggggggggg
213
print eee
mhtmlf mheadf mtitlef#ome 5itle mOtitlef mOheadf
mbod(f mh:f#eu 6onte<do ...mOh:f
eee
print eisitante n<mero2 e, number
gggggggggg L5G* footer gggggggggggggggggggggggggggg
print eee
mObod(fmOhtmlf
eee
1F.1F ,sando $oo6ies em !rogramao $Ì
.uando trabalhamos com o L55', um protocolo de estado, e
precisamos manter a informao atrav$s de muitas pginas
visitadas pelo cliente como num site de compras, a melhor e
mais eficiente forma de manter estas informa>es so atrav$s de
cooAies. !s cooAies funcionam da seguinte forma2 ao
acessarmos uma pgina no servidor ele envia uma mensagem
para o bro1ser, chamada cooAie, ela pode ser armaKenada ou
no, depende da configurao do bro1ser, mas uma veK
armaKenada ela fica no disco rJgido do visitante no formato de
registro tipo te=to. Agora para recuperar estas informa>es basta
acessar estes registros e pronto temos as informa>es
necessrias.
s coo6ies so 'ormados !or 9 cam!os de te2to1
E2!ira1 data em que e=pira o cooAie. Em branco ele e=pira
quando o visitante sair do bro1ser.
DomWnio1 nome de domJnio de seu site.
Path1 6aminho para o diret)rio ou pgina da 1eb que
armaKenou a informao. Em branco se vocD quer recuperar o
cooAie de qualquer diret)rio ou pgina.
214
"eguro1 este campo cont$m a palavra NsecureU ento o cooAie
somente pode ser recuperado em um servidor seguro. Em branco
no tem restrio.
Nome e Na.or1 so armaKenados como um par de nome e valor.
"etando $oo6ies1 para enviar cooAies para o bro1ser. !s
cooAies sero enviados Eunto com o cabealho L55' antes do
6ontent F5(pe. #e vocD quiser identificar o usurio e a sua senha
basta enviar o seguinte te=to2
gdkp(thon24kp(thon
print e#etF6ooAie2,ser%9_R[^Se
print e#etF6ooAie2'ass1ord_R[^12+Se
print e#etF6ooAie2E=pires_5uesda(, +1F9ecF2011 2+2122:0 PG5eSe
print e#etF6ooAie29omain_111.capotasprudentina.com.brSe
print e#etF6ooAie2'ath_OperlSe
...........! resto do conte<do L5G*......
!s atributos E=pires, 9omain e 'ath so opcionais.
Nosso e2em!.o1
gdkp(thon24kp(thon.e=e
print esetFcooAie2,ser%9_sergioSe
print esetFcooAie2'ass1ord_professorSe
print e6ontentFt(pe2te=tOhtmlSe
print ee
printiii
mbod(f
21&
#etando cooAies.
mbod(f
mOhtmlf
iii
8ecuperando 6ooAies2 para recuperar os cooAies armaKenados $
muito simples pois eles esto armaKenados no ambiente 6P% na
varivel L55'n6!!Q%E e tem o seguinte formato2
Ae(1_value1SAe(2_value2S.......
Programa !ara recu!erar coo6ies.
gdkp(thon24kp(thon.e=e
g %mport modules for 6P% handling
from os import environ
import s(s
import string
import cgi, cgitb
cgitb.enableBC
aAi_ii
if environ.hasnAe(BiL55'n6!!Q%EiC2
cooAie_environ.getBiL55'n6!!Q%EiC
aAi_cooAie
print iii
'eguei os cooAies.
iii
print aAi
ArmaKene os programas em cgiFbin, e=ecute o programa
para setar os cooAies e depois o programa que recupera os
cooAies, isto deve ser feito atrav$s do bro1ser.
21;
1F.11 8aRendo do0n.oad de arLui%os
"este e=emplo mostramos como faKer para clicar num linA e
aparecer uma cai=a de dilogo para faKer o do1nload do
arquivo.
gdkp(thon24kp(thon
g L55' Leader
print e6ontentF5(pe2applicationOoctetFstreamS
name_ke@ile"amekekrkneS
print e6ontentF9isposition2 attachmentS
filename_ke@ile"amekekrknkneS
g Abre arquivo a ser enviado
f _ openBeteste.t=te, erbeC
str _ f.readBCS
print str
g @echa arquivo
f.closeBC
1F.1) utros Programas
gdOp(thon24Op(thon
g calendin2.p( F calendario dinamico F prototipo 2
print i6ontentFt(pe2 te=tOhtmlkni
tr(2
from time import time, localtime
from calendar import monthcalendar
220
from string import Eoin
ano, mes, hoEe _ localtimeBtimeBCCX2+Z
print imL5G*fm5%5*Ef6alendario 9inamicomO5%5*Efi
print im7!9[fi
print im6E"5E8fi
print imL1f6alendario de ?02dO?0:dmOL1fi ? Bmes, anoC
print im5A7*Efi
print im58fi
for diansem in Xisegi,iteri,iquai,iquii,ise=i,isabi,idomiZ2
if diansem in Xisabi,idomiZ2 bgcolor _ igreeni
else2 bgcolor _ ibluei
print im5L 0%95L_e:-e 7P6!*!8_e?sefi ? bgcolor
print imL+f?smOL+fmO5Lfi ? diansem
print imO58fi
for semana in monthcalendarBano, mesC2
print im58fi
numndiansem _ 0
for dia in semana2
if dia __ hoEe2
bgcolor _ ipinAi
elif numndiansem f_ -2
bgcolor _ ilightgreeni
else2
bgcolor _ ilightbluei
print im59 A*%P"_e8%PL5e 7P6!*!8_e?sefi ? bgcolor
if dia d_ 02
print imL2f?2dmOL2fi ? dia
print imO59fi
numndiansem _ numndiansem l 1
print imO58fi
221

print imO5A7*EfmO6E"5E8fi
e=cept2
import s(s
from tracebacA import printne=c
s(s.stderr _ s(s.stdout
print imL8fmL+fErro no 6P%2mOL+fm'8Efi
printne=cBC
print imO'8Efi
5ela do bro1ser2
222
4e'erMncias Bi5.iogr'icas
PPI$Q Y '%6b!, Garcos Elias F Insta.ando o
A!acheVP_PVTe"-* no Windo0s, 2004. 9isponJvel em2
http2OO111.guiadohard1are.netOtutoriaisOapacheFphpFm(sqlF
1indo1sO. Acessado2 22 novembro 2011.
P4*Q Y 8AGA*L!, *uciano, A!renda a Programar. 200:.
PP$PQ F Python $Ì Programming. 9isponJvel2
http2OO111.tutorialspoint.comOp(thonOp(thonncginprogramming
.htm. Acessado2 em 21 novembro 2011.
P8"Q Y @E8P, #teven, Pensando em (6inter. 5raduo Wosu$
*abaAi , ,nesp F %lha #olteira Y 200:.
P*8Q Y *,"9L, @rediA, An Introduction to (6inter.1;;;.
P*&$Q Y *A7AQ%, Wosu$, Introduo a Python T#du.o $ f
(6inter. ,nesp Y %lha #olteira F200:.
P*&IQ Y *A7AQ%, Wosu$, Introduo a Python T#du.o Bsico.
,nesp Y %lha #olteira Y 200:.
PPe(Q Y 8!##,G, Puido van, (utoria. Python Nerso ).7.).
200-. 9isponJvel em2
http2OO111.p(thon.org.brO1iAiO9ocumentacao'(thon. Acessado
em2 21 novembro 2011.
PPTQ f '%*P8%G, GarA, Di%e Into Python, 200:.
P4*Q Y 8AGA*L!, *uciano, em Python 4e.ease 1,
22+
200&.
PPPQ F Python na Prtica1 ,m curso o5Keti%o de
Programao Python. 9isponJvel em2
http2OO111.as(nc.com.brOproEectsO Acessado em2 21 novembro
2011.
22:

Pythondobsicoweb 131028070251 Phpapp02

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Pythondobsicoweb 131028070251 Phpapp02

Hochgeladen von

Copyright:

Verfügbare Formate

Antonio Srgio Nogueira

Das könnte Ihnen auch gefallen