Algoritmos_e_Programacao_em_Python

Prévia do material em texto

1 
	
	
	
	
Algoritmos	e	Programação	em	Python	
	
por	
	
	
Prof. Dr. Paulo Roberto Gomes Luzzardi 
	
	
	
	
facebook: Paulo Roberto Gomes Luzzardi 
WhatsApp: 99164-8037 
e-mail: pluzzardi@gmail.com (principal) e pluzzardi@yahoo.com.br 
e-mail (Senac): prgomesluzzardi@senacrs.edu.br 
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	recomendada:	
	
MENEZES,	 Nilo	 Ney	 Coutinho.	 Introdução	 à	 Programação	 com	 Python:	
Algoritmos	e	Lógica	de	Programação	para	Iniciantes.	São	Paulo:	Editora	
Novatec,	2010	(ISBN	978-85-7522-250-8).	
	
	
Pelotas,	quarta-feira,	2	de	maio	de	2018	(09:48	am)	
 
 2 
Sumário	
	
1.	Linguagem	de	Programação	Python .................................................................... 4 
2.	Como	executar	comandos	em	Python .................................................................. 4 
3.	Entrar	na	IDLE	do	Python ................................................................................. 4 
4.	Primeiros	comandos	ou	instruções .................................................................. 4 
5.	Identificadores	e	variáveis............................................................................ 5 
6.	Operadores	aritméticos ..................................................................................... 6 
6.1	Hierarquia	dos	operadores	(precedência)................................................... 7 
7.	Comando	print	(imprimir	dados	na	tela) ...................................................... 7 
8.	Comando	input	(ler	dados	do	teclado) .......................................................... 9 
9.	Deletar	uma	variável	(del) ............................................................................. 9 
10.	Módulos	(import) ............................................................................................. 10 
11.	Funções	de	matemáticas	(math) .................................................................... 11 
12.	Strings	(cadeia	de	caracteres) .................................................................. 13 
12.1	Funções	para	Strings ................................................................................... 13 
13.	Comandos:	Sequência,	Seleção	e	Repetição ............................................... 15 
13.1	Comandos	de	Sequência ................................................................................. 15 
13.2	Lista	de	Exercícios	(Comandos	de	sequência) ....................................... 17 
14.	Operadores	relacionais ................................................................................. 20 
15.	Operadores	lógicos ......................................................................................... 20 
16.	Comando	de	Seleção	(if) ............................................................................... 20 
16.1	Lista	de	Exercícios	(Comando	de	Seleção	if) ....................................... 23 
17.	Contador	e	acumulador ................................................................................... 24 
18.	Comandos	de	Repetição	(while	e	for) ........................................................ 25 
18.1	range	(faixa) ................................................................................................. 27 
18.2	Lista	de	Exercícios	(Comando	de	Repetição	while	e	for) .................. 28 
19.	Listas	em	Python	(vetores).......................................................................... 29 
19.1	Lista	de	Exercícios	de	Vetores	(listas) ............................................... 35 
20.	Questões	de	prova ........................................................................................... 38 
21.	Curiosidades	e	testes	no	Python ................................................................ 43 
22.	Funções	escritas	pelo	programador	em	Python ......................................... 45 
22.1	Exercícios	sobre	funções	em	Python ........................................................ 52 
23.	Criação	e	utilização	de	módulos	em	Python ............................................. 55 
24.	Tratamento	de	erros	(exceções) .................................................................. 58 
25.	Banco	de	Dados	em	Python	(SQLite) ............................................................ 62 
26.	Sistema	de	Arquivos	em	Python .................................................................... 67 
29.	Arquivos	Binários	em	Python ........................................................................ 72 
30.	Sockets	em	Python ........................................................................................... 78 
31.	Threads	em	Python ........................................................................................... 83 
32.	Módulo	tkinter	para	GUI	em	Python ............................................................ 83 
 
 
 
 
 3 
 
 
Lista de Exercícios do Prof. Dr. Ricardo Andrade Cava 
	
DropBox:	
	
https://www.dropbox.com/sh/kea9kr4j2qttnjg/AAAGkXES6sWvRKCJh8R7x9aia/ListaCava?dl=0	
	
 
 
1.	Linguagem	de	Programação	Python	
	
	 Python	é	uma	linguagem	de	programação	interpretada	(onde	cada	linha	
é	compilada	e	executada,	uma	por	vez),	ou	seja,	não	é	compilada	(onde	
todo	o	programa	é	traduzido	para	linguagem	de	máquina	e	posteriormente	
executado).	Em	Python,	cada	comando	tem	sua	sintaxe	verificada,	sendo	
executado	a	seguir.		
	 Python	é	uma	linguagem	de	alto	nível	e	um	software	livre,	ou	seja,	
não	 se	 paga	 por	 sua	 utilização.	 É	 utilizado	 em	 muitas	 aplicações,	
inclusive	em	Redes	de	Computadores	para	criação	de	scripts	utilizados	
em	servidores	e	outras	aplicações	da	área,	além	de	ser	uma	linguagem	de	
uso	geral.	
2.	Como	executar	comandos	em	Python	
 
Windows:	Iniciar	...	Programas	...	Python	3.?	(versão)	
	
Linux:	$	python3.?	(versão	–	digite	TAB	para	descobrir)	
	
MacOsX:	$	python3.?	(TAB	para	descobrir	as	versões	instaladas)	
	
3.	Entrar	na	IDLE	do	Python	
 
	 IDLE	é	a	Interface	Gráfica	da	Linguagem	de	Programação	Python	que	
permite	a	edição	e	execução	dos	programas	escritos	em	Python.	
	
Windows:	Iniciar	...	Programas	...	Python	3.?	(versão)	...	IDLE	
	
Linux:	$	idle-python3.6	&	<enter>	
	
MacOsX:	$	idle3.6	<enter>	
	
Observação:	Todo	programa	fonte	em	Python	possui	a	extensão	“.py”.		
	
Instalação	e	download	do	Python:	http://www.python.org	
4.	Primeiros	comandos	ou	instruções	
 
	 Python	permite	executar	comandos	ou	instruções,	tais	como:	
	
Imprimir	na	tela:		 >>>	print(“Hello”)	<enter>	
	 	 	 	 Hello	
	
Realizar	operações	matemáticas:		 >>>	3	+	4	<enter>	
	 	 	 	 	 	 	 7	
	 	 	 	 	 	 	 >>>	2	**	3	<enter>	
 
 5 
	 	 	 	 	 	 	 8	
	 	 	 	 	 	 	 >>>	
	
Operações	mais	complexas:		 >>>	a	=	3	<enter>	
	 	 	 	 	 	 >>>	b	=	4	<enter>	
	 	 	 	 	 	 >>>	c	=	a	+	b	<enter>	
	 	 	 	 	 	 >>>	print(a,	b,	c)	<enter>	
	 	 	 	 	 	 3	4	7	
	 	 	 	 	 	 >>>	print(“c	=	“,	c)	<enter>	
	 	 	 	 	 	 c	=	7	
	 	 	 	 	 	 >>>	print(3>4)	<enter>	
	 	 	 	 	 	 False	 	 #	valor	lógico	
	 	 	 	 	 	 >>>	
5.	Identificadores	e	variáveis	
	
	 Identificadores	são	os	nomes	criados	pelo	programador	para	fazer	
referência	a	variáveis,	constantes,	funções	e	módulos.	
	
Regras	para	a	criação	de	identificadores:	
	
ü O	primeiro	caracter	deve	ser	uma	letra	ou	sublinha	(_);	
ü Os	caracteres	seguintes	devem	ser	letras,	números	ou	sublinhas;	
ü Não	há	limite	de	caracteres;	
ü Não	é	permitido	a	utilização	de	caracteres	em	branco	(caracter	espaço);	
ü Podem	ser	letras	maiúsculas	e	minúsculas,	pois	são	diferenciados.	
	
Comentário	do	programador:		
	
#	não	é	interpretado	-	comentário	de	uma	linha	
	
”””	
comentário	em	mais	de	uma	linha	
Não	é	interpretado	
”””	
	
’’’	
comentário	em	mais	de	uma	linha	
Não	é	interpretado	
’’’	
	
	 Variáveis	em	Python	existem	em	três	tipos:	int,	float	e	string.	
Na	declaração	de	cada	variável,	Python	especifica	o	tipo,	por	exemplo:	
a	 =	 3,	 a	 é	 declarado	 como	 int,	 b	 =	 3.4	 édeclarado	 como	 float,	 s	 =	
“Python”	ou	s	=	‘Python’	são	string’s.	
	
Função	type:	Exibe	o	Tipo	do	Dado.	
 
 6 
	
#	--------------------------	Type.py	
	
a	=	3	
print(type(a))	
b	=	3.4	
print(type(b))	
c	=	'Python'	
print(type(c))	
d	=	'A'	
print(type(d))	
	
Teste	do	Programa:	
	
=========	RESTART:	/Users/pluzzardi/Documents/Type.py	=========	
<class	'int'>	
<class	'float'>	
<class	'str'>	
<class	'str'>	
>>>	
	
Comando	 id:	 Retorna	 o	 identificador	 do	 objeto,	 número	 inteiro	 que	
identifica	cada	objeto	do	Python.	
	
>>>	a	=	3	
>>>	b	=	4	
>>>	print(id(a))	 #	32	bits	/	8	bits	=	4	bytes	(inteiro)	
4297624000	
>>>	print(id(b))	
4297624032	
>>>	
6.	Operadores	aritméticos	
	
	 Os	operadores	aritméticos	permitem	ao	programador	realizar	várias	
operações	 matemáticas,	 tais	 como:	 adição,	 subtração,	 divisão,	
multiplicação	e	potenciação.	A	seguir,	a	Tabela	1	exibe	os	operadores	
aritméticos	utilizados	em	Python.	
	
	
Tabela	1:	Operadores	Aritméticos	
Matemática	 Operador	aritmético	
Adição	 +	
Subtração	 -	
Multiplicação	 *	
Divisão	 /	
Potenciação	 **	
	
 
 7 
6.1	Hierarquia	dos	operadores	(precedência)	
 
	 A	Tabela	2,	a	seguir,	exibe	a	precedência	dos	operadores	do	Python,	
ou	seja,	a	ordem	de	execução	das	operações	matemáticas.	
	
	
	
 
Tabela	2:	Hierarquia	dos	Operadores	Aritméticos	
Ordem	de	
precedência	
Tipo	de	Operador	
Parênteses	 ()	
**	 Potenciação	
-	(unário)	 Unário	
*	/	%	//	
Multiplicação,	divisão,	modulo	(resto	inteiro	da	divisão)	
e	divisão	inteira	
+	-	 Adição	e	subtração	
	
Exemplos:	
 
>>>	7	/	2	 #	divisão	real	
3.5	
>>>	7	%	2	 #	resto	inteiro	da	divisão	(módulo)	
1	
>>>	7	//	2	 #	divisão	inteira	
3	
>>>	
7.	Comando	print	(imprimir	dados	na	tela)	
	
	 O	 comando	 print	 permite	 enviar	 (imprimir)	 para	 a	 tela	 qualquer	
informação	do	python,	como	números,	constantes,	resultados	de	operações,	
strings,	etc.	
	
Sintaxe	simples:	print(string,	lista_de_variáveis)	
	
Exemplos:	
	
>>>	print(4)	<enter>	
4	
>>>	print(3+4)	<enter>	
7	
>>>	print(3>4)	enter>	
False	 	 	 	 #	tipo	lógico	(True	ou	False)	
>>>	a	=	3	<enter>	
>>>	print(a)	<enter>	
3	
>>>	b	=	4	<enter>	
 
 8 
>>>	print(a+b)	<enter)	
7	
>>>	A	=	7	<enter>	
>>>	print(A+b)	<enter>	
11	
>>>	print(“a	=	”,	a)	<enter>	
a	=	3	
>>>	
>>>	print(4%2)	#	resto	inteiro	da	divisão	
0	
>>>		
>>>	print(3**4)	 #	Potenciação	
81	
>>>	número_dentes	=	32	<enter>	
>>>	print(“Número	de	Dentes:	“,	número_dentes)	<enter>	
>>>	Número	de	Dentes	=	32	
>>>	a	=	3	
>>>	b	=	4	
>>>	print("a	=	",	a,	"b	=	",	b)	
a	=	3	b	=	4	
>>>	dia	=	3	<enter>	
>>>	mês	=	7	<enter>	
>>>	ano	=	2017	<enter>	
>>>	print(“Data:	%02d/%02d/%d”	%(dia,	mês,	ano))	<enter>	
03/07/2017	 #	saída	formatada	
>>>	
	
Tabela	3:	Operadores	%	
Operador	%	 Significado	
%s	 Uma	string	
%c	 Caractere	
%d	 Decimal	inteiro	
%f	 Real	(float)	
%%	 Um	'%'	
	 	
	 Note	que	o	Python	permite	formatar	os	dados	que	serão	exibidos	na	
tela	através	do	print,	para	tanto	usa	os	operadores	da	Tabela	3,	acima.	
Repare	novamente	nos	exemplos	abaixo:	
	
>>>	dia	=	3	<enter>	
>>>	mês	=	7	<enter>	
>>>	ano	=	2017	<enter>	
>>>	print(“Data:	%02d/%02d/%d”	%(dia,	mês,	ano))	<enter>	
03/07/2017	
>>>	
	
#	==================================	data	e	hora	
	
from	datetime	import	datetime	
	
 
 9 
data	=	datetime.now()	
print(data)	
print("Data:	%02d/%02d/%d"	%(data.day,	data.month,	data.year))	
print("Tempo:	%02d:%02d:%02d"	%(data.hour,	data.minute,	data.second))	
	
8.	Comando	input	(ler	dados	do	teclado)	
	
	 O	 comando	 input	 permite	 ler	 informações	 via	 teclado,	 o	 valor	
digitado	pelo	usuário	é	lido	como	uma	string,	podendo	ser	convertido	
para	inteiro	(int)	ou	real	(float).	
	
Sintaxe:	string	input(string	mensagem)	
	
Exemplos:	
	
Entrada	de	uma	String:	
	
>>>	s	=	input(“Digite	um	Nome:	“)	<enter>	
>>>	Digite	um	Nome:	Luzzardi	<enter>	
>>>	print(len(s))	 #	número	de	caracteres	da	string	
8	
>>>	
	
Entrada	de	um	Inteiro:	
	
>>>	i	=	int(input(“Digite	um	Valor:	“))	<enter>	
>>>	Digite	um	Nome:	34	<enter>	
>>>	print(i)	
34	
>>>	
	
Entrada	de	um	Real	(float):	
	
>>>	i	=	float(input(“Digite	um	Valor:	“))	<enter>	
>>>	Digite	um	Nome:	34	<enter>	
>>>	print(i)	
34.0	
>>>	
	
Outra	forma,	em	duas	etapas:	
	
>>>	s	=	input("Digite	um	Valor:	")	<enter>	
Digite	um	Valor:	34	<enter>	
>>>	x	=	int(s)	<enter>	 #	conversão	para	inteiro	
>>>	print(x)	<enter>	
34	
>>>	
9.	Deletar	uma	variável	(del)	
	
 
 10 
	 Em	Python	é	possível	deletar	(apagar,	remover,	desalocar	da	memória	
RAM)	uma	variável	da	memória,	isto	é	feito	através	do	comando	del.	
	
Sintaxe:	>>>	del	variável	
	
Exemplo:	
	
>>>	a	=	3	<enter>	
>>>	print(a)	<enter>	
3	
>>>	del	a	
>>>	print(a)	
Traceback	(most	recent	call	last):	
		File	"<stdin>",	line	1,	in	<module>	
NameError:	name	'a'	is	not	defined	
	
Erro:	identificador	‘a’	não	definido	
	
Observação:	É	possível	também	reinicializar	o	terminal	(shell),	vá	na	
opção	 Shell	 ..	 Restart	 Shell,	 todas	 as	 variáveis	 são	 destruídas,	 ou	
seja,	desalocadas	da	memória	RAM	(Random	Acess	Memory).	
	
10.	Módulos	(import)	
	
	 Python	possui	um	conjunto	de	funções	pré-definidas	agrupadas	em	
estruturas	 chamadas	 de	 módulos,	 tais	 como:	 math	 (mathematics),	 os	
(sistema	operacional),	datetime	(data	e	hora),	etc.	
	
Forma	de	importar:	import	módulo	
	
Para	utilizar	a	função	de	um	módulo:	módulo.função(argumento)	
			
Para	importar	apenas	uma	função	desejada:	from	módulo	import	função	
	
Exemplos:		 >>>	import	math	<enter>	
	 	 >>>	print(math.pi)	<enter>	
3.141592653589793	
	 	 >>>	import	os	<enter>	
	 	 >>>	os.system(“clear”)	<enter>	
	 	 >>>	from	math	import	sqrt	<enter>	
	 	 >>>	print(math.sqrt(16))	
	 	 16	
	 	 >>> 
	
Ajuda	(help)	dos	módulos:	
	
>>>	import	math	<enter>	
 
 11 
>>>	help(math)	<enter>	 #	exibe	funções	do	módulo	math		
	 	 	 	 #	idêntico	ao	Linux	
	
11.	Funções	de	matemáticas	(math)	
	
	 Python	 possui	 diversas	 funções	 matemáticas	 oriundas	 do	 módulo	
“math”.	São	elas:	
	
math.factorial(x):	Retorna	o	valor	fatorial	de	x,	onde	x	deve	ser	sempre	
positivo.	
	
>>>	fat	=	math.factorial(5)	 #	5x4x3x2x1	=	120	
>>>	print(fat)	
120	
>>>		
	
math.modf(x):	Retorna	o	valor	inteiro	e	o	valor	fracionário	da	variável	
x.	
	
	
>>>	print(math.modf(5.34))	
(0.33999999999999986,	5.0)	
>>>		
	
math.exp(x):	Retorna	o	exponencial	de	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	de	x	na	base	pedida.	
	
	
>>>	print(math.log(2,10))	
0.30102999566398114	
>>>	print(math.log(3,10))	
0.47712125471966244	
>>>	
	
math.log1p(x):	Retorna	o	logaritmo	natural	de	x.	
	
	
>>>	print(math.log1p(1))	
0.6931471805599453	
>>>	print(math.log1p(2))	
1.0986122886681098	
>>>	
 
 12 
	
math.sqrt(x):	Retorna	a	raiz	quadrada	de	x.	
	
	
>>>	x	=	16	
>>>	print(math.sqrt(x))	
4.0	
>>>	x	=	-16	 	 #	x	deve	ser	positivo	
>>>	print(math.sqrt(x))	
Traceback	(most	recent	call	last):	
		File	"<stdin>",	line	1,	in	<module>	
ValueError:	math	domain	error	
>>>	
	
math.degrees(x):	Converte	o	ângulo	x	de	radianos	para	graus.	
	
	
	 	 pi	radianos	à	180	graus	
	 	 	
math.radians(x):	Converte	o	ângulo	x	de	graus	para	radianos.	
	
math.sin(x):	Retorna	o	seno	de	x,	onde	x	deve	estar	em	radianos.	
	
>>>	x	=	math.sin(45)	
>>>	print(x)	
0.8509035245341184	
>>>	x	=	math.sin(math.radians(45))	
>>>	print(x)	
0.7071067811865475	
>>>		
	
math.cos(x):	Retorna	o	cosseno	de	x,	onde	x	deve	estar	em	radianos.	
	
>>>	x	=	math.cos(45)	
>>>	print(x)	
0.5253219888177297	
>>>	x	=	math.cos(math.radians(45))	 #	converte	45	para	radianos	
>>>	print(x)	
0.7071067811865476	
	
math(tan(x):	Retorna	a	tangente	de	x,	onde	x	deve	estar	em	radianos.	
	
>>>	tangente	=	math.tan(math.radians(45))	
>>>	print(tangente)	
0.9999999999999999	
>>>math.hypot(x,	y):	Retorna	a	hipotenusa	do	triângulo	retângulo,	onde	x	e	
y	são	os	catetos	oposto	e	adjacente.	
	
>>>	hipotenusa	=	math.hypot(3	,4)	
 
 13 
>>>	print(hipotenusa)	
5.0	
>>>		
	
12.	Strings	(cadeia	de	caracteres)	
 
String	é	uma	sequência	de	caracteres,	letras,	números	e	caracteres	
especiais,	que	permite	trabalhar	com	textos.	
	
>>>	s	=	"Python"	<enter>	
>>>	print(s)	<enter>	
Python	
>>>	print("Número	de	caracteres	da	string:	%d"	%(len(s)))	<enter>	
6	
>>>	
	
ou	
	
>>>	s	=	‘Python’	<enter>	 #	pode	ser	utilizado	aspas	simples	
>>>	l	=	len(s)	<enter>	 	 #	retorna	o	número	de	caracteres	
>>>	print("Número	de	caracteres	da	String:	%d"	%l)	
<enter>	
6	
>>>	
	 outra	forma	de	inicialização:	
	
>>>	s	=	'P'	'y'	't'	'h'	'o'	'n'	<enter)	
>>>	print(s)	<enter>	
Python	
>>>	
	
Vetor	de	Strings:	(será	visto	em	outro	capítulo)	
	
>>>	s	=	('Paulo',	'Roberto',	'Gomes',	'Luzzardi')	<enter>	
>>>	print(s[0])	<enter>	
Paulo	
>>>	print(s[3])	<enter>	
Luzzardi	
>>>		
	
12.1	Funções	para	Strings	
	
#	-------------------------------------------	Split.py	
	
s	=	"Paulo	Roberto	Gomes	Luzzardi"	
print("Número	de	letras:	",	len(s))	
partes	=	s.split('	')	
n	=	len(partes)	
print("Número	de	nomes:	",	n)	
 
 14 
for	i	in	range(n):	
				print(partes[i])	
print(partes)	
	
Teste	do	Programa:	
	
=====	RESTART:	/Users/pluzzardi/Desktop/Python/Python/Split.py	====	
Número	de	letras:		28	
Número	de	nomes:		4	
Paulo	
Roberto	
Gomes	
Luzzardi	
['Paulo',	'Roberto',	'Gomes',	'Luzzardi']	
>>>	
	
Exemplo	de	funções	de	Strings:	
	
#	--------------------------------	String.py	
	
#	--------------------------------------------	len	
s	=	'Paulo	Roberto	Gomes	Luzzardi'	
n	=	len(s)		#	retorna	o	total	de	caracteres	da	string	
print("Número	de	Caracteres:	",	n)	
	
#	--------------------------------------------	count	
caracter	=	'a'	
letras	=	s.count(caracter)		#	retorna	o	número	de	vezes	que	o	caracter	aparece	na	
string	
print('Número	de	letras	"%c"	é	%d'	%(caracter,letras))	
	
#	--------------------------------------------	replace	
s	=	s.replace('Roberto',	'R.')		#	troca	parte	da	string	
s	=	s.replace("Gomes",	"G.")	
print(s)	
	
#	--------------------------------------------	find	
pos	=	s.find('z')			#	procura	a	primeira	aparição	de	uma	letra	
print(pos)	
	
#	--------------------------------------------	upper	e	lower	
print("STRING:	",	s.upper())				#	exibe	como	maiúscula	
print(s)	
print("string:	",	s.lower())				#	exibe	como	minúscula	
print(s)	
	
#	--------------------------------------------	title	
s	=	"paulo	roberto	gomes	luzzardi"	
print(s.title())	
	
#	--------------------------------------------	swapcase	
s	=	'Paulo	Roberto	Gomes	Luzzardi'	
print(s.swapcase())	#	inverte	as	letras	maiúsculas	e	minúsculas	
 
 15 
	
#	--------------------------------------------	isalpha	
print('Contém	apenas	letras:	 ',	s.isalpha())				#	verifica	se	contém	apenas	letras	
s	=	'FatecSenac'	
print('Contém	apenas	letras:	 ',	s.isalpha())	
	
#	---------------------------------------------	isdigit	
print('Contém	apenas	números:	',	s.isdigit())	
s	=	'123456'	
print('Contém	apenas	números:	',	s.isdigit())	
	
Teste	do	Programa:	
	
===========	RESTART:	/Users/pluzzardi/Documents/String.py	==========	
Número	de	Caracteres:		28	
Número	de	letras	"a"	é	2	
Paulo	R.	G.	Luzzardi	
14	
STRING:		PAULO	R.	G.	LUZZARDI	
Paulo	R.	G.	Luzzardi	
string:		paulo	r.	g.	luzzardi	
Paulo	R.	G.	Luzzardi	
Paulo	Roberto	Gomes	Luzzardi	
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.	Comandos:	Sequência,	Seleção	e	Repetição	
 
Python	possui	três	tipos	principais	de	comandos,	sequência,	onde	
todos	são	executados,	seleção,	onde	alguns	são	e	outros	não	são	
executados	e	repetição,	comandos	são	executados	diversas	vezes.	
 
13.1	Comandos	de	Sequência	
 
Comandos	de	Sequência:	
	
	 Todos	os	comandos	(ou	instruções)	em	sequência	são	sempre	
executados	no	fluxo	do	programa.	
	
#	---------------------	Circulo.py	
	
import	math	
	
diametro	=	float(input("Digite	o	valor	do	Diâmetro:	"))	
raio	=	diametro	/	2	
area	=	math.pi	*	raio	**	2	
 
 16 
print("Área	do	Círculo	é:	",	area)	
	
Teste	do	Programa:	
	
Digite	o	valor	do	Diâmetro:	6	<enter>	
Área	do	Círculo	é:	28.274334	
>>>	
	
#	-----------------------------------	Temperatura.py	
	
f	=	120	
c	=	(f	-	32)	*	5	/	9	
print("Celsius:	%d"	%c,	sep='',	end='')	 #	imprime	mesma	linha	
print("	-	Fahrenheit:	",	f)	
	
Teste	do	Programa:	
	
==	RESTART:	/Users/pluzzardi/Desktop/Python/Python/Temperatura.py	==	
Celsius:	48	-	Fahrenheit:		120	 		
>>>	
	
#	----------------------------------	Random.py	
	
import	random	
	
n	=	10	
print("Faixa	de	Sorteio:	0	...	%d"	%(n-1))	
numero	=	int	(random.random()	*	n)	
print("Número	Sorteado:	",	numero)	
#	A	função	random	gera	um	número	float	aleatório	entre	0.0	e	1.0	
	
Teste	do	Programa:	
	
==========	RESTART:	/Users/pluzzardi/Documents/Random.py	=======	
Faixa	de	Sorteio:	0	...	9	
Número	Sorteado:	8	
>>>		
	
#	-----------------------------	Aleatorio.py	
	
import	random	
	
for	i	in	range(6):	
				n	=	random.randint(1,	10)	
				print("n	=	",	n)	
	
Teste	do	Programa:	
	
=======	RESTART:	/Users/pluzzardi/Documents/Aleatorio.py	=======	
n	=		2	
n	=		9	
n	=		7	
 
 17 
n	=		6	
n	=		5	
n	=		7	
>>>	
13.2	Lista	de	Exercícios	(Comandos	de	sequência)	
 
a) Escreva	um	programa	em	Python	que	recebe	dois	valores	via	teclado:	
cateto	 adjacente	 (b)	 e	 cateto	 oposto	 (a)	 e	 calcula	 o	 valor	 da	
hipotenusa	dado	pela	seguinte	fórmula:		
	
	
Teste	do	Programa:		
	
Cateto	Adjacente	(b):	3	<enter>		
Cateto	Oposto	(a):	4	<enter>		
Hipotenusa:	5.0		
	
b) Escreva	um	programa	em	Python	que	lê	4	notas	via	teclado:	n1,	n2,	
n3	 e	 n4	 obtidas	 por	 um	 aluno	 em	 4	 avaliações.	 Calcule	 a	 média	
utilizando	a	seguinte	fórmula:		
n1	+	n2	x	2	+	n3	x	3	+	n4	
Média	=	---------------------------	
7
	
 
 
c) Escreva	um	programa	em	Python	que	recebe	via	teclado:	comprimento	
da	circunferência.	O	programa	deve	calcular	e	imprimir	na	tela	o	
diâmetro	e	o	raio	da	circunferência	(veja	exemplo	abaixo):		
	
Teste	do	Programa:		
	
Comprimento	da	circunferência:	36	<enter>		
Diâmetro:	11.46
	
Raio:	5.73	
	
comprimento	da	circunferência	=	2	.	Pi	.	raio	
 
 18 
diâmetro	=	2	.	raio	
	
d) Desenvolva	um	programa	em	Python	que	recebe	via	teclado:	peso	da	
carne	que	será	vendida	e	preço	por	quilo.	O	programa	deve	calcular	
e	imprimir	na	tela	o	total	a	pagar,	o	valor	pago	ao	ICMS	(17%)	e	
o	lucro	líquido	do	açougue.	
	
	
	
Teste	do	Programa	(1):		
	
	
Peso:	3.5	<enter>
	
Preço	por	Kg	(R$):	4.90	<enter>		
Total	a	pagar:	17.15
	
ICMS	(17%):	2.91
	
Lucro	líquido	do	açougue	(R$):	14.24		
	
Teste	do	Programa	(2):		
	
Peso:	1.5	<enter>
	
Preço	por	Kg	(R$):	9.00	<enter>		
Total	a	pagar:	13.5
	
ICMS	(17%):	2.29
	
Lucro	líquido	do	açougue	(R$):	11.21	
	
e) Escreva	um	programa	em	Python	que	recebe	via	teclado:	a	data	de	
hoje	da	seguinte	forma:	dia,	mês,	ano	e	a	sua	idade,	da	seguinte	
forma:	anos,	meses	e	dias	vividos.	Calcule	e	imprima	a	data	de	
nascimento	no	seguinte	formato:	dd/mm/aaaa.		
	
Teste	do	Programa:		
	
Qual	a	data	de	hoje:
	
Dia:	16	<enter>
	
Mês:	3	<enter>
	
Ano:	2017	<enter>
	
Qual	a	sua	idade:
	
Anos:	55	<enter>
	
Meses:	1	<enter>
	
Dias:	6	<enter>
	
Data	de	Nascimento:	10/02/1962		
	
f) Escreva	 um	 programa	 em	 Python	 que	 recebe	 via	 teclado:	 salário	
mensal	e	percentual	de	reajuste.	Calcular	e	escrever	o	valor	do	
novo	salário.	
	
 
 19 
Teste	do	Programa:		
	
Salário:	500	<enter>
	
Percentual	de	reajuste:	15	<enter>
	
Novo	salário:	575		
	
g) Escreva	um	programa	em	Python	que	lê	via	teclado	as	dimensões	de	
uma	cozinha	retangular	(comprimento,	largura	e	altura),	calcular	
e	escrever	a	quantidade	de	caixas	de	azulejos	para	se	colocar	em	
todas	as	suasparedes	(considere	que	não	será	descontado	a	área	
ocupada	por	portas	e	janelas).	Cada	caixa	de	azulejos	possui	1,5	
m2.		
Teste	do	Programa:		
	
Comprimento:	4.5	<enter>
	
Largura:	3	<enter>	
Altura:	2.8	<enter>

	
Quantidade	de	caixas:	28		
	
h) A	 turma	 C	 é	 composta	 de	 60	 alunos,	 e	 a	 turma	 D	 de	 20	 alunos.	
Escreva	 um	 programa	 em	 Python	 que	 leia	 o	 percentual	 de	 alunos	
reprovados	 na	 turma	 C,	 o	 percentual	 de	 aprovados	 na	 turma	 D,	
calcule	e	escreva:
	
a)	O	número	de	alunos	reprovados	na	turma	C.
	
b)	O	número	de	alunos	reprovados	na	turma	D.		
c)	A	percentagem	de	alunos	reprovados	em	relação	ao	total	de	alunos	
das	duas	turmas.		
	
Teste	do	Programa:		
	
Percentual	de	alunos	reprovados	na	turma	C:	10	<enter>
	
Percentual	de	alunos	aprovados	na	turma	D:	85	<enter>	
Quantidade	de	alunos	reprovados	na	turma	C:	6		
Quantidade	de	alunos	reprovados	na	turma	D:	3		
Percentual	de	alunos	reprovados	em	relação	ao	total	de	alunos	das	duas	turmas:	11.25		
	
i) Escreva	um	programa	em	Python	que	recebe	três	valores	via	teclado:	
a,	b	e	c.	O	programa	deve	calcular	e	imprimir	na	tela	os	valores	
das	raízes	x1	e	x2	dados	pela	fórmula	da	bhaskara,	ou	seja,	uma	
equação	de	segundo	grau:	a.x2	+	b.x	+	c	=	0	
	
Teste	do	Programa:	
	
a	=	1	<enter>
	
 
 20 
b	=	2	<enter>	
c	=	-3	<enter>	
x1	=	1	
x2	=	-3	
14.	Operadores	relacionais	
	
	 Os	 operadores	 relacionais	 permitem	 ao	 programador	 realizar	
comparações.	 A	 seguir,	 a	 Tabela	 4	 exibe	 os	 operadores	 relacionais	
utilizados	em	Python.	
	
Tabela	4:	Operadores	Relacionais	
Operador	relacional	 Função	
==	 Igual	
!=	 Diferente	
>	 Maior	
<	 Menor	
>=	
Maior	ou	
igual	
<=	
Menor	ou	
igual	
	
15.	Operadores	lógicos	
	
	 Os	 operadores	 lógicos	 permitem	 ao	 programador	 realizar	 várias	
comparações	 em	 uma	 mesma	 condição.	 A	 seguir,	 a	 Tabela	 5	 exibe	 os	
operadores	lógicos	utilizados	em	Python.	
	
Tabela	5:	Operadores	Lógicos	
Operador	lógico	
and	
or	
not	
	
and	é	verdadeiro	quando	ambas	condições	forem	verdadeiras	
or	é	verdadeiro	quando	uma	ou	ambas	condições	forem	verdadeiras.	
not	é	o	inverso	da	condição,	ou	seja,	inverte	o	True	ou	False.		
	
16.	Comando	de	Seleção	(if)	
	
 
 21 
	 O	comando	de	seleção	if	permite	o	programa	seguir	dois	caminhos,	
isto	é	feito	através	de	uma	condição,	utilizando	um	operador	relacional	
(Tabela	4),	que	pode	ser	verdadeira	(True)	ou	falsa	(False).	
	
Sintaxe:	if	condição:	comando		 #	simples	
	
	 	 	 ou	
	
	 	 if	condição:	 	 	 #	simples	
	 	 	 comando	
	
	 	 	 ou	
	
	 	 if	condição:	 	 	 #	composto	
	 	 	 comando1	
	 	 else:	
	 	 	 comando2	
	
	 	 	 ou	
	
	 	 if	condição1:	
	 	 	 comando1	
	 	 elif	condição2:	
	 	 	 comando2	
	 	 else:	
	 	 	 comando3	
	
	
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	endentação	no	comando	if	(linha	3),	Python	utiliza	a	
endentação	como	forma	de	formar	blocos	de	comandos,	ou	seja,	delimitar	
instruções	ligadas	a	um	único	comando.	
	
Teste	do	Programa:	
	
=======	RESTART:	/Users/pluzzardi/Documents/If.py	========	
Digite	um	Número:	-5	
Número	é	negativo	
 
 22 
x	=	-5	
>>>		
=======	RESTART:	/Users/pluzzardi/Documents/If.py	========	
Digite	um	Número:	5	
x	=	5	
>>>	
	
Programa	exemplo:	If	completo,	ou	seja,	com	duas	partes	
	
#	----------------------------------------	Par.py	
	
x	=	int(input("Digite	um	Número:	"))	
if	x	%	2	==	0:	
					print("Par")	
else:	
					print("Ímpar")	
	
Teste	do	Programa:	
	
=================	RESTART:	/Users/pluzzardi/Documents/Par.py	=======	
Digite	um	Número:	4	
Par	
>>>	
	
#	-------------------------	Bhaskara.py	
	
import	math	
	
a	=	float(input("a	=	"))	
b	=	float(input("b	=	"))	
c	=	float(input("c	=	"))	
delta	=	b**2	-	4	*	a	*	c	
if	delta	>=	0:	
				x1	=	(-b	+	math.sqrt(delta))	/	2*a	
				x2	=	(-b	-	math.sqrt(delta))	/	2*a	
				print("x1	=	",	x1)	
				print("x2	=	",	x2)	
else:	
				print("Erro:	Raizes	complexas")	
	
Teste	do	Programa:	
	
=====	RESTART:	/Users/pluzzardi/Documents/bhaskara.py	======	
a	=	1	
b	=	2	
c	=	-3	
x1	=		1.0	
x2	=		-3.0	
>>>	
	
Programa	exemplo:	if	com	elif	
	
 
 23 
#	----------------------------------------	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	de	Exercícios	(Comando	de	Seleção	if)	
 
a)Escreva	um	programa	em	Python	que	lê	as	notas	de	duas	avaliações	
de	um	aluno	no	semestre.	Calcular	e	escrever	a	média	semestral	e	a	
seguinte	mensagem:	‘PARABÉNS!	Você	foi	aprovado’	somente	se	o	aluno	
foi	aprovado	(considere	7.0	a	nota	mínima	para	aprovação)	ou	‘Você	
foi	reprovado!	Estude	mais’.		
	
Teste	do	Programa:		
	
Nota	1:	6	<enter>
	
Nota	2:	8	<enter>
	
Média:	7.0	
PARABÉNS!	Você	foi	aprovado	
	
b)Escreva	um	programa	em	Python	que	lê	dois	valores.	Escreva	o	valor	
do	maior,	o	menor	e	a	média	dos	dois	valores.		
	
Teste	do	Programa:		
	
Valor:	3	<enter>
	
Valor:	4	<enter>
	
Maior:	4	
Menor:	3	
Média:	3.5	
	
c)Escreva	um	programa	em	Python	que	lê	o	ano	de	nascimento	de	uma	
pessoa.	Escrever:	PODE	VOTAR	ou	NÃO	PODE	VOTAR	e	a	idade,	conforme	
exemplo	abaixo.		
	
Teste	do	Programa:		
	
Ano	de	Nascimento:	1999	<enter>
	
Status:	PODE	VOTAR	
Idade:	18	anos
	
	
d)	As	maçãs	custam	R$	0,30	ser	forem	compradas	menos	do	que	uma	dúzia,	
e	R$	0,25	ser	forem	compradas	pelo	menos	doze.	Escreva	um	programa	
em	Python	que	leia	o	número	de	maçãs	compradas,	calcule	e	escreva	o	
 
 24 
valor	total	da	compra.		
	
Testes	do	Programa:		
	
Maças:	20	<enter>
	
Valor	da	Compra:	R$	5.00
	
	 ou	
Maças:	12	<enter>
	
Valor	da	Compra:	R$	3.00
	
	
e)	Escreva	um	programa	em	Python	que	recebe	via	teclado	a	altura	e	o	
sexo	(codificado	da	seguinte	forma:	[f]	feminino	-	[m]	masculino)	de	
uma	pessoa.	Calcule	e	imprima	na	tela	o	peso	ideal,	utilizando	as	
seguintes	fórmulas:		
Homens:	72.7	*	h	-	58	
Mulheres:	62.1	*	h	-	44.7		
	
Testes	do	Programa:		
	
Altura:	1.80	<enter>
	
Sexo	[M]	ou	[F]:	m
<enter>	
Peso	Ideal:	72.86	
	 ou	
Altura:	1.65	<enter>
	
Sexo	[M]	ou	[F]:	F
<enter>	
Peso	Ideal:	57.765	
17.	Contador	e	acumulador	
 
Um	contador	é	uma	variável	que	possui	uma	expressão	matemática,	
dentro	 de	 um	 comando	 de	 atribuição,	 que	 realiza	 uma	 contagem	 de	 uma	
certa	quantidade	de	vezes	que	um	comando	de	repetição	é	executado,	ou	
seja,	ela	mantém	a	quantidade	de	vezes	que	um	laço	foi	executado.	Pode-
se	contar	de	um	em	um,	dois	em	dois	e	assim	sucessivamente,	servindo,	
normalmente,	para	contar	o	número	de	elementos.	
Sintaxe:	x	=	x	+	1		 	 #	x	ß	x	+	1	
Note	 que	 é	 somado	 um	 (1)	 ao	 x	 e	 então	 atribuído	 este	 novo	 valor	 ao	
próprio	x.	Note	ainda	que	um	(1)	é	uma	constante,	que	pode	ser	1,	2,	3,	
...	
Um	acumulador	ou	somador	é	uma	variável	que	contém	uma	expressão	
matemática	que	serve	para	acumular	valores	a	cada	vez	que	o	código	é	
executado.	
Sintaxe:	soma	=	soma	+	n		 #	soma	ß	soma	+	n	
 
 25 
Note	que	é	somado	o	valor	‘n’	a	soma	e	atribuído	este	novo	valor	a	
própria	soma.	Note	ainda	que	n	é	uma	variável,	que	pode	ser	qualquer	
valor	inteiro	ou	real	(float).	
18.	Comandos	de	Repetição	(while	e	for)	
	
	 Os	 comandos	 de	 repetição	 while	 e	for	 permitem	 repetir	 diversas	
vezes	 um	 bloco	 de	 comandos	 ou	 instruções.	 While	 repete	 enquanto	 a	
condição	é	verdadeira.		
 
Comando	while:	
	
Sintaxe:		 while	condição:	
	 	 	 comando1	
	 	 	 comando2	
	 	 			 		...	
 
#	---------------------------	While.py	
	
i	=	1	
while	i	<=	10:	
				print("i	=	",	i)	
				i	=	i	+	1	
	
Teste	do	Programa:	
	
=========	RESTART:	/Users/pluzzardi/Documents/While.py	=========	
i	=		1	
i	=		2	
i	=		3	
i	=		4	
i	=		5	
i	=		6	
i	=		7	
i	=		8	
i	=		9	
i	=10	
>>>	
 
#	--------------------	In2.py	
	
import	random	
	
s	=	's'	
while	s	in	['S',	's']:	 #	operador	in	
				num	=	random.randint(1,	10)	
				print("Número	sorteado:	",	num)	
				s	=	input("Continua	[S/N]")	
	
Teste	do	Programa:	
 
 26 
	
=============	RESTART:	/Users/pluzzardi/Documents/In2.py	=========	
Número	sorteado:		2	
Continua	[S/N]s	
Número	sorteado:		2	
Continua	[S/N]s	
Número	sorteado:		7	
Continua	[S/N]s	
Número	sorteado:		10	
Continua	[S/N]n	
>>>	
 
Comando	for:	
	
	 Permite	executar	várias	vezes	um	bloco	de	comandos.	
	
Sintaxe:		 for	variável	in	faixa:	
	 	 	 comando1	
	 	 	 comando2	
	 	 			 		...	
 
Observação:	A	escolha	entre	o	comando	while	e	for	se	dá	sempre	que	sabe-
se	a	quantidade	de	vezes	que	um	bloco	é	executado.	Sempre	que	se	sabe	o	
número	de	vezes,	deve-se	usar	o	comando	for,	caso	contrário,	deve-se	
utilizar	 o	 comando	 while,	 que	 pode	 ser	 controlado	 de	 várias	 formas,	
baseados	em	sua	condição.	
	
	 Para	 utilizar	 o	 comando	 for	 deve-se	 saber	 o	 início	 (start),	 o	
ponto	de	parada	(stop)	e	a	variação	(step).	
		
#	---------------------------------	For.py	
	
for	i	in	range(6):	 #	faixa:	0	à	5,	onde	6	é	o	ponto	de	parada	
				print(i)	
	
======	RESTART:	/Users/pluzzardi/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/pluzzardi/Documents/ForDuplo.py	==========	
 
 27 
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	começa	sempre	em	zero.	
	
#	-----------------------------------	ForDuplo2.py	
	
for	i	in	range(3):	
				for	j	in	range(4):	
								print(i+1,	j+1)	
	
===	RESTART:	/Users/pluzzardi/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	 determinar	 o	 ponto	 de	 partida	 (start),	 ponto	 de	
parada	(stop)	e	a	variação	(step)	usado	no	comando	for.	
	
Sintaxe:	range(start,	stop,	step)	
	
Onde:		Start:	partida	
Stop:	parada	(stop	-	1)	
Step:	passo	(incremento	[+]	ou	decremento	[-])	
	
Exemplos:	
	
for	i	in	range(10):	 	 #	0	1	2	3	4	5	6	7	8	9	
	 print(i)	
 
 28 
	
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:	Nunca	chega	no	ponto	de	parada.	
 
18.2	Lista	de	Exercícios	(Comando	de	Repetição	while	e	for)	
 
a)Escreva	 um	 programa	 em	 Python	 que	 lê	 um	 número	 via	 teclado.	 O	
programa	deve	exibir	se	o	número	é	PAR	ou	ÍMPAR.	O	programa	é	encerrado	
quando	o	número	digitado	for	ZERO.		
	
Teste	do	Programa:		
	
Número:	6	<enter>
	
PAR	
Número:	7	<enter>	
IMPAR	
Número:	0	<enter>	
PAR	
>>>	
	
b)Escreva	 um	 programa	 em	 Python	 que	 lê	 um	 número	 via	 teclado.	 O	
programa	 deve	 exibir:	 POSITIVO,	 NEGATIVO	 ou	 ZERO.	 O	 programa	 é	
encerrado	 quando	 o	 usuário	 digitar	 ‘N’	 ou	 ‘n’	 na	 pergunta	
“Continua	[S/N]?”.		
	
Teste	do	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	
>>>	
	
c)Escreva	um	programa	em	Python	que	lê	um	nome	via	teclado.	O	programa	
deve	exibir	o	número	de	palavras	do	nome	e	a	abreviatura	do	nome.		
 
 29 
	
Teste	do	Programa:		
	
Nome:	Paulo	Roberto	Gomes	Luzzardi	<enter>	
Número	de	palavras:	4	
Abreviatura:	P.	R.	G.	L.	
>>>	
	
d)Escreva	um	programa	em	Python	que	lê	um	nome	via	teclado.	O	programa	
deve	exibir	o	nome	do	autor,	conforme	exemplo	abaixo:		
	
Teste	do	Programa:		
	
Nome:	Paulo	Roberto	Gomes	Luzzardi	<enter>	
Autor:	Luzzardi,	Paulo	R.	G.	
>>>	
	
e)	Escreva	um	programa	em	Python	que	lê	um	nome	qualquer	via	teclado.	
Logo	após	a	entrada	exiba	na	tela:	(a)	todas	as	vogais	do	nome;	(b)	
todas	 as	 consoantes	 do	 nome	 e	 o	 (c)	 total	 de	 letras,	 conforme	 e	
exatamente	igual	ao	teste	abaixo:	
 
Teste	do	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	representados	em	forma	de	listas.	Vetores	
são	estruturas	que	permitem	armazenar	valores	homogêneos,	ou	seja,	de	
mesmo	tipo.	Listas	por	outro	lado,	são	classes	que	permitem	armazenar	
qualquer	tipo	de	informação.	A	seguir	são	vistos	diversos	exemplos	da	
utilização	de	listas.	
 
Exemplo:	Lista1.py	
 
#	-------------------------------	Lista1.py	
 
x	=	[10,	20,	30]	
n	=	len(x)	 	 	 #	retorna	o	número	de	elementos	da	lista	
for	i	in	range(n):	
	 print(x[i])	 	 #	imprime	elemento	por	elemento	
	
	
Teste	do	Programa:	
	
 
 30 
=======	RESTART:	/Users/pluzzardi/Documents/Lista1.py	==========	
10	
20	
30	
>>>	
	
Exemplo:	Lista2.py	
	
#	-------------------------------	Lista2.py	
	
x	=	[]	#	declara	uma	lista	vazia	
n	=	int(input("Número	de	Elementos:	"))	
for	i	in	range(n):	
				num	=	int(input("Digite	um	Número:	"))	
				x.append(num)	 	 #	insere	um	elemento	no	fim	da	lista	
for	i	in	range(n):	
				print('x[',i,']	=	',	x[i],	sep='')	 #	elimina	o	espaço	
print("Lista:	",	x)	
	
Teste	do	Programa:	
	
====	RESTART:	/Users/pluzzardi/Desktop/Python/Python/Lista2.py	====	
Número	de	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(id(x))	
print(id(y))	
t	=	x[:]					 #	cria	uma	cópia	da	lista	x	...	t	=	x.copy()	
print(t	is	x)	
print(id(t))	
print("Número	de	Elementos:	",	len(x))	
	
Teste	do	Programa:	
	
========	RESTART:	/Users/pluzzardi/Documents/Lista3.py	==========	
x	=		[10,	20,	30]	y	=		[10,	20,	30]	
 
 31 
True	
4380371208	
4380371208	
False	
4320652552	
Número	de	Elementos:		3	
>>>	
	
Exemplo:	Lista4.py	
	
#	--------------------------------	Lista4.py	
	
nome	=	[]	
nota	=	[]	
soma	=	0.0	
numeroAlunos	=	4	
for	i	in	range(numeroAlunos):	
				nome.append(input("Nome	do	Aluno:	"))	
				nota.append(float(input("Nota	do	"	+	nome[i]	+	":	")))	
				soma	=	soma	+	nota[i]	
media	=	soma	/	numeroAlunos	
print("Média	da	Turma:",	media)	
	
Teste	do	Programa:	
	
========	RESTART:	/Users/pluzzardi/Documents/Lista4.py	=============	
Nome	do	Aluno:	Paulo	
Nota	do	Paulo:	7	
Nome	do	Aluno:	Roberto	
Nota	do	Roberto:	8	
Nome	do	Aluno:	Gomes	
Nota	do	Gomes:	9	
Nome	do	Aluno:	Luzzardi	
Nota	do	Luzzardi:	10	
Média	da	Turma:	8.5	
>>>	
	
Imprimir	Listas	utilizando	o	comando	for:	
	
lista	=	{10,	20,	30,	40,	50}		 	 #	lista	de	números	inteiros	
	
print("Lista	sem	Ordenação")	
for	i	in	lista:	
				print(i)	
	
print("Lista	Ordenada")	
for	i	in	sorted(lista):	
				print(i)	
	
for	i,	valor	in	enumerate(lista):	 #	com	numeração	
				print("%d	-	%d"	%(i,	valor))	
	
lista	=	list(range(10))	
 
 32 
for	i	in	lista:	
				lista[i]	=	i	+	5	
				print(lista[i])	
print(lista)	
	
nomes	=	{"Carla",	"Ana",	"Debora",	"Eva",	"Beatriz"}	
for	i	in	sorted(nomes):	
				print(i)	
					
#	for	<variável>	in	<lista>:	
#			<bloco	de	código	endentado>	
	
	
Teste	do	Programa:	
	
=====	RESTART:	/Users/pluzzardi/Desktop/Python/Python/For.py	=====	
0	
1	
2	
3	
4	
5	
Lista	sem	Ordenação	
40	
10	
50	
20	
30	
Lista	Ordenada	
10	
20	
30	
40	
50	
0	-	40	
1	-	10	
2	-	50	
3	-	20	
4	-	30	
5	
6	
7	
8	
9	
10	
11	
12	
13	
14	
[5,	6,	7,	8,	9,	10,	11,	12,	13,	14]	
Ana	
Beatriz	
Carla	
 
 33 
Debora	
Eva	
	
Funções	para	operar	listas:	
	
Anexar	o	elemento	nofinal	da	lista:	append	
	
lista.append(elemento)	
	
Remove	o	elemento	da	lista:	remove	
	
lista.remove(elemento)	
	
Limpa	toda	a	lista,	ou	seja,	apaga	todos	os	elementos	da	lista:	clear	
	
lista.clear()	
	
Insere	o	elemento	antes	do	índice:	insert	
	
lista.insert(índice,	elemento)	
	
Remove	o	último	elemento	e	retorna	o	valor:	pop	
	
ultimo	=	lista.pop()	
	
Reverte	os	elementos	da	lista	(muda	a	ordem):	reverse	
	
lista.reverse()	
	
Cria	uma	cópia	da	lista:	copy	
	
temp	=	lista.copy()	
	
Ordena	uma	lista:	sort	
	
lista.sort()	 ou		 lista.sort(reverse	=	True)	
	
Número	de	elementos	de	uma	lista:	len	
	
n	=	len(lista)	
	
Retorna	o	número	de	vezes	de	um	elemento	dentro	de	uma	lista:	count	
	
vezes	=	lista.count(elemento)	
	
 
 34 
Retorna	o	índice	de	um	elemento	em	uma	lista:	index	
	
posição	=	lista.index(elemento)	
	
#	---------------------------------------	Lista.py	
	
lista	=	[40,	30,	50,	10,	20]	
	
lista.sort()	 #	ordena	em	ordem	crescente	
print(lista)	
	
lista.sort(reverse=True)	 #	ordena	em	ordem	decrescente	
print(lista)	
	
#	insert(posição,	valor)	
lista.insert(1,	15)					#	insere	o	elemento	antes	da	posição	
print(lista)	
	
print(lista.count(20))		#	exibe	o	número	de	vezes	do	elemento	
	
print(lista.index(20))		#	exibe	o	índice	do	elemento	
	
ultimo	=	lista.pop()				#	remove	o	último	elemento	
print("Último	elemento:	",	ultimo)	
print(lista)	
	
lista.reverse()					#	inverte	a	lista	(ordem	dos	elementos)	
print(lista)	
	
temp	=	lista.copy()	
print("Lista	Nova:	",	temp)	
	
Teste	do	programa:	
	
===============	RESTART:	/Users/pluzzardi/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	criação	aleatória	de	palpites	para	a	
MegaSena.	
	
#	----------------------------	MegaSena.py	
	
import	random	
 
 35 
	
#	----------------------------	repetido	
def	repetido(num,	n,	t):	
				for	i	in	range(n):	
								if	num[i]	==	t:	
												return(True)	
				return(False)	
	
#	----------------------------	imprime	
def	imprime(num):	
				for	i	in	range(len(num)):	
								t	=	num[i]	
								print("%2d	"	%t,	sep='',	end='')	
				print()	
					
ch	=	's'	
while	ch	in	['S',	's']:	
				palpites	=	int(input("Número	de	palpites:	"))	
				for	i	in	range(palpites):	
								num	=	[]	
								n	=	1	
								num.append(random.randint(1,	60))	
								while	n	!=	6:	
												t	=	random.randint(1,	60)	
												if	not(repetido(num,	n,	t)):	
																num.append(t)	
																n	=	n	+	1	
								num.sort()	 #	ordena	a	lista	
								imprime(num)	
				ch	=	input("Continua	[s/n]?")	
	
Teste	do	Programa:	
	
========	RESTART:	/Users/pluzzardi/Desktop/MegaSena.py	=============	
Número	de	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	de	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	de	Exercícios	de	Vetores	(listas)	
	
 
 36 
a) Escreva	um	programa	em	Python	que	recebe	via	teclado	um	conjunto	
de	letras.	Armazene	todas	as	letras	em	um	vetor	ou	lista	(letras)	
até	que	o	usuário	digite	apenas	<enter>.	Logo	após	copie	todas	as	
letras	 (em	 ordem	 inversa)	 para	 outro	 vetor	 (inverso).	 Ao	 final	
imprima	os	dois	vetores	(conforme	exemplo	abaixo).		
Teste	do	programa:		
Letra: L <enter> 
Letra: I <enter> 
Letra: M <enter> 
Letra: A <enter> 
Letra: <enter> 
[‘L’, ‘I’, ‘M’, ‘A’] 
[‘A’, ‘M’, ‘I’, ‘L’] 
 
b) Escreva	um	programa	em	Python	que	recebe	via	teclado:	número	de	
idades	e	as	respectivas	idades.	Armazene	todas	as	idades	em	um	
vetor	(idade).	Logo	após	a	entrada	de	todas	as	idades,	o	programa	
deve	 receber	 via	 teclado:	idade	 para	 consulta.	 O	 programa	 deve	
imprimir	na	tela,	o	número	de	idades	antes	da	idade	de	consulta	e	
o	número	de	idades	depois	da	idade	de	consulta	(conforme	exemplo	
abaixo).	Exibir	Idade	não	encontrada	se	a	idade	de	consulta	não	
existir.	
Teste	do	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> 
 
c) Escreva	um	programa	em	Python	que	recebe	via	teclado	um	conjunto	
de	números	inteiros.	Armazene	todos	os	números	inteiros	em	um	vetor	
até	que	o	usuário	digite	0	(zero).	Logo	após	permita	ao	usuário	
consultar	 um	 número	 informando	 o	 seu	 valor.	 O	 programa	 deve	
imprimir	na	tela	a	posição	do	número	no	vetor	ou	ERRO:	Número	não	
encontrado	(veja	exemplos	abaixo):		
Exemplo:		
Número: 50 <enter>
 
Número: 30 <enter>
 
 
 37 
Número: 20 <enter>
 
Número: 10 <enter>
 
Número: 40 <enter>
 
Número: 0 <enter>
 
Valor: 20 <enter>
 
Posição no vetor: 2
 
Valor: 40 <enter>
 
Posição no vetor: 4
 
Valor: 60 <enter>
 
ERRO: Número não encontrado 
Valor: 0 <enter> 
 
Observação:	O	programa	termina	quando	o	usuário	digitar	0	(zero).		
d) Escreva	um	programa	em	Python	que	recebe	via	teclado	"n"	conceitos	
(A,	B,	C,	D	e	E)	até	que	o	usuário	digite	F	ou	f.	Armazene	todos	
os	conceitos	em	um	vetor	(conceito).	Imprima	na	tela	o	número	de	
alunos:	aprovados	(A,	B	e	C),	reprovados	(D)	e	os	infrequentes	
(E).	
Teste	do	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) 	Escreva	um	programa	em	Python	que	recebe	via	teclado	“n”	nomes.	
A	 entrada	 dos	 nomes	 termina	 quando	 o	 usuário	 digitar	 apenas	
<enter>.	Logo	após	a	entrada	de	todos	os	nomes	o	programa	deve	
permitir	 a	 entrada	 via	 teclado	 de	 uma	 letra.	 O	 programa	 deve	
imprimir	 na	 tela	 todos	 os	 nomes	 que	 começam	 com	 a	 letra	
especificada	 pelo	 usuário.	 O	 programa	 termina	 quanto	 o	 usuário	
digitar	“”	(nada)	na	entrada	da	letra	(conforme	exemplos	abaixo):		
Teste	do	programa:		
Nome: Paulo <enter> 
Nome: Roberto <enter> 
Nome: Renato <enter> 
Nome: Pedro <enter> 
Nome: Fabio <enter> 
Nome: <enter> 
Letra: R <enter> 
Nome: Roberto 
 
 38 
Nome: Renato 
Letra: P <enter> 
Nome: Paulo 
Nome: Pedro 
Letra: T <enter> 
Letra: <enter> 
 
f) Escreva	um	programa	em	Python	que	recebe	via	teclado	“n”	nomes	
e	idades.	A	entrada	dos	dados	termina	quando	o	usuário	digitar	'N'	
ou	'n'	na	pergunta	"Continua	[S/N]?".	Logo	após	a	entrada	de	todos	
os	dados	o	programa	deve	imprimir	na	tela	todos	os	nomes	e	idades	
desde	o	mais	velho	até	o	mais	novo.		
Teste	do	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	de	prova	
 
A	seguir	são	apresentadas	diversas	questões	de	provas.	Resolva-
as,	 pois	 elas	 servirão	 como	 um	 simulado	 para	 treino	 da	 linguagem	 de	
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 
 
 39 
 
2. Escreva um programa em Python que lê nomes via teclado. 
Para cada nome digitado pelo usuário, armazeneem uma Lista 
[f] para feminino, [m] para masculino ou [i] para 
indeterminado, conforme exemplo abaixo. Ao final imprima a 
Lista, o total de homens, o total de mulheres e o total de 
indeterminados. 
 
Teste do programa: 
 
Nome: Debora <enter> 
Nome: Carla <enter> 
Nome: Beatriz <enter> 
Nome: Paulo <enter> 
Nome: Renato <enter> 
Nome: <enter> 
Lista: [‘f’, ‘f’, ‘i’, ‘m’, ‘m’] 
2 homens 
2 mulheres 
1 indeterminados 
 
3. Escreva um programa em Python que recebe “n” nomes via 
teclado (até que o usuário digite apenas <enter>). Insira 
todos os nomes ORDENADOS em uma Lista de Strings (conforme 
exemplo abaixo). Ao final, o programa deve exibir a Lista 
contendo os nomes em ordem alfabética. 
 
Teste do programa: 
 
Nome: Debora <enter> 
Nome: Carla <enter> 
Nome: Eva <enter> 
Nome: Beatriz <enter> 
Nome: Ana <enter> 
Nome: <enter> 
Lista: [‘Ana’, ‘Beatriz’, ‘Carla’, ‘Debora’, ‘Eva’] 
 
4. Escreva um programa em Python que lê um nome via teclado. 
Logo após a entrada crie uma outra string (invertido) para 
inverter e exibir este nome na tela e ainda o número de 
letras do nome (sem contar os espaços) e o total de espaços 
do nome, conforme exemplo abaixo. 
 
Teste do programa: 
 
Nome: paulo roberto gomes luzzardi <enter> 
Invertido: idrazzul semog otrebor oluap 
Total de Letras: 25 
Total de Espaços: 3 
	
5. Escreva um programa em Python que recebe via teclado: 
valor inicial, valor final e intervalo. O programa deve 
inserir “n” valores em uma Lista (desde o valor inicial até 
o valor final levando em consideração o intervalo entre eles, 
conforme exemplos abaixo. Ao final, o programa deve exibir 
a Lista criada com estes valores. 
 
 40 
 
Teste do programa: 
 
Valor Inicial: 10 <enter> 
Valor Final: 70 <enter> 
Intervalo: 10 <enter> 
Lista: [10, 20, 30, 40, 50, 60, 70] 
 
Valor Inicial: 60 <enter> 
Valor Final: 20 <enter> 
Intervalo: 5 <enter> 
Lista: [60, 55, 50, 45, 40, 35, 30, 25, 20] 
	
6. Escreva um programa em Python que insere “n” números 
inteiros em uma Lista (até que o usuário digite zero). Logo 
após permita a consulta de um valor e então exiba: (a) o 
antecessor e (b) o sucessor ou Antecessor não existe, 
Sucessor não existe ou Elemento não Encontrado (exatamente 
igual aos exemplos abaixo). 
 
Teste do programa: 
 
Valor: 10 <enter> 
Valor: 20 <enter> 
Valor: 30 <enter> 
Valor: 40 <enter> 
Valor: 50 <enter> 
Valor: 0 <enter> 
Lista: [10, 20, 30, 40, 50] 
Valor a consultar: 30 <enter> 
Antecessor: 20 
Sucessor: 40 
Valor a consultar: 10 <enter> 
Antecessor não existe 
Sucessor: 20 
Valor a consultar: 60 <enter> 
Antecessor não existe 
Erro: Elemento não encontrado 
Sucessor não existe 
Valor a consultar: 0 <enter> 
	
7. Escreva um programa em Python que recebe via teclado: 
número de idades e as referidas idades. O programa deve então 
imprimir na tela: (a) as idades em ordem crescente; (b) maior 
idade; (c) menor idade e (d) a média de idades. 
 
Teste do programa: 
 
Número de Idades: 4 <enter> 
Idade: 49 <enter> 
Idade: 51 <enter> 
Idade: 48 <enter> 
Idade: 50 <enter> 
Idades Ordenadas: [48, 49, 50, 51] 
Maior Idade: 51 
Menor Idade: 48 
Média de Idades: 49.5 
	
 
 41 
8. Escreva um programa em Python que lê um vetor R de 5 
elementos contendo o gabarito da LOTO. A seguir, ler um vetor 
A de 10 elementos contendo uma aposta. A seguir imprima 
quantos pontos fez o apostador. 
 
Teste do programa: 
 
[Entrada] 
R: 4 12 34 25 17 (gabarito) 
A: 3 17 55 21 34 4 27 29 20 11 (aposta) 
 
[Saída] 
3 (pontos) 
	
9. Dada a seguinte tela: 
 
 Salário Mensal (R$): 900 <enter> 
 Férias (R$): 450 <enter> 
 13 Salário (R$): 780 <enter> 
 Salário Anual (R$): 12030.00 
 Alíquota do Imposto de Renda: ISENTO 
 
 
 Escreva um programa em Python que recebe via teclado: 
Salário mensal, valor das férias e 13o salário. O programa 
deve calcular e imprimir na tela: Salário Anual e a Alíquota 
do imposto de renda (dada pela tabela abaixo): 
 
Salário Mensal Alíquota do Imposto de Renda 
Menor ou igual a 1.058,00 Isento 
Maior que 1.058,00 15% 
Maior que 2.700,00 27,5% 
 
 
10. Escreva um programa em Python que lê via teclado, um 
número inteiro qualquer (positivo ou negativo). O programa 
deve calcular e imprimir na tela: (a) inverso; (b) quadrado; 
(c) raiz quadrada e (d) cubo deste número. 
 
Teste do programa: 
 
Número: 4 <enter> 
Inverso: 0.25 
Quadrado: 16 
Raiz Quadrada: 2 
Cubo: 64 
 
11. Dado os seguintes exemplos de entrada de dados: 
 
 
 a = 1 <enter> a = 1 <enter> 
 b = -4 <enter> b = 2 <enter> 
 c = 2 <enter> c = 3 <enter> 
 
 Raízes Reais Raízes Complexas 
 
 x1 = 3.41 x1 = -1.00 + 1.41 i 
 x2 = 0.59 x2 = -1.00 - 1.41 i 
 
 
 42 
 
 Escreva um programa em Python que recebe via teclado: 
os coeficientes a, b e c de uma equação do segundo grau. O 
programa deve calcular e imprimir na tela: as raízes x1 e 
x2. 
 
a . x2 + b . x + c = 0 # equação de segundo grau 
 
 
Atenção: Note que as raízes podem ser Reais ou Complexas. 
 
 
delta = b2 – 4ac 
 
 +------ 
 -b +- \/ delta 
Raízes Reais: x1,2 = ------------------ “delta maior ou igual a zero” 
 2.a 
 
 +--------- 
 -b \/ | delta | 
Raízes Complexas: x1,2 = ----- +- ------------- i “delta menor que zero” 
 2.a 2.a 
	
12. Escreva um programa em Python que lê um conjunto de 10 
pares de dados contendo, cada um, a altura e um código para 
masculino (1) e outro para feminino (2) de uma turma de 
alunos. Calcular e imprimir na tela: (a) maior e a menor 
altura da turma e (b) média de altura das mulheres e dos 
homens e (c) total de homens e total de mulheres. 
 
Teste do programa: 
 
[Entrada] 
1.80 (altura) 1 (masculino) 
1.60 (altura) 2 (feminino) 
1.62 (altura) 1 (masculino) 
1.70 (altura) 2 (feminino) 
1.72 (altura) 1 (masculino) 
1.80 (altura) 2 (feminino) 
1.92 (altura) 1 (masculino) 
1.40 (altura) 1 (masculino) 
1.42 (altura) 1 (masculino) 
1.64 (altura) 1 (masculino) 
[Saída] 
1.92 (maior altura da turma) 
1.40 (menor altura da turma) 
1.70 (média de altura das mulheres 
1.65 (média de altura dos homens 
7 Homens 
3 Mulheres 
	
13. Escreva	um	programa	em	Python	que	recebe	via	teclado	“n”	nomes	e	
idades.	A	entrada	dos	dados	termina	quando	o	usuário	digitar	'N'	ou	'n'	
na	pergunta	"Continua	[S/N]?".	Logo	após	a	entrada	de	todos	os	dados	o	
 
 43 
programa	 deve	 imprimir	 na	 tela	 todos	 os	 nomes	 e	 idades	 em	 ordem	
alfabética	(conforme	exemplo	abaixo).	
	
Teste do programa: 
	
Nome:	Beatriz	<enter>	
Idade:	12	<enter>	
Continua	[S/N]?	s	<enter>	
Nome:	Carla	<enter>	
Idade:	13	<enter>	
Continua	[S/N]?	s	<enter>	
Nome:	Debora	<enter>	
Idade:	15	<enter>	
Continua	[S/N]?	s	<enter>	
Nome:	Ana	<enter>	
Idade:	14	<enter>	
Continua	[S/N]?	N	<enter>	
Ana	 	 14	
Beatriz	12	
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	de	valores	por	extenso:	9		
	
21.	Curiosidades	e	testes	no	Python	
 
	 A	seguir	são	vistos	algumas	curiosidades	e	testes	feitos	no	
Python:	
	
#	---------------------------------	Teste.py	
	
#	====================	inicialização	de	várias	variáveis	
 
 44 
	
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	=	%d	-	y	=	%d\n"	%(x,	y))	 #	print	formatado#	=====================	definição	de	uma	função	em	Python	
	
def	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	Digitado:	",	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")	
	
#	==================================	data	e	hora	
	
from	datetime	import	datetime	
	
data	=	datetime.now()	
 
 45 
print(data)	
print("Data:	%02d/%02d/%d"	%(data.day,	data.month,	data.year))	
print("Tempo:	%02d:%02d:%02d"	%(data.hour,	data.minute,	data.second))	
	
Teste	do	Programa:	
	
10	20	
5	
x	=	10	-	y	=	20	
	
4	
Digite	um	Número:	-5	
Valor	Negativo	
Número	Digitado:	-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	com	números	
print(s)	
	
Teste	do	Programa:	
	
==========	RESTART:	/Users/pluzzardi/Documents/str.py	===========	
0,	1,	2,	3,	4,	5,	6,	7,	8,	9,		
>>>	
	
22.	Funções	escritas	pelo	programador	em	Python	
	
	 Em	Python	é	possível	o	programador	escrever	suas	próprias	funções,	
ou	seja,	dividir	os	programas	em	módulos	menores	(programação	modular	
ou	 estruturada	 ou	 dividir	 para	 conquistar).	 Uma	 função	 deve	 ser	 uma	
caixa	preta,	que	depois	de	funcionar	não	precisa	mais	manutenção.	Uma	
função	pode	ou	não	receber	argumentos	(parâmetros)	e	retornar	ou	não	um	
valor.	
	
 
 46 
	 Para	 escrever	 uma	 função	 usa-se	 a	 palavra	 reservada	 def.	 A	
princípio	a	função	deve	estar	localizada	antes	da	chamada	da	função.	A	
sintaxe	é:	
	
def	nome_função(lista	de	argumentos):	
	 comando1	
	 comando2	
	 return(valor)	
	
chamada_função(argumentos)	
	
Exemplo:	
	
#	--------------------------------	Funcoes.py	
	
import	math	
	
def	Hipotenusa(a,	b):	
				h	=	math.sqrt(a**2	+	b**2)	
				return(h)	
	
def	Maior(a,	b):	
				if	a	>=	b:	
								return(a)	
				else:	
								return(b)	
	
def	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	do	Programa:	
	
=====	RESTART:	/Users/pluzzardi/Documents/Funcoes.py	====	
Digite	um	valor	(a):	3	<enter>	
Digite	outro	valor	(b):	4	<enter>	
Hipotenusa:		5.0	
Maior:		4.0	
Menor:		3.0	
>>>	
	
	 Exemplo	usando	uma	função	Raiz,	usando	um	conceito	da	matemática:	
 
 47 
	
def	Raiz(x):	
	 r	=	x	**	0.5	
	 return(r)	
	
def	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	do	Programa:	
	
=====	RESTART:	/Users/pluzzardi/Documents/Raiz.py	====	
Digite	um	valor	(a):	3	<enter>	
Digite	outro	valor	(b):	4	<enter>	
Hipotenusa:		5.0	
	
Funções	recursivas	em	Python:	
	
	 Uma	função	é	dita	recursiva	quando	faz	chamada	a	si	própria,	cada	chamada	é	
colocada	na	pilha	de	execução	do	sistema	e	serve	para	retornar	as	chamadas	anteriores.	
	
#	----------------------------------------------	Fatorial.py	
#	Exemplo	de	função	recursiva,	função	que	chama	a	si	própria	
#	É	complexo	o	ponto	de	parada	
#	----------------------------------------------------------	
	
def	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	do	Programa:	
	
===	RESTART:	/Users/pluzzardi/Documents/Fatorial.py	=====	
Digite	um	valor:	20	<enter>	
Fatorial:		2432902008176640000	
>>>	
	 O	programa	a	seguir,	calcula	o	valor	da	série	de	Fibonacci:	
	
# ...................... Fibonacci.py 
 
def Fibonacci(n): 
 if n == 0: 
 
 48 
 return(0) 
 if n == 1 or n == 2: 
 return(1) 
 else: 
 return(Fibonacci(n-1) + Fibonacci(n-2)) 
 
n = int(input("Fibonacci de: ")) 
print("A sequência de Fibonacci é: ", sep='', end='') 
for i in range(n): 
 print(Fibonacci(i), ", ", end='', sep='') 
	
Teste	do	Programa:	
	
Fibonacci	de:	15	<enter>	
A	sequência	de	Fibonacci	é:	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ência	em	ordem	
reversa	recursivamente:	
	
# ..................... Imprime.py 
 
n = int(input("Número: ")) 
Imprime(n) 
 
def Imprime(n): 
 if n == 0: 
 return 
 else: 
 print(n) 
 Imprime(n-1) 
	
Teste	do	Programa:	
	
Número:	5	<enter>	
5	
4	
3	
2	
1	
	
	 A	seguir	é	visto	um	exemplo	que	mostra	duas	funções	que	permitem	
entrada	de	dados	de	números	reais	(REAL)	ou	números	inteiros	(INTEIRO)	
via	teclado	sem	erro,	ou	seja,	o	usuário	pode	cometer	erros	de	digitação	
que	o	programa	não	é	abortado.	
	
#	----------------------------------------------------------	Float.py	
#	O	programa	testa	a	conversão	de	string	para	float	ou	inteiro		
#					sem	erro	na	entreda	de	dados	com	input	
#	-------------------------------------------------------------------	
	
def	REAL(s):	
				n	=	len(s)	
				temLetras	=	False	
 
 49 
				for	i	in	range(n):	
								if	s[i]	==	',':	
												s	=	s.replace(',','.')	 #	trocar	vírgula	por	ponto	
								if	s[i]	==	'-'	and	i	!=	0:	 #	verifica	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álida")	
								return(-1)	
	
def	INTEIRO(s):	
				n	=	len(s)	
				temLetras	=	False	
				for	i	in	range(n):	
								if	s[i]	==	'-'	and	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álida")	
								return(-1)	
					
s	=	input("Digite	um	Real:	")	
numero	=	REAL(s)	
if	numero	!=	-1:	
				print("Real	digitado	foi:	",	numero)	
while	numero	==	-1:	
				s	=	input("Digite	um	Real:	")	
				numero	=	REAL(s)	
				print("Número	digitado:	",	numero)	
					
s	=	input("Digite	um	Inteiro:	")	
numero	=	INTEIRO(s)	
if	numero	!=	-1:	
				print("Inteiro	digitado	foi:	",	numero)	
while	numero	==	-1:	
				s	=	input("Digite	um	Inteiro:	")	
				numero	=	INTEIRO(s)					
				print("Número	digitado:	",	numero)	
	
Teste	do	Programa:	
	
=====	RESTART:	/Users/pluzzardi/Desktop/Python/Python/float.py	=====	
 
 50 
Digite	um	Real:	1234Paulo	
ERRO:	Conversão	Inválida	
Digite	um	Real:	123,45	
Número	digitado:		123.45	
Digite	um	Inteiro:	paulo123	
ERRO:	Conversão	Inválida	
Digite	um	Inteiro:	123	
Número	digitado:		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.pydef add(x, y): 
 return(x+y) 
 
def sub(x, y): 
 return(x-y) 
 
def mult(x, y): 
 return(x*y) 
 
def div(x, y): 
 if y == 0: 
 return("Erro: Divisão por Zero") 
 return(x/y) 
 
def calculadora(x, y, operador): 
 if operador == '+': 
 valor = add(x,y) 
 else: 
 if operador == '-': 
 valor = sub(x,y) 
 else: 
 if operador == '*': 
 valor = mult(x,y) 
 else: 
 if operador == '/': 
 valor = div(x,y) 
 else: 
 return("ERRO: Operador Inválido") 
 return(valor) 
 
 
 51 
x = float(input("Digite um Valor: ")) 
y = float(input("Digite outro Valor: ")) 
operador = input("Operação [+ - * / **]: ") 
valor = calculadora(x, y, operador) 
print(valor) 
 
Teste	do	Programa:	
 
Digite	um	Valor:	3	
Digite	outro	Valor:	4	
Operação	[+	-	*	/	**]:	/	
0.75	
 
Teste	do	Programa:	
 
Digite	um	Valor:	3	
Digite	outro	Valor:	0	
Operação	[+	-	*	/	**]:	/	
Erro:	Divisão	por	Zero	
 
Teste	do	Programa:	
 
Digite	um	Valor:	3	
Digite	outro	Valor:	4	
Operação	[+	-	*	/	**]:	&	
ERRO:	Operador	Inválido	
 
Exemplo de passagem por referência: 
 
 Passagem de parâmetros por referência, ou seja, quando 
os parâmetros são modificados. 
 
 Note que interessante o comando return, pois ele contém 
duas variáveis. 
 
# ..................... Troca.py 
 
def troca(x, y): 
 temp = x 
 x = y 
 y = temp 
 return(x, y) 
 
x = 3 
y = 4 
print("x = ", x) 
print("y = ", y) 
x, y = troca(x, y) 
print("x = ", x) 
print("y = ", y) 
	
	
Teste	do	Programa:	
	
x	=		3	
 
 52 
y	=		4	
a	=		4	
b	=		3	
	
22.1	Exercícios	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	do	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 = ")) 
 
 53 
c = float(input("c = ")) 
x1, x2 = Bhaskara(a, b, c) 
if x1 != -1 and x2 != -1: 
 print("Raizes Reais") 
 print("x1 = ", x1) 
 print("x2 = ", x2) 
else: 
 print("Raizes Complexas") 
	
Teste	do	Programa:	
	
a	=	1	<enter>	
b	=	2	<enter>	
c	=	-3	<enter>	
Raizes	Reais	
x1	=		1.0	
x2	=		-3.0	
	
Teste	do	Programa:	
	
a	=	1	<enter>	
b	=	2	<enter>	
c	=	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	do	Programa:	
	
Nome:	Paulo	Roberto	Gomes	Luzzardi	<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) 
 
 54 
	
Teste	do	Programa:	
	
Data	[dd/mm/aaaa]:	25/03/2018	<enter>	
Dia:	25	
Mês:	3	
Ano:	2018	
	
Teste	do	Programa:	
	
Data	[dd/mm/aaaa]:	25/03/18	<enter>	
ERRO:	Formato	Inválido	
	
Teste	do	Programa:	
	
Data	[dd/mm/aaaa]:	32/03/18	<enter>	
ERRO:	Dia	Inválido	
	
e)Implemente a função Verifica_Quadrante que recebe dois 
valores inteiros: x e y e retorna o quadrante (1, 2, 3 ou 
4) destas coordenadas, conforme exemplo a seguir: 
	
Trecho do programa principal: 
	
x = int(input("x = ")) 
y = int(input('y = ')) 
n = Verifica_Quadrante(x, y) 
print("Quadrante: %d" %n) 
	
Teste	do	Programa:	
	
x	=	2	
y	=	-2	
Quadrante:	4	
	
f)Implemente a função Final_Placa que recebe uma string 
no formato “xxx9999” (placa) e devolve o final da placa 
com dois dígitos, conforme exemplo a seguir: 
	
Trecho do programa principal: 
	
placa = input("Placa [xxx9999]: ") 
final = FinalPlaca(placa) 
if final != -1: 
 print("Final da Placa é: %d" %final) 
	
Teste	do	Programa:	
	
Placa	[xxx9999]:	etq1234	<enter>	
Final	da	Placa	é:		34	
	
Teste	do	Programa:	
	
Placa	[xxx9999]:	etq123	<enter>	
ERRO:	Formato	Inválido	
 
 55 
	
23.	Criação	e	utilização	de	módulos	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	do	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) 
 
 
 56 
def menor(x, y): 
 if x <= y: 
 return(x) 
 else: 
 return(y) 
	
# .................... Modulos.py 
 
import Luzzardi 
 
x = 3 
y = 4 
print("x = ", x) 
print("y = ", y) 
x, y = Luzzardi.troca(x, y) 
print("x = ", x) 
print("y = ", y) 
print("Maior: ", Luzzardi.maior(x, y)) 
print("Menor: ", Luzzardi.menor(x,y)) 
	
Teste	do	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	é	necessário	“return”	no	final	da	função,	o	término	da	
função	é	pela	identação.	
 
 57 
		
# ....................... Modulos.py 
 
import Luzzardi 
 
x = 3 
y = 4 
Luzzardi.mensagem("x = ", x) 
Luzzardi.mensagem("y = ", y) 
x, y = Luzzardi.troca(x, y) 
Luzzardi.mensagem("x = ", x) 
Luzzardi.mensagem("y = ", y) 
Luzzardi.mensagem("Maior: ", Luzzardi.maior(x, y)) 
Luzzardi.mensagem("Menor: ", Luzzardi.menor(x, y)) 
	
Teste	do	Programa:	
	
x	=		3	
y	=		4	
x	=		4	
y	=		3	
Maior:		4	
Menor:		3	
	
Em	Python	é	possível	o	programador	escrever	suas	próprias	funções	
dentro	de	um	módulo	e	inseri-lo	em	seus	programas.	O	módulo	é	um	arquivo	
Python	(modulo.py)	somente	com	definições	de	funções.	A	princípio,	este	
módulo	deve	estar	junto	ao	programa	fonte,	ou	seja,	na	mesma	localização.	
	
#---------------------------------------------------------	Luzzardi.py	
#	O	programa	testa	a	conversão	de	string	para	float	ou	inteiro		
#					sem	erro	na	entrada	de	dados	com	input	
#	-------------------------------------------------------------------	
	
def	REAL(s):	
				n	=	len(s)	
				temLetras	=	False	
				for	i	in	range(n):	
								if	s[i]	==	',':	
												s	=	s.replace(',','.')		 #	converte	vírgula	em	ponto	
								if	s[i]	==	'-'	and	i	!=	0:	 #	verifica	sinal	negativo	
												temLetras	=	True;	
												break	
								if	s[i]	not	in	['.',	'-',	'0',	'1',	'2',	'3',	'4',	'5',	'6',	'7',	'8','9']:	
	 #	verifica	caracteres	não	numéricos	
											temLetras	=	True	
											break	
				if	not	temLetras:	
								numero	=	float(s)	
								return(numero)	
				else:	
								print("ERRO:	Conversão	Inválida")	
								return(-1)	 #	retorna	um	valor	inválido	
	
 
 58 
def	INTEIRO(s):	
				n	=	len(s)	
				temLetras	=	False	
				for	i	in	range(n):	
								if	s[i]	==	'-'	and	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álida")	
								return(-1)	
	
#	----------------------------------------	Modulo.py	
	
import	Luzzardi	 	 #	inserção	do	módulo	do	programador	
	
s	=	input("Digite	um	Real:	")	
numero	=	luzzardi.REAL(s)	
if	numero	!=	-1:	
				print("Real	digitado	foi:	",	numero)	
while	numero	==	-1:	
				s	=	input("Digite	um	Real:	")	
				numero	=	luzzardi.REAL(s)	
				print("Número	digitado:	",	numero)	
					
s	=	input("Digite	um	Inteiro:	")	
numero	=	luzzardi.INTEIRO(s)	
if	numero	!=	-1:	
				print("Inteiro	digitado	foi:	",	numero)	
while	numero	==	-1:	
				s	=	input("Digite	um	Inteiro:	")	
				numero	=	luzzardi.INTEIRO(s)					
				print("Número	digitado:	",	numero)	
	
=======	RESTART:	/Users/pluzzardi/Desktop/Python/Python/Modulo.py	===	
Digite	um	Real:	1234Paulo	
ERRO:	Conversão	Inválida	
Digite	um	Real:	123,45	
Número	digitado:		123.45	
Digite	um	Inteiro:	123Paulo	
ERRO:	Conversão	Inválida	
Digite	um	Inteiro:	123	
Número	digitado:		123	
>>>	
	
24.	Tratamento	de	erros	(exceções)	
 
 
 59 
Na execução de um programa em Python, podem ocorrer 
erros não previstos que podem interromper a execução normal 
do programa. Tais erros podem ser: 
 
• Conversão numérica inválida; 
• Limite de um vetor (acessar um índice inválido) 
• Problemas em arquivos: abertura, criação ou caminho 
(path); 
• Overflow; 
 
• Erro de entrada e saída (input/output); 
 
• Divisão por zero. 
 
Python pode assumir o controle da execução em caso que 
ocorra uma situação de erro não prevista. 
 
Isso é feito através do mecanismo de tratamento de 
exceções que ao detectar uma situação de erro, o programa em 
Python gera uma exceção. 
 
Se o programa que estiver sendo executado possuir um 
tratamento de exceções (try: ... except ...:), ele assume o 
controle da execução. Mas se a exceção não tiver um 
tratamento associado, o programa é interrompido e é exibida 
uma mensagem de erro e o programa é abortado. 
 
Uma exceção é um evento que indica uma condição anormal 
que interrompe a execução normal de um programa. 
 
O tratamento de erros no Python cria objetos da classe 
error, o tratamento destes erros é feita pela manipulação 
destes objetos. Analise o exemplo abaixo, aonde são testados 
a conversão de string para inteiro (comando input) e raiz 
quadrada de número negativo (math.sqrt()). 
 
Tipo de Exceção: ValueError 
 
#	--------------------------	ValueError.py	
	
import	math	
	
try:	
				num	=	int(input("Digite	um	Número:	"))	
				try:	
								raiz	=	math.sqrt(num)	
								print("Raiz	Quadrada:	",	raiz)	
				except	ValueError	as	error:	
								print("Erro:	",	error)	
except	ValueError	as	error:	
				print("Erro:	",	error)	
	
Teste	do	Programa:	
 
 60 
	
========== RESTART: /Users/pluzzardi/Documents/ValueError.py ======= 
Digite um Número: paulo 
Erro: invalid literal for int() with base 10: 'paulo' 
>>> 
========= RESTART: /Users/pluzzardi/Documents/ValueError.py ======== 
Digite um Número: -16 
Erro: math domain error 
>>> 
======= RESTART: /Users/pluzzardi/Documents/ValueError.py ========= 
Digite um Número: 16 
Raiz Quadrada: 4.0 
>>> 
 
O tratamento de erros em Python baseia-se no comando 
try. A sintaxe é a seguinte: 
 
try: 
 comando 
 comando 
except erro: 
 comando 
 comando 
 
A execução de um bloco de código, protegido por um 
tratamento de erros, é feito colocando o bloco no try, e 
para cada erro que se deseja tratar, deve-se colocar uma 
cláusula except tipo_de_erro as variável_erro: 
 
Exceções são instâncias de classes geradas quando 
houver erro. Estas exceções podem ser captadas e tratadas 
para que não ocorra erros em tempo de execução. 
 
Tipo de Exceção: ZeroDivisionError 
 
# ------------------------------- Zero.py 
 
try: 
 x = float(input("Digite um Valor: ")) 
 y = float(input("Digite outro Valor: ")) 
 try: 
 divisão = x / y 
 print("Divisão é: ", divisão) 
 except ZeroDivisionError as error: 
 print("Erro: ", error) 
except ValueError as error: 
 print('Erro: ', error) 
Teste	do	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 
 
 61 
Erro: float division by zero 
>>> 
 
Tipo de Exceção: NameError e TypeError 
 
# ------------------------------------ NameError.py 
 
try: 
 num = int(input("Valor: ")) 
 print("Soma: ", soma + num) # soma não está definido 
except NameError as error: # erro por nome 
 print("ERRO: ", error) 
 
try: 
 a = 5 
 soma = 'a' + a # tipos diferentes 
 print("Soma: ", soma) 
except TypeError as error: # erro por tipo 
 print("ERRO: ", error) 
 
Teste	do	Programa:	
	
==========	RESTART:	/Users/pluzzardi/Documents/NameError.py	========	
Valor:	5	
ERRO:		name	'soma'	is	not	defined	
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	do	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: 
 
 62 
 file = open(nomeArquivo, 'r') 
except IOError as error: 
 print("Erro: ", error) 
else: 
 print("Nome do Arquivo: ", nomeArquivo) 
 file.close() 
 
Teste	do	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.	Banco	de	Dados	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	do	Banco	de	Dados:	")	
conector	=	sqlite3.connect(nomeBD)	
cursor	=	conector.cursor()	
cursor.execute('''	
								create	table	agenda	(	
												id	integer,	 	 #	identificador	
												nome	text,	
												fone	text)''')	
id	=	1	
nome	=	"Pessoa"	
while	nome	!=	"":	
				print("id:	",	id)	
				nome	=	input("Nome:	")	
				if	nome	!=	"":	
								fone	=	input("Fone:	")	
 
 63 
								cursor.execute('''	
																insert	into	agenda	(id,	nome,	fone)	
																				values(?,	?,	?)	
																				''',	(id,	nome,	fone))	
								conector.commit()	
								id	=	id	+	1	
cursor.close()	
conector.close()	
print("Banco	de	Dados	foi	CRIADO:	",	nomeBD)	
	
Teste	do	Programa:	
	
======	RESTART:	/Users/pluzzardi/Desktop/Python/SQLiteCriaBD.py	=====	
Nome	do	Banco	de	Dados:	Agenda.bd	
id:	1	
Nome:	Paulo	Roberto	
Fone:	99164-8037	
id:	2	
Nome:	Adriane	Maria	
Fone:	99145-6789	
id:	3	
Nome:	Paola	Maria	
Fone:	98478-7856	
id:	4	
Nome:		
Banco	de	Dados	foi	CRIADO:		Agenda.bd	
>>>	
	
 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	do	Banco	de	Dados:	")	
try:	 	 	 	 	 	 	 #	tratamento	de	exceção	
				conector	=	sqlite3.connect(nomeBD)	
				cursor	=	conector.cursor()	
				numRegistros	=	0	
				cursor.execute("SELECT	*	FROM	agenda")	
				result	=	cursor.fetchall()	
				for	contato	in	result:	
									print("id:	%d\nNome:	%s	\nFone:	%s"	%	(contato))	
									numRegistros	+=	1	
				print(numRegistros,	"registro(s)")	
				cursor.close()	
				conector.close()	
except	sqlite3.Error	as	error:	 #	executa	quando	ocorre	um	erro	
				print("Erro:	BD	não	encontrado")	
				print("Erro:	",	error)	
				os.remove(nomeBD)			#	remove	arquivo	criado	
 
 64 
	
	
Teste	do	Programa:	
	
======	RESTART:	/Users/pluzzardi/Desktop/Python/SQLiteLeBD.py	=======	
Nome	do	Banco	de	Dados:	Luzzardi.bd	
id:	1	
Nome:	Paulo	Roberto		
Fone:	99164-8037	
id:	2	
Nome:	Adriane	Maria		
Fone:	99156-4567	
id:	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	do	Banco	de	Dados:	")	
try:	
				conector	=	sqlite3.connect(nomeBD)	
				id	=	'1'	
				cursor	=	conector.cursor()	
				while	id	!=	'0':	
								id	=	input('Digite	o	índice	[0	-	Sair]:	')	
								if	id	!=	'0':	
												cursor.execute("SELECT	*	FROM	agenda	WHERE	id=?",(id))	
												result	=	cursor.fetchall()	
												achei	=	False	
												for	contato	in	result:	
																print("id:	%d\nNome:	%s	\nFone:	%s"	%	(contato))	
																achei	=	True	
												if	not	achei:	
																print("Erro:	Contato	não	Encontrado")	
				cursor.close()	
				conector.close()	
except	sqlite3.Error	as	error:	
				print("ERRO:	BD	não	encontrado")	
				print("Erro:	",	error)	
				os.remove(nomeBD)		 #	remove	arquivo	criado	
	
Teste	do	Programa:	
	
===	RESTART:	/Users/pluzzardi/Desktop/Python/SQLiteConsultaBD.py	====	
Nome	do	Banco	de	Dados:	Agenda.bd	
 
 65 
Digite	o	índice	[0	-	Sair]:	1	
id:	1	
Nome:	Paulo	Roberto		
Fone:	99164-8037	
Digite	o	índice	[0	-	Sair]:	2	
id:	2	
Nome:	Adriane	Maria		
Fone:	99156-4567	
Digite	o	índice	[0	-	Sair]:	3	
id:	3	
Nome:	Paola	Maria		
Fone:	98434-1234	
Digite	o	índice	[0	-	Sair]:	0	
>>>	
	
 O programa a seguir permite remover os campos do banco 
de dados (Agenda.bd) gerados pelo programa anterior através 
da leitura via teclado do identificador (id). 
	
#	------------------------	SQLiteRemoveBD.py	
	
import	sqlite3,	os	
	
nomeBD	=	input("Nome	do	Banco	de	Dados:	")	
try:	
				conector	=	sqlite3.connect(nomeBD)	
				cursor	=	conector.cursor()	
				id	=	'1'	
				while	id	!=	'0':	
								id	=	input("Digite	o	índice	[0	-	Sair]:	")	
								if	id	!=	'0':	
												cursor.execute("DELETE	FROM	agenda	WHERE	id=?",(id))	
												conector.commit()	
												print("Okay,	Contato	REMOVIDO")	
				cursor.close()	
				conector.close()	
except	sqlite3.Error	as	error:	
				print("Erro:	BD	não	encontrado")	
				print("Erro:	",	error)	
				os.remove(nomeBD)	
	
Teste	do	Programa:	
	
=====	RESTART:	/Users/pluzzardi/Desktop/Python/SQLiteRemoveBD.py	====	
Nome	do	Banco	de	Dados:	Agenda.bd	
Digite	o	índice:	3	
Digite	o	índice:	0	
Okay,	Contato	REMOVIDO	
>>>		
=======	RESTART:	/Users/pluzzardi/Desktop/Python/SQLiteLeBD.py	=====	
Nome	do	Banco	de	Dados:	Agenda.bd	
id:	1	
Nome:	Paulo	Roberto		
 
 66 
Fone:	99164-8037	
id:	2	
Nome:	Adriane	Maria		
Fone:	99156-4567	
>>>	
	
#	------------------------	SQLiteAppendBD.py	
	
import	sqlite3,	os	
	
nomeBD	=	input("Nome	do	Banco	de	Dados:	")	
try:	
				conector	=	sqlite3.connect(nomeBD)	
				cursor	=	conector.cursor()	
	
				id	=	1	
				cursor.execute("SELECT	*	FROM	agenda")	
				result	=	cursor.fetchall()	
				for	contato	in	result:	
								id	+=	1	
	
				nome	=	"Pessoa"	
				while	nome	!=	"":	
								print("id:	",	id)	
								nome	=	input("Nome:	")	
								if	nome	!=	"":	
												fone	=	input("Fone:	")	
												cursor.execute('''	
																				INSERT	INTO	agenda	(id,	nome,	fone)	
																								values(?,	?,	?)	
																								''',	(id,	nome,	fone))	
												conector.commit()	
												id	=	id	+	1	
				cursor.close()	
				conector.close()	
except	sqlite3.Error	as	error:	
				print("Erro:	BD	não	encontrado")	
				print("Erro:	",	error)	
				os.remove(nomeBD)	
	
Teste	do	Programa:	
	
====	RESTART:	/Users/pluzzardi/Desktop/Python/SQLiteAppendBD.py	=====	
Nome	do	Banco	de	Dados:	Agenda.bd	
id:		4	
Nome:	Renato	Luis	
Fone:	99134-2345	
id:		5	
Nome:	Cacaio	
Fone:	99891-3456	
id:		6	
Nome:		
>>>	
 
 67 
	
Execução	do	programa	SQLiteLeBD.py	
	
=======	RESTART:	/Users/pluzzardi/Desktop/Python/SQLiteLeBD.py	=====	
Nome	do	Banco	de	Dados:	Agenda.bd	
id:	1	
Nome:	Paulo	Roberto		
Fone:	99164-8037	
id:	2	
Nome:	Adriane	Maria		
Fone:	99156-4567	
id:	3	
Nome:	Paola	Maria		
Fone:	98434-1234	
id:	4	
Nome:	Renato	Luis		
Fone:	99134-2345	
id:	5	
Nome:	Cacaio		
Fone:	99891-3456	
5	registro(s)	
>>>	
26.	Sistema	de	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 
 
 
 68 
1;Paulo Roberto;99164-8037; 
2;Adriane Maria;99156-2345; 
3;Paola Freitas;98678-1234; 
	
# -------------------------------------- FileLeTexto.py 
 
nomeFile = input("Nome do Arquivo: ") 
try: 
 file = open(nomeFile, "r") 
 for linha in file: 
 campos = linha.split(';') 
 print(campos) 
 file.close() 
except IOError as error: 
 print("ERRO: ", error) 
	
Teste	do	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	do	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	do	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' 
>>> 
 
 69 
	
# -------------------------------------- FileAnexaTexto.py 
 
nomeFile = input("Nome do Arquivo: ") 
try: 
 file = open(nomeFile, 'r') 
 id = 1 
 for linha in file: 
 id = id + 1 # contar o número de registros 
 file.close() 
 
 file = open(nomeFile,'a') # anexando no fim do arquivo 
 nome = "Pessoa" 
 while nome != "": 
 print("id: ", id) 
 nome = input("Nome: ") 
 if nome != "": 
 fone = input("Fone: ") 
 linha = str(id) + ";" + nome + ";" + fone + ";" + "\n" 
 file.write(linha) 
 id = id + 1 
 file.close() 
except IOError as error: 
 print("ERRO: ", error) 
	
Teste	do	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	do	Arquivo	alterado:	Dados.txt	
	
['1', 'Paulo Roberto', '99164-8037', '\n'] 
['2', 'Adriane Maria', '99156-2345', '\n'] 
['3', 'Paola Freitas', '98678-1234', '\n'] 
[‘4’;’Renato Luis’;’98778-3456’;’\n’] 
[‘5’;’Francisco Carlos’;’98178-5678’;’\n’] 
	
# ------------------------------- FileCriaTexto.py 
 
nomeFile = input("Nome do Arquivo: ") 
try: 
 file = open(nomeFile, 'w') # cria novo arquivo texto 
 id = 1 # cuidado, apaga se existir 
 nome = "Pessoa" 
 while nome != "": 
 print("id: ", id) 
 nome = input("Nome: ") 
 if nome != "": 
 
 70 
 fone = input("Fone: ") 
 linha = str(id) + ";" + nome + ";" + fone + ";" + "\n" 
 file.write(linha) 
 id = id + 1 
 file.close() 
except IOError as error: 
 print("ERRO: ", error) 
	
Teste	do	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	do	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	do	Programa:	
	
RESTART: 
/Users/pluzzardi/Desktop/Python/Python/File/FileProcuraDadosTexto.py 
Nome do Arquivo: Dados.txt 
Posição [0 - Sair]: 1 
 
 71 
id: 1 
Nome: Paulo Roberto 
Fone: 99164-8037 
Posição [0 - Sair]: 2 
id: 2 
Nome: Adriane Maria 
Fone: 99156-2345 
Posição [0 - Sair]: 3 
id: 3 
Nome: Paola Freitas 
Fone: 98678-1234 
Posição [0 - Sair]: 4 
id: 4 
Nome: Renato Luis 
Fone: 98778-3456 
Posição [0 - Sair]: 5 
id: 5 
Nome: Francisco Carlos 
Fone: 98178-5678 
Posição [0 - Sair]: 6 
Erro: Registro não encontrado 
Posição [0 - Sair]: 7 
Erro: Registro não encontrado 
Posição [0 - Sair]: 8 
Erro: Registro não encontrado 
Posição [0 - Sair]: 9 
Erro: Registro não encontrado 
Posição [0 - Sair]: 0 
Erro: Registro não encontrado 
>>> 
	
# ------------------------------------ FileBuscaDadosTexto.py 
 
nomeFile = input("Nome do Arquivo: ") 
try: 
 file = open(nomeFile, "r") 
 nome = "Pessoa" 
 while nome != "": 
 nome = input("Nome: ") 
 file.seek(0, 0) 
 imprimiu = False 
 for linha in file: 
 campos = linha.split(';') 
 if nome == campos[1]: 
 imprimiu = True 
 print("id: ", campos[0]) 
 print("Nome: ", campos[1]) 
 print("Fone: ", campos[2]) 
 if not imprimiu: 
 print("Erro: Nome não encontrado") 
 file.close() 
except IOError as error: 
 print("ERRO: ", error) 
	
Teste	do	Programa:	
	
RESTART: 
/Users/pluzzardi/Desktop/Python/Python/File/FileBuscaDadosTexto.py 
Nome do Arquivo: Dados.txt 
Nome: Paulo 
Erro: Nome não encontrado 
 
 72 
Nome: Paulo Roberto 
id: 1 
Nome: Paulo Roberto 
Fone: 99164-8037 
Nome: Renato Luis 
id: 4 
Nome: Renato Luis 
Fone: 98778-3456 
Nome: 
Erro: Nome não encontrado 
>>> 
29.	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: 
 
 73 
 print("Atenção: Arquivo não existe") 
 try: 
 file = open(nomeArquivo, "wb") 
 except IOError as error: 
 print("Erro: Impossível criar o arquivo: %s" %nomeArquivo) 
 n = int(input("Número de Elementos: ")) 
 pickle.dump(n, file) 
 for i in range(n): 
 nome = input("Nome: ") 
 pickle.dump(nome, file) 
 telefone = input("Telefone: ") 
 pickle.dump(telefone, file) 
 idade = int(input("Idade: ")) 
 pickle.dump(idade, file) 
 file.close() 
	
Observação:	Note	que	o	número	de	elementos	também	é	salvo	no	arquivo	binário,	para	
depois	ser	lido	no	programa	que	carrega	o	arquivo	binário.		
	
Teste	do	Programa:	
	
Nome	do	Arquivo	Binário:	teste.bin	<enter>	
Número	de	Elementos:		3	<enter>	
Nome:		Paulo	Roberto	<enter>	
Telefone:		99164-8037	<enter>	
Idade:		56	<enter>	
Nome:		Adriane	Maria	<enter>	
Telefone:		99156-3334	<enter>	
Idade:		48	<enter>	
Nome:		Paola	Freitas<enter>	
Telefone:		99167-4567	<enter>	
Idade:		19	<enter>	
	
# ........................ LeBin.py 
 
import pickle 
 
nomeArquivo = input("Nome do Arquivo Binário: ") 
try: 
 file = open(nomeArquivo, "rb") 
 n = pickle.load(file) 
 print("Número de Elementos: ", n) 
 for i in range(n): 
 nome = pickle.load(file) 
 print("Nome: ", nome) 
 telefone = pickle.load(file) 
 print("Telefone: ", telefone) 
 idade = pickle.load(file) 
 print("Idade: ", idade) 
 file.close() 
except IOError as error: 
 print('Atenção: Arquivo não Existe', nomeArquivo) 
 print(error) 
	
Teste	do	Programa:	
	
Nome	do	Arquivo	Binário:	teste.bin	<enter>	
 
 74 
Número	de	Elementos:		3	<enter>	
Nome:		Paulo	Roberto	<enter>	
Telefone:		99164-8037	<enter>	
Idade:		56	<enter>	
Nome:		Adriane	Maria	<enter>	
Telefone:		99156-3334	<enter>	
Idade:		48	<enter>	
Nome:		Paola	Freitas	<enter>	
Telefone:		99167-4567	<enter>	
Idade:		19	<enter>	
	
Exemplo de um programa em Python que grava em um arquivo 
binário: dados.bin uma lista (vetor) contendo os seguintes 
campos: nome (string), telefone (string) e idade (inteiro). 
	
# ........................... GravaBinario 
 
import pickle 
 
nomeArquivo = input("Nome do Arquivo Binário: ") 
lista = ["Paulo Roberto", "99164-8037", 56, 
 "Adriane Maria", "99156-3334", 48, 
 "Paola Freitas", "99181-3456", 19] 
n = len(lista) 
print("n = ", n) 
 
try: 
 file = open(nomeArquivo, "wb") 
except IOError as error: 
 print("Atenção: Impossível criar o arquivo") 
pickle.dump(lista, file) 
file.close() 
print("Okay, Arquivo %s criado" %nomeArquivo) 
	
Teste	do	Programa:	
	
Nome	do	Arquivo	Binário:	dados.bin	<enter>	
n	=		9	
Okay,	Arquivo	dados.bin	criado	
	
# ............................. 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	do	Programa:	
	
Nome	do	Arquivo	Binário:	dados.bin	
 
 75 
Lista:		['Paulo	Roberto',	'99164-8037',	56,	'Adriane	Maria',	'99156-3334',	48,	'Paola	
Freitas',	'99181-3456',	19]	
	
Arquivo	Texto:	Frutas.txt	
	
Abacate	
Ameixa	
Banana	
Bergamota	
Anana	
Morango	
Caqui	
Uva	
Laranja	
Lima	
Goiaba	
Damasco	
Tangerina	
	
# ........................... Letexto.py 
 
nomeArquivo = input("Nome do Arquivo Texto: ") 
linha = [] 
try: 
 file = open(nomeArquivo, "r") 
 for linha in file: 
 linha = file.read() 
 print(linha) 
 file.close() 
except IOError as error: 
 print("Atenção: Arquivo Inexistente") 
	
Teste	do	Programa:	
	
Nome	do	Arquivo	Texto:	Frutas.txt	<enter>	
Abacate	
Ameixa	
Banana	
Bergamota	
Anana	
Morango	
Caqui	
Uva	
Laranja	
Lima	
Goiaba	
Damasco	
Tangerina	
	
# .............................. ConverteTextoBinario.py 
 
import pickle 
 
nomeArquivoTexto = input("Nome do Arquivo Texto: ") 
nomeArquivoBinario = input("Nome do Arquivo Binário: ") 
 
 76 
try: 
 fileTexto = open(nomeArquivoTexto, "r") 
 try: 
 fileBinario = open(nomeArquivoBinario, "wb") # cuidado: 
apaga arquivo se já existir 
 except IOError as error: 
 print("Atenção Impossível CRIAR Arquivo Binário") 
 for linha in fileTexto: 
 linha = fileTexto.read() 
 pickle.dump(linha, fileBinario) 
 print(linha) 
 fileTexto.close() 
 fileBinario.close() 
except IOError as error: 
 print("Atenção: Arquivo texto inexistente") 
	
Teste	do	Programa:	
	
Nome	do	Arquivo	Texto:	Frutas.txt	<enter>	
Nome	do	Arquivo	Binário:	Frutas.bin	<enter>	
Abacate	
	
Ameixa	
	
Banana	
	
Bergamota	
	
Anana	
	
Morango	
	
Caqui	
	
Uva	
	
Laranja	
	
Lima	
	
Goiaba	
	
Damasco	
	
Tangerina	
	
# ........................ LeTextoConvertidoBinario.py 
 
import pickle 
 
nomeArquivo = input("Nome do Arquivo Binário: ") 
try: 
 file = open(nomeArquivo, "rb") 
 try: 
 while True: 
 linha = pickle.load(file) 
 
 77 
 print(linha) 
 file.close() 
 except EOFError as error: 
 print("Atenção: Final do Arquivo") 
except IOError as error: 
 print('Atenção: Arquivo não Existe', nomeArquivo) 
 print(error) 
	
Teste	do	Programa:	
	
Nome	do	Arquivo	Binário:	Frutas.bin	<enter>	
Abacate	
	
Banana	
	
Anana	
	
Caqui	
	
Laranja	
	
Goiaba	
	
Tangerina	
	
Atenção:	Final	do	Arquivo	
	
Atenção:	Função	que	verifica	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: 
 
 78 
 file = open(nomeArquivo, "wb") 
 ch = "S" 
 while ch == "S" or ch == "s": 
 nome = input("Nome: ") 
 pickle.dump(nome, file) 
 idade = int(input("Idade: ")) 
 pickle.dump(idade, file) 
 ch = input("Continua [s/n]? ") 
 file.close() 
 except IOError as error: 
 print("Atenção: Impossível CRIAR o Arquivo") 
	
Teste	do	Programa:	
	
Nome	Arquivo	Binário:	Dados.bin	<enter>	
Nome:	Paulo	Roberto	
Idade:	56	
Continua	[s/n]?	s	
Nome:	Adriane	Maria	
Idade:	48	
Continua	[s/n]?	s	
Nome:	Paola	Freitas	
Idade:	19	
Continua	[s/n]?	s	
Nome:	Julia	Helena	
Idade:	58	
Continua	[s/n]?	s	
Nome:	Ana	Maria	
Idade:	59	
Continua	[s/n]?	n	
	
30.	Sockets	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: 
 
 
 79 
accept( ): aceita uma nova conexão e retorna os valores: o 
novo objeto socket e o endereço que o socket está se 
comunicando. 
 
bind((hostname,port)): conecta o socket ao endereço da 
porta. 
 
close(): fecha o socket. 
 
connect((hostname,port)): conecta-se com outro socket, que 
pode ser externo ou local. Para conexões locais utiliza-se 
localhost ou 127.0.0.1 
 
getpeername(): retorna o endereço IP e a porta na qual o 
socket está conectado. 
 
getsocketname(): retorna o endereço IP da porta do próprio 
socket. 
 
listen(max_connections): inicia ouvindo a porta e fica 
esperando outras conexões. O sistema operacional recusa 
novas conexões quando ela atingir o valor máximo de conexões. 
 
send(string): Envia uma string de dados pelo socket. 
 
Para a criação de programas que utilizem sockets no 
lado do servidor é necessário principalmente o uso dos 
seguintes comandos: 
 
serverSocket=socket.socket(socket.AF_INET,socket.SOCK_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 nolado do cliente é necessário principalmente o uso dos 
seguintes comandos: 
 
clientSocket.socket(socket.AF_INET,socket.SOCK_STREAM): 
para definir o protocolo a ser utilizado. 
 
 
 80 
clientSocket.connect((servidor,porta)): para criar o objeto 
de conexão que irá conectar em um servidor. 
 
clientSocket.send(dados) : para enviar dados. 
 
clientSocket.recv(1024): para receber dados controlando o 
tamanho do buffer. 
 
 
 
Exemplo da criação de uma conexão do lado do Cliente: 
 
# ...................... Cliente.py 
 
import socket 
 
# define host e porta 
HOST = "127.0.0.1" 
PORTA = 5000 
 
# define o protocolo 
cliente = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
 
# tenta conectar ao servidor 
cliente.connect((HOST, PORTA)) 
 
# envia mensagem 
cliente.send("Olá!! Boa Noite!".encode("utf-8")) 
 
print("Mensagem Enviada") 
 
# fecha a conexão 
cliente.close() 
 
Exemplo da “escuta” de uma conexão do lado do Servidor: 
 
# ..................... Servidor.py 
 
import socket 
 
# define host e porta 
HOST = "127.0.0.1" 
PORTA = 5000 
 
# define protocolo 
servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
 
print("Na escuta ...") 
 
# inicia a escuta do lado servidor 
servidor.bind((HOST, PORTA)) 
 
# define o número máximo de conexões na fila 
servidor.listen(1) 
 
# para aceitar novas conexões 
conexao, endereco = servidor.accept() 
 
 81 
 
# recebe os dados enviados pelo cliente 
dados = conexao.recv(1024) 
 
# exibe os dados recebidos 
print("Dados Recebidos: ", dados.decode("utf-8")) 
 
print("Conectado por: ", endereco) 
 
# fecha a conexão 
conexao.close() 
 
Observação: Tem que se executar os dois programas ao mesmo 
tempo, isto pode ser feito via abertura de dois terminais, 
pois um programa “conversa” com o outro. 
 
Teste do Programa: 
 
 
 
 82 
 
 
 
 83 
31.	Threads	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ódulo	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.com/watch?v=vmoH9I9d570&list=PLesCEcYj003ShHnUT83gQEH6KtG8uysUE&index=2	
 
Elementos de interface (widgets) correspondem a 
objetos de diversas classes. São alguns exemplos de 
widgets: 
• Frame (área retangular) 
• Button (botão) 
• Label (rótulo) 
• Text (caixa de texto) 
• Canvas (caixa de desenho) 
 
 
 84 
Exemplo de como criar uma janela gráfica na aplicação 
utilizando o módulo tkinter: 
# ........................ Tk_1.py 
 
import tkinter as tk # renomear um módulo 
 
janela = tk.Tk() 
 
janela.mainloop() 
 
No programa acima é necessário importar o módulo 
“tkinter”. A chamada janela = tk.Tk() cria e exibe uma 
janela gráfica na aplicação. A instrução 
janela.mainloop() faz com que a janela fique ativa, até 
que o usuário resolva fechar a janela no “x” (entrar em 
modo de tratamento de eventos). 
Resultado do programa: 
	
	
	 	
	
	
	
	
	
	
	
	
	
	
No programa abaixo é possível 
colocar o nome na janela, neste caso: “Calculadora”, 
através da instrução janela.title(“Calculadora”).	
	
# .............................. Tk_2.py 
 
import tkinter as tk 
 
janela = tk.Tk() 
 
janela.title("Calculadora") 
 
janela.mainloop() 
	
Resultado do programa: 
	
 
 85 
	
	
 No programa abaixo é possível trocar a cor do 
background (fundo) através da instrução janela[“bg”] = 
“blue) ou janela[“background”] = “blue”. 
	
# .......................... Tk_3.py 
 
import tkinter as tk 
 
janela = tk.Tk() 
 
janela.title("Chat") 
 
janela["bg"] = "blue" # bg é background 
 
janela.mainloop() 
	
Resultado do programa: 
	
	
	
 
 86 
 No programa abaixo é possível especificar o tamanho 
e a posição da janela gráfica, isto é feito através da 
instrução janela.geometry(“LxA+E+T”), onde “L” é a 
largura, “A” é a altura, “E” é a distância da origem 
até a esquerda da janela e “T” é a distância da origem 
até o topo da janela. Alias a origem é na esquerda x 
topo da janela. 
	
	
# .............................. Tk_4.py 
 
import tkinter as tk 
 
janela = tk.Tk() 
 
janela.title("Chat") 
 
janela["background"] = "blue" # bg ou background 
 
janela.geometry("300x300+200+100") 
#LarguraxAltura+distânciaEsquerda+distância_Topo, alguns são opcionais 
 
janela.mainloop() 
	
Resultado do programa: 
	
	
	
	
 
 87 
 No programa abaixo é possível inserir texto na 
janela gráfica, isto é feito através das instruções lb 
= Label(janela, text=mensagem[i]) e lb.place(x=10, 
y=yc).	
	
 Label é um objeto tipo rótulo. 
 
 Place é responsável pela posição de onde a mensagem 
vai ser colocada, ou seja, posição “x” e “y” em relação 
a origem (0,0) [left, top]. 
	
# ............................ Tk_5.py 
 
from tkinter import * 
 
janela = Tk() 
 
janela.title("Chat") 
 
xMax = 300 
yMax = 300 
left = 100 
top = 200 
s = str(xMax) + "x" + str(yMax) + "+" + str(left) + "+" + str(top) 
janela.geometry(s) 
mensagem = ["Olá, tudo bem", "Quando vais vir?", "Não demora", 
"Abraços"] 
n = len(mensagem) 
yc = 10 
for i in range(n): 
 lb = Label(janela, text=mensagem[i]) 
 lb.place(x=10, y=yc) 
 yc = yc + 20 
 
janela.mainloop() 
	
Resultado do programa: 
	
	
 
 88 
	
 No programa abaixo é possível inserir um botão na 
janela gráfica, isto é feito através das instruções 
botao = tk.Button(janela, text=" Aperte ", command= 
Mensagem) [insere o botão na janela da aplicação] e 
botao.pack() [exibe o botão].	
	
	
# ........................... Tk_6.py 
 
import tkinter as tk 
 
def Mensagem(): 
 print("Olá, tudo bem?") 
 
janela = tk.Tk() 
 
janela.title("Tkinter") 
 
janela.geometry("300x300+200+100") 
 
botao = tk.Button(janela, text=" Aperte ", command=Mensagem) 
 
botao.pack() 
 
janela.mainloop() 
	
Resultado do programa: 
	
	
Note que quando o botão foi pressionado, foi impressa a 
mensagem “Olá, tudo bem” na tela em modo texto (ou 
terminal). 
	
 
 89 
O programa a seguir contém um botão (chamado “aperte”) 
que quando pressionado imprime a mensagem “Olá, tudo 
bem?” na janela gráfica. 
 
# ........................... Tk_7.py 
 
import tkinter as tk 
from tkinter import * 
 
def Mensagem(): 
 mensagem = "Olá, tudo bem?" 
 lb = Label(janela, text=mensagem) 
 lb.place(x=100, y=200) 
 
janela = tk.Tk() 
 
janela.title("Tkinter") 
 
janela.geometry("300x300+200+100") 
 
botao = tk.Button(janela, text=" Aperte ", command=Mensagem) 
 
botao.pack() 
 
janela.mainloop() 
	
 
 
O programa a seguir contém uma caixa de diálogo que 
permite a entrada de dados reais e exibe um somador 
(acumulador). 
 
 90 
 
# ........................ Tk_8.py 
 
import tkinter as tk 
from tkinter import * 
 
def Soma(x): 
 somador.set(somador.get() + valor.get()) 
 
def Mensagem(): 
 mensagem = "Digite um valor e pressione <Enter>" 
 lb = Label(janela, text=mensagem) 
 lb.place(x=25, y=200) 
 
janela = tk.Tk() 
 
janela.title("Acumulador") 
 
janela["background"] = "lightblue" 
 
janela.geometry("300x300+200+100") 
 
Mensagem() 
 
somador = DoubleVar(janela) 
 
valor = DoubleVar(janela) 
 
lSomador = Label(textvar=somador)eValor = Entry(textvar=valor) 
 
eValor.bind("<Return>", Soma) 
 
lSomador.pack() 
 
eValor.pack() 
 
janela.mainloop() 
 
 
 
 91 
	
 No programa acima, a caixa de diálogo foi 
realizada através da instrução: eValor = 
Entry(textvar=valor). 
 
O programa a seguir, mostra como encerrar uma 
aplicação através de um botão (Button) e uma chamada de 
um comando do Sistema Operacional: exit, por isto o 
import sys (from sys import exit). 
 
# .............................. Tk_9.py 
 
from sys import exit 
import tkinter as tk 
from tkinter import * 
 
janela = tk.Tk() 
 
janela.title("Tkinter") 
 
janela["background"] = "lightblue" 
 
janela.geometry("300x300+200+100") 
 
Button(janela, text=' Quit ', command=exit).pack() 
 
janela.mainloop() 
 
 
 
O programa a seguir, mostra como configurar um 
rótulo, ou seja, selecionar a fonte, background , borda 
e etc através da instrução 
rotulo.configure(relief="ridge", font="Arial 24 bold", 
border=5, background="yellow"). 
 
 92 
 
# ............................. Tk_10.py 
 
from tkinter import * 
 
janela = Tk() 
janela.title("Rótulo") 
janela.geometry("400x100") 
frame = Frame() ; frame.pack() 
rotulo = Label(frame, text=" Configurando um Rótulo ", 
foreground="blue") 
rotulo.pack() 
rotulo.configure(relief="ridge", font="Arial 24 bold", border=5, 
background="yellow") 
janela.mainloop() 
 
 
 
 O programa a seguir exibe a posição x e y do cursor 
do mouse. 
 
# ........................ Tk_11.py 
 
from tkinter import * 
 
def clique(e): 
 txt = "Mouse: %d x %d" %(e.x,e.y) 
 r.configure(text=txt) 
 
 
janela = Tk() 
janela.title("Mouse") 
r = Label() 
r.pack(expand=True, fill="both") 
r.master.geometry("200x200") 
r.bind("<Button-1>", clique) 
mainloop() 
 
 
 
 
 93 
 O programa a seguir exibe uma listbox. 
 
# ............................ Tk_12.py 
 
from tkinter import * 
 
root = Tk() 
 
listbox = Listbox(root) 
listbox.pack() 
 
for i in range(10): 
 listbox.insert(END, " -> "+str(i)) 
 
mainloop() 
 
 
 
 O seguinte programa mostra como exibir na tela 
gráfica, texto colorido, configurando a cor da frente 
(foreground = fg) e a cor de fundo (background = bg), 
através da instrução: rot = Label(janela, text="Red", 
bg="red", fg="white"). 
 
# ............................ Tk_13.py 
 
from tkinter import * 
 
janela = Tk() 
janela.title("Cores") 
janela.geometry("300x300+200+100") 
rot = Label(janela, text="Red", bg="red", fg="white") 
rot.pack(fill=X) 
rot = Label(janela, text="Green", bg="green", fg="black") 
rot.pack(fill=X) 
rot = Label(janela, text="Blue", bg="blue", fg="white") 
rot.pack(fill=X) 
 
janela.mainloop() 
 
 
 
 94