1. Este documento apresenta um resumo sobre algoritmos e programação em Python ministrado pelo professor Paulo Roberto Gomes Luzzardi.
2. O documento contém 32 seções abordando diversos tópicos da linguagem Python como variáveis, operadores, comandos de entrada e saída, estruturas de repetição e seleção, funções, tratamento de erros e manipulação de arquivos e bancos de dados.
3. Além disso, o documento fornece links para materiais de apoio como lista de exercícios e bibliografia re
Tipos de Cargas - Conhecendo suas Características e Classificações.pdf
Algoritmos e Programação em Python
1. 1
Algoritmos e Programação em Python
por
Prof. Dr. Paulo Roberto Gomes Luzzardi
facebook: Paulo Roberto Gomes Luzzardi
WhatsApp: 99164-8037
e-mail: pluzzardi@gmail.com (principal) e pluzzardi@yahoo.com.br
e-mail (Senac): prgomesluzzardi@senacrs.edu.br
DropBox: https://www.dropbox.com/sh/kea9kr4j2qttnjg/4xXvw0pvxX?m
Hostinger: http://pluzzardi.w.pw e http://pluzzardi.zz.mu (Home Page)
Versão 1.62
02-05-2018
Bibliografia recomendada:
MENEZES, Nilo Ney Coutinho. Introdução à Programação com Python:
Algoritmos e Lógica de Programação para Iniciantes. São Paulo: Editora
Novatec, 2010 (ISBN 978-85-7522-250-8).
Pelotas, quarta-feira, 2 de maio de 2018 (09:48 am)
2. 2
Sumário
1. Linguagem de Programação Python.................................................................... 4
2. Como executar comandos em Python.................................................................. 4
3. Entrar na IDLE do Python ................................................................................. 4
4. Primeiros comandos ou instruções.................................................................. 4
5. Identificadores e variáveis............................................................................ 5
6. Operadores aritméticos ..................................................................................... 6
6.1 Hierarquia dos operadores (precedência)................................................... 7
7. Comando print (imprimir dados na tela) ...................................................... 7
8. Comando input (ler dados do teclado) .......................................................... 9
9. Deletar uma variável (del) ............................................................................. 9
10. Módulos (import)............................................................................................. 10
11. Funções de matemáticas (math).................................................................... 11
12. Strings (cadeia de caracteres).................................................................. 13
12.1 Funções para Strings ................................................................................... 13
13. Comandos: Sequência, Seleção e Repetição............................................... 15
13.1 Comandos de Sequência ................................................................................. 15
13.2 Lista de Exercícios (Comandos de sequência)....................................... 17
14. Operadores relacionais ................................................................................. 20
15. Operadores lógicos......................................................................................... 20
16. Comando de Seleção (if) ............................................................................... 20
16.1 Lista de Exercícios (Comando de Seleção if)....................................... 23
17. Contador e acumulador ................................................................................... 24
18. Comandos de Repetição (while e for) ........................................................ 25
18.1 range (faixa)................................................................................................. 27
18.2 Lista de Exercícios (Comando de Repetição while e for).................. 28
19. Listas em Python (vetores).......................................................................... 29
19.1 Lista de Exercícios de Vetores (listas)............................................... 35
20. Questões de prova........................................................................................... 38
21. Curiosidades e testes no Python................................................................ 43
22. Funções escritas pelo programador em Python......................................... 45
22.1 Exercícios sobre funções em Python ........................................................ 52
23. Criação e utilização de módulos em Python............................................. 55
24. Tratamento de erros (exceções).................................................................. 58
25. Banco de Dados em Python (SQLite)............................................................ 62
26. Sistema de Arquivos em Python.................................................................... 67
29. Arquivos Binários em Python........................................................................ 72
30. Sockets em Python........................................................................................... 78
31. Threads em Python........................................................................................... 83
32. Módulo tkinter para GUI em Python............................................................ 83
3. 3
Lista de Exercícios do Prof. Dr. Ricardo Andrade Cava
DropBox:
https://www.dropbox.com/sh/kea9kr4j2qttnjg/AAAGkXES6sWvRKCJh8R7x9aia/ListaCava?dl=0
5. 5
8
>>>
Operações mais complexas: >>> a = 3 <enter>
>>> b = 4 <enter>
>>> c = a + b <enter>
>>> print(a, b, c) <enter>
3 4 7
>>> print(“c = “, c) <enter>
c = 7
>>> print(3>4) <enter>
False # valor lógico
>>>
5. Identificadores e variáveis
Identificadores são os nomes criados pelo programador para fazer
referência a variáveis, constantes, funções e módulos.
Regras para a criação de identificadores:
ü O primeiro caracter deve ser uma letra ou sublinha (_);
ü Os caracteres seguintes devem ser letras, números ou sublinhas;
ü Não há limite de caracteres;
ü Não é permitido a utilização de caracteres em branco (caracter espaço);
ü Podem ser letras maiúsculas e minúsculas, pois são diferenciados.
Comentário do programador:
# não é interpretado - comentário de uma linha
”””
comentário em mais de uma linha
Não é interpretado
”””
’’’
comentário em mais de uma linha
Não é interpretado
’’’
Variáveis em Python existem em três tipos: int, float e string.
Na declaração de cada variável, Python especifica o tipo, por exemplo:
a = 3, a é declarado como int, b = 3.4 é declarado como float, s =
“Python” ou s = ‘Python’ são string’s.
Função type: Exibe o Tipo do Dado.
9. 9
data = datetime.now()
print(data)
print("Data: %02d/%02d/%d" %(data.day, data.month, data.year))
print("Tempo: %02d:%02d:%02d" %(data.hour, data.minute, data.second))
8. Comando input (ler dados do teclado)
O comando input permite ler informações via teclado, o valor
digitado pelo usuário é lido como uma string, podendo ser convertido
para inteiro (int) ou real (float).
Sintaxe: string input(string mensagem)
Exemplos:
Entrada de uma String:
>>> s = input(“Digite um Nome: “) <enter>
>>> Digite um Nome: Luzzardi <enter>
>>> print(len(s)) # número de caracteres da string
8
>>>
Entrada de um Inteiro:
>>> i = int(input(“Digite um Valor: “)) <enter>
>>> Digite um Nome: 34 <enter>
>>> print(i)
34
>>>
Entrada de um Real (float):
>>> i = float(input(“Digite um Valor: “)) <enter>
>>> Digite um Nome: 34 <enter>
>>> print(i)
34.0
>>>
Outra forma, em duas etapas:
>>> s = input("Digite um Valor: ") <enter>
Digite um Valor: 34 <enter>
>>> x = int(s) <enter> # conversão para inteiro
>>> print(x) <enter>
34
>>>
9. Deletar uma variável (del)
11. 11
>>> help(math) <enter> # exibe funções do módulo math
# idêntico ao Linux
11. Funções de matemáticas (math)
Python possui diversas funções matemáticas oriundas do módulo
“math”. São elas:
math.factorial(x): Retorna o valor fatorial de x, onde x deve ser sempre
positivo.
>>> fat = math.factorial(5) # 5x4x3x2x1 = 120
>>> print(fat)
120
>>>
math.modf(x): Retorna o valor inteiro e o valor fracionário da variável
x.
>>> print(math.modf(5.34))
(0.33999999999999986, 5.0)
>>>
math.exp(x): Retorna o exponencial de x, ou seja, ex
.
>>> print(math.exp(1))
2.718281828459045
>>> print(math.exp(2))
7.38905609893065
>>> print(math.exp(3))
20.085536923187668
>>>
math.log(x, base): Retorna o log de x na base pedida.
>>> print(math.log(2,10))
0.30102999566398114
>>> print(math.log(3,10))
0.47712125471966244
>>>
math.log1p(x): Retorna o logaritmo natural de x.
>>> print(math.log1p(1))
0.6931471805599453
>>> print(math.log1p(2))
1.0986122886681098
>>>
17. 17
n = 6
n = 5
n = 7
>>>
13.2 Lista de Exercícios (Comandos de sequência)
a) Escreva um programa em Python que recebe dois valores via teclado:
cateto adjacente (b) e cateto oposto (a) e calcula o valor da
hipotenusa dado pela seguinte fórmula:
Teste do Programa:
Cateto Adjacente (b): 3 <enter>
Cateto Oposto (a): 4 <enter>
Hipotenusa: 5.0
b) Escreva um programa em Python que lê 4 notas via teclado: n1, n2,
n3 e n4 obtidas por um aluno em 4 avaliações. Calcule a média
utilizando a seguinte fórmula:
n1 + n2 x 2 + n3 x 3 + n4
Média = ---------------------------
7
c) Escreva um programa em Python que recebe via teclado: comprimento
da circunferência. O programa deve calcular e imprimir na tela o
diâmetro e o raio da circunferência (veja exemplo abaixo):
Teste do Programa:
Comprimento da circunferência: 36 <enter>
Diâmetro: 11.46
Raio: 5.73
comprimento da circunferência = 2 . Pi . raio
20. 20
b = 2 <enter>
c = -3 <enter>
x1 = 1
x2 = -3
14. Operadores relacionais
Os operadores relacionais permitem ao programador realizar
comparações. A seguir, a Tabela 4 exibe os operadores relacionais
utilizados em Python.
Tabela 4: Operadores Relacionais
Operador relacional Função
== Igual
!= Diferente
> Maior
< Menor
>=
Maior ou
igual
<=
Menor ou
igual
15. Operadores lógicos
Os operadores lógicos permitem ao programador realizar várias
comparações em uma mesma condição. A seguir, a Tabela 5 exibe os
operadores lógicos utilizados em Python.
Tabela 5: Operadores Lógicos
Operador lógico
and
or
not
and é verdadeiro quando ambas condições forem verdadeiras
or é verdadeiro quando uma ou ambas condições forem verdadeiras.
not é o inverso da condição, ou seja, inverte o True ou False.
16. Comando de Seleção (if)
28. 28
for i in range(0, 10, 2): # 0 2 4 6 8
print(i)
for i in range(0, 11, 2): # 0 2 4 6 8 10
print(i)
for i in range(10, -1, -1): # 10 9 8 7 6 5 4 3 2 1 0
print(i)
for i in range(10, 0, -1): # 10 9 8 7 6 5 4 3 2 1
print(i)
Observação: Nunca chega no ponto de parada.
18.2 Lista de Exercícios (Comando de Repetição while e for)
a)Escreva um programa em Python que lê um número via teclado. O
programa deve exibir se o número é PAR ou ÍMPAR. O programa é encerrado
quando o número digitado for ZERO.
Teste do Programa:
Número: 6 <enter>
PAR
Número: 7 <enter>
IMPAR
Número: 0 <enter>
PAR
>>>
b)Escreva um programa em Python que lê um número via teclado. O
programa deve exibir: POSITIVO, NEGATIVO ou ZERO. O programa é
encerrado quando o usuário digitar ‘N’ ou ‘n’ na pergunta
“Continua [S/N]?”.
Teste do Programa:
Número: 6 <enter>
POSITIVO
Continua [S/N]? s
Número: -7 <enter>
NEGATIVO
Continua [S/N]? S
Número: 0 <enter>
ZERO
Continua [S/N]? N
>>>
c)Escreva um programa em Python que lê um nome via teclado. O programa
deve exibir o número de palavras do nome e a abreviatura do nome.
36. 36
a) Escreva um programa em Python que recebe via teclado um conjunto
de letras. Armazene todas as letras em um vetor ou lista (letras)
até que o usuário digite apenas <enter>. Logo após copie todas as
letras (em ordem inversa) para outro vetor (inverso). Ao final
imprima os dois vetores (conforme exemplo abaixo).
Teste do programa:
Letra: L <enter>
Letra: I <enter>
Letra: M <enter>
Letra: A <enter>
Letra: <enter>
[‘L’, ‘I’, ‘M’, ‘A’]
[‘A’, ‘M’, ‘I’, ‘L’]
b) Escreva um programa em Python que recebe via teclado: número de
idades e as respectivas idades. Armazene todas as idades em um
vetor (idade). Logo após a entrada de todas as idades, o programa
deve receber via teclado: idade para consulta. O programa deve
imprimir na tela, o número de idades antes da idade de consulta e
o número de idades depois da idade de consulta (conforme exemplo
abaixo). Exibir Idade não encontrada se a idade de consulta não
existir.
Teste do programa:
Número de idades: 6 <enter>
Idade: 30 <enter>
Idade: 60 <enter>
Idade: 10 <enter>
Idade: 50 <enter>
Idade: 20 <enter>
Idade: 40 <enter>
Idade para consulta: 50 <enter>
Antes: 3
Depois: 2
Continua [S/N]? n <enter>
c) Escreva um programa em Python que recebe via teclado um conjunto
de números inteiros. Armazene todos os números inteiros em um vetor
até que o usuário digite 0 (zero). Logo após permita ao usuário
consultar um número informando o seu valor. O programa deve
imprimir na tela a posição do número no vetor ou ERRO: Número não
encontrado (veja exemplos abaixo):
Exemplo:
Número: 50 <enter>
Número: 30 <enter>
37. 37
Número: 20 <enter>
Número: 10 <enter>
Número: 40 <enter>
Número: 0 <enter>
Valor: 20 <enter>
Posição no vetor: 2
Valor: 40 <enter>
Posição no vetor: 4
Valor: 60 <enter>
ERRO: Número não encontrado
Valor: 0 <enter>
Observação: O programa termina quando o usuário digitar 0 (zero).
d) Escreva um programa em Python que recebe via teclado "n" conceitos
(A, B, C, D e E) até que o usuário digite F ou f. Armazene todos
os conceitos em um vetor (conceito). Imprima na tela o número de
alunos: aprovados (A, B e C), reprovados (D) e os infrequentes
(E).
Teste do programa:
Conceito: B <enter>
Conceito: A <enter>
Conceito: E <enter>
Conceito: B <enter>
Conceito: D <enter>
Conceito: C <enter>
Conceito: A <enter>
Conceito: E <enter>
Conceito: f <enter>
5 Aprovado(s)
1 Reprovado(s)
2 Infrequente (s)
e) Escreva um programa em Python que recebe via teclado “n” nomes.
A entrada dos nomes termina quando o usuário digitar apenas
<enter>. Logo após a entrada de todos os nomes o programa deve
permitir a entrada via teclado de uma letra. O programa deve
imprimir na tela todos os nomes que começam com a letra
especificada pelo usuário. O programa termina quanto o usuário
digitar “” (nada) na entrada da letra (conforme exemplos abaixo):
Teste do programa:
Nome: Paulo <enter>
Nome: Roberto <enter>
Nome: Renato <enter>
Nome: Pedro <enter>
Nome: Fabio <enter>
Nome: <enter>
Letra: R <enter>
Nome: Roberto
38. 38
Nome: Renato
Letra: P <enter>
Nome: Paulo
Nome: Pedro
Letra: T <enter>
Letra: <enter>
f) Escreva um programa em Python que recebe via teclado “n” nomes
e idades. A entrada dos dados termina quando o usuário digitar 'N'
ou 'n' na pergunta "Continua [S/N]?". Logo após a entrada de todos
os dados o programa deve imprimir na tela todos os nomes e idades
desde o mais velho até o mais novo.
Teste do programa:
Nome: Ana <enter>
Idade: 12 <enter>
Continua [S/N]? s <enter>
Nome: Beatriz <enter>
Idade: 13 <enter>
Continua [S/N]? s <enter>
Nome: Carla <enter>
Idade: 14 <enter>
Continua [S/N]? N <enter>
Carla 14
Beatriz 13
Ana 12
20. Questões de prova
A seguir são apresentadas diversas questões de provas. Resolva-
as, pois elas servirão como um simulado para treino da linguagem de
programação Python.
1. Escreva um programa em Python que lê um nome qualquer via
teclado. Logo após a entrada, imprima na tela o nome
abreviado e a quantidade de palavras abreviadas, conforme e
exatamente igual aos testes abaixo:
Teste do programa (1):
Nome: Paulo Roberto Gomes Luzzardi <enter>
Abreviatura: Paulo R. G. Luzzardi
Palavras abreviadas: 2
Teste do programa (2):
Nome: adriane maria machado freitas luzzardi <enter>
Abreviatura: adriane m. m. f. luzzardi
Palavras abreviadas: 3
39. 39
2. Escreva um programa em Python que lê nomes via teclado.
Para cada nome digitado pelo usuário, armazene em uma Lista
[f] para feminino, [m] para masculino ou [i] para
indeterminado, conforme exemplo abaixo. Ao final imprima a
Lista, o total de homens, o total de mulheres e o total de
indeterminados.
Teste do programa:
Nome: Debora <enter>
Nome: Carla <enter>
Nome: Beatriz <enter>
Nome: Paulo <enter>
Nome: Renato <enter>
Nome: <enter>
Lista: [‘f’, ‘f’, ‘i’, ‘m’, ‘m’]
2 homens
2 mulheres
1 indeterminados
3. Escreva um programa em Python que recebe “n” nomes via
teclado (até que o usuário digite apenas <enter>). Insira
todos os nomes ORDENADOS em uma Lista de Strings (conforme
exemplo abaixo). Ao final, o programa deve exibir a Lista
contendo os nomes em ordem alfabética.
Teste do programa:
Nome: Debora <enter>
Nome: Carla <enter>
Nome: Eva <enter>
Nome: Beatriz <enter>
Nome: Ana <enter>
Nome: <enter>
Lista: [‘Ana’, ‘Beatriz’, ‘Carla’, ‘Debora’, ‘Eva’]
4. Escreva um programa em Python que lê um nome via teclado.
Logo após a entrada crie uma outra string (invertido) para
inverter e exibir este nome na tela e ainda o número de
letras do nome (sem contar os espaços) e o total de espaços
do nome, conforme exemplo abaixo.
Teste do programa:
Nome: paulo roberto gomes luzzardi <enter>
Invertido: idrazzul semog otrebor oluap
Total de Letras: 25
Total de Espaços: 3
5. Escreva um programa em Python que recebe via teclado:
valor inicial, valor final e intervalo. O programa deve
inserir “n” valores em uma Lista (desde o valor inicial até
o valor final levando em consideração o intervalo entre eles,
conforme exemplos abaixo. Ao final, o programa deve exibir
a Lista criada com estes valores.
40. 40
Teste do programa:
Valor Inicial: 10 <enter>
Valor Final: 70 <enter>
Intervalo: 10 <enter>
Lista: [10, 20, 30, 40, 50, 60, 70]
Valor Inicial: 60 <enter>
Valor Final: 20 <enter>
Intervalo: 5 <enter>
Lista: [60, 55, 50, 45, 40, 35, 30, 25, 20]
6. Escreva um programa em Python que insere “n” números
inteiros em uma Lista (até que o usuário digite zero). Logo
após permita a consulta de um valor e então exiba: (a) o
antecessor e (b) o sucessor ou Antecessor não existe,
Sucessor não existe ou Elemento não Encontrado (exatamente
igual aos exemplos abaixo).
Teste do programa:
Valor: 10 <enter>
Valor: 20 <enter>
Valor: 30 <enter>
Valor: 40 <enter>
Valor: 50 <enter>
Valor: 0 <enter>
Lista: [10, 20, 30, 40, 50]
Valor a consultar: 30 <enter>
Antecessor: 20
Sucessor: 40
Valor a consultar: 10 <enter>
Antecessor não existe
Sucessor: 20
Valor a consultar: 60 <enter>
Antecessor não existe
Erro: Elemento não encontrado
Sucessor não existe
Valor a consultar: 0 <enter>
7. Escreva um programa em Python que recebe via teclado:
número de idades e as referidas idades. O programa deve então
imprimir na tela: (a) as idades em ordem crescente; (b) maior
idade; (c) menor idade e (d) a média de idades.
Teste do programa:
Número de Idades: 4 <enter>
Idade: 49 <enter>
Idade: 51 <enter>
Idade: 48 <enter>
Idade: 50 <enter>
Idades Ordenadas: [48, 49, 50, 51]
Maior Idade: 51
Menor Idade: 48
Média de Idades: 49.5
41. 41
8. Escreva um programa em Python que lê um vetor R de 5
elementos contendo o gabarito da LOTO. A seguir, ler um vetor
A de 10 elementos contendo uma aposta. A seguir imprima
quantos pontos fez o apostador.
Teste do programa:
[Entrada]
R: 4 12 34 25 17 (gabarito)
A: 3 17 55 21 34 4 27 29 20 11 (aposta)
[Saída]
3 (pontos)
9. Dada a seguinte tela:
Salário Mensal (R$): 900 <enter>
Férias (R$): 450 <enter>
13 Salário (R$): 780 <enter>
Salário Anual (R$): 12030.00
Alíquota do Imposto de Renda: ISENTO
Escreva um programa em Python que recebe via teclado:
Salário mensal, valor das férias e 13o salário. O programa
deve calcular e imprimir na tela: Salário Anual e a Alíquota
do imposto de renda (dada pela tabela abaixo):
Salário Mensal Alíquota do Imposto de Renda
Menor ou igual a 1.058,00 Isento
Maior que 1.058,00 15%
Maior que 2.700,00 27,5%
10. Escreva um programa em Python que lê via teclado, um
número inteiro qualquer (positivo ou negativo). O programa
deve calcular e imprimir na tela: (a) inverso; (b) quadrado;
(c) raiz quadrada e (d) cubo deste número.
Teste do programa:
Número: 4 <enter>
Inverso: 0.25
Quadrado: 16
Raiz Quadrada: 2
Cubo: 64
11. Dado os seguintes exemplos de entrada de dados:
a = 1 <enter> a = 1 <enter>
b = -4 <enter> b = 2 <enter>
c = 2 <enter> c = 3 <enter>
Raízes Reais Raízes Complexas
x1 = 3.41 x1 = -1.00 + 1.41 i
x2 = 0.59 x2 = -1.00 - 1.41 i
42. 42
Escreva um programa em Python que recebe via teclado:
os coeficientes a, b e c de uma equação do segundo grau. O
programa deve calcular e imprimir na tela: as raízes x1 e
x2.
a . x2
+ b . x + c = 0 # equação de segundo grau
Atenção: Note que as raízes podem ser Reais ou Complexas.
delta = b2 – 4ac
+------
-b +- / delta
Raízes Reais: x1,2 = ------------------ “delta maior ou igual a zero”
2.a
+---------
-b / | delta |
Raízes Complexas: x1,2 = ----- +- ------------- i “delta menor que zero”
2.a 2.a
12. Escreva um programa em Python que lê um conjunto de 10
pares de dados contendo, cada um, a altura e um código para
masculino (1) e outro para feminino (2) de uma turma de
alunos. Calcular e imprimir na tela: (a) maior e a menor
altura da turma e (b) média de altura das mulheres e dos
homens e (c) total de homens e total de mulheres.
Teste do programa:
[Entrada]
1.80 (altura) 1 (masculino)
1.60 (altura) 2 (feminino)
1.62 (altura) 1 (masculino)
1.70 (altura) 2 (feminino)
1.72 (altura) 1 (masculino)
1.80 (altura) 2 (feminino)
1.92 (altura) 1 (masculino)
1.40 (altura) 1 (masculino)
1.42 (altura) 1 (masculino)
1.64 (altura) 1 (masculino)
[Saída]
1.92 (maior altura da turma)
1.40 (menor altura da turma)
1.70 (média de altura das mulheres
1.65 (média de altura dos homens
7 Homens
3 Mulheres
13. Escreva um programa em Python que recebe via teclado “n” nomes e
idades. A entrada dos dados termina quando o usuário digitar 'N' ou 'n'
na pergunta "Continua [S/N]?". Logo após a entrada de todos os dados o
43. 43
programa deve imprimir na tela todos os nomes e idades em ordem
alfabética (conforme exemplo abaixo).
Teste do programa:
Nome: Beatriz <enter>
Idade: 12 <enter>
Continua [S/N]? s <enter>
Nome: Carla <enter>
Idade: 13 <enter>
Continua [S/N]? s <enter>
Nome: Debora <enter>
Idade: 15 <enter>
Continua [S/N]? s <enter>
Nome: Ana <enter>
Idade: 14 <enter>
Continua [S/N]? N <enter>
Ana 14
Beatriz 12
Carla 13
Debora 15
14. Escreva um programa em Python que recebe via teclado:
valor e quantidade até que o usuário tecle zero (0) no valor.
O programa deve inserir ambos valores em uma Lista (conforme
exemplo abaixo). Ao final, o programa deve criar e exibir
outra Lista (Lista por extenso) contendo todos os valores
por extenso (conforme exemplo abaixo) e ainda o total de
valores da lista por extenso.
Teste do programa:
Valor: 10 <enter>
Quantidade: 3 <enter>
Valor: 20 <enter>
Quantidade: 4 <enter>
Valor: 30 <enter>
Quantidade: 2 <enter>
Valor: 0 <enter>
Lista: [10, 3, 20, 4, 30, 2]
Lista por Extenso: [10, 10, 10, 20, 20, 20, 20, 30, 30]
Total de valores por extenso: 9
21. Curiosidades e testes no Python
A seguir são vistos algumas curiosidades e testes feitos no
Python:
# --------------------------------- Teste.py
# ==================== inicialização de várias variáveis
46. 46
Para escrever uma função usa-se a palavra reservada def. A
princípio a função deve estar localizada antes da chamada da função. A
sintaxe é:
def nome_função(lista de argumentos):
comando1
comando2
return(valor)
chamada_função(argumentos)
Exemplo:
# -------------------------------- Funcoes.py
import math
def Hipotenusa(a, b):
h = math.sqrt(a**2 + b**2)
return(h)
def Maior(a, b):
if a >= b:
return(a)
else:
return(b)
def Menor(a, b):
if a <= b:
return(a)
else:
return(b)
a = float(input("Digite um valor (a): "))
b = float(input("Digite outro valor (b): "))
print("Hipotenusa: ", Hipotenusa(a,b))
print("Maior: ", Maior(a, b))
print("Menor: ", Menor(a, b))
Teste do Programa:
===== RESTART: /Users/pluzzardi/Documents/Funcoes.py ====
Digite um valor (a): 3 <enter>
Digite outro valor (b): 4 <enter>
Hipotenusa: 5.0
Maior: 4.0
Menor: 3.0
>>>
Exemplo usando uma função Raiz, usando um conceito da matemática:
47. 47
def Raiz(x):
r = x ** 0.5
return(r)
def Hipotenusa(a, b):
h = Raiz(a*a + b*b)
return(h)
a = float(input("Digite um valor (a): "))
b = float(input("Digite outro valor (b): "))
print("Hipotenusa: ", Hipotenusa(a,b))
Teste do Programa:
===== RESTART: /Users/pluzzardi/Documents/Raiz.py ====
Digite um valor (a): 3 <enter>
Digite outro valor (b): 4 <enter>
Hipotenusa: 5.0
Funções recursivas em Python:
Uma função é dita recursiva quando faz chamada a si própria, cada chamada é
colocada na pilha de execução do sistema e serve para retornar as chamadas anteriores.
# ---------------------------------------------- Fatorial.py
# Exemplo de função recursiva, função que chama a si própria
# É complexo o ponto de parada
# ----------------------------------------------------------
def Fatorial(n):
if n <= 1:
return(1)
fat = n * Fatorial(n-1)
return(fat)
x = int(input("Digite um valor: "))
fat = Fatorial(x)
print("Fatorial: ", fat)
Teste do Programa:
=== RESTART: /Users/pluzzardi/Documents/Fatorial.py =====
Digite um valor: 20 <enter>
Fatorial: 2432902008176640000
>>>
O programa a seguir, calcula o valor da série de Fibonacci:
# ...................... Fibonacci.py
def Fibonacci(n):
if n == 0:
48. 48
return(0)
if n == 1 or n == 2:
return(1)
else:
return(Fibonacci(n-1) + Fibonacci(n-2))
n = int(input("Fibonacci de: "))
print("A sequência de Fibonacci é: ", sep='', end='')
for i in range(n):
print(Fibonacci(i), ", ", end='', sep='')
Teste do Programa:
Fibonacci de: 15 <enter>
A sequência de Fibonacci é: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377,
O programa a seguir, imprime na tela números em sequência em ordem
reversa recursivamente:
# ..................... Imprime.py
n = int(input("Número: "))
Imprime(n)
def Imprime(n):
if n == 0:
return
else:
print(n)
Imprime(n-1)
Teste do Programa:
Número: 5 <enter>
5
4
3
2
1
A seguir é visto um exemplo que mostra duas funções que permitem
entrada de dados de números reais (REAL) ou números inteiros (INTEIRO)
via teclado sem erro, ou seja, o usuário pode cometer erros de digitação
que o programa não é abortado.
# ---------------------------------------------------------- Float.py
# O programa testa a conversão de string para float ou inteiro
# sem erro na entreda de dados com input
# -------------------------------------------------------------------
def REAL(s):
n = len(s)
temLetras = False
50. 50
Digite um Real: 1234Paulo
ERRO: Conversão Inválida
Digite um Real: 123,45
Número digitado: 123.45
Digite um Inteiro: paulo123
ERRO: Conversão Inválida
Digite um Inteiro: 123
Número digitado: 123
>>>
Python permite que o programador defina suas próprias
funções, ou seja, permite que o programador defina pequenos
módulos. Este processo permite “dividir para conquistar”, ou
seja, dividir o programa em problemas menores.
Sintaxe: def nome_módulo(lista de parâmetros):
Return
Existem dois tipos de passagem de parâmetros: por valor
(não altera o valor dos parâmetros) ou por referência (altera
o valor dos parâmetros).
Exemplo de passagem por valor:
# ..................... Calc.py
def add(x, y):
return(x+y)
def sub(x, y):
return(x-y)
def mult(x, y):
return(x*y)
def div(x, y):
if y == 0:
return("Erro: Divisão por Zero")
return(x/y)
def calculadora(x, y, operador):
if operador == '+':
valor = add(x,y)
else:
if operador == '-':
valor = sub(x,y)
else:
if operador == '*':
valor = mult(x,y)
else:
if operador == '/':
valor = div(x,y)
else:
return("ERRO: Operador Inválido")
return(valor)
51. 51
x = float(input("Digite um Valor: "))
y = float(input("Digite outro Valor: "))
operador = input("Operação [+ - * / **]: ")
valor = calculadora(x, y, operador)
print(valor)
Teste do Programa:
Digite um Valor: 3
Digite outro Valor: 4
Operação [+ - * / **]: /
0.75
Teste do Programa:
Digite um Valor: 3
Digite outro Valor: 0
Operação [+ - * / **]: /
Erro: Divisão por Zero
Teste do Programa:
Digite um Valor: 3
Digite outro Valor: 4
Operação [+ - * / **]: &
ERRO: Operador Inválido
Exemplo de passagem por referência:
Passagem de parâmetros por referência, ou seja, quando
os parâmetros são modificados.
Note que interessante o comando return, pois ele contém
duas variáveis.
# ..................... Troca.py
def troca(x, y):
temp = x
x = y
y = temp
return(x, y)
x = 3
y = 4
print("x = ", x)
print("y = ", y)
x, y = troca(x, y)
print("x = ", x)
print("y = ", y)
Teste do Programa:
x = 3
52. 52
y = 4
a = 4
b = 3
22.1 Exercícios sobre funções em Python
a) A seguir, implemente a função Hipotenusa que recebe
cateto adjacente (a) e o cateto oposto (b) e retorna o
valor da hipotenusa dado pela seguinte fórmula:
Trecho do programa principal:
a = float(input("a = "))
b = float(input("b = "))
h = Hipotenusa(a, b)
print("Hipotenusa é: %.2f" %h)
Teste do Programa:
a = 3 <enter>
b = 4 <enter>
Hipotenusa é: 5.00
b) No exercício a seguir, implemente a função Bhaskara,
que recebe três (3) parâmetros: a, b e c e retorna as
duas (2) variáveis: x1 e x2 se existirem, para que o
programa funcione conforme exemplos a seguir:
x1, x2 = -b +- raiz(b2 – 4.a.c) dividido por 2 . a
delta = b2 – 4.a.c
Se delta >= 0:
Raízes_reais
Existe x1 e x2
Senão:
Raizes_complexas
Trecho do programa principal:
a = float(input("a = "))
b = float(input("b = "))
53. 53
c = float(input("c = "))
x1, x2 = Bhaskara(a, b, c)
if x1 != -1 and x2 != -1:
print("Raizes Reais")
print("x1 = ", x1)
print("x2 = ", x2)
else:
print("Raizes Complexas")
Teste do Programa:
a = 1 <enter>
b = 2 <enter>
c = -3 <enter>
Raizes Reais
x1 = 1.0
x2 = -3.0
Teste do Programa:
a = 1 <enter>
b = 2 <enter>
c = 3 <enter>
Erro: Raizes Complexas
c)Implemente a função Palavras que recebe uma string e
retorna o número de palavras desta string, conforme
exemplo a seguir:
Trecho do programa principal:
s = input("Nome: ")
n = Palavras(s)
print("Seu nome tem %d palavra(s)" %n)
Teste do Programa:
Nome: Paulo Roberto Gomes Luzzardi <enter>
Seu nome tem 4 palavra(s)
d)Implemente a função Verifica_Data que recebe uma string
no formato “dd/mm/aaaa” e retorna o dia, mês e ano (como
inteiros) contidos na string de entrada, conforme exemplo
a seguir:
Trecho do programa principal:
data = input("Data [dd/mm/aaaa]: ")
dia, mes, ano = Verifica_Data(data)
if dia != -1:
print("Dia: %d" %dia)
if mes != -1:
print("Mês: %d" %mes)
if ano != -1:
print("Ano: %d" %ano)
55. 55
23. Criação e utilização de módulos em Python
Python permite modularizar os programas, ou seja,
permite que o programador defina seus próprios módulos, desta
forma ele utiliza em outros programas. Um módulo nada mais
é do que um conjunto de funções.
Exemplo da definição do módulo Luzzardi.py.
# ................................ Módulo: Luzzardi.py
def troca(x, y):
temp = x
x = y
y = temp
return(x, y)
Exemplo de um programa que utiliza o módulo Luzzardi.py e
que tem a função troca.
import Luzzardi
x = 3
y = 4
print("x = ", x)
print("y = ", y)
x, y = Luzzardi.troca(x, y)
print("x = ", x)
print("y = ", y)
Teste do Programa:
x = 3
y = 4
x = 4
y = 3
Exemplo da definição do módulo Luzzardi.py com mais duas
funções: maior e menor.
# .................... Módulo: Luzzardi.py
def troca(x, y):
temp = x
x = y
y = temp
return(x, y)
def maior(x, y):
if x >= y:
return(x)
else:
return(y)
56. 56
def menor(x, y):
if x <= y:
return(x)
else:
return(y)
# .................... Modulos.py
import Luzzardi
x = 3
y = 4
print("x = ", x)
print("y = ", y)
x, y = Luzzardi.troca(x, y)
print("x = ", x)
print("y = ", y)
print("Maior: ", Luzzardi.maior(x, y))
print("Menor: ", Luzzardi.menor(x,y))
Teste do Programa:
x = 3
y = 4
x = 4
y = 3
Maior: 4
Menor: 3
Exemplo da definição do módulo Luzzardi.py com mais uma
função: mensagem.
# .................... Módulo: Luzzardi.py
def troca(x, y):
temp = x
x = y
y = temp
return(x, y)
def maior(x, y):
if x >= y:
return(x)
else:
return(y)
def menor(x, y):
if x <= y:
return(x)
else:
return(y)
def mensagem(mensagem, valor):
print(mensagem, valor)
Observação: Note que não é necessário “return” no final da função, o término da
função é pela identação.
57. 57
# ....................... Modulos.py
import Luzzardi
x = 3
y = 4
Luzzardi.mensagem("x = ", x)
Luzzardi.mensagem("y = ", y)
x, y = Luzzardi.troca(x, y)
Luzzardi.mensagem("x = ", x)
Luzzardi.mensagem("y = ", y)
Luzzardi.mensagem("Maior: ", Luzzardi.maior(x, y))
Luzzardi.mensagem("Menor: ", Luzzardi.menor(x, y))
Teste do Programa:
x = 3
y = 4
x = 4
y = 3
Maior: 4
Menor: 3
Em Python é possível o programador escrever suas próprias funções
dentro de um módulo e inseri-lo em seus programas. O módulo é um arquivo
Python (modulo.py) somente com definições de funções. A princípio, este
módulo deve estar junto ao programa fonte, ou seja, na mesma localização.
#--------------------------------------------------------- Luzzardi.py
# O programa testa a conversão de string para float ou inteiro
# sem erro na entrada de dados com input
# -------------------------------------------------------------------
def REAL(s):
n = len(s)
temLetras = False
for i in range(n):
if s[i] == ',':
s = s.replace(',', '.') # converte vírgula em ponto
if s[i] == '-' and i != 0: # verifica sinal negativo
temLetras = True;
break
if s[i] not in ['.', '-', '0', '1', '2', '3', '4', '5', '6', '7', '8','9']:
# verifica caracteres não numéricos
temLetras = True
break
if not temLetras:
numero = float(s)
return(numero)
else:
print("ERRO: Conversão Inválida")
return(-1) # retorna um valor inválido
59. 59
Na execução de um programa em Python, podem ocorrer
erros não previstos que podem interromper a execução normal
do programa. Tais erros podem ser:
• Conversão numérica inválida;
• Limite de um vetor (acessar um índice inválido)
• Problemas em arquivos: abertura, criação ou caminho
(path);
• Overflow;
• Erro de entrada e saída (input/output);
• Divisão por zero.
Python pode assumir o controle da execução em caso que
ocorra uma situação de erro não prevista.
Isso é feito através do mecanismo de tratamento de
exceções que ao detectar uma situação de erro, o programa em
Python gera uma exceção.
Se o programa que estiver sendo executado possuir um
tratamento de exceções (try: ... except ...:), ele assume o
controle da execução. Mas se a exceção não tiver um
tratamento associado, o programa é interrompido e é exibida
uma mensagem de erro e o programa é abortado.
Uma exceção é um evento que indica uma condição anormal
que interrompe a execução normal de um programa.
O tratamento de erros no Python cria objetos da classe
error, o tratamento destes erros é feita pela manipulação
destes objetos. Analise o exemplo abaixo, aonde são testados
a conversão de string para inteiro (comando input) e raiz
quadrada de número negativo (math.sqrt()).
Tipo de Exceção: ValueError
# -------------------------- ValueError.py
import math
try:
num = int(input("Digite um Número: "))
try:
raiz = math.sqrt(num)
print("Raiz Quadrada: ", raiz)
except ValueError as error:
print("Erro: ", error)
except ValueError as error:
print("Erro: ", error)
Teste do Programa:
60. 60
========== RESTART: /Users/pluzzardi/Documents/ValueError.py =======
Digite um Número: paulo
Erro: invalid literal for int() with base 10: 'paulo'
>>>
========= RESTART: /Users/pluzzardi/Documents/ValueError.py ========
Digite um Número: -16
Erro: math domain error
>>>
======= RESTART: /Users/pluzzardi/Documents/ValueError.py =========
Digite um Número: 16
Raiz Quadrada: 4.0
>>>
O tratamento de erros em Python baseia-se no comando
try. A sintaxe é a seguinte:
try:
comando
comando
except erro:
comando
comando
A execução de um bloco de código, protegido por um
tratamento de erros, é feito colocando o bloco no try, e
para cada erro que se deseja tratar, deve-se colocar uma
cláusula except tipo_de_erro as variável_erro:
Exceções são instâncias de classes geradas quando
houver erro. Estas exceções podem ser captadas e tratadas
para que não ocorra erros em tempo de execução.
Tipo de Exceção: ZeroDivisionError
# ------------------------------- Zero.py
try:
x = float(input("Digite um Valor: "))
y = float(input("Digite outro Valor: "))
try:
divisão = x / y
print("Divisão é: ", divisão)
except ZeroDivisionError as error:
print("Erro: ", error)
except ValueError as error:
print('Erro: ', error)
Teste do Programa:
======= RESTART: /Users/pluzzardi/Desktop/Python/Python/Zero.py ======
Digite um Valor: paulo
Erro: could not convert string to float: 'paulo'
>>>
======= RESTART: /Users/pluzzardi/Desktop/Python/Python/Zero.py =====
Digite um Valor: 4
Digite outro Valor: 0
61. 61
Erro: float division by zero
>>>
Tipo de Exceção: NameError e TypeError
# ------------------------------------ NameError.py
try:
num = int(input("Valor: "))
print("Soma: ", soma + num) # soma não está definido
except NameError as error: # erro por nome
print("ERRO: ", error)
try:
a = 5
soma = 'a' + a # tipos diferentes
print("Soma: ", soma)
except TypeError as error: # erro por tipo
print("ERRO: ", error)
Teste do Programa:
========== RESTART: /Users/pluzzardi/Documents/NameError.py ========
Valor: 5
ERRO: name 'soma' is not defined
ERRO: must be str, not int
>>>
Tipo de Exceção: IndexError
# ------------------------- LimiteVetor.py
x = [10, 20, 30, 40, 50]
n = 5
try:
i = 1
while i <= n: # erro i <= n, pois o vetor começa em ZERO
print(x[i])
i = i + 1
except IndexError as error:
print("Erro: ", error)
Teste do Programa:
========= RESTART: /Users/pluzzardi/Documents/LimiteVetor.py ========
20
30
40
50
Erro: list index out of range
>>>
Tipo de Exceção: IOError (Arquivos)
# ---------------------------------------- FileCria.py
nomeArquivo = input("Nome do Arquivo: ")
try:
62. 62
file = open(nomeArquivo, 'r')
except IOError as error:
print("Erro: ", error)
else:
print("Nome do Arquivo: ", nomeArquivo)
file.close()
Teste do Programa:
========== RESTART: /Users/pluzzardi/Documents/FileCria.py ========
Nome do Arquivo: Agenda.bd
Nome do Arquivo: Agenda.bd
>>>
========== RESTART: /Users/pluzzardi/Documents/FileCria.py ==========
Nome do Arquivo: test.bd
Erro: [Errno 2] No such file or directory: 'test.bd'
>>>
25. Banco de Dados em Python (SQLite)
A seguir são dados alguns exemplos de programas com
Banco de Dados (BD) em Python (SQLiteCriaBD, SQLiteLeBD,
SQLiteConsultaBD, SQLiteRemoveBD e SQLiteAppendBD). É criado
um banco de dados de uma agenda contendo id (identificador),
nome e fone utilizando o módulo SQLite3.
SQLiteCriaBD: Cria um banco de dados.
SQLiteLeBD: Faz a leitura dos registros do BD criado.
SQLiteConsultaBD: Consulta um registro através do id.
SQLiteRemoveBD: Remove um registro através do id.
SQLiteAppendBD: Anexa novos registros ao final do BD.
O programa a seguir cria um BD (Agenda.bd) com uma
tabela “agenda” com os seguintes campos: id, nome e fone.
# ------------------------ SQLiteCriaBD.py
import sqlite3
nomeBD = input("Nome do Banco de Dados: ")
conector = sqlite3.connect(nomeBD)
cursor = conector.cursor()
cursor.execute('''
create table agenda (
id integer, # identificador
nome text,
fone text)
''')
id = 1
nome = "Pessoa"
while nome != "":
print("id: ", id)
nome = input("Nome: ")
if nome != "":
fone = input("Fone: ")
64. 64
Teste do Programa:
====== RESTART: /Users/pluzzardi/Desktop/Python/SQLiteLeBD.py =======
Nome do Banco de Dados: Luzzardi.bd
id: 1
Nome: Paulo Roberto
Fone: 99164-8037
id: 2
Nome: Adriane Maria
Fone: 99156-4567
id: 3
Nome: Paola Maria
Fone: 98434-1234
3 registro(s)
>>>
O programa a seguir faz uma consulta dos campos do banco
de dados (Agenda.bd) gerados pelo programa anterior através
da leitura via teclado do identificador (id).
# ------------------------ SQLiteConsultaBD.py
import sqlite3, os
nomeBD = input("Nome do Banco de Dados: ")
try:
conector = sqlite3.connect(nomeBD)
id = '1'
cursor = conector.cursor()
while id != '0':
id = input('Digite o índice [0 - Sair]: ')
if id != '0':
cursor.execute("SELECT * FROM agenda WHERE id=?",(id))
result = cursor.fetchall()
achei = False
for contato in result:
print("id: %dnNome: %s nFone: %s" % (contato))
achei = True
if not achei:
print("Erro: Contato não Encontrado")
cursor.close()
conector.close()
except sqlite3.Error as error:
print("ERRO: BD não encontrado")
print("Erro: ", error)
os.remove(nomeBD) # remove arquivo criado
Teste do Programa:
=== RESTART: /Users/pluzzardi/Desktop/Python/SQLiteConsultaBD.py ====
Nome do Banco de Dados: Agenda.bd
65. 65
Digite o índice [0 - Sair]: 1
id: 1
Nome: Paulo Roberto
Fone: 99164-8037
Digite o índice [0 - Sair]: 2
id: 2
Nome: Adriane Maria
Fone: 99156-4567
Digite o índice [0 - Sair]: 3
id: 3
Nome: Paola Maria
Fone: 98434-1234
Digite o índice [0 - Sair]: 0
>>>
O programa a seguir permite remover os campos do banco
de dados (Agenda.bd) gerados pelo programa anterior através
da leitura via teclado do identificador (id).
# ------------------------ SQLiteRemoveBD.py
import sqlite3, os
nomeBD = input("Nome do Banco de Dados: ")
try:
conector = sqlite3.connect(nomeBD)
cursor = conector.cursor()
id = '1'
while id != '0':
id = input("Digite o índice [0 - Sair]: ")
if id != '0':
cursor.execute("DELETE FROM agenda WHERE id=?",(id))
conector.commit()
print("Okay, Contato REMOVIDO")
cursor.close()
conector.close()
except sqlite3.Error as error:
print("Erro: BD não encontrado")
print("Erro: ", error)
os.remove(nomeBD)
Teste do Programa:
===== RESTART: /Users/pluzzardi/Desktop/Python/SQLiteRemoveBD.py ====
Nome do Banco de Dados: Agenda.bd
Digite o índice: 3
Digite o índice: 0
Okay, Contato REMOVIDO
>>>
======= RESTART: /Users/pluzzardi/Desktop/Python/SQLiteLeBD.py =====
Nome do Banco de Dados: Agenda.bd
id: 1
Nome: Paulo Roberto
68. 68
1;Paulo Roberto;99164-8037;
2;Adriane Maria;99156-2345;
3;Paola Freitas;98678-1234;
# -------------------------------------- FileLeTexto.py
nomeFile = input("Nome do Arquivo: ")
try:
file = open(nomeFile, "r")
for linha in file:
campos = linha.split(';')
print(campos)
file.close()
except IOError as error:
print("ERRO: ", error)
Teste do Programa:
======== RESTART: /Users/pluzzardi/Documents/FileLeTexto.py ======
Nome do Arquivo: Dados.txt
['1', 'Paulo Roberto', '99164-8037', 'n']
['2', 'Adriane Maria', '99156-2345', 'n']
['3', 'Paola Freitas', '98678-1234', 'n']
>>>
# ------------------------------- FileLeDadosTexto.py
nomeFile = input("Nome do Arquivo: ")
try:
file = open(nomeFile, "r")
for linha in file:
campos = linha.split(';')
print("id: ", campos[0])
print("Nome: ", campos[1])
print("Fone: ", campos[2])
file.close()
except IOError as error:
print("ERRO: ", error)
Teste do Programa:
====== RESTART: /Users/pluzzardi/Documents/FileLeDadosTexto.py =====
Nome do Arquivo: Dados.txt
id: 1
Nome: Paulo Roberto
Fone: 99164-8037
id: 2
Nome: Adriane Maria
Fone: 99156-2345
id: 3
Nome: Paola Freitas
Fone: 98678-1234
>>>
Teste do Programa: (Arquivo texto não existe)
====== RESTART: /Users/pluzzardi/Documents/FileLeDadosTexto.py ====
Nome do Arquivo: Dados.bd
ERRO: [Errno 2] No such file or directory: 'Dados.bd'
>>>
69. 69
# -------------------------------------- FileAnexaTexto.py
nomeFile = input("Nome do Arquivo: ")
try:
file = open(nomeFile, 'r')
id = 1
for linha in file:
id = id + 1 # contar o número de registros
file.close()
file = open(nomeFile,'a') # anexando no fim do arquivo
nome = "Pessoa"
while nome != "":
print("id: ", id)
nome = input("Nome: ")
if nome != "":
fone = input("Fone: ")
linha = str(id) + ";" + nome + ";" + fone + ";" + "n"
file.write(linha)
id = id + 1
file.close()
except IOError as error:
print("ERRO: ", error)
Teste do Programa:
======== RESTART: /Users/pluzzardi/Documents/FileAnexaTexto.py ======
Nome do Arquivo: Dados.txt
id: 3
Nome: Renato Luis
Fone: 98778-3456
Gravou dados
id: 4
Nome: Francisco Carlos
Fone: 98178-5678
Gravou dados
id: 5
Nome:
>>>
Listagem do Arquivo alterado: Dados.txt
['1', 'Paulo Roberto', '99164-8037', 'n']
['2', 'Adriane Maria', '99156-2345', 'n']
['3', 'Paola Freitas', '98678-1234', 'n']
[‘4’;’Renato Luis’;’98778-3456’;’n’]
[‘5’;’Francisco Carlos’;’98178-5678’;’n’]
# ------------------------------- FileCriaTexto.py
nomeFile = input("Nome do Arquivo: ")
try:
file = open(nomeFile, 'w') # cria novo arquivo texto
id = 1 # cuidado, apaga se existir
nome = "Pessoa"
while nome != "":
print("id: ", id)
nome = input("Nome: ")
if nome != "":
70. 70
fone = input("Fone: ")
linha = str(id) + ";" + nome + ";" + fone + ";" + "n"
file.write(linha)
id = id + 1
file.close()
except IOError as error:
print("ERRO: ", error)
Teste do Programa:
======= RESTART: /Users/pluzzardi/Documents/FileCriaTexto.py ======
Nome do Arquivo: Luz.txt
id: 1
Nome: Paulo Roberto
Fone: 99164-8037
id: 2
Nome: Renato Luis
Fone: 98778-3456
id: 3
Nome: Francisco Carlos
Fone: 98178-5678
id: 4
Nome:
>>>
Listagem do Arquivo: Luz.txt
1;Paulo Roberto;99164-8037;
2;Renato Luis; 98778-3456;
3;Francisco Carlos; 98178-5678;
# ------------------------------- FileProcuraDadosTexto.py
nomeFile = input("Nome do Arquivo: ")
try:
file = open(nomeFile, "r")
posicao = 1
while posicao != 0:
posicao = int(input("Posição [0 - Sair]: "))
file.seek(0, 0) # reinicializa o cursor do arquivo no início
imprimiu = False
for linha in file:
campos = linha.split(';')
if campos[0] == str(posicao):
imprimiu = True
print("id: ", campos[0])
print("Nome: ", campos[1])
print("Fone: ", campos[2])
if not imprimiu:
print("Erro: Registro não encontrado")
file.close()
except IOError as error:
print("ERRO: ", error)
Teste do Programa:
RESTART:
/Users/pluzzardi/Desktop/Python/Python/File/FileProcuraDadosTexto.py
Nome do Arquivo: Dados.txt
Posição [0 - Sair]: 1
71. 71
id: 1
Nome: Paulo Roberto
Fone: 99164-8037
Posição [0 - Sair]: 2
id: 2
Nome: Adriane Maria
Fone: 99156-2345
Posição [0 - Sair]: 3
id: 3
Nome: Paola Freitas
Fone: 98678-1234
Posição [0 - Sair]: 4
id: 4
Nome: Renato Luis
Fone: 98778-3456
Posição [0 - Sair]: 5
id: 5
Nome: Francisco Carlos
Fone: 98178-5678
Posição [0 - Sair]: 6
Erro: Registro não encontrado
Posição [0 - Sair]: 7
Erro: Registro não encontrado
Posição [0 - Sair]: 8
Erro: Registro não encontrado
Posição [0 - Sair]: 9
Erro: Registro não encontrado
Posição [0 - Sair]: 0
Erro: Registro não encontrado
>>>
# ------------------------------------ FileBuscaDadosTexto.py
nomeFile = input("Nome do Arquivo: ")
try:
file = open(nomeFile, "r")
nome = "Pessoa"
while nome != "":
nome = input("Nome: ")
file.seek(0, 0)
imprimiu = False
for linha in file:
campos = linha.split(';')
if nome == campos[1]:
imprimiu = True
print("id: ", campos[0])
print("Nome: ", campos[1])
print("Fone: ", campos[2])
if not imprimiu:
print("Erro: Nome não encontrado")
file.close()
except IOError as error:
print("ERRO: ", error)
Teste do Programa:
RESTART:
/Users/pluzzardi/Desktop/Python/Python/File/FileBuscaDadosTexto.py
Nome do Arquivo: Dados.txt
Nome: Paulo
Erro: Nome não encontrado
72. 72
Nome: Paulo Roberto
id: 1
Nome: Paulo Roberto
Fone: 99164-8037
Nome: Renato Luis
id: 4
Nome: Renato Luis
Fone: 98778-3456
Nome:
Erro: Nome não encontrado
>>>
29. Arquivos Binários em Python
Como foi visto no capítulo 26, Python permite operar com
arquivos binários e textos através de algumas funções, tais
como: open, write, read, close, etc.
Enquanto um arquivo texto é formado de linhas de
caracteres terminados com um ‘n’, um arquivo binário possui
campos de vários tipos, tais como: inteiro, real, string,
etc.
pickle é um módulo do Python que permite a serialização de
objetos, ou seja, transforma objetos em sequências de bytes.
Outros módulos similares podem ser utilizados, tais como:
Marshal, Struct (como na linguagem C), JSON e Shelve.
Exemplo de um programa em Python que grava em um arquivo
binário: teste.bin os seguintes campos: nome (string),
telefone (string) e idade (inteiro).
# ........................ GravaBin.py
import pickle
nomeArquivo = input("Nome do Arquivo Binário: ")
try:
file = open(nomeArquivo, "rb")
file.close()
ch = input("Atenção: Arquivo já existe, sobre-escrever [s/n]")
if ch == "S" or ch == "s":
try:
file = open(nomeArquivo, "wb")
except IOError as error:
print("Erro: Impossível criar o arquivo: %s" %nomeArquivo)
n = int(input("Número de Elementos: "))
pickle.dump(n, file)
for i in range(n):
nome = input("Nome: ")
pickle.dump(nome, file)
telefone = input("Telefone: ")
pickle.dump(telefone, file)
idade = int(input("Idade: "))
pickle.dump(idade, file)
file.close()
except IOError as error:
73. 73
print("Atenção: Arquivo não existe")
try:
file = open(nomeArquivo, "wb")
except IOError as error:
print("Erro: Impossível criar o arquivo: %s" %nomeArquivo)
n = int(input("Número de Elementos: "))
pickle.dump(n, file)
for i in range(n):
nome = input("Nome: ")
pickle.dump(nome, file)
telefone = input("Telefone: ")
pickle.dump(telefone, file)
idade = int(input("Idade: "))
pickle.dump(idade, file)
file.close()
Observação: Note que o número de elementos também é salvo no arquivo binário, para
depois ser lido no programa que carrega o arquivo binário.
Teste do Programa:
Nome do Arquivo Binário: teste.bin <enter>
Número de Elementos: 3 <enter>
Nome: Paulo Roberto <enter>
Telefone: 99164-8037 <enter>
Idade: 56 <enter>
Nome: Adriane Maria <enter>
Telefone: 99156-3334 <enter>
Idade: 48 <enter>
Nome: Paola Freitas <enter>
Telefone: 99167-4567 <enter>
Idade: 19 <enter>
# ........................ LeBin.py
import pickle
nomeArquivo = input("Nome do Arquivo Binário: ")
try:
file = open(nomeArquivo, "rb")
n = pickle.load(file)
print("Número de Elementos: ", n)
for i in range(n):
nome = pickle.load(file)
print("Nome: ", nome)
telefone = pickle.load(file)
print("Telefone: ", telefone)
idade = pickle.load(file)
print("Idade: ", idade)
file.close()
except IOError as error:
print('Atenção: Arquivo não Existe', nomeArquivo)
print(error)
Teste do Programa:
Nome do Arquivo Binário: teste.bin <enter>