Algoritmos e Programação em Python

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ão 1.62
02-05-2018

Bibliografia re“omen”a”a:

MENEZES, Nilo Ney Coutinho. Intro”ução à Programação “om Python:

Algoritmos e Lógi“a ”e Programação para Ini“iantes. São Paulo: E”itora
Novate“, 2010 (ISBN 978-85-7522-250-8).

Pelotas, quarta-feira, 2 ”e maio ”e 2018 (09:48 am)

1
 Sumário

1. Linguagem ”e Programação Python .................................................................... 4

2. Como exe“utar “oman”os em Python .................................................................. 4
3. Entrar na IDLE ”o Python ................................................................................. 4
4. Primeiros “oman”os ou instruções .................................................................. 4
5. I”entifi“a”ores e variáveis............................................................................ 5
6. Opera”ores aritméti“os ..................................................................................... 6
6.1 Hierarquia ”os opera”ores (pre“e”ên“ia)................................................... 7
7. Coman”o print (imprimir ”a”os na tela) ...................................................... 7
8. Coman”o input (ler ”a”os ”o te“la”o) .......................................................... 9
9. Deletar uma variável (”el) ............................................................................. 9
10. Mó”ulos (import) ............................................................................................. 10
11. Funções ”e matemáti“as (math) .................................................................... 11
12. Strings (“a”eia ”e “ara“teres) .................................................................. 13
12.1 Funções para Strings ................................................................................... 13
13. Coman”os: Sequên“ia, Seleção e Repetição............................................... 15
13.1 Coman”os ”e Sequên“ia ................................................................................. 15
13.2 Lista ”e Exer“í“ios (Coman”os ”e sequên“ia) ....................................... 17
14. Opera”ores rela“ionais ................................................................................. 20
15. Opera”ores lógi“os ......................................................................................... 20
16. Coman”o ”e Seleção (if) ............................................................................... 20
16.1 Lista ”e Exer“í“ios (Coman”o ”e Seleção if) ....................................... 23
17. Conta”or e a“umula”or ................................................................................... 24
18. Coman”os ”e Repetição (while e for) ........................................................ 25
18.1 range (faixa)................................................................................................. 27
18.2 Lista ”e Exer“í“ios (Coman”o ”e Repetição while e for) .................. 28
19. Listas em Python (vetores).......................................................................... 29
19.1 Lista ”e Exer“í“ios ”e Vetores (listas)............................................... 35
20. Questões ”e prova ........................................................................................... 38
21. Curiosi”a”es e testes no Python ................................................................ 43
22. Funções es“ritas pelo programa”or em Python ......................................... 45
22.1 Exer“í“ios sobre funções em Python ........................................................ 52
23. Criação e utilização ”e mó”ulos em Python ............................................. 55
24. Tratamento ”e erros (ex“eções) .................................................................. 58
25. Ban“o ”e Da”os em Python (SQLite) ............................................................ 62
26. Sistema ”e Arquivos em Python .................................................................... 67
29. Arquivos Binários em Python........................................................................ 72
30. So“kets em Python ........................................................................................... 78
31. Threa”s em Python ........................................................................................... 83
32. Mó”ulo tkinter para GUI em Python ............................................................ 83

2
Lista de Exercícios do Prof. Dr. Ricardo Andrade Cava

DropBox:

https://www.”ropbox.“om/sh/kea9kr4j2qttnjg/AAAGkXES6sWvRKCJh8R7x9aia/ListaCava?”l=0

3
1. Linguagem ”e Programação Python

Python é uma linguagem ”e programação interpreta”a (on”e “a”a linha

é “ompila”a e exe“uta”a, uma por vez), ou seja, não é “ompila”a (on”e
to”o o programa é tra”uzi”o para linguagem ”e máquina e posteriormente
exe“uta”o). Em Python, “a”a “oman”o tem sua sintaxe verifi“a”a, sen”o
exe“uta”o a seguir.
Python é uma linguagem ”e alto nível e um software livre, ou seja,
não se paga por sua utilização. É utiliza”o em muitas apli“ações,
in“lusive em Re”es ”e Computa”ores para “riação ”e s“ripts utiliza”os
em servi”ores e outras apli“ações ”a área, além ”e ser uma linguagem ”e
uso geral.

2. Como exe“utar “oman”os em Python

Win”ows: Ini“iar ... Programas ... Python 3.? (versão)

Linux: $ python3.? (versão – ”igite TAB para ”es“obrir)

Ma“OsX: $ python3.? (TAB para ”es“obrir as versões instala”as)

3. Entrar na IDLE ”o Python

IDLE é a Interfa“e Gráfi“a ”a Linguagem ”e Programação Python que

permite a e”ição e exe“ução ”os programas es“ritos em Python.

Win”ows: Ini“iar ... Programas ... Python 3.? (versão) ... IDLE

Linux: $ i”le-python3.6 & <enter>

Ma“OsX: $ i”le3.6 <enter>

Observação: To”o programa fonte em Python possui a extensão .py .

Instalação e ”ownloa” ”o Python: http://www.python.org

4. Primeiros “oman”os ou instruções

Python permite exe“utar “oman”os ou instruções, tais “omo:

Imprimir na tela: >>> print( Hello ) <enter>

Hello

Realizar operações matemáti“as: >>> 3 + 4 <enter>

7
>>> 2 ** 3 <enter>
 8
>>>

Operações mais “omplexas: >>> a = 3 <enter>

>>> b = 4 <enter>
>>> “ = a + b <enter>
>>> print(a, b, “) <enter>
3 4 7
>>> print( “ = , “) <enter>
“ = 7
>>> print(3>4) <enter>
False # valor lógi“o
>>>

5. I”entifi“a”ores e variáveis

I”entifi“a”ores são os nomes “ria”os pelo programa”or para fazer

referên“ia a variáveis, “onstantes, funções e mó”ulos.

Regras para a “riação ”e i”entifi“a”ores:

ü O primeiro “ara“ter ”eve ser uma letra ou sublinha (‘);

ü Os “ara“teres seguintes ”evem ser letras, números ou sublinhas;
ü Não há limite ”e “ara“teres;
ü Não é permiti”o a utilização ”e “ara“teres em bran“o (“ara“ter espaço);
ü Po”em ser letras maiús“ulas e minús“ulas, pois são ”iferen“ia”os.

Comentário ”o programa”or:

# não é interpreta”o - “omentário ”e uma linha

“omentário em mais ”e uma linha

Não é interpreta”o

“omentário em mais ”e uma linha

Não é interpreta”o

Variáveis em Python existem em três tipos: int, float e string.

Na ”e“laração ”e “a”a variável, Python espe“ifi“a o tipo, por exemplo:
a = 3, a é ”e“lara”o “omo int, b = 3.4 é ”e“lara”o “omo float, s =
Python ou s = Python são string s.

Função type: Exibe o Tipo ”o Da”o.

5
# -------------------------- Type.py

a = 3
print(type(a))
b = 3.4
print(type(b))
“ = 'Python'
print(type(“))
” = 'A'
print(type(”))

Teste ”o Programa:

========= RESTART: /Users/pluzzar”i/Do“uments/Type.py =========

<“lass 'int'>
<“lass 'float'>
<“lass 'str'>
<“lass 'str'>
>>>

Coman”o i”: Retorna o i”entifi“a”or ”o objeto, número inteiro que

i”entifi“a “a”a objeto ”o Python.

>>> a = 3
>>> b = 4
>>> print(i”(a)) # 32 bits / 8 bits = 4 bytes (inteiro)
4297624000
>>> print(i”(b))
4297624032
>>>

6. Opera”ores aritméti“os

Os opera”ores aritméti“os permitem ao programa”or realizar várias

operações matemáti“as, tais “omo: a”ição, subtração, ”ivisão,
multipli“ação e poten“iação. A seguir, a Tabela 1 exibe os opera”ores
aritméti“os utiliza”os em Python.

Tabela 1: Opera”ores Aritméti“os

Matemáti“a Opera”or aritméti“o
A”ição +
Subtração -
Multipli“ação *
Divisão /
Poten“iação **

6
6.1 Hierarquia ”os opera”ores (pre“e”ên“ia)

A Tabela 2, a seguir, exibe a pre“e”ên“ia ”os opera”ores ”o Python,

ou seja, a or”em ”e exe“ução ”as operações matemáti“as.

Tabela 2: Hierarquia ”os Opera”ores Aritméti“os

Or”em ”e Tipo ”e Opera”or
pre“e”ên“ia
Parênteses ()
** Poten“iação
- (unário) Unário
Multipli“ação, ”ivisão, mo”ulo (resto inteiro ”a ”ivisão)
* / % //
e ”ivisão inteira
+ - A”ição e subtração

Exemplos:

>>> 7 / 2 # ”ivisão real

3.5
>>> 7 % 2 # resto inteiro ”a ”ivisão (mó”ulo)
1
>>> 7 // 2 # ”ivisão inteira
3
>>>

7. Coman”o print (imprimir ”a”os na tela)

O “oman”o print permite enviar (imprimir) para a tela qualquer

informação ”o python, “omo números, “onstantes, resulta”os ”e operações,
strings, et“.

Sintaxe simples: print(string, lista‘”e‘variáveis)

Exemplos:

>>> print(4) <enter>

4
>>> print(3+4) <enter>
7
>>> print(3>4) enter>
False # tipo lógi“o (True ou False)
>>> a = 3 <enter>
>>> print(a) <enter>
3
>>> b = 4 <enter>

7
>>> print(a+b) <enter)
7
>>> A = 7 <enter>
>>> print(A+b) <enter>
11
>>> print( a = , a) <enter>
a = 3
>>>
>>> print(4%2) # resto inteiro ”a ”ivisão
0
>>>
>>> print(3**4) # Poten“iação
81
>>> número‘”entes = 32 <enter>
>>> print( Número ”e Dentes: , número‘”entes) <enter>
>>> Número ”e Dentes = 32
>>> a = 3
>>> b = 4
>>> print("a = ", a, "b = ", b)
a = 3 b = 4
>>> ”ia = 3 <enter>
>>> mês = 7 <enter>
>>> ano = 2017 <enter>
>>> print( Data: %02”/%02”/%” %(”ia, mês, ano)) <enter>
03/07/2017 # saí”a formata”a
>>>

Tabela 3: Opera”ores %
Opera”or % Signifi“a”o
%s Uma string
%“ Cara“tere
%” De“imal inteiro
%f Real (float)
%% Um '%'

Note que o Python permite formatar os ”a”os que serão exibi”os na

tela através ”o print, para tanto usa os opera”ores ”a Tabela 3, a“ima.
Repare novamente nos exemplos abaixo:

>>> ”ia = 3 <enter>

>>> mês = 7 <enter>
>>> ano = 2017 <enter>
>>> print( Data: %02”/%02”/%” %(”ia, mês, ano)) <enter>
03/07/2017
>>>

# ================================== ”ata e hora

from ”atetime import ”atetime

8
”ata = ”atetime.now()
print(”ata)
print("Data: %02”/%02”/%”" %(”ata.”ay, ”ata.month, ”ata.year))
print("Tempo: %02”:%02”:%02”" %(”ata.hour, ”ata.minute, ”ata.se“on”))

8. Coman”o input (ler ”a”os ”o te“la”o)

O “oman”o input permite ler informações via te“la”o, o valor

”igita”o pelo usuário é li”o “omo uma string, po”en”o ser “onverti”o
para inteiro (int) ou real (float).

Sintaxe: string input(string mensagem)

Exemplos:

Entra”a ”e uma String:

>>> s = input( Digite um Nome: ) <enter>

>>> Digite um Nome: Luzzar”i <enter>
>>> print(len(s)) # número ”e “ara“teres ”a string
8
>>>

Entra”a ”e um Inteiro:

>>> i = int(input( Digite um Valor: )) <enter>

>>> Digite um Nome: 34 <enter>
>>> print(i)
34
>>>

Entra”a ”e um Real (float):

>>> i = float(input( Digite um Valor: )) <enter>

>>> Digite um Nome: 34 <enter>
>>> print(i)
34.0
>>>

Outra forma, em ”uas etapas:

>>> s = input("Digite um Valor: ") <enter>

Digite um Valor: 34 <enter>
>>> x = int(s) <enter> # “onversão para inteiro
>>> print(x) <enter>
34
>>>

9. Deletar uma variável (”el)

9
 Em Python é possível ”eletar (apagar, remover, ”esalo“ar ”a memória
RAM) uma variável ”a memória, isto é feito através ”o “oman”o ”el.

Sintaxe: >>> ”el variável

Exemplo:

>>> a = 3 <enter>
>>> print(a) <enter>
3
>>> ”el a
>>> print(a)
Tra“eba“k (most re“ent “all last):
File "<st”in>", line 1, in <mo”ule>
NameError: name 'a' is not ”efine”

Erro: i”entifi“a”or a não ”efini”o

Observação: É possível também reini“ializar o terminal (shell), vá na

opção Shell .. Restart Shell, to”as as variáveis são ”estruí”as, ou
seja, ”esalo“a”as ”a memória RAM (Ran”om A“ess Memory).

10. Mó”ulos (import)

Python possui um “onjunto ”e funções pré-”efini”as agrupa”as em

estruturas “hama”as ”e mó”ulos, tais “omo: math (mathemati“s), os
(sistema opera“ional), ”atetime (”ata e hora), et“.

Forma ”e importar: import mó”ulo

Para utilizar a função ”e um mó”ulo: mó”ulo.função(argumento)

Para importar apenas uma função ”eseja”a: from mó”ulo import função

Exemplos: >>> import math <enter>

>>> print(math.pi) <enter>
3.141592653589793
>>> import os <enter>
>>> os.system( “lear ) <enter>
>>> from math import sqrt <enter>
>>> print(math.sqrt(16))
16
>>>

Aju”a (help) ”os mó”ulos:

>>> import math <enter>

10
>>> help(math) <enter> # exibe funções ”o mó”ulo math
# i”ênti“o ao Linux

11. Funções ”e matemáti“as (math)

Python possui ”iversas funções matemáti“as oriun”as ”o mó”ulo

math . São elas:

math.fa“torial(x): Retorna o valor fatorial ”e x, on”e x ”eve ser sempre

positivo.

>>> fat = math.fa“torial(5) # 5x4x3x2x1 = 120

>>> print(fat)
120
>>>

math.mo”f(x): Retorna o valor inteiro e o valor fra“ionário ”a variável

x.

>>> print(math.mo”f(5.34))
(0.33999999999999986, 5.0)
>>>

math.exp(x): Retorna o exponen“ial ”e x, ou seja, ex.

>>> print(math.exp(1))
2.718281828459045
>>> print(math.exp(2))
7.38905609893065
>>> print(math.exp(3))
20.085536923187668
>>>

math.log(x, base): Retorna o log ”e x na base pe”i”a.

>>> print(math.log(2,10))
0.30102999566398114
>>> print(math.log(3,10))
0.47712125471966244
>>>

math.log1p(x): Retorna o logaritmo natural ”e x.

>>> print(math.log1p(1))
0.6931471805599453
>>> print(math.log1p(2))
1.0986122886681098
>>>

11
math.sqrt(x): Retorna a raiz qua”ra”a ”e x.

>>> x = 16
>>> print(math.sqrt(x))
4.0
>>> x = -16 # x ”eve ser positivo
>>> print(math.sqrt(x))
Tra“eba“k (most re“ent “all last):
File "<st”in>", line 1, in <mo”ule>
ValueError: math ”omain error
>>>

math.”egrees(x): Converte o ângulo x ”e ra”ianos para graus.

pi ra”ianos à 180 graus

math.ra”ians(x): Converte o ângulo x ”e graus para ra”ianos.

math.sin(x): Retorna o seno ”e x, on”e x ”eve estar em ra”ianos.

>>> x = math.sin(45)
>>> print(x)
0.8509035245341184
>>> x = math.sin(math.ra”ians(45))
>>> print(x)
0.7071067811865475
>>>

math.“os(x): Retorna o “osseno ”e x, on”e x ”eve estar em ra”ianos.

>>> x = math.“os(45)
>>> print(x)
0.5253219888177297
>>> x = math.“os(math.ra”ians(45)) # “onverte 45 para ra”ianos
>>> print(x)
0.7071067811865476

math(tan(x): Retorna a tangente ”e x, on”e x ”eve estar em ra”ianos.

>>> tangente = math.tan(math.ra”ians(45))

>>> print(tangente)
0.9999999999999999
>>>

math.hypot(x, y): Retorna a hipotenusa ”o triângulo retângulo, on”e x e

y são os “atetos oposto e a”ja“ente.

>>> hipotenusa = math.hypot(3 ,4)

12
>>> print(hipotenusa)
5.0
>>>

12. Strings (“a”eia ”e “ara“teres)

String é uma sequên“ia ”e “ara“teres, letras, números e “ara“teres

espe“iais, que permite trabalhar “om textos.

>>> s = "Python" <enter>

>>> print(s) <enter>
Python
>>> print("Número ”e “ara“teres ”a string: %”" %(len(s))) <enter>
6
>>>

ou

>>> s = Python <enter> # po”e ser utiliza”o aspas simples

>>> l = len(s) <enter> # retorna o número ”e “ara“teres
>>> print("Número ”e “ara“teres ”a String: %”" %l)
<enter>
6
>>>
outra forma ”e ini“ialização:

>>> s = 'P' 'y' 't' 'h' 'o' 'n' <enter)

>>> print(s) <enter>
Python
>>>

Vetor ”e Strings: (será visto em outro “apítulo)

>>> s = ('Paulo', 'Roberto', 'Gomes', 'Luzzar”i') <enter>

>>> print(s[0]) <enter>
Paulo
>>> print(s[3]) <enter>
Luzzar”i
>>>

12.1 Funções para Strings

# ------------------------------------------- Split.py

s = "Paulo Roberto Gomes Luzzar”i"

print("Número ”e letras: ", len(s))
partes = s.split(' ')
n = len(partes)
print("Número ”e nomes: ", n)

13
for i in range(n):
print(partes[i])
print(partes)

Teste ”o Programa:

===== RESTART: /Users/pluzzar”i/Desktop/Python/Python/Split.py ====

Número ”e letras: 28
Número ”e nomes: 4
Paulo
Roberto
Gomes
Luzzar”i
['Paulo', 'Roberto', 'Gomes', 'Luzzar”i']
>>>

Exemplo ”e funções ”e Strings:

# -------------------------------- String.py

# -------------------------------------------- len
s = 'Paulo Roberto Gomes Luzzar”i'
n = len(s) # retorna o total ”e “ara“teres ”a string
print("Número ”e Cara“teres: ", n)

# -------------------------------------------- “ount
“ara“ter = 'a'
letras = s.“ount(“ara“ter) # retorna o número ”e vezes que o “ara“ter apare“e na
string
print('Número ”e letras "%“" é %”' %(“ara“ter,letras))

# -------------------------------------------- repla“e
s = s.repla“e('Roberto', 'R.') # tro“a parte ”a string
s = s.repla“e("Gomes", "G.")
print(s)

# -------------------------------------------- fin”
pos = s.fin”('z') # pro“ura a primeira aparição ”e uma letra
print(pos)

# -------------------------------------------- upper e lower

print("STRING: ", s.upper()) # exibe “omo maiús“ula
print(s)
print("string: ", s.lower()) # exibe “omo minús“ula
print(s)

# -------------------------------------------- title
s = "paulo roberto gomes luzzar”i"
print(s.title())

# -------------------------------------------- swap“ase
s = 'Paulo Roberto Gomes Luzzar”i'
print(s.swap“ase()) # inverte as letras maiús“ulas e minús“ulas

14
# -------------------------------------------- isalpha
print('Contém apenas letras: ฀', s.isalpha()) # verifi“a se “ontém apenas letras
s = 'Fate“Sena“'
print('Contém apenas letras: ฀', s.isalpha())

# --------------------------------------------- is”igit
print('Contém apenas números: ', s.is”igit())
s = '123456'
print('Contém apenas números: ', s.is”igit())

Teste ”o Programa:

=========== RESTART: /Users/pluzzar”i/Do“uments/String.py ==========

Número ”e Cara“teres: 28
Número ”e letras "a" é 2
Paulo R. G. Luzzar”i
14
STRING: PAULO R. G. LUZZARDI
Paulo R. G. Luzzar”i
string: paulo r. g. luzzar”i
Paulo R. G. Luzzar”i
Paulo Roberto Gomes Luzzar”i
pAULO rOBERTO gOMES lUZZARDI
Contém apenas letras: ฀ False
Contém apenas letras: ฀ True
Contém apenas números: False
Contém apenas números: True
>>>

13. Coman”os: Sequên“ia, Seleção e Repetição

Python possui três tipos prin“ipais ”e “oman”os, sequên“ia, on”e

to”os são exe“uta”os, seleção, on”e alguns são e outros não são
exe“uta”os e repetição, “oman”os são exe“uta”os ”iversas vezes.

13.1 Coman”os ”e Sequên“ia

Coman”os ”e Sequên“ia:

To”os os “oman”os (ou instruções) em sequên“ia são sempre

exe“uta”os no fluxo ”o programa.

# --------------------- Cir“ulo.py

import math

”iametro = float(input("Digite o valor ”o Diâmetro: "))

raio = ”iametro / 2
area = math.pi * raio ** 2

15
print("Área ”o Cír“ulo é: ", area)

Teste ”o Programa:

Digite o valor ”o Diâmetro: 6 <enter>

Área ”o Cír“ulo é: 28.274334
>>>

# ----------------------------------- Temperatura.py

f = 120
“ = (f - 32) * 5 / 9
print("Celsius: %”" %“, sep='', en”='') # imprime mesma linha
print(" - Fahrenheit: ", f)

Teste ”o Programa:

== RESTART: /Users/pluzzar”i/Desktop/Python/Python/Temperatura.py ==
Celsius: 48 - Fahrenheit: 120
>>>

# ---------------------------------- Ran”om.py

import ran”om

n = 10
print("Faixa ”e Sorteio: 0 ... %”" %(n-1))
numero = int (ran”om.ran”om() * n)
print("Número Sortea”o: ", numero)
# A função ran”om gera um número float aleatório entre 0.0 e 1.0

Teste ”o Programa:

========== RESTART: /Users/pluzzar”i/Do“uments/Ran”om.py =======

Faixa ”e Sorteio: 0 ... 9
Número Sortea”o: 8
>>>

# ----------------------------- Aleatorio.py

import ran”om

for i in range(6):
n = ran”om.ran”int(1, 10)
print("n = ", n)

Teste ”o Programa:

======= RESTART: /Users/pluzzar”i/Do“uments/Aleatorio.py =======

n = 2
n = 9
n = 7

16
n = 6
n = 5
n = 7
>>>

13.2 Lista ”e Exer“í“ios (Coman”os ”e sequên“ia)

a) Es“reva um programa em Python que re“ebe ”ois valores via te“la”o:

“ateto a”ja“ente (b) e “ateto oposto (a) e “al“ula o valor ”a
hipotenusa ”a”o pela seguinte fórmula:

Teste ”o Programa:

Cateto A”ja“ente (b): 3 <enter>

Cateto Oposto (a): 4 <enter>
Hipotenusa: 5.0

b) Es“reva um programa em Python que lê 4 notas via te“la”o: n1, n2,

n3 e n4 obti”as por um aluno em 4 avaliações. Cal“ule a mé”ia
utilizan”o a seguinte fórmula:

n1 + n2 x 2 + n3 x 3 + n4
Mé”ia = ---------------------------
7

“) Es“reva um programa em Python que re“ebe via te“la”o: “omprimento

”a “ir“unferên“ia. O programa ”eve “al“ular e imprimir na tela o
”iâmetro e o raio ”a “ir“unferên“ia (veja exemplo abaixo):

Teste ”o Programa:

Comprimento ”a “ir“unferên“ia: 36 <enter>

Diâmetro: 11.46
Raio: 5.73

“omprimento ”a “ir“unferên“ia = 2 . Pi . raio

17
 ”iâmetro = 2 . raio

”) Desenvolva um programa em Python que re“ebe via te“la”o: peso ”a

“arne que será ven”i”a e preço por quilo. O programa ”eve “al“ular
e imprimir na tela o total a pagar, o valor pago ao ICMS (17%) e
o lu“ro líqui”o ”o açougue.

Teste ”o Programa (1):

Peso: 3.5 <enter>

Preço por Kg (R$): 4.90 <enter>
Total a pagar: 17.15
ICMS (17%): 2.91
Lu“ro líqui”o ”o açougue (R$): 14.24

Teste ”o Programa (2):

Peso: 1.5 <enter>

Preço por Kg (R$): 9.00 <enter>
Total a pagar: 13.5
ICMS (17%): 2.29
Lu“ro líqui”o ”o açougue (R$): 11.21

e) Es“reva um programa em Python que re“ebe via te“la”o: a ”ata ”e

hoje ”a seguinte forma: ”ia, mês, ano e a sua i”a”e, ”a seguinte
forma: anos, meses e ”ias vivi”os. Cal“ule e imprima a ”ata ”e
nas“imento no seguinte formato: ””/mm/aaaa.

Teste ”o Programa:

Qual a ”ata ”e hoje:

Dia: 16 <enter>
Mês: 3 <enter>
Ano: 2017 <enter>
Qual a sua i”a”e:
Anos: 55 <enter>
Meses: 1 <enter>
Dias: 6 <enter>
Data ”e Nas“imento: 10/02/1962

f) Es“reva um programa em Python que re“ebe via te“la”o: salário

mensal e per“entual ”e reajuste. Cal“ular e es“rever o valor ”o
novo salário.

18
Teste ”o Programa:

Salário: 500 <enter>

Per“entual ”e reajuste: 15 <enter>
Novo salário: 575

g) Es“reva um programa em Python que lê via te“la”o as ”imensões ”e

uma “ozinha retangular (“omprimento, largura e altura), “al“ular
e es“rever a quanti”a”e ”e “aixas ”e azulejos para se “olo“ar em
to”as as suas pare”es (“onsi”ere que não será ”es“onta”o a área
o“upa”a por portas e janelas). Ca”a “aixa ”e azulejos possui 1,5
m2.

Teste ”o Programa:

Comprimento: 4.5 <enter>

Largura: 3 <enter>
Altura: 2.8 <enter>
Quanti”a”e ”e “aixas: 28

h) A turma C é “omposta ”e 60 alunos, e a turma D ”e 20 alunos.

Es“reva um programa em Python que leia o per“entual ”e alunos
reprova”os na turma C, o per“entual ”e aprova”os na turma D,
“al“ule e es“reva:
a) O número ”e alunos reprova”os na turma C.
b) O número ”e alunos reprova”os na turma D.
“) A per“entagem ”e alunos reprova”os em relação ao total ”e alunos
”as ”uas turmas.

Teste ”o Programa:

Per“entual ”e alunos reprova”os na turma C: 10 <enter>

Per“entual ”e alunos aprova”os na turma D: 85 <enter>
Quanti”a”e ”e alunos reprova”os na turma C: 6
Quanti”a”e ”e alunos reprova”os na turma D: 3
Per“entual ”e alunos reprova”os em relação ao total ”e alunos ”as ”uas turmas: 11.25

i) Es“reva um programa em Python que re“ebe três valores via te“la”o:

a, b e “. O programa ”eve “al“ular e imprimir na tela os valores
”as raízes x1 e x2 ”a”os pela fórmula ”a bhaskara, ou seja, uma
equação ”e segun”o grau: a.x2 + b.x + “ = 0

Teste ”o Programa:

a = 1 <enter>

19
b = 2 <enter>
“ = -3 <enter>
x1 = 1
x2 = -3

14. Opera”ores rela“ionais

Os opera”ores rela“ionais permitem ao programa”or realizar

“omparações. A seguir, a Tabela 4 exibe os opera”ores rela“ionais
utiliza”os em Python.

Tabela 4: Opera”ores Rela“ionais

Opera”or rela“ional Função
== Igual
!= Diferente
> Maior
< Menor
Maior ou
>=
igual
Menor ou
<=
igual

15. Opera”ores lógi“os

Os opera”ores lógi“os permitem ao programa”or realizar várias

“omparações em uma mesma “on”ição. A seguir, a Tabela 5 exibe os
opera”ores lógi“os utiliza”os em Python.

Tabela 5: Opera”ores Lógi“os

Opera”or lógi“o
an”
or
not

an” é ver”a”eiro quan”o ambas “on”ições forem ver”a”eiras

or é ver”a”eiro quan”o uma ou ambas “on”ições forem ver”a”eiras.
not é o inverso ”a “on”ição, ou seja, inverte o True ou False.

16. Coman”o ”e Seleção (if)

20
 O “oman”o ”e seleção if permite o programa seguir ”ois “aminhos,
isto é feito através ”e uma “on”ição, utilizan”o um opera”or rela“ional
(Tabela 4), que po”e ser ver”a”eira (True) ou falsa (False).

Sintaxe: if “on”ição: “oman”o # simples

ou

if “on”ição: # simples
“oman”o

ou

if “on”ição: # “omposto
“oman”o1
else:
“oman”o2

ou

if “on”ição1:
“oman”o1
elif “on”ição2:
“oman”o2
else:
“oman”o3

Programa Exemplo: if simples

# -------------------------------------- If.py

1: x = int(input("Digite um Número: "))

2: if x < 0:
3: print("Número é negativo")
4: print("x = ", x)

Observação: Note a en”entação no “oman”o if (linha 3), Python utiliza a

en”entação “omo forma ”e formar blo“os ”e “oman”os, ou seja, ”elimitar
instruções liga”as a um úni“o “oman”o.

Teste ”o Programa:

======= RESTART: /Users/pluzzar”i/Do“uments/If.py ========

Digite um Número: -5
Número é negativo

21
x = -5
>>>
======= RESTART: /Users/pluzzar”i/Do“uments/If.py ========
Digite um Número: 5
x = 5
>>>

Programa exemplo: If “ompleto, ou seja, “om ”uas partes

# ---------------------------------------- Par.py

x = int(input("Digite um Número: "))

if x % 2 == 0:
print("Par")
else:
print("Ímpar")

Teste ”o Programa:

================= RESTART: /Users/pluzzar”i/Do“uments/Par.py =======

Digite um Número: 4
Par
>>>

# ------------------------- Bhaskara.py

import math

a = float(input("a = "))
b = float(input("b = "))
“ = float(input("“ = "))
”elta = b**2 - 4 * a * “
if ”elta >= 0:
x1 = (-b + math.sqrt(”elta)) / 2*a
x2 = (-b - math.sqrt(”elta)) / 2*a
print("x1 = ", x1)
print("x2 = ", x2)
else:
print("Erro: Raizes “omplexas")

Teste ”o Programa:

===== RESTART: /Users/pluzzar”i/Do“uments/bhaskara.py ======

a = 1
b = 2
“ = -3
x1 = 1.0
x2 = -3.0
>>>

Programa exemplo: if “om elif

22
# ---------------------------------------- Elif.py

numero = int(input("Digite um Número: "))

if numero > 0:
print("Positivo")
elif numero < 0:
print("Negativo")
else:
print("Zero")

16.1 Lista ”e Exer“í“ios (Coman”o ”e Seleção if)

a)Es“reva um programa em Python que lê as notas ”e ”uas avaliações

”e um aluno no semestre. Cal“ular e es“rever a mé”ia semestral e a
seguinte mensagem: PARABÉNS! Vo“ê foi aprova”o somente se o aluno
foi aprova”o (“onsi”ere 7.0 a nota mínima para aprovação) ou Vo“ê
foi reprova”o! Estu”e mais .

Teste ”o Programa:

Nota 1: 6 <enter>
Nota 2: 8 <enter>
Mé”ia: 7.0
PARABÉNS! Vo“ê foi aprova”o

b)Es“reva um programa em Python que lê ”ois valores. Es“reva o valor

”o maior, o menor e a mé”ia ”os ”ois valores.

Teste ”o Programa:

Valor: 3 <enter>
Valor: 4 <enter>
Maior: 4
Menor: 3
Mé”ia: 3.5

“)Es“reva um programa em Python que lê o ano ”e nas“imento ”e uma

pessoa. Es“rever: PODE VOTAR ou NÃO PODE VOTAR e a i”a”e, “onforme
exemplo abaixo.

Teste ”o Programa:

Ano ”e Nas“imento: 1999 <enter>

Status: PODE VOTAR
I”a”e: 18 anos

”) As maçãs “ustam R$ 0,30 ser forem “ompra”as menos ”o que uma ”úzia,
e R$ 0,25 ser forem “ompra”as pelo menos ”oze. Es“reva um programa
em Python que leia o número ”e maçãs “ompra”as, “al“ule e es“reva o

23
 valor total ”a “ompra.

Testes ”o Programa:

Maças: 20 <enter>
Valor ”a Compra: R$ 5.00
ou
Maças: 12 <enter>
Valor ”a Compra: R$ 3.00

e) Es“reva um programa em Python que re“ebe via te“la”o a altura e o

sexo (“o”ifi“a”o ”a seguinte forma: [f] feminino - [m] mas“ulino) ”e
uma pessoa. Cal“ule e imprima na tela o peso i”eal, utilizan”o as
seguintes fórmulas:
Homens: 72.7 * h - 58
Mulheres: 62.1 * h - 44.7

Testes ”o Programa:

Altura: 1.80 <enter>

Sexo [M] ou [F]: m <enter>
Peso I”eal: 72.86
ou
Altura: 1.65 <enter>
Sexo [M] ou [F]: F <enter>
Peso I”eal: 57.765

17. Conta”or e a“umula”or

Um “onta”or é uma variável que possui uma expressão matemáti“a,

”entro ”e um “oman”o ”e atribuição, que realiza uma “ontagem ”e uma
“erta quanti”a”e ”e vezes que um “oman”o ”e repetição é exe“uta”o, ou
seja, ela mantém a quanti”a”e ”e vezes que um laço foi exe“uta”o. Po”e-
se “ontar ”e um em um, ”ois em ”ois e assim su“essivamente, servin”o,
normalmente, para “ontar o número ”e elementos.

Sintaxe: x = x + 1 # x ß x + 1

Note que é soma”o um (1) ao x e então atribuí”o este novo valor ao

próprio x. Note ain”a que um (1) é uma “onstante, que po”e ser 1, 2, 3,
...

Um a“umula”or ou soma”or é uma variável que “ontém uma expressão

matemáti“a que serve para a“umular valores a “a”a vez que o “ó”igo é
exe“uta”o.

Sintaxe: soma = soma + n # soma ß soma + n

24
Note que é soma”o o valor n a soma e atribuí”o este novo valor a
própria soma. Note ain”a que n é uma variável, que po”e ser qualquer
valor inteiro ou real (float).

18. Coman”os ”e Repetição (while e for)

Os “oman”os ”e repetição while e for permitem repetir ”iversas

vezes um blo“o ”e “oman”os ou instruções. While repete enquanto a
“on”ição é ver”a”eira.

Coman”o while:

Sintaxe: while “on”ição:

“oman”o1
“oman”o2
...
# --------------------------- While.py

i = 1
while i <= 10:
print("i = ", i)
i = i + 1

Teste ”o Programa:

========= RESTART: /Users/pluzzar”i/Do“uments/While.py =========

i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9
i = 10
>>>

# -------------------- In2.py

import ran”om

s = 's'
while s in ['S', 's']: # opera”or in
num = ran”om.ran”int(1, 10)
print("Número sortea”o: ", num)
s = input("Continua [S/N]")

Teste ”o Programa:

25
============= RESTART: /Users/pluzzar”i/Do“uments/In2.py =========
Número sortea”o: 2
Continua [S/N]s
Número sortea”o: 2
Continua [S/N]s
Número sortea”o: 7
Continua [S/N]s
Número sortea”o: 10
Continua [S/N]n
>>>

Coman”o for:

Permite exe“utar várias vezes um blo“o ”e “oman”os.

Sintaxe: for variável in faixa:

“oman”o1
“oman”o2
...

Observação: A es“olha entre o “oman”o while e for se ”á sempre que sabe-

se a quanti”a”e ”e vezes que um blo“o é exe“uta”o. Sempre que se sabe o
número ”e vezes, ”eve-se usar o “oman”o for, “aso “ontrário, ”eve-se
utilizar o “oman”o while, que po”e ser “ontrola”o ”e várias formas,
basea”os em sua “on”ição.

Para utilizar o “oman”o for ”eve-se saber o iní“io (start), o

ponto ”e para”a (stop) e a variação (step).

# --------------------------------- For.py

for i in range(6): # faixa: 0 à 5, on”e 6 é o ponto ”e para”a

print(i)

====== RESTART: /Users/pluzzar”i/Desktop/Python/Python/For.py =====

0
1
2
3
4
5
>>>

# ----------------------------------- ForDuplo.py

for i in range(3):
for j in range(4):
print(i, j)

====== RESTART: /Users/pluzzar”i/Do“uments/ForDuplo.py ==========

26
0 0
0 1
0 2
0 3
1 0
1 1
1 2
1 3
2 0
2 1
2 2
2 3
>>>

Observação: Note que “omeça sempre em zero.

# ----------------------------------- ForDuplo2.py

for i in range(3):
for j in range(4):
print(i+1, j+1)

=== RESTART: /Users/pluzzar”i/Desktop/Python/Python/ForDuplo2.py ===

1 1
1 2
1 3
1 4
2 1
2 2
2 3
2 4
3 1
3 2
3 3
3 4
>>>

18.1 range (faixa)

Range permite ”eterminar o ponto ”e parti”a (start), ponto ”e

para”a (stop) e a variação (step) usa”o no “oman”o for.

Sintaxe: range(start, stop, step)

On”e: Start: parti”a

Stop: para”a (stop - 1)
Step: passo (in“remento [+] ou ”e“remento [-])

Exemplos:

for i in range(10): # 0 1 2 3 4 5 6 7 8 9
print(i)

27
for i in range(0, 10, 2): # 0 2 4 6 8
print(i)

for i in range(0, 11, 2): # 0 2 4 6 8 10

print(i)

for i in range(10, -1, -1): # 10 9 8 7 6 5 4 3 2 1 0

print(i)

for i in range(10, 0, -1): # 10 9 8 7 6 5 4 3 2 1

print(i)

Observação: Nun“a “hega no ponto ”e para”a.

18.2 Lista ”e Exer“í“ios (Coman”o ”e Repetição while e for)

a)Es“reva um programa em Python que lê um número via te“la”o. O

programa ”eve exibir se o número é PAR ou ÍMPAR. O programa é en“erra”o
quan”o o número ”igita”o for ZERO.

Teste ”o Programa:

Número: 6 <enter>
PAR
Número: 7 <enter>
IMPAR
Número: 0 <enter>
PAR
>>>

b)Es“reva um programa em Python que lê um número via te“la”o. O

programa ”eve exibir: POSITIVO, NEGATIVO ou ZERO. O programa é
en“erra”o quan”o o usuário ”igitar N ou n na pergunta
Continua [S/N]? .

Teste ”o Programa:

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
>>>

“)Es“reva um programa em Python que lê um nome via te“la”o. O programa

”eve exibir o número ”e palavras ”o nome e a abreviatura ”o nome.

28
Teste ”o Programa:

Nome: Paulo Roberto Gomes Luzzar”i <enter>

Número ”e palavras: 4
Abreviatura: P. R. G. L.
>>>

”)Es“reva um programa em Python que lê um nome via te“la”o. O programa

”eve exibir o nome ”o autor, “onforme exemplo abaixo:

Teste ”o Programa:

Nome: Paulo Roberto Gomes Luzzar”i <enter>

Autor: Luzzar”i, Paulo R. G.
>>>

e) Es“reva um programa em Python que lê um nome qualquer via te“la”o.

Logo após a entra”a exiba na tela: (a) to”as as vogais ”o nome; (b)
to”as as “onsoantes ”o nome e o (“) total ”e letras, “onforme e
exatamente igual ao teste abaixo:

Teste ”o Programa:

Nome: paulo roberto gomes luzzardi <enter>

Vogais: auooeooeuai (11)
Consoantes: plrbrtgmslzzrd (14)
Total de letras: 25
>>>

19. Listas em Python (vetores)

Em Python vetores são representa”os em forma ”e listas. Vetores

são estruturas que permitem armazenar valores homogêneos, ou seja, ”e
mesmo tipo. Listas por outro la”o, são “lasses que permitem armazenar
qualquer tipo ”e informação. A seguir são vistos ”iversos exemplos ”a
utilização ”e listas.

Exemplo: Lista1.py

# ------------------------------- Lista1.py

x = [10, 20, 30]

n = len(x) # retorna o número ”e elementos ”a lista
for i in range(n):
print(x[i]) # imprime elemento por elemento

Teste ”o Programa:

29
======= RESTART: /Users/pluzzar”i/Do“uments/Lista1.py ==========
10
20
30
>>>

Exemplo: Lista2.py

# ------------------------------- Lista2.py

x = [] # ”e“lara uma lista vazia

n = int(input("Número ”e Elementos: "))
for i in range(n):
num = int(input("Digite um Número: "))
x.appen”(num) # insere um elemento no fim ”a lista
for i in range(n):
print('x[',i,'] = ', x[i], sep='') # elimina o espaço
print("Lista: ", x)

Teste ”o Programa:

==== RESTART: /Users/pluzzar”i/Desktop/Python/Python/Lista2.py ====

Número ”e Elementos: 4
Digite um Número: 10
Digite um Número: 20
Digite um Número: 30
Digite um Nú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(x is y)
print(i”(x))
print(i”(y))
t = x[:] # “ria uma “ópia ”a lista x ... t = x.“opy()
print(t is x)
print(i”(t))
print("Número ”e Elementos: ", len(x))

Teste ”o Programa:

======== RESTART: /Users/pluzzar”i/Do“uments/Lista3.py ==========

x = [10, 20, 30] y = [10, 20, 30]

30
True
4380371208
4380371208
False
4320652552
Número ”e Elementos: 3
>>>

Exemplo: Lista4.py

# -------------------------------- Lista4.py

nome = []
nota = []
soma = 0.0
numeroAlunos = 4
for i in range(numeroAlunos):
nome.appen”(input("Nome ”o Aluno: "))
nota.appen”(float(input("Nota ”o " + nome[i] + ": ")))
soma = soma + nota[i]
me”ia = soma / numeroAlunos
print("Mé”ia ”a Turma:", me”ia)

Teste ”o Programa:

======== RESTART: /Users/pluzzar”i/Do“uments/Lista4.py =============

Nome ”o Aluno: Paulo
Nota ”o Paulo: 7
Nome ”o Aluno: Roberto
Nota ”o Roberto: 8
Nome ”o Aluno: Gomes
Nota ”o Gomes: 9
Nome ”o Aluno: Luzzar”i
Nota ”o Luzzar”i: 10
Mé”ia ”a Turma: 8.5
>>>

Imprimir Listas utilizan”o o “oman”o for:

lista = {10, 20, 30, 40, 50} # lista ”e números inteiros

print("Lista sem Or”enação")

for i in lista:
print(i)

print("Lista Or”ena”a")
for i in sorte”(lista):
print(i)

for i, valor in enumerate(lista): # “om numeração

print("%” - %”" %(i, valor))

lista = list(range(10))

31
for i in lista:
lista[i] = i + 5
print(lista[i])
print(lista)

nomes = {"Carla", "Ana", "Debora", "Eva", "Beatriz"}

for i in sorte”(nomes):
print(i)

# for <variável> in <lista>:

# <blo“o ”e “ó”igo en”enta”o>

Teste ”o Programa:

===== RESTART: /Users/pluzzar”i/Desktop/Python/Python/For.py =====

0
1
2
3
4
5
Lista sem Or”enação
40
10
50
20
30
Lista Or”ena”a
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

32
Debora
Eva

Funções para operar listas:

Anexar o elemento no final ”a lista: appen”

lista.appen”(elemento)

Remove o elemento ”a lista: remove

lista.remove(elemento)

Limpa to”a a lista, ou seja, apaga to”os os elementos ”a lista: “lear

lista.“lear()

Insere o elemento antes ”o ín”i“e: insert

lista.insert(ín”i“e, elemento)

Remove o último elemento e retorna o valor: pop

ultimo = lista.pop()

Reverte os elementos ”a lista (mu”a a or”em): reverse

lista.reverse()

Cria uma “ópia ”a lista: “opy

temp = lista.“opy()

Or”ena uma lista: sort

lista.sort() ou lista.sort(reverse = True)

Número ”e elementos ”e uma lista: len

n = len(lista)

Retorna o número ”e vezes ”e um elemento ”entro ”e uma lista: “ount

vezes = lista.“ount(elemento)

33
Retorna o ín”i“e ”e um elemento em uma lista: in”ex

posição = lista.in”ex(elemento)

# --------------------------------------- Lista.py

lista = [40, 30, 50, 10, 20]

lista.sort() # or”ena em or”em “res“ente

print(lista)

lista.sort(reverse=True) # or”ena em or”em ”e“res“ente

print(lista)

# insert(posição, valor)
lista.insert(1, 15) # insere o elemento antes ”a posição
print(lista)

print(lista.“ount(20)) # exibe o número ”e vezes ”o elemento

print(lista.in”ex(20)) # exibe o ín”i“e ”o elemento

ultimo = lista.pop() # remove o último elemento

print("Último elemento: ", ultimo)
print(lista)

lista.reverse() # inverte a lista (or”em ”os elementos)

print(lista)

temp = lista.“opy()
print("Lista Nova: ", temp)

Teste ”o programa:

=============== RESTART: /Users/pluzzar”i/Desktop/Lista.py =========

[10, 20, 30, 40, 50]
[50, 40, 30, 20, 10]
[50, 15, 40, 30, 20, 10]
1
4
Último elemento: 10
[50, 15, 40, 30, 20]
[20, 30, 40, 15, 50]
Lista Nova: [20, 30, 40, 15, 50]
>>>

O programa a seguir mostra a “riação aleatória ”e palpites para a

MegaSena.

# ---------------------------- MegaSena.py

import ran”om

34
# ---------------------------- repeti”o
”ef repeti”o(num, n, t):
for i in range(n):
if num[i] == t:
return(True)
return(False)

# ---------------------------- imprime
”ef imprime(num):
for i in range(len(num)):
t = num[i]
print("%2” " %t, sep='', en”='')
print()

“h = 's'
while “h in ['S', 's']:
palpites = int(input("Número ”e palpites: "))
for i in range(palpites):
num = []
n = 1
num.appen”(ran”om.ran”int(1, 60))
while n != 6:
t = ran”om.ran”int(1, 60)
if not(repeti”o(num, n, t)):
num.appen”(t)
n = n + 1
num.sort() # or”ena a lista
imprime(num)
“h = input("Continua [s/n]?")

Teste ”o Programa:

======== RESTART: /Users/pluzzar”i/Desktop/MegaSena.py =============

Número ”e palpites: 5
3 9 14 17 26 40
2 7 10 12 28 54
9 13 16 30 36 39
2 26 29 43 47 54
5 12 23 31 37 55
Continua [s/n]?s
Número ”e palpites: 6
9 11 23 26 33 34
8 28 31 40 43 50
9 17 22 24 28 47
22 31 33 36 39 45
16 27 39 40 43 46
15 31 36 42 48 60
Continua [s/n]?n
>>>

19.1 Lista ”e Exer“í“ios ”e Vetores (listas)

35
 a) Es“reva um programa em Python que re“ebe via te“la”o um “onjunto
”e letras. Armazene to”as as letras em um vetor ou lista (letras)
até que o usuário ”igite apenas <enter>. Logo após “opie to”as as
letras (em or”em inversa) para outro vetor (inverso). Ao final
imprima os ”ois vetores (“onforme exemplo abaixo).

Teste ”o programa:

Letra: L <enter>
Letra: I <enter>
Letra: M <enter>
Letra: A <enter>
Letra: <enter>
[‘L’, ‘I’, ‘M’, ‘A’]
[‘A’, ‘M’, ‘I’, ‘L’]

b) Es“reva um programa em Python que re“ebe via te“la”o: número ”e

i”a”es e as respe“tivas i”a”es. Armazene to”as as i”a”es em um
vetor (i”a”e). Logo após a entra”a ”e to”as as i”a”es, o programa
”eve re“eber via te“la”o: i”a”e para “onsulta. O programa ”eve
imprimir na tela, o número ”e i”a”es antes ”a i”a”e ”e “onsulta e
o número ”e i”a”es ”epois ”a i”a”e ”e “onsulta (“onforme exemplo
abaixo). Exibir I”a”e não en“ontra”a se a i”a”e ”e “onsulta não
existir.

Teste ”o programa:

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>

“) Es“reva um programa em Python que re“ebe via te“la”o um “onjunto

”e números inteiros. Armazene to”os os números inteiros em um vetor
até que o usuário ”igite 0 (zero). Logo após permita ao usuário
“onsultar um número informan”o o seu valor. O programa ”eve
imprimir na tela a posição ”o número no vetor ou ERRO: Número não
en“ontra”o (veja exemplos abaixo):

Exemplo:

Número: 50 <enter>
Número: 30 <enter>

36
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: O programa termina quan”o o usuário ”igitar 0 (zero).

”) Es“reva um programa em Python que re“ebe via te“la”o "n" “on“eitos

(A, B, C, D e E) até que o usuário ”igite F ou f. Armazene to”os
os “on“eitos em um vetor (“on“eito). Imprima na tela o número ”e
alunos: aprova”os (A, B e C), reprova”os (D) e os infrequentes
(E).

Teste ”o programa:

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) Es“reva um programa em Python que re“ebe via te“la”o n nomes.

A entra”a ”os nomes termina quan”o o usuário ”igitar apenas
<enter>. Logo após a entra”a ”e to”os os nomes o programa ”eve
permitir a entra”a via te“la”o ”e uma letra. O programa ”eve
imprimir na tela to”os os nomes que “omeçam “om a letra
espe“ifi“a”a pelo usuário. O programa termina quanto o usuário
”igitar (na”a) na entra”a ”a letra (“onforme exemplos abaixo):

Teste ”o programa:

Nome: Paulo <enter>

Nome: Roberto <enter>
Nome: Renato <enter>
Nome: Pedro <enter>
Nome: Fabio <enter>
Nome: <enter>
Letra: R <enter>
Nome: Roberto

37
Nome: Renato
Letra: P <enter>
Nome: Paulo
Nome: Pedro
Letra: T <enter>
Letra: <enter>

f) Es“reva um programa em Python que re“ebe via te“la”o n nomes

e i”a”es. A entra”a ”os ”a”os termina quan”o o usuário ”igitar 'N'
ou 'n' na pergunta "Continua [S/N]?". Logo após a entra”a ”e to”os
os ”a”os o programa ”eve imprimir na tela to”os os nomes e i”a”es
”es”e o mais velho até o mais novo.

Teste ”o programa:

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ões ”e prova

A seguir são apresenta”as ”iversas questões ”e provas. Resolva-

as, pois elas servirão “omo um simula”o para treino ”a linguagem ”e
programação Python.

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

38
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.

39
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

40
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

41
 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. Es“reva um programa em Python que re“ebe via te“la”o n nomes e

i”a”es. A entra”a ”os ”a”os termina quan”o o usuário ”igitar 'N' ou 'n'
na pergunta "Continua [S/N]?". Logo após a entra”a ”e to”os os ”a”os o

42
programa ”eve imprimir na tela to”os os nomes e i”a”es em or”em
alfabéti“a (“onforme exemplo abaixo).

Teste do programa:

Nome: Beatriz <enter>

I”a”e: 12 <enter>
Continua [S/N]? s <enter>
Nome: Carla <enter>
I”a”e: 13 <enter>
Continua [S/N]? s <enter>
Nome: Debora <enter>
I”a”e: 15 <enter>
Continua [S/N]? s <enter>
Nome: Ana <enter>
I”a”e: 14 <enter>
Continua [S/N]? N <enter>
Ana 14
Beatriz12
Carla 13
Debora 15

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]
Lista por Extenso: [10, 10, 10, 20, 20, 20, 20, 30, 30]
Total ”e valores por extenso: 9

21. Curiosi”a”es e testes no Python

A seguir são vistos algumas “uriosi”a”es e testes feitos no

Python:

# --------------------------------- Teste.py

# ==================== ini“ialização ”e várias variáveis

43
a, b = 10, 20
print(a, b)

# ==================== None (nulo ou null

x = None # None é nulo ou null

x = 5
print(x)

# ===================== imprimir várias variáveis

x = 10
y = 20
print("x = %” - y = %”\n" %(x, y)) # print formata”o

# ===================== ”efinição ”e uma função em Python

”ef maior(x, y):

if x > y:
return(x)
else:
return(y)

print(maior(3,4))

# ============================== if simples

x = int(input("Digite um Número: "))

if x < 0:
print('Valor Negativo')
print("Número Digita”o: ", x)

# ============================== imprimir uma string

for letter in "python":

print(letter)

# ============================== if ... elif ... else ...

numero = int(input("Digite um Número: "))

if numero > 0:
print("Positivo")
elif numero < 0:
print("Negativo")
else:
print("Zero")

# ================================== ”ata e hora

from ”atetime import ”atetime

”ata = ”atetime.now()

44
print(”ata)
print("Data: %02”/%02”/%”" %(”ata.”ay, ”ata.month, ”ata.year))
print("Tempo: %02”:%02”:%02”" %(”ata.hour, ”ata.minute, ”ata.se“on”))

Teste ”o Programa:

10 20
5
x = 10 - y = 20

4
Digite um Número: -5
Valor Negativo
Número Digita”o: -5
p
y
t
h
o
n
Digite um Número: 0
Zero
2017-03-08 14:47:17.866354
Data: 08/03/2017
Tempo: 15:01:59
>>>

# ----------------------------------- str.py

s = ""
for i in range(10):
s = s + str(i) + ", " # forma uma string “om números
print(s)

Teste ”o Programa:

========== RESTART: /Users/pluzzar”i/Do“uments/str.py ===========

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
>>>

22. Funções es“ritas pelo programa”or em Python

Em Python é possível o programa”or es“rever suas próprias funções,

ou seja, ”ivi”ir os programas em mó”ulos menores (programação mo”ular
ou estrutura”a ou ”ivi”ir para “onquistar). Uma função ”eve ser uma
“aixa preta, que ”epois ”e fun“ionar não pre“isa mais manutenção. Uma
função po”e ou não re“eber argumentos (parâmetros) e retornar ou não um
valor.

45
 Para es“rever uma função usa-se a palavra reserva”a ”ef. A
prin“ípio a função ”eve estar lo“aliza”a antes ”a “hama”a ”a função. A
sintaxe é:

”ef nome‘função(lista ”e argumentos):

“oman”o1
“oman”o2
return(valor)

“hama”a‘função(argumentos)

Exemplo:

# -------------------------------- Fun“oes.py

import math

”ef Hipotenusa(a, b):

h = math.sqrt(a**2 + b**2)
return(h)

”ef Maior(a, b):

if a >= b:
return(a)
else:
return(b)

”ef Menor(a, b):

if a <= b:
return(a)
else:
return(b)

a = float(input("Digite um valor (a): "))

b = float(input("Digite outro valor (b): "))
print("Hipotenusa: ", Hipotenusa(a,b))
print("Maior: ", Maior(a, b))
print("Menor: ", Menor(a, b))

Teste ”o Programa:

===== RESTART: /Users/pluzzar”i/Do“uments/Fun“oes.py ====

Digite um valor (a): 3 <enter>
Digite outro valor (b): 4 <enter>
Hipotenusa: 5.0
Maior: 4.0
Menor: 3.0
>>>

Exemplo usan”o uma função Raiz, usan”o um “on“eito ”a matemáti“a:

46
”ef Raiz(x):
r = x ** 0.5
return(r)

”ef Hipotenusa(a, b):

h = Raiz(a*a + b*b)
return(h)

a = float(input("Digite um valor (a): "))

b = float(input("Digite outro valor (b): "))
print("Hipotenusa: ", Hipotenusa(a,b))

Teste ”o Programa:

===== RESTART: /Users/pluzzar”i/Do“uments/Raiz.py ====

Digite um valor (a): 3 <enter>
Digite outro valor (b): 4 <enter>
Hipotenusa: 5.0

Funções re“ursivas em Python:

Uma função é ”ita re“ursiva quan”o faz “hama”a a si própria, “a”a “hama”a é
“olo“a”a na pilha ”e exe“ução ”o sistema e serve para retornar as “hama”as anteriores.

# ---------------------------------------------- Fatorial.py
# Exemplo ”e função re“ursiva, função que “hama a si própria
# É “omplexo o ponto ”e para”a
# ----------------------------------------------------------

”ef Fatorial(n):
if n <= 1:
return(1)
fat = n * Fatorial(n-1)
return(fat)

x = int(input("Digite um valor: "))

fat = Fatorial(x)
print("Fatorial: ", fat)

Teste ”o Programa:

=== RESTART: /Users/pluzzar”i/Do“uments/Fatorial.py =====

Digite um valor: 20 <enter>
Fatorial: 2432902008176640000
>>>
O programa a seguir, “al“ula o valor ”a série ”e Fibona““i:

# ...................... Fibonacci.py

def Fibonacci(n):
if n == 0:

47
 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='')

Teste ”o Programa:

Fibona““i ”e: 15 <enter>

A sequên“ia ”e Fibona““i é: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377,

O programa a seguir, imprime na tela números em sequên“ia em or”em

reversa re“ursivamente:

# ..................... Imprime.py

n = int(input("Número: "))
Imprime(n)

def Imprime(n):
if n == 0:
return
else:
print(n)
Imprime(n-1)

Teste ”o Programa:

Número: 5 <enter>
5
4
3
2
1

A seguir é visto um exemplo que mostra ”uas funções que permitem

entra”a ”e ”a”os ”e números reais (REAL) ou números inteiros (INTEIRO)
via te“la”o sem erro, ou seja, o usuário po”e “ometer erros ”e ”igitação
que o programa não é aborta”o.

# ---------------------------------------------------------- Float.py
# O programa testa a “onversão ”e string para float ou inteiro
# sem erro na entre”a ”e ”a”os “om input
# -------------------------------------------------------------------

”ef REAL(s):
n = len(s)
temLetras = False

48
 for i in range(n):
if s[i] == ',':
s = s.repla“e(',','.') # tro“ar vírgula por ponto
if s[i] == '-' an” i != 0: # verifi“a o sinal negativo
temLetras = True;
break
if s[i] not in ['.', ',', '-', '0', '1', '2', '3', '4', '5', '6', '7', '8','9']:
temLetras = True
break
if not temLetras:
numero = float(s)
return(numero)
else:
print("ERRO: Conversão Inváli”a")
return(-1)

”ef INTEIRO(s):
n = len(s)
temLetras = False
for i in range(n):
if s[i] == '-' an” i != 0:
temLetras = True;
break
if s[i] not in ['-', '0', '1', '2', '3', '4', '5', '6', '7', '8','9']:
temLetras = True
break
if not temLetras:
numero = int(s)
return(numero)
else:
print("ERRO: Conversão Inváli”a")
return(-1)

s = input("Digite um Real: ")

numero = REAL(s)
if numero != -1:
print("Real ”igita”o foi: ", numero)
while numero == -1:
s = input("Digite um Real: ")
numero = REAL(s)
print("Número ”igita”o: ", numero)

s = input("Digite um Inteiro: ")

numero = INTEIRO(s)
if numero != -1:
print("Inteiro ”igita”o foi: ", numero)
while numero == -1:
s = input("Digite um Inteiro: ")
numero = INTEIRO(s)
print("Número ”igita”o: ", numero)

Teste ”o Programa:

===== RESTART: /Users/pluzzar”i/Desktop/Python/Python/float.py =====

49
Digite um Real: 1234Paulo
ERRO: Conversão Inváli”a
Digite um Real: 123,45
Número ”igita”o: 123.45
Digite um Inteiro: paulo123
ERRO: Conversão Inváli”a
Digite um Inteiro: 123
Número ”igita”o: 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)

50
x = float(input("Digite um Valor: "))
y = float(input("Digite outro Valor: "))
operador = input("Operação [+ - * / **]: ")
valor = calculadora(x, y, operador)
print(valor)

Teste ”o Programa:

Digite um Valor: 3
Digite outro Valor: 4
Operação [+ - * / **]: /
0.75

Teste ”o Programa:

Digite um Valor: 3
Digite outro Valor: 0
Operação [+ - * / **]: /
Erro: Divisão por Zero

Teste ”o Programa:

Digite um Valor: 3
Digite outro Valor: 4
Operação [+ - * / **]: &
ERRO: Opera”or Inváli”o

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)

Teste ”o Programa:

x = 3

51
y = 4
a = 4
b = 3

22.1 Exer“í“ios sobre funções em Python

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)

Teste ”o Programa:

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 = "))

52
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")

Teste ”o Programa:

a = 1 <enter>
b = 2 <enter>
“ = -3 <enter>
Raizes Reais
x1 = 1.0
x2 = -3.0

Teste ”o Programa:

a = 1 <enter>
b = 2 <enter>
“ = 3 <enter>
Erro: Raizes Complexas

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)

Teste ”o Programa:

Nome: Paulo Roberto Gomes Luzzar”i <enter>

Seu nome tem 4 palavra(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)

53
Teste ”o Programa:

Data [””/mm/aaaa]: 25/03/2018 <enter>

Dia: 25
Mês: 3
Ano: 2018

Teste ”o Programa:

Data [””/mm/aaaa]: 25/03/18 <enter>

ERRO: Formato Inváli”o

Teste ”o Programa:

Data [””/mm/aaaa]: 32/03/18 <enter>

ERRO: Dia Inváli”o

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)

Teste ”o Programa:

x = 2
y = -2
Qua”rante: 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)

Teste ”o Programa:

Pla“a [xxx9999]: etq1234 <enter>

Final ”a Pla“a é: 34

Teste ”o Programa:

Pla“a [xxx9999]: etq123 <enter>

ERRO: Formato Inváli”o

54
23. Criação e utilização ”e mó”ulos em Python

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)

Teste ”o Programa:

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)

55
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))

Teste ”o Programa:

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: Note que não é ne“essário return no final ”a função, o término ”a

função é pela i”entação.

56
# ....................... 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))

Teste ”o Programa:

x = 3
y = 4
x = 4
y = 3
Maior: 4
Menor: 3

Em Python é possível o programa”or es“rever suas próprias funções

”entro ”e um mó”ulo e inseri-lo em seus programas. O mó”ulo é um arquivo
Python (mo”ulo.py) somente “om ”efinições ”e funções. A prin“ípio, este
mó”ulo ”eve estar junto ao programa fonte, ou seja, na mesma lo“alização.

#--------------------------------------------------------- Luzzar”i.py
# O programa testa a “onversão ”e string para float ou inteiro
# sem erro na entra”a ”e ”a”os “om input
# -------------------------------------------------------------------

”ef REAL(s):
n = len(s)
temLetras = False
for i in range(n):
if s[i] == ',':
s = s.repla“e(',', '.') # “onverte vírgula em ponto
if s[i] == '-' an” i != 0: # verifi“a sinal negativo
temLetras = True;
break
if s[i] not in ['.', '-', '0', '1', '2', '3', '4', '5', '6', '7', '8','9']:
# verifi“a “ara“teres não numéri“os
temLetras = True
break
if not temLetras:
numero = float(s)
return(numero)
else:
print("ERRO: Conversão Inváli”a")
return(-1) # retorna um valor inváli”o

57
”ef INTEIRO(s):
n = len(s)
temLetras = False
for i in range(n):
if s[i] == '-' an” i != 0:
temLetras = True;
break
if s[i] not in ['-', '0', '1', '2', '3', '4', '5', '6', '7', '8','9']:
temLetras = True
break
if not temLetras:
numero = int(s)
return(numero)
else:
print("ERRO: Conversão Inváli”a")
return(-1)

# ---------------------------------------- Mo”ulo.py

import Luzzar”i # inserção ”o mó”ulo ”o programa”or

s = input("Digite um Real: ")

numero = luzzar”i.REAL(s)
if numero != -1:
print("Real ”igita”o foi: ", numero)
while numero == -1:
s = input("Digite um Real: ")
numero = luzzar”i.REAL(s)
print("Número ”igita”o: ", numero)

s = input("Digite um Inteiro: ")

numero = luzzar”i.INTEIRO(s)
if numero != -1:
print("Inteiro ”igita”o foi: ", numero)
while numero == -1:
s = input("Digite um Inteiro: ")
numero = luzzar”i.INTEIRO(s)
print("Número ”igita”o: ", numero)

======= RESTART: /Users/pluzzar”i/Desktop/Python/Python/Mo”ulo.py ===

Digite um Real: 1234Paulo
ERRO: Conversão Inváli”a
Digite um Real: 123,45
Número ”igita”o: 123.45
Digite um Inteiro: 123Paulo
ERRO: Conversão Inváli”a
Digite um Inteiro: 123
Número ”igita”o: 123
>>>

24. Tratamento ”e erros (ex“eções)

58
 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

import math

try:
num = int(input("Digite um Número: "))
try:
raiz = math.sqrt(num)
print("Raiz Qua”ra”a: ", raiz)
ex“ept ValueError as error:
print("Erro: ", error)
ex“ept ValueError as error:
print("Erro: ", error)

Teste ”o Programa:

59
========== 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)
Teste ”o Programa:

======= 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

60
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)

Teste ”o Programa:

========== RESTART: /Users/pluzzar”i/Do“uments/NameError.py ========

Valor: 5
ERRO: name 'soma' is not ”efine”
ERRO: must be str, not int
>>>

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)

Teste ”o Programa:

========= 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:

61
 file = open(nomeArquivo, 'r')
except IOError as error:
print("Erro: ", error)
else:
print("Nome do Arquivo: ", nomeArquivo)
file.close()

Teste ”o Programa:

========== 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. Ban“o ”e Da”os em Python (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

import sqlite3

nomeBD = input("Nome ”o Ban“o ”e Da”os: ")

“one“tor = sqlite3.“onne“t(nomeBD)
“ursor = “one“tor.“ursor()
“ursor.exe“ute('''
“reate table agen”a (
i” integer, # i”entifi“a”or
nome text,
fone text)
''')
i” = 1
nome = "Pessoa"
while nome != "":
print("i”: ", i”)
nome = input("Nome: ")
if nome != "":
fone = input("Fone: ")

62
 “ursor.exe“ute('''
insert into agen”a (i”, nome, fone)
values(?, ?, ?)
''', (i”, nome, fone))
“one“tor.“ommit()
i” = i” + 1
“ursor.“lose()
“one“tor.“lose()
print("Ban“o ”e Da”os foi CRIADO: ", nomeBD)

Teste ”o Programa:

====== RESTART: /Users/pluzzar”i/Desktop/Python/SQLiteCriaBD.py =====

Nome ”o Ban“o ”e Da”os: Agen”a.b”
i”: 1
Nome: Paulo Roberto
Fone: 99164-8037
i”: 2
Nome: A”riane Maria
Fone: 99145-6789
i”: 3
Nome: Paola Maria
Fone: 98478-7856
i”: 4
Nome:
Ban“o ”e Da”os foi CRIADO: Agen”a.b”
>>>

O programa a seguir faz uma leitura dos campos do banco

de dados (Agenda.bd) gerado pelo programa anterior.

# -------------------------- SQLiteLeBD.py

import sqlite3 # as lite

import os

nomeBD = input("Nome ”o Ban“o ”e Da”os: ")

try: # tratamento ”e ex“eção
“one“tor = sqlite3.“onne“t(nomeBD)
“ursor = “one“tor.“ursor()
numRegistros = 0
“ursor.exe“ute("SELECT * FROM agen”a")
result = “ursor.fet“hall()
for “ontato in result:
print("i”: %”\nNome: %s \nFone: %s" % (“ontato))
numRegistros += 1
print(numRegistros, "registro(s)")
“ursor.“lose()
“one“tor.“lose()
ex“ept sqlite3.Error as error: # exe“uta quan”o o“orre um erro
print("Erro: BD não en“ontra”o")
print("Erro: ", error)
os.remove(nomeBD) # remove arquivo “ria”o

63
Teste ”o Programa:

====== RESTART: /Users/pluzzar”i/Desktop/Python/SQLiteLeBD.py =======

Nome ”o Ban“o ”e Da”os: Luzzar”i.b”
i”: 1
Nome: Paulo Roberto
Fone: 99164-8037
i”: 2
Nome: A”riane Maria
Fone: 99156-4567
i”: 3
Nome: Paola Maria
Fone: 98434-1234
3 registro(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

import sqlite3, os

nomeBD = input("Nome ”o Ban“o ”e Da”os: ")

try:
“one“tor = sqlite3.“onne“t(nomeBD)
i” = '1'
“ursor = “one“tor.“ursor()
while i” != '0':
i” = input('Digite o ín”i“e [0 - Sair]: ')
if i” != '0':
“ursor.exe“ute("SELECT * FROM agen”a WHERE i”=?",(i”))
result = “ursor.fet“hall()
a“hei = False
for “ontato in result:
print("i”: %”\nNome: %s \nFone: %s" % (“ontato))
a“hei = True
if not a“hei:
print("Erro: Contato não En“ontra”o")
“ursor.“lose()
“one“tor.“lose()
ex“ept sqlite3.Error as error:
print("ERRO: BD não en“ontra”o")
print("Erro: ", error)
os.remove(nomeBD) # remove arquivo “ria”o

Teste ”o Programa:

=== RESTART: /Users/pluzzar”i/Desktop/Python/SQLiteConsultaBD.py ====

Nome ”o Ban“o ”e Da”os: Agen”a.b”

64
Digite o ín”i“e [0 - Sair]: 1
i”: 1
Nome: Paulo Roberto
Fone: 99164-8037
Digite o ín”i“e [0 - Sair]: 2
i”: 2
Nome: A”riane Maria
Fone: 99156-4567
Digite o ín”i“e [0 - Sair]: 3
i”: 3
Nome: Paola Maria
Fone: 98434-1234
Digite o ín”i“e [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

import sqlite3, os

nomeBD = input("Nome ”o Ban“o ”e Da”os: ")

try:
“one“tor = sqlite3.“onne“t(nomeBD)
“ursor = “one“tor.“ursor()
i” = '1'
while i” != '0':
i” = input("Digite o ín”i“e [0 - Sair]: ")
if i” != '0':
“ursor.exe“ute("DELETE FROM agen”a WHERE i”=?",(i”))
“one“tor.“ommit()
print("Okay, Contato REMOVIDO")
“ursor.“lose()
“one“tor.“lose()
ex“ept sqlite3.Error as error:
print("Erro: BD não en“ontra”o")
print("Erro: ", error)
os.remove(nomeBD)

Teste ”o Programa:

===== RESTART: /Users/pluzzar”i/Desktop/Python/SQLiteRemoveBD.py ====

Nome ”o Ban“o ”e Da”os: Agen”a.b”
Digite o ín”i“e: 3
Digite o ín”i“e: 0
Okay, Contato REMOVIDO
>>>
======= RESTART: /Users/pluzzar”i/Desktop/Python/SQLiteLeBD.py =====
Nome ”o Ban“o ”e Da”os: Agen”a.b”
i”: 1
Nome: Paulo Roberto

65
Fone: 99164-8037
i”: 2
Nome: A”riane Maria
Fone: 99156-4567
>>>

# ------------------------ SQLiteAppen”BD.py

import sqlite3, os

nomeBD = input("Nome ”o Ban“o ”e Da”os: ")

try:
“one“tor = sqlite3.“onne“t(nomeBD)
“ursor = “one“tor.“ursor()

i” = 1
“ursor.exe“ute("SELECT * FROM agen”a")
result = “ursor.fet“hall()
for “ontato in result:
i” += 1

nome = "Pessoa"
while nome != "":
print("i”: ", i”)
nome = input("Nome: ")
if nome != "":
fone = input("Fone: ")
“ursor.exe“ute('''
INSERT INTO agen”a (i”, nome, fone)
values(?, ?, ?)
''', (i”, nome, fone))
“one“tor.“ommit()
i” = i” + 1
“ursor.“lose()
“one“tor.“lose()
ex“ept sqlite3.Error as error:
print("Erro: BD não en“ontra”o")
print("Erro: ", error)
os.remove(nomeBD)

Teste ”o Programa:

==== RESTART: /Users/pluzzar”i/Desktop/Python/SQLiteAppen”BD.py =====

Nome ”o Ban“o ”e Da”os: Agen”a.b”
i”: 4
Nome: Renato Luis
Fone: 99134-2345
i”: 5
Nome: Ca“aio
Fone: 99891-3456
i”: 6
Nome:
>>>

66
Exe“ução ”o programa SQLiteLeBD.py

======= RESTART: /Users/pluzzar”i/Desktop/Python/SQLiteLeBD.py =====

Nome ”o Ban“o ”e Da”os: Agen”a.b”
i”: 1
Nome: Paulo Roberto
Fone: 99164-8037
i”: 2
Nome: A”riane Maria
Fone: 99156-4567
i”: 3
Nome: Paola Maria
Fone: 98434-1234
i”: 4
Nome: Renato Luis
Fone: 99134-2345
i”: 5
Nome: Ca“aio
Fone: 99891-3456
5 registro(s)
>>>

26. Sistema ”e Arquivos em Python

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

67
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)

Teste ”o Programa:

======== 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)

Teste ”o Programa:

====== 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
>>>

Teste ”o Programa: (Arquivo texto não existe)

====== RESTART: /Users/pluzzardi/Documents/FileLeDadosTexto.py ====

Nome do Arquivo: Dados.bd
ERRO: [Errno 2] No such file or directory: 'Dados.bd'
>>>

68
# -------------------------------------- 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)

Teste ”o Programa:

======== 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:
>>>

Listagem ”o Arquivo altera”o: Da”os.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 != "":

69
 fone = input("Fone: ")
linha = str(id) + ";" + nome + ";" + fone + ";" + "\n"
file.write(linha)
id = id + 1
file.close()
except IOError as error:
print("ERRO: ", error)

Teste ”o Programa:

======= 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:
>>>

Listagem ”o Arquivo: 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)

Teste ”o Programa:

RESTART:
/Users/pluzzardi/Desktop/Python/Python/File/FileProcuraDadosTexto.py
Nome do Arquivo: Dados.txt
Posição [0 - Sair]: 1

70
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)

Teste ”o Programa:

RESTART:
/Users/pluzzardi/Desktop/Python/Python/File/FileBuscaDadosTexto.py
Nome do Arquivo: Dados.txt
Nome: Paulo
Erro: Nome não encontrado

71
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. Arquivos Binários em Python

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:

72
 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: Note que o número ”e elementos também é salvo no arquivo binário, para
”epois ser li”o no programa que “arrega o arquivo binário.

Teste ”o Programa:

Nome ”o Arquivo Binário: teste.bin <enter>

Número ”e Elementos: 3 <enter>
Nome: Paulo Roberto <enter>
Telefone: 99164-8037 <enter>
I”a”e: 56 <enter>
Nome: A”riane Maria <enter>
Telefone: 99156-3334 <enter>
I”a”e: 48 <enter>
Nome: Paola Freitas <enter>
Telefone: 99167-4567 <enter>
I”a”e: 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)

Teste ”o Programa:

Nome ”o Arquivo Binário: teste.bin <enter>

73
Número ”e Elementos: 3 <enter>
Nome: Paulo Roberto <enter>
Telefone: 99164-8037 <enter>
I”a”e: 56 <enter>
Nome: A”riane Maria <enter>
Telefone: 99156-3334 <enter>
I”a”e: 48 <enter>
Nome: Paola Freitas <enter>
Telefone: 99167-4567 <enter>
I”a”e: 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)

Teste ”o Programa:

Nome ”o Arquivo Binário: ”a”os.bin <enter>

n = 9
Okay, Arquivo ”a”os.bin “ria”o

# ............................. 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()

Teste ”o Programa:

Nome ”o Arquivo Binário: ”a”os.bin

74
Lista: ['Paulo Roberto', '99164-8037', 56, 'A”riane Maria', '99156-3334', 48, 'Paola
Freitas', '99181-3456', 19]

Arquivo Texto: Frutas.txt

Aba“ate
Ameixa
Banana
Bergamota
Anana
Morango
Caqui
Uva
Laranja
Lima
Goiaba
Damas“o
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")

Teste ”o Programa:

Nome ”o Arquivo Texto: Frutas.txt <enter>

Aba“ate
Ameixa
Banana
Bergamota
Anana
Morango
Caqui
Uva
Laranja
Lima
Goiaba
Damas“o
Tangerina

# .............................. ConverteTextoBinario.py

import pickle

nomeArquivoTexto = input("Nome do Arquivo Texto: ")

nomeArquivoBinario = input("Nome do Arquivo Binário: ")

75
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")

Teste ”o Programa:

Nome ”o Arquivo Texto: Frutas.txt <enter>

Nome ”o Arquivo Binário: Frutas.bin <enter>
Aba“ate

Ameixa

Banana

Bergamota

Anana

Morango

Caqui

Uva

Laranja

Lima

Goiaba

Damas“o

Tangerina

# ........................ LeTextoConvertidoBinario.py

import pickle

nomeArquivo = input("Nome do Arquivo Binário: ")

try:
file = open(nomeArquivo, "rb")
try:
while True:
linha = pickle.load(file)

76
 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)

Teste ”o Programa:

Nome ”o Arquivo Binário: Frutas.bin <enter>

Aba“ate

Banana

Anana

Caqui

Laranja

Goiaba

Tangerina

Atenção: Final ”o Arquivo

Atenção: Função que verifi“a se um arquivo já 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:

77
 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")

Teste ”o Programa:

Nome Arquivo Binário: Da”os.bin <enter>

Nome: Paulo Roberto
I”a”e: 56
Continua [s/n]? s
Nome: A”riane Maria
I”a”e: 48
Continua [s/n]? s
Nome: Paola Freitas
I”a”e: 19
Continua [s/n]? s
Nome: Julia Helena
I”a”e: 58
Continua [s/n]? s
Nome: Ana Maria
I”a”e: 59
Continua [s/n]? n

30. So“kets em Python

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:

78
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_STREA
M): 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.

79
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()

80
# 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:

81
82
31. Threa”s em Python

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ó”ulo tkinter para GUI em Python

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.“om/wat“h?v=vmoH9I9”570&list=PLesCE“Yj003ShHnUT83gQEH6KtG8uysUE&in”ex=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)

83
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:

84
 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:

85
 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:

86
 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:

87
 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).

88
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).

89
# ........................ 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()

90
 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").

91
# ............................. 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()

92
 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()

93
94