Algoritmos e Programação 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.52	
04-04-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,	4	de	abril	de	2018	(10:55	am)	
 
2 
Sumário	
	
1.	Linguagem	de	Programação	Python ......................................................................... 5 
2.	Como	executar	comandos	em	Python ....................................................................... 5 
3.	Entrar	na	IDLE	do	Python ...................................................................................... 5 
4.	Primeiros	comandos	ou	instruções ....................................................................... 5 
5.	Identificadores	e	variáveis................................................................................. 6 
6.	Operadores	aritméticos .......................................................................................... 7 
6.1	Hierarquia	dos	operadores	(precedência)........................................................ 8 
7.	Comando	print	(imprimir	dados	na	tela) ........................................................... 8 
8.	Comando	input	(ler	dados	do	teclado) ............................................................. 10 
9.	Deletar	uma	variável	(del) ................................................................................ 11 
10.	Módulos	(import) .................................................................................................. 11 
11.	Funções	de	matemáticas	(math) ......................................................................... 12 
12.	Strings	(cadeia	de	caracteres) ....................................................................... 14 
12.1	Funções	para	Strings ........................................................................................ 14 
13.	Comandos:	Sequência,	Seleção	e	Repetição .................................................... 16 
13.1	Comandos	de	Sequência ...................................................................................... 16 
13.2	Lista	de	Exercícios	(Comandos	de	sequência) ............................................ 18 
14.	Operadores	relacionais ...................................................................................... 21 
15.	Operadores	lógicos .............................................................................................. 21 
16.	Comando	de	Seleção	(if) .................................................................................... 22 
16.1	Lista	de	Exercícios	(Comando	de	Seleção	if) ............................................ 24 
17.	Contador	e	acumulador ........................................................................................ 25 
18.	Comandos	de	Repetição	(while	e	for) ............................................................. 26 
18.1	range	(faixa) ...................................................................................................... 28 
18.2	Lista	de	Exercícios	(Comando	de	Repetição	while	e	for) ....................... 29 
19.	Listas	em	Python	(vetores)............................................................................... 30 
19.1	Lista	de	Exercícios	de	Vetores	(listas) .................................................... 37 
20.	Questões	de	prova ................................................................................................ 39 
21.	Curiosidades	e	testes	no	Python ..................................................................... 44 
22.	Funções	escritas	pelo	programador	em	Python .............................................. 46 
22.1	Exercícios	sobre	funções	em	Python ............................................................. 53 
23.	Criação	e	utilização	de	módulos	em	Python .................................................. 55 
24.	Tratamento	de	erros	(exceções) ....................................................................... 59 
25.	Banco	de	Dados	em	Python	(SQLite) ................................................................. 63 
26.	Sistema	de	Arquivos	em	Python ......................................................................... 68 
29.	Arquivos	Binários	em	Python ............................................................................. 73 
30.	Sockets	em	Python ................................................................................................ 79 
 
3 
 83 
 83 
31.	Threads	em	Python ................................................................................................ 84 
 
4 
 
 
 
 
 
Lista de Exercícios do Prof. Dr. Ricardo Andrade Cava 
	
DropBox:	
	
https://www.dropbox.com/sh/kea9kr4j2qttnjg/AAAGkXES6sWvRKCJh8R7x9aia/ListaCava?dl=0	
	
 
5 
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>	
 
6 
	 	 	 	 	 	 	 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árioem	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.	
	
 
7 
Função	type:	Exibe	o	Tipo	do	Dado.	
	
#	--------------------------	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	 **	
 
8 
	
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>	
 
9 
3	
>>>	b	=	4	<enter>	
>>>	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	
	
 
10 
from	datetime	import	datetime	
	
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	
>>>	
 
11 
9.	Deletar	uma	variável	(del)	
	
	 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	
	 	 >>> 
	
 
12 
Ajuda	(help)	dos	módulos:	
	
>>>	import	math	<enter>	
>>>	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	
 
13 
>>>	print(math.log1p(2))	
1.0986122886681098	
>>>	
	
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	
>>>		
	
 
14 
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)	
>>>	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"	
 
15 
print("Número	de	letras:	",	len(s))	
partes	=	s.split('	')	
n	=	len(partes)	
print("Número	de	nomes:	",	n)	
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())	
 
16 
	
#	--------------------------------------------	swapcase	
s	=	'Paulo	Roberto	Gomes	Luzzardi'	
print(s.swapcase())	#	inverte	as	letras	maiúsculas	e	minúsculas	
	
#	--------------------------------------------	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	
 
17 
	
diametro	=	float(input("Digite	o	valor	do	Diâmetro:	"))	
raio	=	diametro	/	2	
area	=	math.pi	*	raio	**	2	
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:	
	
 
18 
=======	RESTART:	/Users/pluzzardi/Documents/Aleatorio.py	=======	
n	=		2	
n	=		9	
n	=		7	
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>		
 
19 
Diâmetro:	11.46
	
Raio:	5.73	
	
comprimento	da	circunferência	=	2	.	Pi	.	raio	
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	imprimaa	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	
 
20 
mensal	e	percentual	de	reajuste.	Calcular	e	escrever	o	valor	do	
novo	salário.	
	
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	suas	paredes	(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	
 
21 
	
Teste	do	Programa:	
	
a	=	1	<enter>
	
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.		
 
22 
	
16.	Comando	de	Seleção	(if)	
	
	 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.	
	
 
23 
Teste	do	Programa:	
	
=======	RESTART:	/Users/pluzzardi/Documents/If.py	========	
Digite	um	Número:	-5	
Número	é	negativo	
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	
 
24 
x2	=		-3.0	
>>>	
	
Programa	exemplo:	if	com	elif	
	
#	----------------------------------------	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
	
 
25 
	
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	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	 novovalor	 ao	
próprio	x.	Note	ainda	que	um	(1)	é	uma	constante,	que	pode	ser	1,	2,	
3,	...	
 
26 
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	
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	
	
 
27 
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:	
	
=============	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	
>>>	
	
 
28 
#	-----------------------------------	ForDuplo.py	
	
for	i	in	range(3):	
				for	j	in	range(4):	
								print(i,	j)	
	
======	RESTART:	/Users/pluzzardi/Documents/ForDuplo.py	==========	
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	
 
29 
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)	
	
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	
 
30 
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.		
	
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	
 
 
31 
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:	
	
=======	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()	
 
32 
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]	
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)	
	
 
33 
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))	
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	
 
34 
11	
12	
13	
14	
[5,	6,	7,	8,	9,	10,	11,	12,	13,	14]	
Ana	
Beatriz	
Carla	
Debora	
Eva	
	
Funções	para	operar	listas:	
	
Anexar	o	elemento	no	final	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	
 
35 
	
n	=	len(lista)	
	
Retorna	o	número	de	vezes	de	um	elemento	dentro	de	uma	lista:	count	
	
vezes	=	lista.count(elemento)	
	
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]	
>>>	
 
36 
	
	 O	programa	a	seguir	mostra	a	criação	aleatória	de	palpites	para	
a	MegaSena.	
	
#	----------------------------	MegaSena.py	
	
import	random	
	
#	----------------------------	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		
 
37 
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)	
	
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	
 
38 
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>
 
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):		
 
39 
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 
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): 
 
40 
 
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 
 
2. Escreva um programa em Python que lê nomes via teclado. 
Para cada nome digitado pelo usuário, armazene em uma Lista 
[f] para feminino, [m] para masculino ou [i] para 
indeterminado, conforme exemplo abaixo. Ao final imprima a 
Lista, o total de homens, o total de mulheres e o total de 
indeterminados. 
 
Teste do programa: 
 
Nome: Debora <enter> 
Nome: Carla <enter> 
Nome: Beatriz <enter> 
Nome: Paulo <enter> 
Nome: Renato <enter> 
Nome: <enter> 
Lista: [‘f’, ‘f’, ‘i’, ‘m’, ‘m’] 
2 homens 
2 mulheres 
1 indeterminados 
 
3. Escreva um programa em Python que recebe “n” nomes via 
teclado (até que o usuário digite apenas <enter>). Insira 
todos os nomes ORDENADOS em uma Lista de Strings (conforme 
exemplo abaixo). Ao final, o programa deve exibir a Lista 
contendo os nomes em ordem alfabética. 
 
Teste do programa: 
 
Nome: Debora <enter> 
Nome: Carla <enter> 
Nome: Eva <enter> 
Nome: Beatriz <enter> 
Nome: Ana <enter> 
Nome: <enter> 
Lista: [‘Ana’, ‘Beatriz’, ‘Carla’, ‘Debora’, ‘Eva’] 
 
4. Escreva um programa em Python que lê um nome via 
teclado. Logo após a entrada crie uma outra string 
(invertido) para inverter e exibir este nome na tela e 
ainda o número de letras do nome (sem contar os espaços) e 
o total de espaços do nome, conforme exemplo abaixo. 
 
Teste do programa: 
 
Nome: paulo roberto gomes luzzardi <enter> 
Invertido: idrazzul semog otrebor oluap 
 
41 
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. 
 
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> 
 
42 
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 
	
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: 
 
43 
 
 
 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 
 
 
 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 
 
44 
7 Homens 
3 Mulheres 
	
13. Escrevaum	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	 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	
 
 
45 
	 A	seguir	são	vistos	algumas	curiosidades	e	testes	feitos	no	
Python:	
	
#	---------------------------------	Teste.py	
	
#	====================	inicialização	de	várias	variáveis	
	
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")	
 
46 
	
#	==================================	data	e	hora	
	
from	datetime	import	datetime	
	
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))	
	
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	
 
47 
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.	
	
	 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	
 
48 
Menor:		3.0	
>>>	
	
	 Exemplo	usando	uma	função	Raiz,	usando	um	conceito	da	matemática:	
	
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:	
 
49 
	
# ...................... Fibonacci.py 
 
def Fibonacci(n): 
 if n == 0: 
 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	
 
50 
#	-------------------------------------------------------------------	
	
def	REAL(s):	
				n	=	len(s)	
				temLetras	=	False	
				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)					
 
51 
				print("Número	digitado:	",	numero)	
	
Teste	do	Programa:	
	
=====	RESTART:	/Users/pluzzardi/Desktop/Python/Python/float.py	=====	
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.py 
 
def add(x, y): 
 return(x+y) 
 
def sub(x, y): 
 return(x-y) 
 
def mult(x, y): 
 return(x*y) 
 
def div(x, y): 
 if y == 0: 
 return("Erro: Divisão por Zero") 
 return(x/y) 
 
def calculadora(x, y, operador): 
 if operador == '+': 
 valor = add(x,y) 
 else: 
 if operador == '-': 
 valor = sub(x,y) 
 else: 
 if operador == '*': 
 valor = mult(x,y) 
 else: 
 if operador == '/': 
 
52 
 valor = div(x,y) 
 else: 
 return("ERRO: Operador Inválido") 
 return(valor) 
 
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) 
 
53 
	
	
Teste	do	Programa:	
	
x	=		3	
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 
 
54 
 
Trecho do programa principal: 
 
a = float(input("a = ")) 
b = float(input("b = ")) 
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: 
 
55 
 print("Dia: %d" %dia) 
if mes != -1: 
 print("Mês: %d" %mes) 
if ano != -1: 
 print("Ano: %d" %ano) 
	
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	
	
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) 
print("Final da Placa é: %d" %final) 
	
Teste	do	Programa:	
	
Placa	[xxx9999]:	etq1234	<enter>	
Final	da	Placa	é:		34	
	
23.	Criação	e	utilização	de	módulos	em	Python	
	
 
56 
	 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) 
 
def menor(x, y): 
 if x <= y: 
 return(x) 
 
57 
 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.	
		
# ....................... Modulos.py 
 
 
58 
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	
	
def	INTEIRO(s):	
				n	=	len(s)	
 
59 
				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)	
 
Na execução de um programa em Python, podem ocorrer 
erros não previstos que podem interromper a execução normal 
 
60 
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:	
	
========== RESTART: /Users/pluzzardi/Documents/ValueError.py ======= 
 
61 
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 
Erro: float division by zero 
>>> 
 
 
62 
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