Upload
dinhkiet
View
266
Download
9
Embed Size (px)
Citation preview
1
AlgoritmoseProgramaçãoemPython
por
Prof. Dr. Paulo Roberto Gomes Luzzardi
facebook: Paulo Roberto Gomes Luzzardi WhatsApp: 99164-8037
e-mail: [email protected] (principal) e [email protected]
e-mail (Senac): [email protected] DropBox: https://www.dropbox.com/sh/kea9kr4j2qttnjg/4xXvw0pvxX?m
Hostinger: http://pluzzardi.w.pw e http://pluzzardi.zz.mu (Home Page)
Versão1.62
02-05-2018
Bibliografiarecomendada:
MENEZES, Nilo Ney Coutinho. Introdução à Programação com Python:
AlgoritmoseLógicadeProgramaçãoparaIniciantes.SãoPaulo:Editora
Novatec,2010(ISBN978-85-7522-250-8).
Pelotas,quarta-feira,2demaiode2018(09:48am)
2
Sumário
1.LinguagemdeProgramaçãoPython .................................................................... 4 2.ComoexecutarcomandosemPython .................................................................. 4 3.EntrarnaIDLEdoPython ................................................................................. 4 4.Primeiroscomandosouinstruções .................................................................. 4 5.Identificadoresevariáveis............................................................................ 5 6.Operadoresaritméticos ..................................................................................... 6 6.1Hierarquiadosoperadores(precedência)................................................... 7 7.Comandoprint(imprimirdadosnatela) ...................................................... 7 8.Comandoinput(lerdadosdoteclado) .......................................................... 9 9.Deletarumavariável(del) ............................................................................. 9 10.Módulos(import) ............................................................................................. 10 11.Funçõesdematemáticas(math) .................................................................... 11 12.Strings(cadeiadecaracteres) .................................................................. 13 12.1FunçõesparaStrings ................................................................................... 13 13.Comandos:Sequência,SeleçãoeRepetição ............................................... 15 13.1ComandosdeSequência ................................................................................. 15 13.2ListadeExercícios(Comandosdesequência) ....................................... 17 14.Operadoresrelacionais ................................................................................. 20 15.Operadoreslógicos ......................................................................................... 20 16.ComandodeSeleção(if) ............................................................................... 20 16.1ListadeExercícios(ComandodeSeleçãoif) ....................................... 23 17.Contadoreacumulador ................................................................................... 24 18.ComandosdeRepetição(whileefor) ........................................................ 25 18.1range(faixa) ................................................................................................. 27 18.2ListadeExercícios(ComandodeRepetiçãowhileefor) .................. 28 19.ListasemPython(vetores).......................................................................... 29 19.1ListadeExercíciosdeVetores(listas) ............................................... 35 20.Questõesdeprova ........................................................................................... 38 21.CuriosidadesetestesnoPython ................................................................ 43 22.FunçõesescritaspeloprogramadoremPython ......................................... 45 22.1ExercíciossobrefunçõesemPython ........................................................ 52 23.CriaçãoeutilizaçãodemódulosemPython ............................................. 55 24.Tratamentodeerros(exceções) .................................................................. 58 25.BancodeDadosemPython(SQLite) ............................................................ 62 26.SistemadeArquivosemPython .................................................................... 67 29.ArquivosBináriosemPython ........................................................................ 72 30.SocketsemPython ........................................................................................... 78 31.ThreadsemPython ........................................................................................... 83 32.MódulotkinterparaGUIemPython ............................................................ 83
3
Lista de Exercícios do Prof. Dr. Ricardo Andrade Cava
DropBox:
https://www.dropbox.com/sh/kea9kr4j2qttnjg/AAAGkXES6sWvRKCJh8R7x9aia/ListaCava?dl=0
1.LinguagemdeProgramaçãoPython
Pythonéumalinguagemdeprogramaçãointerpretada(ondecadalinha
écompiladaeexecutada,umaporvez),ouseja,nãoécompilada(onde
todooprogramaétraduzidoparalinguagemdemáquinaeposteriormente
executado).EmPython,cadacomandotemsuasintaxeverificada,sendo
executadoaseguir.
Pythonéumalinguagemdealtoníveleumsoftwarelivre,ouseja,não se paga por sua utilização. É utilizado em muitas aplicações,
inclusiveemRedesdeComputadoresparacriaçãodescriptsutilizadosemservidoreseoutrasaplicaçõesdaárea,alémdeserumalinguagemde
usogeral.
2.ComoexecutarcomandosemPython Windows:Iniciar...Programas...Python3.?(versão)
Linux:$python3.?(versão–digiteTABparadescobrir)
MacOsX:$python3.?(TABparadescobrirasversõesinstaladas)
3.EntrarnaIDLEdoPython IDLEéaInterfaceGráficadaLinguagemdeProgramaçãoPythonque
permiteaediçãoeexecuçãodosprogramasescritosemPython.
Windows:Iniciar...Programas...Python3.?(versão)...IDLE
Linux:$idle-python3.6&<enter>
MacOsX:$idle3.6<enter>
Observação:TodoprogramafonteemPythonpossuiaextensão“.py”.
InstalaçãoedownloaddoPython:http://www.python.org
4.Primeiroscomandosouinstruções Pythonpermiteexecutarcomandosouinstruções,taiscomo:
Imprimirnatela: >>>print(“Hello”)<enter>
Hello
Realizaroperaçõesmatemáticas: >>>3+4<enter>
7
>>>2**3<enter>
5
8
>>>
Operaçõesmaiscomplexas: >>>a=3<enter>
>>>b=4<enter>
>>>c=a+b<enter>
>>>print(a,b,c)<enter>
347
>>>print(“c=“,c)<enter>
c=7
>>>print(3>4)<enter>
False #valorlógico
>>>
5.Identificadoresevariáveis
Identificadoressãoosnomescriadospeloprogramadorparafazer
referênciaavariáveis,constantes,funçõesemódulos.
Regrasparaacriaçãodeidentificadores:
ü Oprimeirocaracterdeveserumaletraousublinha(_);
ü Oscaracteresseguintesdevemserletras,númerosousublinhas;
ü Nãohálimitedecaracteres;
ü Nãoépermitidoautilizaçãodecaracteresembranco(caracterespaço);
ü Podemserletrasmaiúsculaseminúsculas,poissãodiferenciados.
Comentáriodoprogramador:
#nãoéinterpretado-comentáriodeumalinha
”””
comentárioemmaisdeumalinha
Nãoéinterpretado
”””
’’’
comentárioemmaisdeumalinha
Nãoéinterpretado
’’’
VariáveisemPythonexistememtrêstipos:int,floatestring.
Nadeclaraçãodecadavariável,Pythonespecificaotipo,porexemplo:
a = 3, a é declarado como int, b = 3.4 é declarado como float, s =
“Python”ous=‘Python’sãostring’s.
Funçãotype:ExibeoTipodoDado.
6
#--------------------------Type.py
a=3
print(type(a))
b=3.4
print(type(b))
c='Python'
print(type(c))
d='A'
print(type(d))
TestedoPrograma:
=========RESTART:/Users/pluzzardi/Documents/Type.py=========
<class'int'>
<class'float'>
<class'str'>
<class'str'>
>>>
Comando id: Retorna o identificador do objeto, número inteiro que
identificacadaobjetodoPython.
>>>a=3
>>>b=4
>>>print(id(a)) #32bits/8bits=4bytes(inteiro)
4297624000
>>>print(id(b))
4297624032
>>>
6.Operadoresaritméticos
Osoperadoresaritméticospermitemaoprogramadorrealizarvárias
operações matemáticas, tais como: adição, subtração, divisão,
multiplicaçãoepotenciação.Aseguir,aTabela1exibeosoperadores
aritméticosutilizadosemPython.
Tabela1:OperadoresAritméticos
Matemática Operadoraritmético
Adição +
Subtração -
Multiplicação *
Divisão /
Potenciação **
7
6.1Hierarquiadosoperadores(precedência) ATabela2,aseguir,exibeaprecedênciadosoperadoresdoPython,
ouseja,aordemdeexecuçãodasoperaçõesmatemáticas.
Tabela2:HierarquiadosOperadoresAritméticos
Ordemde
precedência
TipodeOperador
Parênteses ()
** Potenciação
-(unário) Unário
*/%//Multiplicação,divisão,modulo(restointeirodadivisão)
edivisãointeira
+- Adiçãoesubtração
Exemplos:
>>>7/2 #divisãoreal
3.5
>>>7%2 #restointeirodadivisão(módulo)
1
>>>7//2 #divisãointeira
3
>>>
7.Comandoprint(imprimirdadosnatela)
O comando print permite enviar (imprimir) para a tela qualquerinformaçãodopython,comonúmeros,constantes,resultadosdeoperações,
strings,etc.
Sintaxesimples:print(string,lista_de_variáveis)Exemplos:
>>>print(4)<enter>
4
>>>print(3+4)<enter>
7
>>>print(3>4)enter>
False #tipológico(TrueouFalse)
>>>a=3<enter>
>>>print(a)<enter>
3
>>>b=4<enter>
8
>>>print(a+b)<enter)
7
>>>A=7<enter>
>>>print(A+b)<enter>
11
>>>print(“a=”,a)<enter>
a=3
>>>
>>>print(4%2)#restointeirodadivisão
0
>>>
>>>print(3**4) #Potenciação
81
>>>número_dentes=32<enter>
>>>print(“NúmerodeDentes:“,número_dentes)<enter>
>>>NúmerodeDentes=32
>>>a=3
>>>b=4
>>>print("a=",a,"b=",b)
a=3b=4
>>>dia=3<enter>
>>>mês=7<enter>
>>>ano=2017<enter>
>>>print(“Data:%02d/%02d/%d”%(dia,mês,ano))<enter>
03/07/2017 #saídaformatada
>>>
Tabela3:Operadores%
Operador% Significado
%s Umastring
%c Caractere
%d Decimalinteiro
%f Real(float)
%% Um'%'
NotequeoPythonpermiteformatarosdadosqueserãoexibidosna
telaatravésdoprint,paratantousaosoperadoresdaTabela3,acima.Reparenovamentenosexemplosabaixo:
>>>dia=3<enter>
>>>mês=7<enter>
>>>ano=2017<enter>
>>>print(“Data:%02d/%02d/%d”%(dia,mês,ano))<enter>
03/07/2017
>>>
#==================================dataehora
fromdatetimeimportdatetime
9
data=datetime.now()
print(data)
print("Data:%02d/%02d/%d"%(data.day,data.month,data.year))
print("Tempo:%02d:%02d:%02d"%(data.hour,data.minute,data.second))
8.Comandoinput(lerdadosdoteclado)
O comando input permite ler informações via teclado, o valor
digitadopelousuárioélidocomoumastring,podendoserconvertido
parainteiro(int)oureal(float).
Sintaxe:stringinput(stringmensagem)Exemplos:
EntradadeumaString:
>>>s=input(“DigiteumNome:“)<enter>
>>>DigiteumNome:Luzzardi<enter>
>>>print(len(s)) #númerodecaracteresdastring
8
>>>
EntradadeumInteiro:
>>>i=int(input(“DigiteumValor:“))<enter>
>>>DigiteumNome:34<enter>
>>>print(i)
34
>>>
EntradadeumReal(float):
>>>i=float(input(“DigiteumValor:“))<enter>
>>>DigiteumNome:34<enter>
>>>print(i)
34.0
>>>
Outraforma,emduasetapas:
>>>s=input("DigiteumValor:")<enter>
DigiteumValor:34<enter>
>>>x=int(s)<enter> #conversãoparainteiro
>>>print(x)<enter>
34
>>>
9.Deletarumavariável(del)
10
EmPythonépossíveldeletar(apagar,remover,desalocardamemória
RAM)umavariáveldamemória,istoéfeitoatravésdocomandodel.
Sintaxe:>>>delvariável
Exemplo:
>>>a=3<enter>
>>>print(a)<enter>
3
>>>dela
>>>print(a)
Traceback(mostrecentcalllast):
File"<stdin>",line1,in<module>
NameError:name'a'isnotdefined
Erro:identificador‘a’nãodefinido
Observação:Épossíveltambémreinicializaroterminal(shell),vána
opção Shell .. Restart Shell, todas as variáveis são destruídas, ou
seja,desalocadasdamemóriaRAM(RandomAcessMemory).
10.Módulos(import)
Pythonpossuiumconjuntodefunçõespré-definidasagrupadasem
estruturas chamadas de módulos, tais como: math (mathematics), os
(sistemaoperacional),datetime(dataehora),etc.
Formadeimportar:importmódulo
Parautilizarafunçãodeummódulo:módulo.função(argumento)
Paraimportarapenasumafunçãodesejada:frommóduloimportfunção
Exemplos: >>>importmath<enter>
>>>print(math.pi)<enter>
3.141592653589793
>>>importos<enter>
>>>os.system(“clear”)<enter>
>>>frommathimportsqrt<enter>
>>>print(math.sqrt(16))
16
>>>
Ajuda(help)dosmódulos:
>>>importmath<enter>
11
>>>help(math)<enter> #exibefunçõesdomódulomath #idênticoaoLinux
11.Funçõesdematemáticas(math)
Python possui diversas funções matemáticas oriundas do módulo
“math”.Sãoelas:
math.factorial(x):Retornaovalorfatorialdex,ondexdevesersempre
positivo.
>>>fat=math.factorial(5) #5x4x3x2x1=120
>>>print(fat)
120
>>>
math.modf(x):Retornaovalorinteiroeovalorfracionáriodavariável
x.
>>>print(math.modf(5.34))
(0.33999999999999986,5.0)
>>>
math.exp(x):Retornaoexponencialdex,ouseja,ex.
>>>print(math.exp(1))
2.718281828459045
>>>print(math.exp(2))
7.38905609893065
>>>print(math.exp(3))
20.085536923187668
>>>
math.log(x,base):Retornaologdexnabasepedida.
>>>print(math.log(2,10))
0.30102999566398114
>>>print(math.log(3,10))
0.47712125471966244
>>>
math.log1p(x):Retornaologaritmonaturaldex.
>>>print(math.log1p(1))
0.6931471805599453
>>>print(math.log1p(2))
1.0986122886681098
>>>
12
math.sqrt(x):Retornaaraizquadradadex.
>>>x=16
>>>print(math.sqrt(x))
4.0
>>>x=-16 #xdeveserpositivo
>>>print(math.sqrt(x))
Traceback(mostrecentcalllast):
File"<stdin>",line1,in<module>
ValueError:mathdomainerror
>>>
math.degrees(x):Converteoânguloxderadianosparagraus.
piradianosà180graus
math.radians(x):Converteoânguloxdegrauspararadianos.
math.sin(x):Retornaosenodex,ondexdeveestaremradianos.
>>>x=math.sin(45)
>>>print(x)
0.8509035245341184
>>>x=math.sin(math.radians(45))
>>>print(x)
0.7071067811865475
>>>
math.cos(x):Retornaocossenodex,ondexdeveestaremradianos.
>>>x=math.cos(45)
>>>print(x)
0.5253219888177297
>>>x=math.cos(math.radians(45)) #converte45pararadianos
>>>print(x)
0.7071067811865476
math(tan(x):Retornaatangentedex,ondexdeveestaremradianos.
>>>tangente=math.tan(math.radians(45))
>>>print(tangente)
0.9999999999999999
>>>
math.hypot(x,y):Retornaahipotenusadotriânguloretângulo,ondexe
ysãooscatetosopostoeadjacente.
>>>hipotenusa=math.hypot(3,4)
13
>>>print(hipotenusa)
5.0
>>>
12.Strings(cadeiadecaracteres)
Stringéumasequênciadecaracteres,letras,númerosecaracteresespeciais,quepermitetrabalharcomtextos.
>>>s="Python"<enter>
>>>print(s)<enter>
Python
>>>print("Númerodecaracteresdastring:%d"%(len(s)))<enter>
6
>>>
ou
>>>s=‘Python’<enter> #podeserutilizadoaspassimples
>>>l=len(s)<enter> #retornaonúmerodecaracteres
>>>print("NúmerodecaracteresdaString:%d"%l)<enter>
6
>>>
outraformadeinicialização:
>>>s='P''y''t''h''o''n'<enter)
>>>print(s)<enter>
Python
>>>
VetordeStrings:(serávistoemoutrocapítulo)
>>>s=('Paulo','Roberto','Gomes','Luzzardi')<enter>
>>>print(s[0])<enter>
Paulo
>>>print(s[3])<enter>
Luzzardi
>>>
12.1FunçõesparaStrings
#-------------------------------------------Split.py
s="PauloRobertoGomesLuzzardi"
print("Númerodeletras:",len(s))
partes=s.split('')
n=len(partes)
print("Númerodenomes:",n)
14
foriinrange(n):
print(partes[i])
print(partes)
TestedoPrograma:
=====RESTART:/Users/pluzzardi/Desktop/Python/Python/Split.py====
Númerodeletras:28
Númerodenomes:4
Paulo
Roberto
Gomes
Luzzardi
['Paulo','Roberto','Gomes','Luzzardi']
>>>
ExemplodefunçõesdeStrings:
#--------------------------------String.py
#--------------------------------------------len
s='PauloRobertoGomesLuzzardi'
n=len(s)#retornaototaldecaracteresdastring
print("NúmerodeCaracteres:",n)
#--------------------------------------------count
caracter='a'
letras=s.count(caracter)#retornaonúmerodevezesqueocaracteraparecena
string
print('Númerodeletras"%c"é%d'%(caracter,letras))
#--------------------------------------------replace
s=s.replace('Roberto','R.')#trocapartedastring
s=s.replace("Gomes","G.")
print(s)
#--------------------------------------------find
pos=s.find('z')#procuraaprimeiraapariçãodeumaletra
print(pos)
#--------------------------------------------upperelower
print("STRING:",s.upper())#exibecomomaiúscula
print(s)
print("string:",s.lower())#exibecomominúscula
print(s)
#--------------------------------------------title
s="paulorobertogomesluzzardi"
print(s.title())
#--------------------------------------------swapcase
s='PauloRobertoGomesLuzzardi'
print(s.swapcase())#inverteasletrasmaiúsculaseminúsculas
15
#--------------------------------------------isalpha
print('Contémapenasletras: ',s.isalpha())#verificasecontémapenasletras
s='FatecSenac'
print('Contémapenasletras: ',s.isalpha())
#---------------------------------------------isdigit
print('Contémapenasnúmeros:',s.isdigit())
s='123456'
print('Contémapenasnúmeros:',s.isdigit())
TestedoPrograma:
===========RESTART:/Users/pluzzardi/Documents/String.py==========
NúmerodeCaracteres:28
Númerodeletras"a"é2
PauloR.G.Luzzardi
14
STRING:PAULOR.G.LUZZARDI
PauloR.G.Luzzardi
string:paulor.g.luzzardi
PauloR.G.Luzzardi
PauloRobertoGomesLuzzardi
pAULOrOBERTOgOMESlUZZARDI
Contémapenasletras: False
Contémapenasletras: True
Contémapenasnúmeros:False
Contémapenasnúmeros:True
>>>
13.Comandos:Sequência,SeleçãoeRepetição
Pythonpossuitrêstiposprincipaisdecomandos,sequência,onde
todossãoexecutados,seleção,ondealgunssãoeoutrosnãosão
executadoserepetição,comandossãoexecutadosdiversasvezes.
13.1ComandosdeSequência ComandosdeSequência:
Todososcomandos(ouinstruções)emsequênciasãosempre
executadosnofluxodoprograma.
#---------------------Circulo.py
importmath
diametro=float(input("DigiteovalordoDiâmetro:"))
raio=diametro/2
area=math.pi*raio**2
16
print("ÁreadoCírculoé:",area)
TestedoPrograma:
DigiteovalordoDiâmetro:6<enter>
ÁreadoCírculoé:28.274334
>>>
#-----------------------------------Temperatura.py
f=120
c=(f-32)*5/9
print("Celsius:%d"%c,sep='',end='') #imprimemesmalinha
print("-Fahrenheit:",f)
TestedoPrograma:
==RESTART:/Users/pluzzardi/Desktop/Python/Python/Temperatura.py==
Celsius:48-Fahrenheit:120
>>>
#----------------------------------Random.py
importrandom
n=10
print("FaixadeSorteio:0...%d"%(n-1))
numero=int(random.random()*n)
print("NúmeroSorteado:",numero)
#Afunçãorandomgeraumnúmerofloataleatórioentre0.0e1.0
TestedoPrograma:
==========RESTART:/Users/pluzzardi/Documents/Random.py=======
FaixadeSorteio:0...9
NúmeroSorteado:8
>>>
#-----------------------------Aleatorio.py
importrandom
foriinrange(6):
n=random.randint(1,10)
print("n=",n)
TestedoPrograma:
=======RESTART:/Users/pluzzardi/Documents/Aleatorio.py=======
n=2
n=9
n=7
17
n=6
n=5
n=7
>>>
13.2ListadeExercícios(Comandosdesequência)
a) EscrevaumprogramaemPythonquerecebedoisvaloresviateclado:cateto adjacente (b) e cateto oposto (a) e calcula o valor da
hipotenusadadopelaseguintefórmula:
TestedoPrograma:
CatetoAdjacente(b):3<enter>CatetoOposto(a):4<enter>
Hipotenusa:5.0
b) EscrevaumprogramaemPythonquelê4notasviateclado:n1,n2,n3 e n4 obtidas por um aluno em 4 avaliações. Calcule a média
utilizandoaseguintefórmula:
n1+n2x2+n3x3+n4
Média=---------------------------
7
c) EscrevaumprogramaemPythonquerecebeviateclado:comprimentodacircunferência.Oprogramadevecalculareimprimirnatelao
diâmetroeoraiodacircunferência(vejaexemploabaixo):
TestedoPrograma:
Comprimentodacircunferência:36<enter>
Diâmetro:11.46
Raio:5.73
comprimentodacircunferência=2.Pi.raio
18
diâmetro=2.raio
d) DesenvolvaumprogramaemPythonquerecebeviateclado:pesodacarnequeserávendidaepreçoporquilo.Oprogramadevecalcular
eimprimirnatelaototalapagar,ovalorpagoaoICMS(17%)e
olucrolíquidodoaçougue.
TestedoPrograma(1):
Peso:3.5<enter>
PreçoporKg(R$):4.90<enter>
Totalapagar:17.15
ICMS(17%):2.91
Lucrolíquidodoaçougue(R$):14.24
TestedoPrograma(2):
Peso:1.5<enter>
PreçoporKg(R$):9.00<enter>
Totalapagar:13.5
ICMS(17%):2.29
Lucrolíquidodoaçougue(R$):11.21
e) EscrevaumprogramaemPythonquerecebeviateclado:adatadehojedaseguinteforma:dia,mês,anoeasuaidade,daseguinte
forma:anos,mesesediasvividos.Calculeeimprimaadatade
nascimentonoseguinteformato:dd/mm/aaaa.
TestedoPrograma:
Qualadatadehoje:
Dia:16<enter>
Mês:3<enter>
Ano:2017<enter>
Qualasuaidade:
Anos:55<enter>
Meses:1<enter>
Dias:6<enter>
DatadeNascimento:10/02/1962
f) Escreva um programa em Python que recebe via teclado: saláriomensalepercentualdereajuste.Calculareescreverovalordo
novosalário.
19
TestedoPrograma:
Salário:500<enter>
Percentualdereajuste:15<enter>
Novosalário:575
g) EscrevaumprogramaemPythonquelêviatecladoasdimensõesdeumacozinharetangular(comprimento,larguraealtura),calcular
eescreveraquantidadedecaixasdeazulejosparasecolocarem
todasassuasparedes(considerequenãoserádescontadoaárea
ocupadaporportasejanelas).Cadacaixadeazulejospossui1,5
m2.
TestedoPrograma:
Comprimento:4.5<enter>
Largura:3<enter>
Altura:2.8<enter>
Quantidadedecaixas:28
h) A turma C é composta de 60 alunos, e a turma D de 20 alunos.Escreva um programa em Python que leia o percentual de alunos
reprovados na turma C, o percentual de aprovados na turma D,
calculeeescreva:
a)OnúmerodealunosreprovadosnaturmaC.
b)OnúmerodealunosreprovadosnaturmaD.
c)Apercentagemdealunosreprovadosemrelaçãoaototaldealunos
dasduasturmas.
TestedoPrograma:
PercentualdealunosreprovadosnaturmaC:10<enter>
PercentualdealunosaprovadosnaturmaD:85<enter>
QuantidadedealunosreprovadosnaturmaC:6
QuantidadedealunosreprovadosnaturmaD:3
Percentualdealunosreprovadosemrelaçãoaototaldealunosdasduasturmas:11.25
i) EscrevaumprogramaemPythonquerecebetrêsvaloresviateclado:a,bec.Oprogramadevecalculareimprimirnatelaosvalores
dasraízesx1ex2dadospelafórmuladabhaskara,ouseja,uma
equaçãodesegundograu:a.x2+b.x+c=0
TestedoPrograma:
a=1<enter>
20
b=2<enter>
c=-3<enter>
x1=1
x2=-3
14.Operadoresrelacionais
Os operadores relacionais permitem ao programador realizar
comparações. A seguir, a Tabela 4 exibe os operadores relacionais
utilizadosemPython.
Tabela4:OperadoresRelacionais
Operadorrelacional Função
== Igual
!= Diferente
> Maior
< Menor
>=Maiorou
igual
<=Menorou
igual
15.Operadoreslógicos
Os operadores lógicos permitem ao programador realizar várias
comparações em uma mesma condição. A seguir, a Tabela 5 exibe os
operadoreslógicosutilizadosemPython.
Tabela5:OperadoresLógicos
Operadorlógico
and
or
not
andéverdadeiroquandoambascondiçõesforemverdadeiras
oréverdadeiroquandoumaouambascondiçõesforemverdadeiras.
notéoinversodacondição,ouseja,inverteoTrueouFalse.
16.ComandodeSeleção(if)
21
Ocomandodeseleçãoifpermiteoprogramaseguirdoiscaminhos,
istoéfeitoatravésdeumacondição,utilizandoumoperadorrelacional
(Tabela4),quepodeserverdadeira(True)oufalsa(False).
Sintaxe:ifcondição:comando #simples
ou
ifcondição: #simples
comando
ou
ifcondição: #composto
comando1
else:
comando2
ou
ifcondição1:
comando1
elifcondição2:
comando2
else:
comando3
ProgramaExemplo:ifsimples
#--------------------------------------If.py
1:x=int(input("DigiteumNúmero:"))
2:ifx<0:
3:print("Númeroénegativo")
4:print("x=",x)
Observação:Noteaendentaçãonocomandoif(linha3),Pythonutilizaa
endentaçãocomoformadeformarblocosdecomandos,ouseja,delimitar
instruçõesligadasaumúnicocomando.
TestedoPrograma:
=======RESTART:/Users/pluzzardi/Documents/If.py========
DigiteumNúmero:-5
Númeroénegativo
22
x=-5
>>>
=======RESTART:/Users/pluzzardi/Documents/If.py========
DigiteumNúmero:5
x=5
>>>
Programaexemplo:Ifcompleto,ouseja,comduaspartes
#----------------------------------------Par.py
x=int(input("DigiteumNúmero:"))
ifx%2==0:
print("Par")
else:
print("Ímpar")
TestedoPrograma:
=================RESTART:/Users/pluzzardi/Documents/Par.py=======
DigiteumNúmero:4
Par
>>>
#-------------------------Bhaskara.py
importmath
a=float(input("a="))
b=float(input("b="))
c=float(input("c="))
delta=b**2-4*a*c
ifdelta>=0:
x1=(-b+math.sqrt(delta))/2*a
x2=(-b-math.sqrt(delta))/2*a
print("x1=",x1)
print("x2=",x2)
else:
print("Erro:Raizescomplexas")
TestedoPrograma:
=====RESTART:/Users/pluzzardi/Documents/bhaskara.py======
a=1
b=2
c=-3
x1=1.0
x2=-3.0
>>>
Programaexemplo:ifcomelif
23
#----------------------------------------Elif.py
numero=int(input("DigiteumNúmero:"))
ifnumero>0:
print("Positivo")
elifnumero<0:
print("Negativo")
else:
print("Zero")
16.1ListadeExercícios(ComandodeSeleçãoif)
a)EscrevaumprogramaemPythonquelêasnotasdeduasavaliações
deumalunonosemestre.Calculareescreveramédiasemestralea
seguintemensagem:‘PARABÉNS!Vocêfoiaprovado’somenteseoaluno
foiaprovado(considere7.0anotamínimaparaaprovação)ou‘Você
foireprovado!Estudemais’.
TestedoPrograma:
Nota1:6<enter>
Nota2:8<enter>
Média:7.0
PARABÉNS!Vocêfoiaprovado
b)EscrevaumprogramaemPythonquelêdoisvalores.Escrevaovalor
domaior,omenoreamédiadosdoisvalores.
TestedoPrograma:
Valor:3<enter>
Valor:4<enter>
Maior:4
Menor:3
Média:3.5
c)EscrevaumprogramaemPythonquelêoanodenascimentodeuma
pessoa.Escrever:PODEVOTARouNÃOPODEVOTAReaidade,conforme
exemploabaixo.
TestedoPrograma:
AnodeNascimento:1999<enter>
Status:PODEVOTAR
Idade:18anos
d)AsmaçãscustamR$0,30serforemcompradasmenosdoqueumadúzia,
eR$0,25serforemcompradaspelomenosdoze.Escrevaumprograma
emPythonqueleiaonúmerodemaçãscompradas,calculeeescrevao
24
valortotaldacompra.
TestesdoPrograma:
Maças:20<enter>
ValordaCompra:R$5.00
ou
Maças:12<enter>
ValordaCompra:R$3.00
e)EscrevaumprogramaemPythonquerecebeviatecladoaalturaeo
sexo(codificadodaseguinteforma:[f]feminino-[m]masculino)de
umapessoa.Calculeeimprimanatelaopesoideal,utilizandoas
seguintesfórmulas:
Homens:72.7*h-58
Mulheres:62.1*h-44.7
TestesdoPrograma:
Altura:1.80<enter>
Sexo[M]ou[F]:m<enter>
PesoIdeal:72.86
ou
Altura:1.65<enter>
Sexo[M]ou[F]:F<enter>
PesoIdeal:57.765
17.Contadoreacumulador
Umcontadoréumavariávelquepossuiumaexpressãomatemática,
dentro de um comando de atribuição, que realiza uma contagem de uma
certaquantidadedevezesqueumcomandoderepetiçãoéexecutado,ou
seja,elamantémaquantidadedevezesqueumlaçofoiexecutado.Pode-
secontardeumemum,doisemdoiseassimsucessivamente,servindo,
normalmente,paracontaronúmerodeelementos.
Sintaxe:x=x+1 #xßx+1
Note que é somado um (1) ao x e então atribuído este novo valor ao
própriox.Noteaindaqueum(1)éumaconstante,quepodeser1,2,3,
...
Umacumuladorousomadoréumavariávelquecontémumaexpressão
matemáticaqueserveparaacumularvaloresacadavezqueocódigoé
executado.
Sintaxe:soma=soma+n #somaßsoma+n
25
Notequeésomadoovalor‘n’asomaeatribuídoestenovovalora
própriasoma.Noteaindaquenéumavariável,quepodeserqualquer
valorinteirooureal(float).
18.ComandosdeRepetição(whileefor)
Os comandos de repetição while efor permitem repetir diversas
vezes um bloco de comandos ou instruções. While repete enquanto a
condiçãoéverdadeira. Comandowhile:
Sintaxe: whilecondição:
comando1
comando2
... #---------------------------While.py
i=1
whilei<=10:
print("i=",i)
i=i+1
TestedoPrograma:
=========RESTART:/Users/pluzzardi/Documents/While.py=========
i=1
i=2
i=3
i=4
i=5
i=6
i=7
i=8
i=9
i=10
>>> #--------------------In2.py
importrandom
s='s'
whilesin['S','s']: #operadorin
num=random.randint(1,10)
print("Númerosorteado:",num)
s=input("Continua[S/N]")
TestedoPrograma:
26
=============RESTART:/Users/pluzzardi/Documents/In2.py=========
Númerosorteado:2
Continua[S/N]s
Númerosorteado:2
Continua[S/N]s
Númerosorteado:7
Continua[S/N]s
Númerosorteado:10
Continua[S/N]n
>>> Comandofor:
Permiteexecutarváriasvezesumblocodecomandos.
Sintaxe: forvariávelinfaixa:
comando1
comando2
... Observação:Aescolhaentreocomandowhileeforsedásemprequesabe-
seaquantidadedevezesqueumblocoéexecutado.Semprequesesabeo
númerodevezes,deve-seusarocomandofor,casocontrário,deve-se
utilizar o comando while, que pode ser controlado de várias formas,
baseadosemsuacondição.
Para utilizar o comando for deve-se saber o início (start), opontodeparada(stop)eavariação(step).#---------------------------------For.py
foriinrange(6): #faixa:0à5,onde6éopontodeparada
print(i)
======RESTART:/Users/pluzzardi/Desktop/Python/Python/For.py=====
0
1
2
3
4
5
>>>
#-----------------------------------ForDuplo.py
foriinrange(3):
forjinrange(4):
print(i,j)
======RESTART:/Users/pluzzardi/Documents/ForDuplo.py==========
27
00
01
02
03
10
11
12
13
20
21
22
23
>>>
Observação:Notequecomeçasempreemzero.
#-----------------------------------ForDuplo2.py
foriinrange(3):
forjinrange(4):
print(i+1,j+1)
===RESTART:/Users/pluzzardi/Desktop/Python/Python/ForDuplo2.py===
11
12
13
14
21
22
23
24
31
32
33
34
>>>
18.1range(faixa)
Range permite determinar o ponto de partida (start), ponto deparada(stop)eavariação(step)usadonocomandofor.
Sintaxe:range(start,stop,step)
Onde:Start:partidaStop:parada(stop-1)Step:passo(incremento[+]oudecremento[-])
Exemplos:
foriinrange(10): #0123456789
print(i)
28
foriinrange(0,10,2): #02468
print(i)
foriinrange(0,11,2): #0246810
print(i)
foriinrange(10,-1,-1): #109876543210
print(i)
foriinrange(10,0,-1): #10987654321
print(i)
Observação:Nuncacheganopontodeparada.
18.2ListadeExercícios(ComandodeRepetiçãowhileefor)
a)Escreva um programa em Python que lê um número via teclado. O
programadeveexibirseonúmeroéPARouÍMPAR.Oprogramaéencerrado
quandoonúmerodigitadoforZERO.
TestedoPrograma:
Número:6<enter>
PAR
Número:7<enter>
IMPAR
Número:0<enter>
PAR
>>>
b)Escreva um programa em Python que lê um número via teclado. O
programa deve exibir: POSITIVO, NEGATIVO ou ZERO. O programa é
encerrado quando o usuário digitar ‘N’ ou ‘n’ na pergunta
“Continua[S/N]?”.
TestedoPrograma:
Número:6<enter>
POSITIVO
Continua[S/N]?s
Número:-7<enter>
NEGATIVO
Continua[S/N]?S
Número:0<enter>
ZERO
Continua[S/N]?N
>>>
c)EscrevaumprogramaemPythonquelêumnomeviateclado.Oprograma
deveexibironúmerodepalavrasdonomeeaabreviaturadonome.
29
TestedoPrograma:
Nome:PauloRobertoGomesLuzzardi<enter>
Númerodepalavras:4
Abreviatura:P.R.G.L.
>>>
d)EscrevaumprogramaemPythonquelêumnomeviateclado.Oprograma
deveexibironomedoautor,conformeexemploabaixo:
TestedoPrograma:
Nome:PauloRobertoGomesLuzzardi<enter>
Autor:Luzzardi,PauloR.G.
>>>
e)EscrevaumprogramaemPythonquelêumnomequalquerviateclado.
Logoapósaentradaexibanatela:(a)todasasvogaisdonome;(b)
todas as consoantes do nome e o (c) total de letras, conforme e
exatamenteigualaotesteabaixo: TestedoPrograma: Nome: paulo roberto gomes luzzardi <enter> Vogais: auooeooeuai (11) Consoantes: plrbrtgmslzzrd (14) Total de letras: 25 >>>
19.ListasemPython(vetores)
EmPythonvetoressãorepresentadosemformadelistas.Vetores
sãoestruturasquepermitemarmazenarvaloreshomogêneos,ouseja,de
mesmotipo.Listasporoutrolado,sãoclassesquepermitemarmazenar
qualquertipodeinformação.Aseguirsãovistosdiversosexemplosda
utilizaçãodelistas. Exemplo:Lista1.py #-------------------------------Lista1.py
x=[10,20,30]
n=len(x) #retornaonúmerodeelementosdalista
foriinrange(n):
print(x[i]) #imprimeelementoporelemento
TestedoPrograma:
30
=======RESTART:/Users/pluzzardi/Documents/Lista1.py==========
10
20
30
>>>
Exemplo:Lista2.py
#-------------------------------Lista2.py
x=[]#declaraumalistavazia
n=int(input("NúmerodeElementos:"))
foriinrange(n):
num=int(input("DigiteumNúmero:"))
x.append(num) #insereumelementonofimdalista
foriinrange(n):
print('x[',i,']=',x[i],sep='') #eliminaoespaço
print("Lista:",x)
TestedoPrograma:
====RESTART:/Users/pluzzardi/Desktop/Python/Python/Lista2.py====
NúmerodeElementos:4
DigiteumNúmero:10
DigiteumNúmero:20
DigiteumNúmero:30
DigiteumNúmero:40
x[0]=10
x[1]=20
x[2]=30
x[3]=40
Lista:[10,20,30,40]
>>>
Exemplo:Lista3.py
#------------------------------Lista3.py
x=[10,20,30]
y=x
print("x=",x,"y=",y)
print(xisy)
print(id(x))
print(id(y))
t=x[:] #criaumacópiadalistax...t=x.copy()
print(tisx)
print(id(t))
print("NúmerodeElementos:",len(x))
TestedoPrograma:
========RESTART:/Users/pluzzardi/Documents/Lista3.py==========
x=[10,20,30]y=[10,20,30]
31
True
4380371208
4380371208
False
4320652552
NúmerodeElementos:3
>>>
Exemplo:Lista4.py
#--------------------------------Lista4.py
nome=[]
nota=[]
soma=0.0
numeroAlunos=4
foriinrange(numeroAlunos):
nome.append(input("NomedoAluno:"))
nota.append(float(input("Notado"+nome[i]+":")))
soma=soma+nota[i]
media=soma/numeroAlunos
print("MédiadaTurma:",media)
TestedoPrograma:
========RESTART:/Users/pluzzardi/Documents/Lista4.py=============
NomedoAluno:Paulo
NotadoPaulo:7
NomedoAluno:Roberto
NotadoRoberto:8
NomedoAluno:Gomes
NotadoGomes:9
NomedoAluno:Luzzardi
NotadoLuzzardi:10
MédiadaTurma:8.5
>>>
ImprimirListasutilizandoocomandofor:
lista={10,20,30,40,50} #listadenúmerosinteiros
print("ListasemOrdenação")
foriinlista:
print(i)
print("ListaOrdenada")
foriinsorted(lista):
print(i)
fori,valorinenumerate(lista): #comnumeração
print("%d-%d"%(i,valor))
lista=list(range(10))
32
foriinlista:lista[i]=i+5
print(lista[i])
print(lista)
nomes={"Carla","Ana","Debora","Eva","Beatriz"}
foriinsorted(nomes):
print(i)
#for<variável>in<lista>:
#<blocodecódigoendentado>
TestedoPrograma:
=====RESTART:/Users/pluzzardi/Desktop/Python/Python/For.py=====
0
1
2
3
4
5
ListasemOrdenação
40
10
50
20
30
ListaOrdenada
10
20
30
40
50
0-40
1-10
2-50
3-20
4-30
5
6
7
8
9
10
11
12
13
14
[5,6,7,8,9,10,11,12,13,14]
Ana
Beatriz
Carla
33
Debora
Eva
Funçõesparaoperarlistas:
Anexaroelementonofinaldalista:append
lista.append(elemento)
Removeoelementodalista:remove
lista.remove(elemento)
Limpatodaalista,ouseja,apagatodososelementosdalista:clear
lista.clear()
Insereoelementoantesdoíndice:insert
lista.insert(índice,elemento)
Removeoúltimoelementoeretornaovalor:pop
ultimo=lista.pop()
Reverteoselementosdalista(mudaaordem):reverse
lista.reverse()
Criaumacópiadalista:copy
temp=lista.copy()
Ordenaumalista:sort
lista.sort() ou lista.sort(reverse=True)
Númerodeelementosdeumalista:len
n=len(lista)
Retornaonúmerodevezesdeumelementodentrodeumalista:count
vezes=lista.count(elemento)
34
Retornaoíndicedeumelementoemumalista:index
posição=lista.index(elemento)
#---------------------------------------Lista.py
lista=[40,30,50,10,20]
lista.sort() #ordenaemordemcrescente
print(lista)
lista.sort(reverse=True) #ordenaemordemdecrescente
print(lista)
#insert(posição,valor)
lista.insert(1,15)#insereoelementoantesdaposição
print(lista)
print(lista.count(20))#exibeonúmerodevezesdoelemento
print(lista.index(20))#exibeoíndicedoelemento
ultimo=lista.pop()#removeoúltimoelemento
print("Últimoelemento:",ultimo)
print(lista)
lista.reverse()#invertealista(ordemdoselementos)
print(lista)
temp=lista.copy()
print("ListaNova:",temp)
Testedoprograma:
===============RESTART:/Users/pluzzardi/Desktop/Lista.py=========
[10,20,30,40,50]
[50,40,30,20,10]
[50,15,40,30,20,10]
1
4
Últimoelemento:10
[50,15,40,30,20]
[20,30,40,15,50]
ListaNova:[20,30,40,15,50]
>>>
Oprogramaaseguirmostraacriaçãoaleatóriadepalpitesparaa
MegaSena.
#----------------------------MegaSena.py
importrandom
35
#----------------------------repetido
defrepetido(num,n,t):
foriinrange(n):
ifnum[i]==t:
return(True)
return(False)
#----------------------------imprime
defimprime(num):
foriinrange(len(num)):
t=num[i]
print("%2d"%t,sep='',end='')
print()
ch='s'
whilechin['S','s']:
palpites=int(input("Númerodepalpites:"))
foriinrange(palpites):
num=[]
n=1
num.append(random.randint(1,60))
whilen!=6:
t=random.randint(1,60)
ifnot(repetido(num,n,t)):
num.append(t)
n=n+1
num.sort() #ordenaalista
imprime(num)
ch=input("Continua[s/n]?")
TestedoPrograma:
========RESTART:/Users/pluzzardi/Desktop/MegaSena.py=============
Númerodepalpites:5
3914172640
2710122854
91316303639
22629434754
51223313755
Continua[s/n]?s
Númerodepalpites:6
91123263334
82831404350
91722242847
223133363945
162739404346
153136424860
Continua[s/n]?n
>>>
19.1ListadeExercíciosdeVetores(listas)
36
a) EscrevaumprogramaemPythonquerecebeviatecladoumconjuntodeletras.Armazenetodasasletrasemumvetoroulista(letras)
atéqueousuáriodigiteapenas<enter>.Logoapóscopietodasas
letras (em ordem inversa) para outro vetor (inverso). Ao final
imprimaosdoisvetores(conformeexemploabaixo).
Testedoprograma:
Letra: L <enter> Letra: I <enter> Letra: M <enter> Letra: A <enter> Letra: <enter> [‘L’, ‘I’, ‘M’, ‘A’] [‘A’, ‘M’, ‘I’, ‘L’]
b) EscrevaumprogramaemPythonquerecebeviateclado:númerodeidadeseasrespectivasidades.Armazenetodasasidadesemum
vetor(idade).Logoapósaentradadetodasasidades,oprograma
deve receber via teclado:idade para consulta. O programa deve
imprimirnatela,onúmerodeidadesantesdaidadedeconsultae
onúmerodeidadesdepoisdaidadedeconsulta(conformeexemplo
abaixo).ExibirIdadenãoencontradaseaidadedeconsultanão
existir.
Testedoprograma:
Número de idades: 6 <enter> Idade: 30 <enter> Idade: 60 <enter> Idade: 10 <enter> Idade: 50 <enter> Idade: 20 <enter> Idade: 40 <enter> Idade para consulta: 50 <enter> Antes: 3 Depois: 2 Continua [S/N]? n <enter>
c) EscrevaumprogramaemPythonquerecebeviatecladoumconjuntodenúmerosinteiros.Armazenetodososnúmerosinteirosemumvetor
atéqueousuáriodigite0(zero).Logoapóspermitaaousuário
consultar um número informando o seu valor. O programa deve
imprimirnatelaaposiçãodonúmeronovetorouERRO:Númeronão
encontrado(vejaexemplosabaixo):
Exemplo:
Número: 50 <enter> Número: 30 <enter>
37
Número: 20 <enter> Número: 10 <enter> Número: 40 <enter> Número: 0 <enter> Valor: 20 <enter> Posição no vetor: 2 Valor: 40 <enter> Posição no vetor: 4 Valor: 60 <enter> ERRO: Número não encontrado Valor: 0 <enter> Observação:Oprogramaterminaquandoousuáriodigitar0(zero).
d) EscrevaumprogramaemPythonquerecebeviateclado"n"conceitos(A,B,C,DeE)atéqueousuáriodigiteFouf.Armazenetodos
osconceitosemumvetor(conceito).Imprimanatelaonúmerode
alunos:aprovados(A,BeC),reprovados(D)eosinfrequentes
(E).
Testedoprograma:
Conceito: B <enter> Conceito: A <enter> Conceito: E <enter> Conceito: B <enter> Conceito: D <enter> Conceito: C <enter> Conceito: A <enter> Conceito: E <enter> Conceito: f <enter> 5 Aprovado(s) 1 Reprovado(s) 2 Infrequente (s)
e) EscrevaumprogramaemPythonquerecebeviateclado“n”nomes.
A entrada dos nomes termina quando o usuário digitar apenas
<enter>.Logoapósaentradadetodososnomesoprogramadeve
permitir a entrada via teclado de uma letra. O programa deve
imprimir na tela todos os nomes que começam com a letra
especificada pelo usuário. O programa termina quanto o usuário
digitar“”(nada)naentradadaletra(conformeexemplosabaixo):
Testedoprograma:
Nome: Paulo <enter> Nome: Roberto <enter> Nome: Renato <enter> Nome: Pedro <enter> Nome: Fabio <enter> Nome: <enter> Letra: R <enter> Nome: Roberto
38
Nome: Renato Letra: P <enter> Nome: Paulo Nome: Pedro Letra: T <enter> Letra: <enter>
f) EscrevaumprogramaemPythonquerecebeviateclado“n”nomes
eidades.Aentradadosdadosterminaquandoousuáriodigitar'N'
ou'n'napergunta"Continua[S/N]?".Logoapósaentradadetodos
osdadosoprogramadeveimprimirnatelatodososnomeseidades
desdeomaisvelhoatéomaisnovo.
Testedoprograma:
Nome: Ana <enter> Idade: 12 <enter> Continua [S/N]? s <enter> Nome: Beatriz <enter> Idade: 13 <enter> Continua [S/N]? s <enter> Nome: Carla <enter> Idade: 14 <enter> Continua [S/N]? N <enter> Carla 14 Beatriz 13 Ana 12
20.Questõesdeprova
Aseguirsãoapresentadasdiversasquestõesdeprovas.Resolva-
as, pois elas servirão como um simulado para treino da linguagem de
programaçãoPython. 1. Escreva um programa em Python que lê um nome qualquer via teclado. Logo após a entrada, imprima na tela o nome abreviado e a quantidade de palavras abreviadas, conforme e exatamente igual aos testes abaixo: Teste do programa (1): Nome: Paulo Roberto Gomes Luzzardi <enter> Abreviatura: Paulo R. G. Luzzardi Palavras abreviadas: 2 Teste do programa (2): Nome: adriane maria machado freitas luzzardi <enter> Abreviatura: adriane m. m. f. luzzardi Palavras abreviadas: 3
39
2. Escreva um programa em Python que lê nomes via teclado. Para cada nome digitado pelo usuário, armazene em uma Lista [f] para feminino, [m] para masculino ou [i] para indeterminado, conforme exemplo abaixo. Ao final imprima a Lista, o total de homens, o total de mulheres e o total de indeterminados. Teste do programa: Nome: Debora <enter> Nome: Carla <enter> Nome: Beatriz <enter> Nome: Paulo <enter> Nome: Renato <enter> Nome: <enter> Lista: [‘f’, ‘f’, ‘i’, ‘m’, ‘m’] 2 homens 2 mulheres 1 indeterminados 3. Escreva um programa em Python que recebe “n” nomes via teclado (até que o usuário digite apenas <enter>). Insira todos os nomes ORDENADOS em uma Lista de Strings (conforme exemplo abaixo). Ao final, o programa deve exibir a Lista contendo os nomes em ordem alfabética. Teste do programa: Nome: Debora <enter> Nome: Carla <enter> Nome: Eva <enter> Nome: Beatriz <enter> Nome: Ana <enter> Nome: <enter> Lista: [‘Ana’, ‘Beatriz’, ‘Carla’, ‘Debora’, ‘Eva’] 4. Escreva um programa em Python que lê um nome via teclado. Logo após a entrada crie uma outra string (invertido) para inverter e exibir este nome na tela e ainda o número de letras do nome (sem contar os espaços) e o total de espaços do nome, conforme exemplo abaixo. Teste do programa: Nome: paulo roberto gomes luzzardi <enter> Invertido: idrazzul semog otrebor oluap Total de Letras: 25 Total de Espaços: 3
5. Escreva um programa em Python que recebe via teclado: valor inicial, valor final e intervalo. O programa deve inserir “n” valores em uma Lista (desde o valor inicial até o valor final levando em consideração o intervalo entre eles, conforme exemplos abaixo. Ao final, o programa deve exibir a Lista criada com estes valores.
40
Teste do programa: Valor Inicial: 10 <enter> Valor Final: 70 <enter> Intervalo: 10 <enter> Lista: [10, 20, 30, 40, 50, 60, 70] Valor Inicial: 60 <enter> Valor Final: 20 <enter> Intervalo: 5 <enter> Lista: [60, 55, 50, 45, 40, 35, 30, 25, 20]
6. Escreva um programa em Python que insere “n” números inteiros em uma Lista (até que o usuário digite zero). Logo após permita a consulta de um valor e então exiba: (a) o antecessor e (b) o sucessor ou Antecessor não existe, Sucessor não existe ou Elemento não Encontrado (exatamente igual aos exemplos abaixo). Teste do programa: Valor: 10 <enter> Valor: 20 <enter> Valor: 30 <enter> Valor: 40 <enter> Valor: 50 <enter> Valor: 0 <enter> Lista: [10, 20, 30, 40, 50] Valor a consultar: 30 <enter> Antecessor: 20 Sucessor: 40 Valor a consultar: 10 <enter> Antecessor não existe Sucessor: 20 Valor a consultar: 60 <enter> Antecessor não existe Erro: Elemento não encontrado Sucessor não existe Valor a consultar: 0 <enter>
7. Escreva um programa em Python que recebe via teclado: número de idades e as referidas idades. O programa deve então imprimir na tela: (a) as idades em ordem crescente; (b) maior idade; (c) menor idade e (d) a média de idades. Teste do programa: Número de Idades: 4 <enter> Idade: 49 <enter> Idade: 51 <enter> Idade: 48 <enter> Idade: 50 <enter> Idades Ordenadas: [48, 49, 50, 51] Maior Idade: 51 Menor Idade: 48 Média de Idades: 49.5
41
8. Escreva um programa em Python que lê um vetor R de 5 elementos contendo o gabarito da LOTO. A seguir, ler um vetor A de 10 elementos contendo uma aposta. A seguir imprima quantos pontos fez o apostador. Teste do programa: [Entrada] R: 4 12 34 25 17 (gabarito) A: 3 17 55 21 34 4 27 29 20 11 (aposta) [Saída] 3 (pontos)
9. Dada a seguinte tela: Salário Mensal (R$): 900 <enter> Férias (R$): 450 <enter> 13 Salário (R$): 780 <enter> Salário Anual (R$): 12030.00 Alíquota do Imposto de Renda: ISENTO Escreva um programa em Python que recebe via teclado: Salário mensal, valor das férias e 13o salário. O programa deve calcular e imprimir na tela: Salário Anual e a Alíquota do imposto de renda (dada pela tabela abaixo):
Salário Mensal Alíquota do Imposto de Renda Menor ou igual a 1.058,00 Isento Maior que 1.058,00 15% Maior que 2.700,00 27,5%
10. Escreva um programa em Python que lê via teclado, um número inteiro qualquer (positivo ou negativo). O programa deve calcular e imprimir na tela: (a) inverso; (b) quadrado; (c) raiz quadrada e (d) cubo deste número. Teste do programa: Número: 4 <enter> Inverso: 0.25 Quadrado: 16 Raiz Quadrada: 2 Cubo: 64 11. Dado os seguintes exemplos de entrada de dados: a = 1 <enter> a = 1 <enter> b = -4 <enter> b = 2 <enter> c = 2 <enter> c = 3 <enter> Raízes Reais Raízes Complexas x1 = 3.41 x1 = -1.00 + 1.41 i x2 = 0.59 x2 = -1.00 - 1.41 i
42
Escreva um programa em Python que recebe via teclado: os coeficientes a, b e c de uma equação do segundo grau. O programa deve calcular e imprimir na tela: as raízes x1 e x2. a . x2 + b . x + c = 0 # equação de segundo grau Atenção: Note que as raízes podem ser Reais ou Complexas. delta = b2 – 4ac +------ -b +- \/ delta Raízes Reais: x1,2 = ------------------ “delta maior ou igual a zero” 2.a +--------- -b \/ | delta | Raízes Complexas: x1,2 = ----- +- ------------- i “delta menor que zero” 2.a 2.a
12. Escreva um programa em Python que lê um conjunto de 10 pares de dados contendo, cada um, a altura e um código para masculino (1) e outro para feminino (2) de uma turma de alunos. Calcular e imprimir na tela: (a) maior e a menor altura da turma e (b) média de altura das mulheres e dos homens e (c) total de homens e total de mulheres. Teste do programa: [Entrada] 1.80 (altura) 1 (masculino) 1.60 (altura) 2 (feminino) 1.62 (altura) 1 (masculino) 1.70 (altura) 2 (feminino) 1.72 (altura) 1 (masculino) 1.80 (altura) 2 (feminino) 1.92 (altura) 1 (masculino) 1.40 (altura) 1 (masculino) 1.42 (altura) 1 (masculino) 1.64 (altura) 1 (masculino) [Saída] 1.92 (maior altura da turma) 1.40 (menor altura da turma) 1.70 (média de altura das mulheres 1.65 (média de altura dos homens 7 Homens 3 Mulheres
13. EscrevaumprogramaemPythonquerecebeviateclado“n”nomese
idades.Aentradadosdadosterminaquandoousuáriodigitar'N'ou'n'
napergunta"Continua[S/N]?".Logoapósaentradadetodososdadoso
43
programa deve imprimir na tela todos os nomes e idades em ordem
alfabética(conformeexemploabaixo).
Teste do programa: Nome:Beatriz<enter>
Idade:12<enter>
Continua[S/N]?s<enter>
Nome:Carla<enter>
Idade:13<enter>
Continua[S/N]?s<enter>
Nome:Debora<enter>
Idade:15<enter>
Continua[S/N]?s<enter>
Nome:Ana<enter>
Idade:14<enter>
Continua[S/N]?N<enter>
Ana 14
Beatriz12
Carla 13
Debora15
14. Escreva um programa em Python que recebe via teclado: valor e quantidade até que o usuário tecle zero (0) no valor. O programa deve inserir ambos valores em uma Lista (conforme exemplo abaixo). Ao final, o programa deve criar e exibir outra Lista (Lista por extenso) contendo todos os valores por extenso (conforme exemplo abaixo) e ainda o total de valores da lista por extenso.
Teste do programa: Valor: 10 <enter> Quantidade: 3 <enter> Valor: 20 <enter> Quantidade: 4 <enter> Valor: 30 <enter> Quantidade: 2 <enter> Valor: 0 <enter> Lista:[10,3,20,4,30,2]
ListaporExtenso:[10,10,10,20,20,20,20,30,30]
Totaldevaloresporextenso:9
21.CuriosidadesetestesnoPython Aseguirsãovistosalgumascuriosidadesetestesfeitosno
Python:
#---------------------------------Teste.py
#====================inicializaçãodeváriasvariáveis
44
a,b=10,20
print(a,b)
#====================None(nuloounull
x=None#Noneénuloounull
x=5
print(x)
#=====================imprimirváriasvariáveis
x=10
y=20
print("x=%d-y=%d\n"%(x,y)) #printformatado
#=====================definiçãodeumafunçãoemPython
defmaior(x,y):
ifx>y:
return(x)
else:
return(y)
print(maior(3,4))
#==============================ifsimples
x=int(input("DigiteumNúmero:"))
ifx<0:
print('ValorNegativo')
print("NúmeroDigitado:",x)
#==============================imprimirumastring
forletterin"python":
print(letter)
#==============================if...elif...else...
numero=int(input("DigiteumNúmero:"))
ifnumero>0:
print("Positivo")
elifnumero<0:
print("Negativo")
else:
print("Zero")
#==================================dataehora
fromdatetimeimportdatetime
data=datetime.now()
45
print(data)
print("Data:%02d/%02d/%d"%(data.day,data.month,data.year))
print("Tempo:%02d:%02d:%02d"%(data.hour,data.minute,data.second))
TestedoPrograma:
1020
5
x=10-y=20
4
DigiteumNúmero:-5
ValorNegativo
NúmeroDigitado:-5
p
y
t
h
o
n
DigiteumNúmero:0
Zero
2017-03-0814:47:17.866354
Data:08/03/2017
Tempo:15:01:59
>>>
#-----------------------------------str.py
s=""
foriinrange(10):
s=s+str(i)+"," #formaumastringcomnúmeros
print(s)
TestedoPrograma:
==========RESTART:/Users/pluzzardi/Documents/str.py===========
0,1,2,3,4,5,6,7,8,9,
>>>
22.FunçõesescritaspeloprogramadoremPython
EmPythonépossíveloprogramadorescreversuasprópriasfunções,
ouseja,dividirosprogramasemmódulosmenores(programaçãomodular
ou estruturada ou dividir para conquistar). Uma função deve ser uma
caixapreta,quedepoisdefuncionarnãoprecisamaismanutenção.Uma
funçãopodeounãoreceberargumentos(parâmetros)eretornarounãoum
valor.
46
Para escrever uma função usa-se a palavra reservada def. A
princípioafunçãodeveestarlocalizadaantesdachamadadafunção.A
sintaxeé:
defnome_função(listadeargumentos): comando1 comando2 return(valor)chamada_função(argumentos)Exemplo:
#--------------------------------Funcoes.py
importmath
defHipotenusa(a,b):
h=math.sqrt(a**2+b**2)
return(h)
defMaior(a,b):
ifa>=b:
return(a)
else:
return(b)
defMenor(a,b):
ifa<=b:
return(a)
else:
return(b)
a=float(input("Digiteumvalor(a):"))
b=float(input("Digiteoutrovalor(b):"))
print("Hipotenusa:",Hipotenusa(a,b))
print("Maior:",Maior(a,b))
print("Menor:",Menor(a,b))
TestedoPrograma:
=====RESTART:/Users/pluzzardi/Documents/Funcoes.py====
Digiteumvalor(a):3<enter>
Digiteoutrovalor(b):4<enter>
Hipotenusa:5.0
Maior:4.0
Menor:3.0
>>>
ExemplousandoumafunçãoRaiz,usandoumconceitodamatemática:
47
defRaiz(x):
r=x**0.5
return(r)
defHipotenusa(a,b):
h=Raiz(a*a+b*b)
return(h)
a=float(input("Digiteumvalor(a):"))
b=float(input("Digiteoutrovalor(b):"))
print("Hipotenusa:",Hipotenusa(a,b))
TestedoPrograma:
=====RESTART:/Users/pluzzardi/Documents/Raiz.py====
Digiteumvalor(a):3<enter>
Digiteoutrovalor(b):4<enter>
Hipotenusa:5.0
FunçõesrecursivasemPython:
Umafunçãoéditarecursivaquandofazchamadaasiprópria,cadachamadaé
colocadanapilhadeexecuçãodosistemaeservepararetornaraschamadasanteriores.
#----------------------------------------------Fatorial.py
#Exemplodefunçãorecursiva,funçãoquechamaasiprópria
#Écomplexoopontodeparada
#----------------------------------------------------------
defFatorial(n):
ifn<=1:
return(1)
fat=n*Fatorial(n-1)
return(fat)
x=int(input("Digiteumvalor:"))
fat=Fatorial(x)
print("Fatorial:",fat)
TestedoPrograma:
===RESTART:/Users/pluzzardi/Documents/Fatorial.py=====
Digiteumvalor:20<enter>
Fatorial:2432902008176640000
>>>
Oprogramaaseguir,calculaovalordasériedeFibonacci:
# ...................... Fibonacci.py def Fibonacci(n): if n == 0:
48
return(0) if n == 1 or n == 2: return(1) else: return(Fibonacci(n-1) + Fibonacci(n-2)) n = int(input("Fibonacci de: ")) print("A sequência de Fibonacci é: ", sep='', end='') for i in range(n): print(Fibonacci(i), ", ", end='', sep='') TestedoPrograma:
Fibonaccide:15<enter>
AsequênciadeFibonaccié:0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,
Oprogramaaseguir,imprimenatelanúmerosemsequênciaemordem
reversarecursivamente:
# ..................... Imprime.py n = int(input("Número: ")) Imprime(n) def Imprime(n): if n == 0: return else: print(n) Imprime(n-1) TestedoPrograma:
Número:5<enter>
5
4
3
2
1
Aseguirévistoumexemploquemostraduasfunçõesquepermitem
entradadedadosdenúmerosreais(REAL)ounúmerosinteiros(INTEIRO)
viatecladosemerro,ouseja,ousuáriopodecometererrosdedigitação
queoprogramanãoéabortado.
#----------------------------------------------------------Float.py
#Oprogramatestaaconversãodestringparafloatouinteiro
#semerronaentredadedadoscominput
#-------------------------------------------------------------------
defREAL(s):
n=len(s)
temLetras=False
49
foriinrange(n):
ifs[i]==',':
s=s.replace(',','.') #trocarvírgulaporponto
ifs[i]=='-'andi!=0: #verificaosinalnegativo
temLetras=True;
breakifs[i]notin['.',',','-','0','1','2','3','4','5','6','7','8','9']:
temLetras=True
break
ifnottemLetras:
numero=float(s)
return(numero)
else:
print("ERRO:ConversãoInválida")
return(-1)
defINTEIRO(s):
n=len(s)
temLetras=False
foriinrange(n):
ifs[i]=='-'andi!=0:
temLetras=True;
break
ifs[i]notin['-','0','1','2','3','4','5','6','7','8','9']:
temLetras=True
break
ifnottemLetras:
numero=int(s)
return(numero)
else:
print("ERRO:ConversãoInválida")
return(-1)
s=input("DigiteumReal:")
numero=REAL(s)
ifnumero!=-1:
print("Realdigitadofoi:",numero)
whilenumero==-1:
s=input("DigiteumReal:")
numero=REAL(s)
print("Númerodigitado:",numero)
s=input("DigiteumInteiro:")
numero=INTEIRO(s)
ifnumero!=-1:
print("Inteirodigitadofoi:",numero)
whilenumero==-1:
s=input("DigiteumInteiro:")
numero=INTEIRO(s)
print("Númerodigitado:",numero)
TestedoPrograma:
=====RESTART:/Users/pluzzardi/Desktop/Python/Python/float.py=====
50
DigiteumReal:1234Paulo
ERRO:ConversãoInválida
DigiteumReal:123,45
Númerodigitado:123.45
DigiteumInteiro:paulo123
ERRO:ConversãoInválida
DigiteumInteiro:123
Númerodigitado:123
>>>
Python permite que o programador defina suas próprias funções, ou seja, permite que o programador defina pequenos módulos. Este processo permite “dividir para conquistar”, ou seja, dividir o programa em problemas menores. Sintaxe: def nome_módulo(lista de parâmetros): Return Existem dois tipos de passagem de parâmetros: por valor (não altera o valor dos parâmetros) ou por referência (altera o valor dos parâmetros). Exemplo de passagem por valor: # ..................... Calc.py def add(x, y): return(x+y) def sub(x, y): return(x-y) def mult(x, y): return(x*y) def div(x, y): if y == 0: return("Erro: Divisão por Zero") return(x/y) def calculadora(x, y, operador): if operador == '+': valor = add(x,y) else: if operador == '-': valor = sub(x,y) else: if operador == '*': valor = mult(x,y) else: if operador == '/': valor = div(x,y) else: return("ERRO: Operador Inválido") return(valor)
51
x = float(input("Digite um Valor: ")) y = float(input("Digite outro Valor: ")) operador = input("Operação [+ - * / **]: ") valor = calculadora(x, y, operador) print(valor) TestedoPrograma:
DigiteumValor:3
DigiteoutroValor:4
Operação[+-*/**]:/
0.75
TestedoPrograma:
DigiteumValor:3
DigiteoutroValor:0
Operação[+-*/**]:/
Erro:DivisãoporZero
TestedoPrograma:
DigiteumValor:3
DigiteoutroValor:4
Operação[+-*/**]:&
ERRO:OperadorInválido
Exemplo de passagem por referência: Passagem de parâmetros por referência, ou seja, quando os parâmetros são modificados. Note que interessante o comando return, pois ele contém duas variáveis. # ..................... Troca.py def troca(x, y): temp = x x = y y = temp return(x, y) x = 3 y = 4 print("x = ", x) print("y = ", y) x, y = troca(x, y) print("x = ", x) print("y = ", y)
TestedoPrograma:
x=3
52
y=4
a=4
b=3
22.1ExercíciossobrefunçõesemPython
a) A seguir, implemente a função Hipotenusa que recebe cateto adjacente (a) e o cateto oposto (b) e retorna o valor da hipotenusa dado pela seguinte fórmula:
Trecho do programa principal: a = float(input("a = ")) b = float(input("b = ")) h = Hipotenusa(a, b) print("Hipotenusa é: %.2f" %h)
TestedoPrograma:
a=3<enter>
b=4<enter>
Hipotenusaé:5.00
b) No exercício a seguir, implemente a função Bhaskara,
que recebe três (3) parâmetros: a, b e c e retorna as duas (2) variáveis: x1 e x2 se existirem, para que o programa funcione conforme exemplos a seguir:
x1, x2 = -b +- raiz(b2 – 4.a.c) dividido por 2 . a delta = b2 – 4.a.c Se delta >= 0: Raízes_reais Existe x1 e x2 Senão: Raizes_complexas
Trecho do programa principal: a = float(input("a = ")) b = float(input("b = "))
53
c = float(input("c = ")) x1, x2 = Bhaskara(a, b, c) if x1 != -1 and x2 != -1: print("Raizes Reais") print("x1 = ", x1) print("x2 = ", x2) else: print("Raizes Complexas")
TestedoPrograma:
a=1<enter>
b=2<enter>
c=-3<enter>
RaizesReais
x1=1.0
x2=-3.0
TestedoPrograma:
a=1<enter>
b=2<enter>
c=3<enter>
Erro:RaizesComplexas
c)Implemente a função Palavras que recebe uma string e retorna o número de palavras desta string, conforme exemplo a seguir:
Trecho do programa principal: s = input("Nome: ") n = Palavras(s) print("Seu nome tem %d palavra(s)" %n)
TestedoPrograma:
Nome:PauloRobertoGomesLuzzardi<enter>
Seunometem4palavra(s)
d)Implemente a função Verifica_Data que recebe uma string no formato “dd/mm/aaaa” e retorna o dia, mês e ano (como inteiros) contidos na string de entrada, conforme exemplo a seguir:
Trecho do programa principal: data = input("Data [dd/mm/aaaa]: ") dia, mes, ano = Verifica_Data(data) if dia != -1: print("Dia: %d" %dia) if mes != -1: print("Mês: %d" %mes) if ano != -1: print("Ano: %d" %ano)
54
TestedoPrograma:
Data[dd/mm/aaaa]:25/03/2018<enter>
Dia:25
Mês:3
Ano:2018
TestedoPrograma:
Data[dd/mm/aaaa]:25/03/18<enter>
ERRO:FormatoInválido
TestedoPrograma:
Data[dd/mm/aaaa]:32/03/18<enter>
ERRO:DiaInválido
e)Implemente a função Verifica_Quadrante que recebe dois valores inteiros: x e y e retorna o quadrante (1, 2, 3 ou 4) destas coordenadas, conforme exemplo a seguir:
Trecho do programa principal: x = int(input("x = ")) y = int(input('y = ')) n = Verifica_Quadrante(x, y) print("Quadrante: %d" %n)
TestedoPrograma:
x=2
y=-2
Quadrante:4
f)Implemente a função Final_Placa que recebe uma string no formato “xxx9999” (placa) e devolve o final da placa com dois dígitos, conforme exemplo a seguir:
Trecho do programa principal: placa = input("Placa [xxx9999]: ") final = FinalPlaca(placa) if final != -1: print("Final da Placa é: %d" %final) TestedoPrograma:
Placa[xxx9999]:etq1234<enter>
FinaldaPlacaé:34
TestedoPrograma:
Placa[xxx9999]:etq123<enter>
ERRO:FormatoInválido
55
23.CriaçãoeutilizaçãodemódulosemPython
Python permite modularizar os programas, ou seja, permite que o programador defina seus próprios módulos, desta forma ele utiliza em outros programas. Um módulo nada mais é do que um conjunto de funções. Exemplo da definição do módulo Luzzardi.py. # ................................ Módulo: Luzzardi.py def troca(x, y): temp = x x = y y = temp return(x, y)
Exemplo de um programa que utiliza o módulo Luzzardi.py e que tem a função troca. import Luzzardi x = 3 y = 4 print("x = ", x) print("y = ", y) x, y = Luzzardi.troca(x, y) print("x = ", x) print("y = ", y)
TestedoPrograma:
x=3
y=4
x=4
y=3
Exemplo da definição do módulo Luzzardi.py com mais duas funções: maior e menor. # .................... Módulo: Luzzardi.py def troca(x, y): temp = x x = y y = temp return(x, y) def maior(x, y): if x >= y: return(x) else: return(y)
56
def menor(x, y): if x <= y: return(x) else: return(y) # .................... Modulos.py import Luzzardi x = 3 y = 4 print("x = ", x) print("y = ", y) x, y = Luzzardi.troca(x, y) print("x = ", x) print("y = ", y) print("Maior: ", Luzzardi.maior(x, y)) print("Menor: ", Luzzardi.menor(x,y))
TestedoPrograma:
x=3
y=4
x=4
y=3
Maior:4
Menor:3
Exemplo da definição do módulo Luzzardi.py com mais uma função: mensagem. # .................... Módulo: Luzzardi.py def troca(x, y): temp = x x = y y = temp return(x, y) def maior(x, y): if x >= y: return(x) else: return(y) def menor(x, y): if x <= y: return(x) else: return(y) def mensagem(mensagem, valor): print(mensagem, valor)
Observação:Notequenãoénecessário“return”nofinaldafunção,otérminoda
funçãoépelaidentação.
57
# ....................... Modulos.py import Luzzardi x = 3 y = 4 Luzzardi.mensagem("x = ", x) Luzzardi.mensagem("y = ", y) x, y = Luzzardi.troca(x, y) Luzzardi.mensagem("x = ", x) Luzzardi.mensagem("y = ", y) Luzzardi.mensagem("Maior: ", Luzzardi.maior(x, y)) Luzzardi.mensagem("Menor: ", Luzzardi.menor(x, y))
TestedoPrograma:
x=3
y=4
x=4
y=3
Maior:4
Menor:3
EmPythonépossíveloprogramadorescreversuasprópriasfunções
dentrodeummóduloeinseri-loemseusprogramas.Omóduloéumarquivo
Python(modulo.py)somentecomdefiniçõesdefunções.Aprincípio,este
módulodeveestarjuntoaoprogramafonte,ouseja,namesmalocalização.
#---------------------------------------------------------Luzzardi.py
#Oprogramatestaaconversãodestringparafloatouinteiro
#semerronaentradadedadoscominput
#-------------------------------------------------------------------
defREAL(s):
n=len(s)
temLetras=False
foriinrange(n):
ifs[i]==',':
s=s.replace(',','.') #convertevírgulaemponto
ifs[i]=='-'andi!=0: #verificasinalnegativo
temLetras=True;
break
ifs[i]notin['.','-','0','1','2','3','4','5','6','7','8','9']:
#verificacaracteresnãonuméricos
temLetras=True
break
ifnottemLetras:
numero=float(s)
return(numero)
else:
print("ERRO:ConversãoInválida")
return(-1) #retornaumvalorinválido
58
defINTEIRO(s):
n=len(s)
temLetras=False
foriinrange(n):
ifs[i]=='-'andi!=0:
temLetras=True;
break
ifs[i]notin['-','0','1','2','3','4','5','6','7','8','9']:
temLetras=True
break
ifnottemLetras:
numero=int(s)
return(numero)
else:
print("ERRO:ConversãoInválida")
return(-1)
#----------------------------------------Modulo.py
importLuzzardi #inserçãodomódulodoprogramador
s=input("DigiteumReal:")
numero=luzzardi.REAL(s)
ifnumero!=-1:
print("Realdigitadofoi:",numero)
whilenumero==-1:
s=input("DigiteumReal:")
numero=luzzardi.REAL(s)
print("Númerodigitado:",numero)
s=input("DigiteumInteiro:")
numero=luzzardi.INTEIRO(s)
ifnumero!=-1:
print("Inteirodigitadofoi:",numero)
whilenumero==-1:
s=input("DigiteumInteiro:")
numero=luzzardi.INTEIRO(s)
print("Númerodigitado:",numero)
=======RESTART:/Users/pluzzardi/Desktop/Python/Python/Modulo.py===
DigiteumReal:1234Paulo
ERRO:ConversãoInválida
DigiteumReal:123,45
Númerodigitado:123.45
DigiteumInteiro:123Paulo
ERRO:ConversãoInválida
DigiteumInteiro:123
Númerodigitado:123
>>>
24.Tratamentodeerros(exceções)
59
Na execução de um programa em Python, podem ocorrer erros não previstos que podem interromper a execução normal do programa. Tais erros podem ser:
• Conversão numérica inválida; • Limite de um vetor (acessar um índice inválido) • Problemas em arquivos: abertura, criação ou caminho
(path); • Overflow; • Erro de entrada e saída (input/output); • Divisão por zero.
Python pode assumir o controle da execução em caso que
ocorra uma situação de erro não prevista. Isso é feito através do mecanismo de tratamento de
exceções que ao detectar uma situação de erro, o programa em Python gera uma exceção.
Se o programa que estiver sendo executado possuir um
tratamento de exceções (try: ... except ...:), ele assume o controle da execução. Mas se a exceção não tiver um tratamento associado, o programa é interrompido e é exibida uma mensagem de erro e o programa é abortado.
Uma exceção é um evento que indica uma condição anormal
que interrompe a execução normal de um programa. O tratamento de erros no Python cria objetos da classe
error, o tratamento destes erros é feita pela manipulação destes objetos. Analise o exemplo abaixo, aonde são testados a conversão de string para inteiro (comando input) e raiz quadrada de número negativo (math.sqrt()). Tipo de Exceção: ValueError #--------------------------ValueError.py
importmath
try:
num=int(input("DigiteumNúmero:"))
try:
raiz=math.sqrt(num)
print("RaizQuadrada:",raiz)
exceptValueErroraserror:
print("Erro:",error)
exceptValueErroraserror:
print("Erro:",error)
TestedoPrograma:
60
========== RESTART: /Users/pluzzardi/Documents/ValueError.py ======= Digite um Número: paulo Erro: invalid literal for int() with base 10: 'paulo' >>> ========= RESTART: /Users/pluzzardi/Documents/ValueError.py ======== Digite um Número: -16 Erro: math domain error >>> ======= RESTART: /Users/pluzzardi/Documents/ValueError.py ========= Digite um Número: 16 Raiz Quadrada: 4.0 >>>
O tratamento de erros em Python baseia-se no comando try. A sintaxe é a seguinte:
try: comando comando except erro: comando comando
A execução de um bloco de código, protegido por um tratamento de erros, é feito colocando o bloco no try, e para cada erro que se deseja tratar, deve-se colocar uma cláusula except tipo_de_erro as variável_erro:
Exceções são instâncias de classes geradas quando
houver erro. Estas exceções podem ser captadas e tratadas para que não ocorra erros em tempo de execução. Tipo de Exceção: ZeroDivisionError # ------------------------------- Zero.py try: x = float(input("Digite um Valor: ")) y = float(input("Digite outro Valor: ")) try: divisão = x / y print("Divisão é: ", divisão) except ZeroDivisionError as error: print("Erro: ", error) except ValueError as error: print('Erro: ', error) TestedoPrograma:
======= RESTART: /Users/pluzzardi/Desktop/Python/Python/Zero.py ====== Digite um Valor: paulo Erro: could not convert string to float: 'paulo' >>> ======= RESTART: /Users/pluzzardi/Desktop/Python/Python/Zero.py ===== Digite um Valor: 4 Digite outro Valor: 0
61
Erro: float division by zero >>>
Tipo de Exceção: NameError e TypeError # ------------------------------------ NameError.py try: num = int(input("Valor: ")) print("Soma: ", soma + num) # soma não está definido except NameError as error: # erro por nome print("ERRO: ", error) try: a = 5 soma = 'a' + a # tipos diferentes print("Soma: ", soma) except TypeError as error: # erro por tipo print("ERRO: ", error) TestedoPrograma:
==========RESTART:/Users/pluzzardi/Documents/NameError.py========
Valor:5
ERRO:name'soma'isnotdefined
ERRO:mustbestr,notint
>>>
Tipo de Exceção: IndexError # ------------------------- LimiteVetor.py x = [10, 20, 30, 40, 50] n = 5 try: i = 1 while i <= n: # erro i <= n, pois o vetor começa em ZERO print(x[i]) i = i + 1 except IndexError as error: print("Erro: ", error) TestedoPrograma: ========= RESTART: /Users/pluzzardi/Documents/LimiteVetor.py ======== 20 30 40 50 Erro: list index out of range >>>
Tipo de Exceção: IOError (Arquivos) # ---------------------------------------- FileCria.py nomeArquivo = input("Nome do Arquivo: ") try:
62
file = open(nomeArquivo, 'r') except IOError as error: print("Erro: ", error) else: print("Nome do Arquivo: ", nomeArquivo) file.close() TestedoPrograma: ========== RESTART: /Users/pluzzardi/Documents/FileCria.py ======== Nome do Arquivo: Agenda.bd Nome do Arquivo: Agenda.bd >>> ========== RESTART: /Users/pluzzardi/Documents/FileCria.py ========== Nome do Arquivo: test.bd Erro: [Errno 2] No such file or directory: 'test.bd' >>>
25.BancodeDadosemPython(SQLite)
A seguir são dados alguns exemplos de programas com Banco de Dados (BD) em Python (SQLiteCriaBD, SQLiteLeBD, SQLiteConsultaBD, SQLiteRemoveBD e SQLiteAppendBD). É criado um banco de dados de uma agenda contendo id (identificador), nome e fone utilizando o módulo SQLite3. SQLiteCriaBD: Cria um banco de dados. SQLiteLeBD: Faz a leitura dos registros do BD criado. SQLiteConsultaBD: Consulta um registro através do id. SQLiteRemoveBD: Remove um registro através do id. SQLiteAppendBD: Anexa novos registros ao final do BD. O programa a seguir cria um BD (Agenda.bd) com uma tabela “agenda” com os seguintes campos: id, nome e fone. #------------------------SQLiteCriaBD.py
importsqlite3
nomeBD=input("NomedoBancodeDados:")
conector=sqlite3.connect(nomeBD)
cursor=conector.cursor()
cursor.execute('''
createtableagenda(
idinteger, #identificador
nometext,
fonetext)
''')
id=1
nome="Pessoa"
whilenome!="":
print("id:",id)
nome=input("Nome:")
ifnome!="":
fone=input("Fone:")
63
cursor.execute('''
insertintoagenda(id,nome,fone)
values(?,?,?)
''',(id,nome,fone))
conector.commit()
id=id+1
cursor.close()
conector.close()
print("BancodeDadosfoiCRIADO:",nomeBD)
TestedoPrograma:
======RESTART:/Users/pluzzardi/Desktop/Python/SQLiteCriaBD.py=====
NomedoBancodeDados:Agenda.bd
id:1
Nome:PauloRoberto
Fone:99164-8037
id:2
Nome:AdrianeMaria
Fone:99145-6789
id:3
Nome:PaolaMaria
Fone:98478-7856
id:4
Nome:
BancodeDadosfoiCRIADO:Agenda.bd
>>>
O programa a seguir faz uma leitura dos campos do banco de dados (Agenda.bd) gerado pelo programa anterior.
#--------------------------SQLiteLeBD.py
importsqlite3#aslite
importos
nomeBD=input("NomedoBancodeDados:")
try: #tratamentodeexceção
conector=sqlite3.connect(nomeBD)
cursor=conector.cursor()
numRegistros=0
cursor.execute("SELECT*FROMagenda")
result=cursor.fetchall()
forcontatoinresult:
print("id:%d\nNome:%s\nFone:%s"%(contato))
numRegistros+=1
print(numRegistros,"registro(s)")
cursor.close()
conector.close()
exceptsqlite3.Erroraserror: #executaquandoocorreumerro
print("Erro:BDnãoencontrado")
print("Erro:",error)
os.remove(nomeBD)#removearquivocriado
64
TestedoPrograma:
======RESTART:/Users/pluzzardi/Desktop/Python/SQLiteLeBD.py=======
NomedoBancodeDados:Luzzardi.bd
id:1
Nome:PauloRoberto
Fone:99164-8037
id:2
Nome:AdrianeMaria
Fone:99156-4567
id:3
Nome:PaolaMaria
Fone:98434-1234
3registro(s)
>>>
O programa a seguir faz uma consulta dos campos do banco de dados (Agenda.bd) gerados pelo programa anterior através da leitura via teclado do identificador (id).
#------------------------SQLiteConsultaBD.py
importsqlite3,os
nomeBD=input("NomedoBancodeDados:")
try:
conector=sqlite3.connect(nomeBD)
id='1'
cursor=conector.cursor()
whileid!='0':
id=input('Digiteoíndice[0-Sair]:')
ifid!='0':
cursor.execute("SELECT*FROMagendaWHEREid=?",(id))
result=cursor.fetchall()
achei=False
forcontatoinresult:
print("id:%d\nNome:%s\nFone:%s"%(contato))
achei=True
ifnotachei:
print("Erro:ContatonãoEncontrado")
cursor.close()
conector.close()
exceptsqlite3.Erroraserror:
print("ERRO:BDnãoencontrado")
print("Erro:",error)
os.remove(nomeBD) #removearquivocriado
TestedoPrograma:
===RESTART:/Users/pluzzardi/Desktop/Python/SQLiteConsultaBD.py====
NomedoBancodeDados:Agenda.bd
65
Digiteoíndice[0-Sair]:1
id:1
Nome:PauloRoberto
Fone:99164-8037
Digiteoíndice[0-Sair]:2
id:2
Nome:AdrianeMaria
Fone:99156-4567
Digiteoíndice[0-Sair]:3
id:3
Nome:PaolaMaria
Fone:98434-1234
Digiteoíndice[0-Sair]:0
>>>
O programa a seguir permite remover os campos do banco de dados (Agenda.bd) gerados pelo programa anterior através da leitura via teclado do identificador (id).
#------------------------SQLiteRemoveBD.py
importsqlite3,os
nomeBD=input("NomedoBancodeDados:")
try:
conector=sqlite3.connect(nomeBD)
cursor=conector.cursor()
id='1'
whileid!='0':
id=input("Digiteoíndice[0-Sair]:")
ifid!='0':
cursor.execute("DELETEFROMagendaWHEREid=?",(id))
conector.commit()
print("Okay,ContatoREMOVIDO")
cursor.close()
conector.close()
exceptsqlite3.Erroraserror:
print("Erro:BDnãoencontrado")
print("Erro:",error)
os.remove(nomeBD)
TestedoPrograma:
=====RESTART:/Users/pluzzardi/Desktop/Python/SQLiteRemoveBD.py====
NomedoBancodeDados:Agenda.bd
Digiteoíndice:3
Digiteoíndice:0
Okay,ContatoREMOVIDO
>>>
=======RESTART:/Users/pluzzardi/Desktop/Python/SQLiteLeBD.py=====
NomedoBancodeDados:Agenda.bd
id:1
Nome:PauloRoberto
66
Fone:99164-8037
id:2
Nome:AdrianeMaria
Fone:99156-4567
>>>
#------------------------SQLiteAppendBD.py
importsqlite3,os
nomeBD=input("NomedoBancodeDados:")
try:
conector=sqlite3.connect(nomeBD)
cursor=conector.cursor()
id=1
cursor.execute("SELECT*FROMagenda")
result=cursor.fetchall()
forcontatoinresult:
id+=1
nome="Pessoa"
whilenome!="":
print("id:",id)
nome=input("Nome:")
ifnome!="":
fone=input("Fone:")
cursor.execute('''
INSERTINTOagenda(id,nome,fone)
values(?,?,?)
''',(id,nome,fone))
conector.commit()
id=id+1
cursor.close()
conector.close()
exceptsqlite3.Erroraserror:
print("Erro:BDnãoencontrado")
print("Erro:",error)
os.remove(nomeBD)
TestedoPrograma:
====RESTART:/Users/pluzzardi/Desktop/Python/SQLiteAppendBD.py=====
NomedoBancodeDados:Agenda.bd
id:4
Nome:RenatoLuis
Fone:99134-2345
id:5
Nome:Cacaio
Fone:99891-3456
id:6
Nome:
>>>
67
ExecuçãodoprogramaSQLiteLeBD.py
=======RESTART:/Users/pluzzardi/Desktop/Python/SQLiteLeBD.py=====
NomedoBancodeDados:Agenda.bd
id:1
Nome:PauloRoberto
Fone:99164-8037
id:2
Nome:AdrianeMaria
Fone:99156-4567
id:3
Nome:PaolaMaria
Fone:98434-1234
id:4
Nome:RenatoLuis
Fone:99134-2345
id:5
Nome:Cacaio
Fone:99891-3456
5registro(s)
>>>
26.SistemadeArquivosemPython Python permite operar com arquivos binários e texto através de algumas funções, tais como: open, write, read, close, etc.
Um arquivo texto é formado de linhas de caracteres terminados com um ‘\n’. Conforme exemplo abaixo: Dados.txt. Sintaxe do comando open: file = open(nomeArquivo, modo) Modo: ‘r’ read (leitura) ‘w’ write (escrita) ‘a’ append (anexar no fim) ‘r+’ read e write (leitura e escrita) ‘b’ binary (binário) Comandos para operar arquivos: read(): Permite ler o conteúdo do arquivo. readline(): Permite ler uma única linha do arquivo. seek(colunas, posição): Posiciona o arquivo no ponto do arquivo: Posição 0 é o início do arquivo, 1 é a posição do arquivo atual e 2 é o final do arquivo. write(string): Grava o conteúdo da string para o arquivo, retornando o número de caracteres escritos. close(): Fecha o arquivo aberto. Arquivo texto: Dados.txt
68
1;Paulo Roberto;99164-8037; 2;Adriane Maria;99156-2345; 3;Paola Freitas;98678-1234; # -------------------------------------- FileLeTexto.py nomeFile = input("Nome do Arquivo: ") try: file = open(nomeFile, "r") for linha in file: campos = linha.split(';') print(campos) file.close() except IOError as error: print("ERRO: ", error)
TestedoPrograma:
======== RESTART: /Users/pluzzardi/Documents/FileLeTexto.py ====== Nome do Arquivo: Dados.txt ['1', 'Paulo Roberto', '99164-8037', '\n'] ['2', 'Adriane Maria', '99156-2345', '\n'] ['3', 'Paola Freitas', '98678-1234', '\n'] >>> # ------------------------------- FileLeDadosTexto.py nomeFile = input("Nome do Arquivo: ") try: file = open(nomeFile, "r") for linha in file: campos = linha.split(';') print("id: ", campos[0]) print("Nome: ", campos[1]) print("Fone: ", campos[2]) file.close() except IOError as error: print("ERRO: ", error)
TestedoPrograma:
====== RESTART: /Users/pluzzardi/Documents/FileLeDadosTexto.py ===== Nome do Arquivo: Dados.txt id: 1 Nome: Paulo Roberto Fone: 99164-8037 id: 2 Nome: Adriane Maria Fone: 99156-2345 id: 3 Nome: Paola Freitas Fone: 98678-1234 >>>
TestedoPrograma:(Arquivotextonãoexiste)
====== RESTART: /Users/pluzzardi/Documents/FileLeDadosTexto.py ==== Nome do Arquivo: Dados.bd ERRO: [Errno 2] No such file or directory: 'Dados.bd' >>>
69
# -------------------------------------- FileAnexaTexto.py nomeFile = input("Nome do Arquivo: ") try: file = open(nomeFile, 'r') id = 1 for linha in file: id = id + 1 # contar o número de registros file.close() file = open(nomeFile,'a') # anexando no fim do arquivo nome = "Pessoa" while nome != "": print("id: ", id) nome = input("Nome: ") if nome != "": fone = input("Fone: ") linha = str(id) + ";" + nome + ";" + fone + ";" + "\n" file.write(linha) id = id + 1 file.close() except IOError as error: print("ERRO: ", error)
TestedoPrograma:
======== RESTART: /Users/pluzzardi/Documents/FileAnexaTexto.py ====== Nome do Arquivo: Dados.txt id: 3 Nome: Renato Luis Fone: 98778-3456 Gravou dados id: 4 Nome: Francisco Carlos Fone: 98178-5678 Gravou dados id: 5 Nome: >>>
ListagemdoArquivoalterado:Dados.txt
['1', 'Paulo Roberto', '99164-8037', '\n'] ['2', 'Adriane Maria', '99156-2345', '\n'] ['3', 'Paola Freitas', '98678-1234', '\n'] [‘4’;’Renato Luis’;’98778-3456’;’\n’] [‘5’;’Francisco Carlos’;’98178-5678’;’\n’] # ------------------------------- FileCriaTexto.py nomeFile = input("Nome do Arquivo: ") try: file = open(nomeFile, 'w') # cria novo arquivo texto id = 1 # cuidado, apaga se existir nome = "Pessoa" while nome != "": print("id: ", id) nome = input("Nome: ") if nome != "":
70
fone = input("Fone: ") linha = str(id) + ";" + nome + ";" + fone + ";" + "\n" file.write(linha) id = id + 1 file.close() except IOError as error: print("ERRO: ", error)
TestedoPrograma:
======= RESTART: /Users/pluzzardi/Documents/FileCriaTexto.py ====== Nome do Arquivo: Luz.txt id: 1 Nome: Paulo Roberto Fone: 99164-8037 id: 2 Nome: Renato Luis Fone: 98778-3456 id: 3 Nome: Francisco Carlos Fone: 98178-5678 id: 4 Nome: >>>
ListagemdoArquivo:Luz.txt
1;Paulo Roberto;99164-8037; 2;Renato Luis; 98778-3456; 3;Francisco Carlos; 98178-5678; # ------------------------------- FileProcuraDadosTexto.py nomeFile = input("Nome do Arquivo: ") try: file = open(nomeFile, "r") posicao = 1 while posicao != 0: posicao = int(input("Posição [0 - Sair]: ")) file.seek(0, 0) # reinicializa o cursor do arquivo no início imprimiu = False for linha in file: campos = linha.split(';') if campos[0] == str(posicao): imprimiu = True print("id: ", campos[0]) print("Nome: ", campos[1]) print("Fone: ", campos[2]) if not imprimiu: print("Erro: Registro não encontrado") file.close() except IOError as error: print("ERRO: ", error)
TestedoPrograma:
RESTART: /Users/pluzzardi/Desktop/Python/Python/File/FileProcuraDadosTexto.py Nome do Arquivo: Dados.txt Posição [0 - Sair]: 1
71
id: 1 Nome: Paulo Roberto Fone: 99164-8037 Posição [0 - Sair]: 2 id: 2 Nome: Adriane Maria Fone: 99156-2345 Posição [0 - Sair]: 3 id: 3 Nome: Paola Freitas Fone: 98678-1234 Posição [0 - Sair]: 4 id: 4 Nome: Renato Luis Fone: 98778-3456 Posição [0 - Sair]: 5 id: 5 Nome: Francisco Carlos Fone: 98178-5678 Posição [0 - Sair]: 6 Erro: Registro não encontrado Posição [0 - Sair]: 7 Erro: Registro não encontrado Posição [0 - Sair]: 8 Erro: Registro não encontrado Posição [0 - Sair]: 9 Erro: Registro não encontrado Posição [0 - Sair]: 0 Erro: Registro não encontrado >>> # ------------------------------------ FileBuscaDadosTexto.py nomeFile = input("Nome do Arquivo: ") try: file = open(nomeFile, "r") nome = "Pessoa" while nome != "": nome = input("Nome: ") file.seek(0, 0) imprimiu = False for linha in file: campos = linha.split(';') if nome == campos[1]: imprimiu = True print("id: ", campos[0]) print("Nome: ", campos[1]) print("Fone: ", campos[2]) if not imprimiu: print("Erro: Nome não encontrado") file.close() except IOError as error: print("ERRO: ", error)
TestedoPrograma:
RESTART: /Users/pluzzardi/Desktop/Python/Python/File/FileBuscaDadosTexto.py Nome do Arquivo: Dados.txt Nome: Paulo Erro: Nome não encontrado
72
Nome: Paulo Roberto id: 1 Nome: Paulo Roberto Fone: 99164-8037 Nome: Renato Luis id: 4 Nome: Renato Luis Fone: 98778-3456 Nome: Erro: Nome não encontrado >>>
29.ArquivosBináriosemPython
Como foi visto no capítulo 26, Python permite operar com arquivos binários e textos através de algumas funções, tais como: open, write, read, close, etc.
Enquanto um arquivo texto é formado de linhas de caracteres terminados com um ‘\n’, um arquivo binário possui campos de vários tipos, tais como: inteiro, real, string, etc.
pickle é um módulo do Python que permite a serialização de objetos, ou seja, transforma objetos em sequências de bytes. Outros módulos similares podem ser utilizados, tais como: Marshal, Struct (como na linguagem C), JSON e Shelve. Exemplo de um programa em Python que grava em um arquivo binário: teste.bin os seguintes campos: nome (string), telefone (string) e idade (inteiro). # ........................ GravaBin.py import pickle nomeArquivo = input("Nome do Arquivo Binário: ") try: file = open(nomeArquivo, "rb") file.close() ch = input("Atenção: Arquivo já existe, sobre-escrever [s/n]") if ch == "S" or ch == "s": try: file = open(nomeArquivo, "wb") except IOError as error: print("Erro: Impossível criar o arquivo: %s" %nomeArquivo) n = int(input("Número de Elementos: ")) pickle.dump(n, file) for i in range(n): nome = input("Nome: ") pickle.dump(nome, file) telefone = input("Telefone: ") pickle.dump(telefone, file) idade = int(input("Idade: ")) pickle.dump(idade, file) file.close() except IOError as error:
73
print("Atenção: Arquivo não existe") try: file = open(nomeArquivo, "wb") except IOError as error: print("Erro: Impossível criar o arquivo: %s" %nomeArquivo) n = int(input("Número de Elementos: ")) pickle.dump(n, file) for i in range(n): nome = input("Nome: ") pickle.dump(nome, file) telefone = input("Telefone: ") pickle.dump(telefone, file) idade = int(input("Idade: ")) pickle.dump(idade, file) file.close()
Observação:Notequeonúmerodeelementostambémésalvonoarquivobinário,para
depoisserlidonoprogramaquecarregaoarquivobinário.
TestedoPrograma:
NomedoArquivoBinário:teste.bin<enter>
NúmerodeElementos:3<enter>
Nome:PauloRoberto<enter>
Telefone:99164-8037<enter>
Idade:56<enter>
Nome:AdrianeMaria<enter>
Telefone:99156-3334<enter>
Idade:48<enter>
Nome:PaolaFreitas<enter>
Telefone:99167-4567<enter>
Idade:19<enter>
# ........................ LeBin.py import pickle nomeArquivo = input("Nome do Arquivo Binário: ") try: file = open(nomeArquivo, "rb") n = pickle.load(file) print("Número de Elementos: ", n) for i in range(n): nome = pickle.load(file) print("Nome: ", nome) telefone = pickle.load(file) print("Telefone: ", telefone) idade = pickle.load(file) print("Idade: ", idade) file.close() except IOError as error: print('Atenção: Arquivo não Existe', nomeArquivo) print(error)
TestedoPrograma:
NomedoArquivoBinário:teste.bin<enter>
74
NúmerodeElementos:3<enter>
Nome:PauloRoberto<enter>
Telefone:99164-8037<enter>
Idade:56<enter>
Nome:AdrianeMaria<enter>
Telefone:99156-3334<enter>
Idade:48<enter>
Nome:PaolaFreitas<enter>
Telefone:99167-4567<enter>
Idade:19<enter>
Exemplo de um programa em Python que grava em um arquivo binário: dados.bin uma lista (vetor) contendo os seguintes campos: nome (string), telefone (string) e idade (inteiro). # ........................... GravaBinario import pickle nomeArquivo = input("Nome do Arquivo Binário: ") lista = ["Paulo Roberto", "99164-8037", 56, "Adriane Maria", "99156-3334", 48, "Paola Freitas", "99181-3456", 19] n = len(lista) print("n = ", n) try: file = open(nomeArquivo, "wb") except IOError as error: print("Atenção: Impossível criar o arquivo") pickle.dump(lista, file) file.close() print("Okay, Arquivo %s criado" %nomeArquivo)
TestedoPrograma:
NomedoArquivoBinário:dados.bin<enter>
n=9
Okay,Arquivodados.bincriado
# ............................. LeBinario import pickle lista = [] nomeArquivo = input("Nome do Arquivo Binário: ") try: file = open(nomeArquivo, "rb") except IOError as errror: print("Atenção: Arquivo Inexistente") lista = pickle.load(file) print("Lista: ", lista) file.close()
TestedoPrograma:
NomedoArquivoBinário:dados.bin
75
Lista:['PauloRoberto','99164-8037',56,'AdrianeMaria','99156-3334',48,'Paola
Freitas','99181-3456',19]
ArquivoTexto:Frutas.txt
Abacate
Ameixa
Banana
Bergamota
Anana
Morango
Caqui
Uva
Laranja
Lima
Goiaba
Damasco
Tangerina
# ........................... Letexto.py nomeArquivo = input("Nome do Arquivo Texto: ") linha = [] try: file = open(nomeArquivo, "r") for linha in file: linha = file.read() print(linha) file.close() except IOError as error: print("Atenção: Arquivo Inexistente")
TestedoPrograma:
NomedoArquivoTexto:Frutas.txt<enter>
Abacate
Ameixa
Banana
Bergamota
Anana
Morango
Caqui
Uva
Laranja
Lima
Goiaba
Damasco
Tangerina
# .............................. ConverteTextoBinario.py import pickle nomeArquivoTexto = input("Nome do Arquivo Texto: ") nomeArquivoBinario = input("Nome do Arquivo Binário: ")
76
try: fileTexto = open(nomeArquivoTexto, "r") try: fileBinario = open(nomeArquivoBinario, "wb") # cuidado: apaga arquivo se já existir except IOError as error: print("Atenção Impossível CRIAR Arquivo Binário") for linha in fileTexto: linha = fileTexto.read() pickle.dump(linha, fileBinario) print(linha) fileTexto.close() fileBinario.close() except IOError as error: print("Atenção: Arquivo texto inexistente")
TestedoPrograma:
NomedoArquivoTexto:Frutas.txt<enter>
NomedoArquivoBinário:Frutas.bin<enter>
Abacate
Ameixa
Banana
Bergamota
Anana
Morango
Caqui
Uva
Laranja
Lima
Goiaba
Damasco
Tangerina
# ........................ LeTextoConvertidoBinario.py import pickle nomeArquivo = input("Nome do Arquivo Binário: ") try: file = open(nomeArquivo, "rb") try: while True: linha = pickle.load(file)
77
print(linha) file.close() except EOFError as error: print("Atenção: Final do Arquivo") except IOError as error: print('Atenção: Arquivo não Existe', nomeArquivo) print(error)
TestedoPrograma:
NomedoArquivoBinário:Frutas.bin<enter>
Abacate
Banana
Anana
Caqui
Laranja
Goiaba
Tangerina
Atenção:FinaldoArquivo
Atenção:Funçãoqueverificaseumarquivojáexiste:
def ArquivoExiste(nomeArquivo):
try:
file = open(nomeArquivo, "r")
except IOError: # se não precisar da variável error não precisa
return False # definir
file.close()
return True
# .............................. GravaDados.py import pickle def ArquivoExiste(nomeArquivo): try: file = open(nomeArquivo, "r") except IOError: return False file.close() return True nomeArquivo = input("Nome Arquivo Binário: ") if not(ArquivoExiste(nomeArquivo)): try:
78
file = open(nomeArquivo, "wb") ch = "S" while ch == "S" or ch == "s": nome = input("Nome: ") pickle.dump(nome, file) idade = int(input("Idade: ")) pickle.dump(idade, file) ch = input("Continua [s/n]? ") file.close() except IOError as error: print("Atenção: Impossível CRIAR o Arquivo")
TestedoPrograma:
NomeArquivoBinário:Dados.bin<enter>
Nome:PauloRoberto
Idade:56
Continua[s/n]?s
Nome:AdrianeMaria
Idade:48
Continua[s/n]?s
Nome:PaolaFreitas
Idade:19
Continua[s/n]?s
Nome:JuliaHelena
Idade:58
Continua[s/n]?s
Nome:AnaMaria
Idade:59
Continua[s/n]?n
30.SocketsemPython
Socket é um mecanismo para comunicação de programas em dois sentidos que funcionam em uma rede computadores.
O cliente solicita que uma conexão seja estabelecida com o servidor através de um Socket.
Quando o servidor aceita o pedido de conexão, ele cria
um novo socket por uma porta diferente. No cliente, outro socket é criado e então é utilizado para a comunicação com este servidor.
Programas que utilizam sockets trabalham sempre em
formato cliente-servidor, e para isto é necessário criar um programa servidor, que “escutará” as conexões em uma porta, e o programa cliente, que faz a conexão com algum socket disponível em alguma porta.
Os principais comandos para uso de sockets em Python
são os seguintes:
79
accept( ): aceita uma nova conexão e retorna os valores: o novo objeto socket e o endereço que o socket está se comunicando. bind((hostname,port)): conecta o socket ao endereço da porta. close(): fecha o socket. connect((hostname,port)): conecta-se com outro socket, que pode ser externo ou local. Para conexões locais utiliza-se localhost ou 127.0.0.1 getpeername(): retorna o endereço IP e a porta na qual o socket está conectado. getsocketname(): retorna o endereço IP da porta do próprio socket. listen(max_connections): inicia ouvindo a porta e fica esperando outras conexões. O sistema operacional recusa novas conexões quando ela atingir o valor máximo de conexões. send(string): Envia uma string de dados pelo socket.
Para a criação de programas que utilizem sockets no lado do servidor é necessário principalmente o uso dos seguintes comandos: serverSocket=socket.socket(socket.AF_INET,socket.SOCK_STREAM): para definir o protocolo a ser utilizado. serverSocket.bind((host,porta)): iniciando a escuta de conexões no lado do servidor. serverSocket.listen(1): realiza o controle de conexões simultâneas que o servidor suportará. serverSocket.send(dados): para enviar dados. serverSocket.recv(1024): para receber dados controlando o tamanho do buffer.
Para a criação de programas que utilizem sockets no
lado do cliente é necessário principalmente o uso dos seguintes comandos:
clientSocket.socket(socket.AF_INET,socket.SOCK_STREAM): para definir o protocolo a ser utilizado.
80
clientSocket.connect((servidor,porta)): para criar o objeto de conexão que irá conectar em um servidor. clientSocket.send(dados) : para enviar dados. clientSocket.recv(1024): para receber dados controlando o tamanho do buffer. Exemplo da criação de uma conexão do lado do Cliente: # ...................... Cliente.py import socket # define host e porta HOST = "127.0.0.1" PORTA = 5000 # define o protocolo cliente = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # tenta conectar ao servidor cliente.connect((HOST, PORTA)) # envia mensagem cliente.send("Olá!! Boa Noite!".encode("utf-8")) print("Mensagem Enviada") # fecha a conexão cliente.close() Exemplo da “escuta” de uma conexão do lado do Servidor: # ..................... Servidor.py import socket # define host e porta HOST = "127.0.0.1" PORTA = 5000 # define protocolo servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM) print("Na escuta ...") # inicia a escuta do lado servidor servidor.bind((HOST, PORTA)) # define o número máximo de conexões na fila servidor.listen(1) # para aceitar novas conexões conexao, endereco = servidor.accept()
81
# recebe os dados enviados pelo cliente dados = conexao.recv(1024) # exibe os dados recebidos print("Dados Recebidos: ", dados.decode("utf-8")) print("Conectado por: ", endereco) # fecha a conexão conexao.close() Observação: Tem que se executar os dois programas ao mesmo tempo, isto pode ser feito via abertura de dois terminais, pois um programa “conversa” com o outro. Teste do Programa:
83
31.ThreadsemPython
Forma de um processo dividir-se em duas ou mais tarefas que podem ser executadas concorrentemente, ou seja, pode ser visto como um fluxo de controle sequencial isolado dentro do programa.
Uma thread tem começo, fim e uma sequência de comandos. Uma thread em Python não é um programa, pois não executa sozinha, ela executa dentro de um programa.
Threads permitem que um programa simples possa executar várias tarefas diferentes ao mesmo tempo, independentemente uma das outras. Programas multithreaded são programas que contém várias threads, executando tarefas distintas simultaneamente.
32.MódulotkinterparaGUIemPython
Existe um módulo não-nativo no Python que permite desenvolver interfaces gráficas (GUI - Graphics User Interface).
Este módulo se chama “tkinter” (tk interface ou toolkit interface). Onde tk vem de toolkit, ou seja, um conjunto de ferramentas gráficas.
Ele é baseado em tcl/tk. Tcl é Tool Command Language
(Linguagem de Comandos de Ferramentas), ou seja, uma linguagem de programação para scripts. Link para vídeo aulas sobre o módulo “tkinter”:
https://www.youtube.com/watch?v=vmoH9I9d570&list=PLesCEcYj003ShHnUT83gQEH6KtG8uysUE&index=2
Elementos de interface (widgets) correspondem a objetos de diversas classes. São alguns exemplos de widgets:
• Frame (área retangular) • Button (botão) • Label (rótulo) • Text (caixa de texto) • Canvas (caixa de desenho)
84
Exemplo de como criar uma janela gráfica na aplicação utilizando o módulo tkinter:
# ........................ Tk_1.py import tkinter as tk # renomear um módulo janela = tk.Tk() janela.mainloop()
No programa acima é necessário importar o módulo “tkinter”. A chamada janela = tk.Tk() cria e exibe uma janela gráfica na aplicação. A instrução janela.mainloop() faz com que a janela fique ativa, até que o usuário resolva fechar a janela no “x” (entrar em modo de tratamento de eventos).
Resultado do programa:
No programa abaixo é possível colocar o nome na janela, neste caso: “Calculadora”, através da instrução janela.title(“Calculadora”).# .............................. Tk_2.py import tkinter as tk janela = tk.Tk() janela.title("Calculadora") janela.mainloop()
Resultado do programa:
85
No programa abaixo é possível trocar a cor do background (fundo) através da instrução janela[“bg”] = “blue) ou janela[“background”] = “blue”. # .......................... Tk_3.py import tkinter as tk janela = tk.Tk() janela.title("Chat") janela["bg"] = "blue" # bg é background janela.mainloop()
Resultado do programa:
86
No programa abaixo é possível especificar o tamanho e a posição da janela gráfica, isto é feito através da instrução janela.geometry(“LxA+E+T”), onde “L” é a largura, “A” é a altura, “E” é a distância da origem até a esquerda da janela e “T” é a distância da origem até o topo da janela. Alias a origem é na esquerda x topo da janela.
# .............................. Tk_4.py import tkinter as tk janela = tk.Tk() janela.title("Chat") janela["background"] = "blue" # bg ou background janela.geometry("300x300+200+100") #LarguraxAltura+distânciaEsquerda+distância_Topo, alguns são opcionais janela.mainloop()
Resultado do programa:
87
No programa abaixo é possível inserir texto na janela gráfica, isto é feito através das instruções lb = Label(janela, text=mensagem[i]) e lb.place(x=10, y=yc).
Label é um objeto tipo rótulo. Place é responsável pela posição de onde a mensagem vai ser colocada, ou seja, posição “x” e “y” em relação a origem (0,0) [left, top]. # ............................ Tk_5.py from tkinter import * janela = Tk() janela.title("Chat") xMax = 300 yMax = 300 left = 100 top = 200 s = str(xMax) + "x" + str(yMax) + "+" + str(left) + "+" + str(top) janela.geometry(s) mensagem = ["Olá, tudo bem", "Quando vais vir?", "Não demora", "Abraços"] n = len(mensagem) yc = 10 for i in range(n): lb = Label(janela, text=mensagem[i]) lb.place(x=10, y=yc) yc = yc + 20 janela.mainloop()
Resultado do programa:
88
No programa abaixo é possível inserir um botão na janela gráfica, isto é feito através das instruções botao = tk.Button(janela, text=" Aperte ", command= Mensagem) [insere o botão na janela da aplicação] e botao.pack() [exibe o botão].
# ........................... Tk_6.py import tkinter as tk def Mensagem(): print("Olá, tudo bem?") janela = tk.Tk() janela.title("Tkinter") janela.geometry("300x300+200+100") botao = tk.Button(janela, text=" Aperte ", command=Mensagem) botao.pack() janela.mainloop()
Resultado do programa:
Note que quando o botão foi pressionado, foi impressa a mensagem “Olá, tudo bem” na tela em modo texto (ou terminal).
89
O programa a seguir contém um botão (chamado “aperte”) que quando pressionado imprime a mensagem “Olá, tudo bem?” na janela gráfica. # ........................... Tk_7.py import tkinter as tk from tkinter import * def Mensagem(): mensagem = "Olá, tudo bem?" lb = Label(janela, text=mensagem) lb.place(x=100, y=200) janela = tk.Tk() janela.title("Tkinter") janela.geometry("300x300+200+100") botao = tk.Button(janela, text=" Aperte ", command=Mensagem) botao.pack() janela.mainloop()
O programa a seguir contém uma caixa de diálogo que permite a entrada de dados reais e exibe um somador (acumulador).
90
# ........................ Tk_8.py import tkinter as tk from tkinter import * def Soma(x): somador.set(somador.get() + valor.get()) def Mensagem(): mensagem = "Digite um valor e pressione <Enter>" lb = Label(janela, text=mensagem) lb.place(x=25, y=200) janela = tk.Tk() janela.title("Acumulador") janela["background"] = "lightblue" janela.geometry("300x300+200+100") Mensagem() somador = DoubleVar(janela) valor = DoubleVar(janela) lSomador = Label(textvar=somador) eValor = Entry(textvar=valor) eValor.bind("<Return>", Soma) lSomador.pack() eValor.pack() janela.mainloop()
91
No programa acima, a caixa de diálogo foi realizada através da instrução: eValor = Entry(textvar=valor).
O programa a seguir, mostra como encerrar uma
aplicação através de um botão (Button) e uma chamada de um comando do Sistema Operacional: exit, por isto o import sys (from sys import exit).
# .............................. Tk_9.py from sys import exit import tkinter as tk from tkinter import * janela = tk.Tk() janela.title("Tkinter") janela["background"] = "lightblue" janela.geometry("300x300+200+100") Button(janela, text=' Quit ', command=exit).pack() janela.mainloop()
O programa a seguir, mostra como configurar um rótulo, ou seja, selecionar a fonte, background , borda e etc através da instrução rotulo.configure(relief="ridge", font="Arial 24 bold", border=5, background="yellow").
92
# ............................. Tk_10.py from tkinter import * janela = Tk() janela.title("Rótulo") janela.geometry("400x100") frame = Frame() ; frame.pack() rotulo = Label(frame, text=" Configurando um Rótulo ", foreground="blue") rotulo.pack() rotulo.configure(relief="ridge", font="Arial 24 bold", border=5, background="yellow") janela.mainloop()
O programa a seguir exibe a posição x e y do cursor do mouse. # ........................ Tk_11.py from tkinter import * def clique(e): txt = "Mouse: %d x %d" %(e.x,e.y) r.configure(text=txt) janela = Tk() janela.title("Mouse") r = Label() r.pack(expand=True, fill="both") r.master.geometry("200x200") r.bind("<Button-1>", clique) mainloop()
93
O programa a seguir exibe uma listbox. # ............................ Tk_12.py from tkinter import * root = Tk() listbox = Listbox(root) listbox.pack() for i in range(10): listbox.insert(END, " -> "+str(i)) mainloop()
O seguinte programa mostra como exibir na tela gráfica, texto colorido, configurando a cor da frente (foreground = fg) e a cor de fundo (background = bg), através da instrução: rot = Label(janela, text="Red", bg="red", fg="white"). # ............................ Tk_13.py from tkinter import * janela = Tk() janela.title("Cores") janela.geometry("300x300+200+100") rot = Label(janela, text="Red", bg="red", fg="white") rot.pack(fill=X) rot = Label(janela, text="Green", bg="green", fg="black") rot.pack(fill=X) rot = Label(janela, text="Blue", bg="blue", fg="white") rot.pack(fill=X) janela.mainloop()