Vous êtes sur la page 1sur 58

Algoritmos e Programação com a

Linguagem de Programação 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.40
06-07-2017

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, quinta-feira, 6 de julho de 2017 (10:17 am)

1
Sumário

1. Linguagem de Programação Python ............................................................... 3


2. Como executar comandos em Python ............................................................ 3
3. Entrar na IDLE do Python ................................................................................ 3
4. Primeiros comandos ou instruções ............................................................ 3
5. Identificadores e variáveis ........................................................................ 4
6. Operadores aritméticos .................................................................................... 5
6.1 Hierarquia dos operadores (precedência) ......................................... 5
7. Comando print (imprimir dados na tela) .............................................. 6
8. Comando input (ler dados do teclado) ................................................... 7
9. Deletar uma variável (del) ........................................................................... 8
10. Módulos (import) ................................................................................................ 9
11. Funções de matemáticas (math) ................................................................. 9
12. Strings (cadeia de caracteres) ............................................................. 11
12.1 Funções para Strings .................................................................................. 12
13. Comandos: Sequência, Seleção e Repetição ..................................... 13
13.1 Comandos de Sequência ................................................................................ 13
13.2 Lista de Exercícios (Comandos de sequência) ........................... 14
14. Operadores relacionais ................................................................................ 18
15. Operadores lógicos .......................................................................................... 18
16. Comando de Seleção (if) .............................................................................. 18
16.1 Lista de Exercícios (Comando de Seleção if) ........................... 20
17. Contador e acumulador .................................................................................. 22
18. Comandos de Repetição (while e for) ................................................. 22
18.1 range (faixa) ................................................................................................... 24
18.2 Lista de Exercícios (Comando de Repetição while e for) . 25
19. Listas em Python (vetores) ...................................................................... 26
19.1 Lista de Exercícios de Vetores (listas) ..................................... 32
20. Questões de prova ............................................................................................ 35
21. Curiosidades e testes no Python .......................................................... 40
22. Funções escritas pelo programador em Python .............................. 41
23. Criação e utilização de módulos em Python .................................. 44
24. Tratamento de erros (exceções) ............................................................. 46
25. Banco de Dados em Python (SQLite) ...................................................... 49
26. Sistema de Arquivos em Python ............................................................... 53

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

DropBox:
https://www.dropbox.com/sh/kea9kr4j2qttnjg/AAAGkXES6sWvRKCJh8R7x9aia/ListaCava?dl=0

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

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

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

a = 3
print(type(a))

4
b = 3.4
print(type(b))
c = 'Python'
print(type(c))
d = 'A'
print(type(d))

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

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.

5
Tabela 2: Hierarquia dos Operadores Aritméticos
Ordem de Tipo de Operador
precedência
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>
>>> 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

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

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>

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

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

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


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

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

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)

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


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

11
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)
for i in range(n):
print(partes[i])
print(partes)

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

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

Resultado 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
print("Área do Círculo é: ", area)

13
Resultado 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)

Resultado 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

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

Resultado do Programa:

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

14
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


diâmetro = 2 . raio

d) Desenvolva um programa em Python que recebe via


teclado: peso da carne que será vendida e preço por

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

Teste do Programa:

Salário: 500 <enter>



Percentual de reajuste: 15 <enter>

Novo salário: 575

16
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

Teste do Programa:

a = 1 <enter>

b = 2 <enter>
c = -3 <enter>
x1 = 1
x2 = -3

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

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

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

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

19
Resultado 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")

Resultado 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

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


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

21
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

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

Resultado do Programa:

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

22
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]")

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

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


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.

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

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

25
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

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

26
Resultado 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)

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

Resultado do Programa:

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


x = [10, 20, 30] y = [10, 20, 30]
True
4380371208
4380371208
False
4320652552

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

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

28
Resultado 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
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()

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

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)

30
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

# ---------------------------- 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]?")

Resultado do Programa:

======== RESTART: /Users/pluzzardi/Desktop/MegaSena.py =============


Número de palpites: 5

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

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>


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

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)

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

34
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

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>

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

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>

36
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

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%

37
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

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]

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

39
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

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

40
elif numero < 0:
print("Negativo")
else:
print("Zero")

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

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

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

41
pode ou não receber argumentos (parâmetros) e retornar ou
não um valor.

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.

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

Resultado do Programa:

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


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

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

Resultado do Programa:

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


Digite um valor: 20
Fatorial: 2432902008176640000
>>>

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

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

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

23. Criação e utilização de módulos em Python

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

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

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

46
print("Erro: ", error)

Teste do Programa:

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

47
Digite um Valor: 4
Digite outro Valor: 0
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: ")

48
try:
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: ")
cursor.execute('''
insert into agenda (id, nome, fone)

49
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

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

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

51
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
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 != "":

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

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.

53
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

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

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

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

55
Gravou dados
id: 5
Nome:
>>>

Listagem do Arquivo alterado: Dados.txt

1;Paulo Roberto;99164-8037;
2;Adriane Maria;99156-2345;
3;Paola Freitas;98678-1234;
4;Renato Luis;98778-3456;
5;Francisco Carlos;98178-5678;

# ------------------------------- 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 != "":
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

56
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
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: ")

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

58