• Author / Uploaded
• Joanna De Cássia Valadares

• Categories
• Python (Lenguaje de programación)
• Lenguaje de programación
• Matemáticas elementales
• Ingeniería informática
• Física y matemáticas

Citation preview

Algoritmos e Programação em Python

por Prof. Dr. Paulo Roberto Gomes Luzzardi

facebook: Paulo Roberto Gomes Luzzardi WhatsApp: 99164-8037 e-mail: [email protected] (principal) e [email protected] e-mail (Senac): [email protected] DropBox: https://www.dropbox.com/sh/kea9kr4j2qttnjg/4xXvw0pvxX?m Hostinger: http://pluzzardi.w.pw e http://pluzzardi.zz.mu (Home Page) Versão 1.62 02-05-2018 Bibliografia 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)

1

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

2

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

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

3

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 & MacOsX: $ idle3.6 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”)







Hello

Realizar operações matemáticas:











>>> 3 + 4 7 >>> 2 ** 3











Operações mais complexas:













8 >>>

>>> a = 3 >>> b = 4 >>> c = a + b >>> print(a, b, c) 3 4 7 >>> print(“c = “, c) c = 7 >>> print(3>4) 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.

5

# -------------------------- Type.py a = 3 print(type(a)) b = 3.4 print(type(b)) c = 'Python' print(type(c)) d = 'A' print(type(d)) Teste do Programa: ========= RESTART: /Users/pluzzardi/Documents/Type.py ========= >>>

Comando id: Retorna o identificador do objeto, número inteiro que identifica cada objeto do Python. >>> a = 3 >>> b = 4 >>> print(id(a)) 4297624000 >>> print(id(b)) 4297624032 >>>

# 32 bits / 8 bits = 4 bytes (inteiro)

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

6.1 Hierarquia dos operadores (precedência)

A Tabela 2, a seguir, exibe a precedência dos operadores do Python, ou seja, a ordem de execução das operações matemáticas. Tabela 2: Hierarquia dos Operadores Aritméticos Ordem de precedência

Tipo de Operador

Parênteses

()

**

Potenciação

- (unário)

Unário

* / % //

Multiplicação, divisão, modulo (resto inteiro da divisão) e divisão inteira

+ -

Adição e subtração

Exemplos:

>>> 7 / 2 3.5 >>> 7 % 2 1 >>> 7 // 2 3 >>>

# divisão real # resto inteiro da divisão (módulo) # divisão inteira

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) 4 >>> print(3+4) 7 >>> print(3>4) enter> False >>> a = 3 >>> print(a) 3 >>> b = 4

# tipo lógico (True ou False)

7

>>> print(a+b) >> A = 7 >>> print(A+b) 11 >>> print(“a = ”, a) a = 3 >>> >>> print(4%2) # resto inteiro da divisão 0 >>> >>> print(3**4) # Potenciação 81 >>> número_dentes = 32 >>> print(“Número de Dentes: “, número_dentes) >>> Número de Dentes = 32 >>> a = 3 >>> b = 4 >>> print("a = ", a, "b = ", b) a = 3 b = 4 >>> dia = 3 >>> mês = 7 >>> ano = 2017 >>> print(“Data: %02d/%02d/%d” %(dia, mês, ano)) 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 >>> mês = 7 >>> ano = 2017 >>> print(“Data: %02d/%02d/%d” %(dia, mês, ano)) 03/07/2017 >>> # ================================== data e hora from datetime import datetime

8

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: “) >>> Digite um Nome: Luzzardi # número de caracteres da string >>> print(len(s)) 8 >>> Entrada de um Inteiro: >>> i = int(input(“Digite um Valor: “)) >>> Digite um Nome: 34 >>> print(i) 34 >>> Entrada de um Real (float):

>>> i = float(input(“Digite um Valor: “)) >>> Digite um Nome: 34 >>> print(i) 34.0 >>>

Outra forma, em duas etapas:

>>> s = input("Digite um Valor: ") Digite um Valor: 34 # conversão para inteiro >>> x = int(s) >>> print(x) 34 >>>

9. Deletar uma variável (del)

9

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 >>> print(a) 3 >>> del a >>> print(a) Traceback (most recent call last): File "", line 1, in NameError: name 'a' is not defined

Erro: identificador ‘a’ não definido Observação: É possível também reinicializar o terminal (shell), vá na opção Shell .. Restart Shell, todas as variáveis são destruídas, ou seja, desalocadas da memória RAM (Random Acess Memory). 10. Módulos (import) Python possui um conjunto de funções pré-definidas agrupadas em estruturas chamadas de módulos, tais como: math (mathematics), os (sistema operacional), datetime (data e hora), etc. Forma de importar: import módulo Para utilizar a função de um módulo: módulo.função(argumento) Para importar apenas uma função desejada: from módulo import função

Exemplos:





>>> import math >>> print(math.pi) 3.141592653589793 >>> import os >>> os.system(“clear”) >>> from math import sqrt >>> print(math.sqrt(16)) 16 >>>

Ajuda (help) dos módulos: >>> import math

10

>>> help(math)

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

11

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 "", line 1, in ValueError: math domain error >>>

math.degrees(x): Converte o ângulo x de radianos para graus. 
 pi radianos à 180 graus math.radians(x): Converte o ângulo x de graus para radianos. math.sin(x): Retorna o seno de x, onde x deve estar em radianos. >>> x = math.sin(45) >>> print(x) 0.8509035245341184 >>> x = math.sin(math.radians(45)) >>> print(x) 0.7071067811865475 >>>

math.cos(x): Retorna o cosseno de x, onde x deve estar em radianos. >>> x = math.cos(45) >>> print(x) 0.5253219888177297 >>> x = math.cos(math.radians(45)) # converte 45 para radianos >>> print(x) 0.7071067811865476

math(tan(x): Retorna a tangente de x, onde x deve estar em radianos. >>> tangente = math.tan(math.radians(45)) >>> print(tangente) 0.9999999999999999 >>>

math.hypot(x, y): Retorna a hipotenusa do triângulo retângulo, onde x e y são os catetos oposto e adjacente. >>> hipotenusa = math.hypot(3 ,4)

12

>>> 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" >>> print(s) Python >>> print("Número de caracteres da string: %d" %(len(s))) 6 >>>

ou >>> s = ‘Python’ # pode ser utilizado aspas simples # retorna o número de caracteres >>> l = len(s)

>>> print("Número de caracteres da String: %d" %l) 6 >>>



outra forma de inicialização:

>>> s = 'P' 'y' 't' 'h' 'o' 'n' >> print(s) Python >>> Vetor de Strings: (será visto em outro capítulo) >>> s = ('Paulo', 'Roberto', 'Gomes', 'Luzzardi') >>> print(s[0]) Paulo >>> print(s[3]) Luzzardi >>>

12.1 Funções para Strings # ------------------------------------------- Split.py s = "Paulo Roberto Gomes Luzzardi" print("Número de letras: ", len(s)) partes = s.split(' ') n = len(partes) print("Número de nomes: ", n)

13

for i in range(n): print(partes[i]) print(partes) Teste do Programa: ===== RESTART: /Users/pluzzardi/Desktop/Python/Python/Split.py ==== Número de letras: 28 Número de nomes: 4 Paulo Roberto Gomes Luzzardi ['Paulo', 'Roberto', 'Gomes', 'Luzzardi'] >>> Exemplo de funções de Strings: # -------------------------------- String.py # -------------------------------------------- len s = 'Paulo Roberto Gomes Luzzardi' n = len(s) # retorna o total de caracteres da string print("Número de Caracteres: ", n) # -------------------------------------------- count caracter = 'a' letras = s.count(caracter) # retorna o número de vezes que o caracter aparece na string print('Número de letras "%c" é %d' %(caracter,letras)) # -------------------------------------------- replace s = s.replace('Roberto', 'R.') # troca parte da string s = s.replace("Gomes", "G.") print(s) # -------------------------------------------- find pos = s.find('z') # procura a primeira aparição de uma letra print(pos) # -------------------------------------------- upper e lower print("STRING: ", s.upper()) # exibe como maiúscula print(s) print("string: ", s.lower()) # exibe como minúscula print(s) # -------------------------------------------- title s = "paulo roberto gomes luzzardi" print(s.title()) # -------------------------------------------- swapcase s = 'Paulo Roberto Gomes Luzzardi' print(s.swapcase()) # inverte as letras maiúsculas e minúsculas

14

# -------------------------------------------- isalpha print('Contém apenas letras: ', s.isalpha()) # verifica se contém apenas letras s = 'FatecSenac' print('Contém apenas letras: ', s.isalpha()) # --------------------------------------------- isdigit print('Contém apenas números: ', s.isdigit()) s = '123456' print('Contém apenas números: ', s.isdigit()) Teste do Programa: =========== RESTART: /Users/pluzzardi/Documents/String.py ========== Número de Caracteres: 28 Número de letras "a" é 2 Paulo R. G. Luzzardi 14 STRING: PAULO R. G. LUZZARDI Paulo R. G. Luzzardi string: paulo r. g. luzzardi Paulo R. G. Luzzardi Paulo Roberto Gomes Luzzardi pAULO rOBERTO gOMES lUZZARDI Contém apenas letras: False Contém apenas letras: True Contém apenas números: False Contém apenas números: True >>>

13. Comandos: Sequência, Seleção e Repetição

Python possui três tipos principais de comandos, sequência, onde todos são executados, seleção, onde alguns são e outros não são executados e repetição, comandos são executados diversas vezes. 13.1 Comandos de Sequência Comandos de Sequência: Todos os comandos (ou instruções) em sequência são sempre executados no fluxo do programa. # --------------------- Circulo.py import math diametro = float(input("Digite o valor do Diâmetro: ")) raio = diametro / 2 area = math.pi * raio ** 2

15

print("Área do Círculo é: ", area)

Teste do Programa:

Digite o valor do Diâmetro: 6 Área do Círculo é: 28.274334 >>>

# ----------------------------------- Temperatura.py f = 120 c = (f - 32) * 5 / 9 print("Celsius: %d" %c, sep='', end='') # imprime mesma linha print(" - Fahrenheit: ", f)

Teste do Programa:

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

# ---------------------------------- Random.py import random n = 10 print("Faixa de Sorteio: 0 ... %d" %(n-1)) numero = int (random.random() * n) print("Número Sorteado: ", numero) # A função random gera um número float aleatório entre 0.0 e 1.0

Teste do Programa: ========== RESTART: /Users/pluzzardi/Documents/Random.py ======= Faixa de Sorteio: 0 ... 9 Número Sorteado: 8 >>> # ----------------------------- Aleatorio.py import random for i in range(6): n = random.randint(1, 10) print("n = ", n) Teste do Programa: ======= RESTART: /Users/pluzzardi/Documents/Aleatorio.py ======= n = 2 n = 9 n = 7

16

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 Cateto Oposto (a): 4 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 Diâmetro: 11.46
 Raio: 5.73 comprimento da circunferência = 2 . Pi . raio

17

diâmetro = 2 . raio

d) Desenvolva um programa em Python que recebe via teclado: peso da carne que será vendida e preço por quilo. O programa deve calcular e imprimir na tela o total a pagar, o valor pago ao ICMS (17%) e o lucro líquido do açougue. 


Teste do Programa (1):


 Peso: 3.5 
 Preço por Kg (R$): 4.90 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 
 Preço por Kg (R$): 9.00 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 
 Mês: 3 
 Ano: 2017 
 Qual a sua idade:
 Anos: 55 
 Meses: 1 
 Dias: 6 
 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.

18

Teste do Programa: Salário: 500 
 Percentual de reajuste: 15 
 Novo salário: 575

g) Escreva um programa em Python que lê via teclado as dimensões de uma cozinha retangular (comprimento, largura e altura), calcular e escrever a quantidade de caixas de azulejos para se colocar em todas as suas paredes (considere que não será descontado a área ocupada por portas e janelas). Cada caixa de azulejos possui 1,5 m2. Teste do Programa: Comprimento: 4.5 
 Largura: 3 Altura: 2.8 

 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 
 Percentual de alunos aprovados na turma D: 85 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 




19

b = 2 c = -3 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

>> ======= RESTART: /Users/pluzzardi/Documents/If.py ======== Digite um Número: 5 x = 5 >>>

Programa exemplo: If completo, ou seja, com duas partes

# ---------------------------------------- Par.py x = int(input("Digite um Número: ")) if x % 2 == 0: print("Par") else: print("Ímpar")

Teste do Programa:

================= RESTART: /Users/pluzzardi/Documents/Par.py ======= Digite um Número: 4 Par >>>

# ------------------------- Bhaskara.py import math a = float(input("a = ")) b = float(input("b = ")) c = float(input("c = ")) delta = b**2 - 4 * a * c if delta >= 0: x1 = (-b + math.sqrt(delta)) / 2*a x2 = (-b - math.sqrt(delta)) / 2*a print("x1 = ", x1) print("x2 = ", x2) else: print("Erro: Raizes complexas")

Teste do Programa:

===== RESTART: /Users/pluzzardi/Documents/bhaskara.py ====== a = 1 b = 2 c = -3 x1 = 1.0 x2 = -3.0 >>>

Programa exemplo: if com elif

22

# ---------------------------------------- Elif.py numero = int(input("Digite um Número: ")) if numero > 0: print("Positivo") elif numero < 0: print("Negativo") else: print("Zero")

16.1 Lista 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 
 Nota 2: 8 
 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 
 Valor: 4 
 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 
 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

23

valor total da compra. Testes do Programa: Maças: 20 
 Valor da Compra: R$ 5.00
 ou Maças: 12 
 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 
 Sexo [M] ou [F]: m
 Peso Ideal: 72.86 ou Altura: 1.65 
 Sexo [M] ou [F]: F
 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. Podese 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

24

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 >> # -------------------- In2.py import random s = 's' # operador in while s in ['S', 's']: num = random.randint(1, 10) print("Número sorteado: ", num) s = input("Continua [S/N]") Teste do Programa:

25

============= 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 sabese a quantidade de vezes que um bloco é executado. Sempre que se sabe o número de vezes, deve-se usar o comando for, caso contrário, deve-se utilizar o comando while, que pode ser controlado de várias formas, baseados em sua condição. Para utilizar o comando for deve-se saber o início (start), o ponto de parada (stop) e a variação (step). # --------------------------------- For.py for i in range(6): # faixa: 0 à 5, onde 6 é o ponto de parada print(i) ====== RESTART: /Users/pluzzardi/Desktop/Python/Python/For.py ===== 0 1 2 3 4 5 >>> # ----------------------------------- ForDuplo.py for i in range(3): for j in range(4): print(i, j) ====== RESTART: /Users/pluzzardi/Documents/ForDuplo.py ==========

26

0 0 0 1 0 2 0 3 1 0 1 1 1 2 1 3 2 0 2 1 2 2 2 3 >>> Observação: Note que começa sempre em zero. # ----------------------------------- ForDuplo2.py for i in range(3): for j in range(4): print(i+1, j+1) === RESTART: /Users/pluzzardi/Desktop/Python/Python/ForDuplo2.py === 1 1 1 2 1 3 1 4 2 1 2 2 2 3 2 4 3 1 3 2 3 3 3 4 >>>

18.1 range (faixa)

Range permite determinar o ponto de partida (start), ponto de parada (stop) e a variação (step) usado no comando for. Sintaxe: range(start, stop, step) Onde: Start: partida Stop: parada (stop - 1) Step: passo (incremento [+] ou decremento [-]) Exemplos: for i in range(10): # 0 1 2 3 4 5 6 7 8 9 print(i)

27

for i in range(0, 10, 2): # 0 2 4 6 8 print(i) for i in range(0, 11, 2): # 0 2 4 6 8 10 print(i) for i in range(10, -1, -1): # 10 9 8 7 6 5 4 3 2 1 0 print(i) for i in range(10, 0, -1): # 10 9 8 7 6 5 4 3 2 1 print(i) Observação: 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 
 PAR Número: 7 IMPAR Número: 0 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 
 POSITIVO Continua [S/N]? s Número: -7 NEGATIVO Continua [S/N]? S Número: 0 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. 28

Teste do Programa: Nome: Paulo Roberto Gomes Luzzardi 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 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 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) for i in range(n): print(x[i]) Teste do Programa:



# retorna o número de elementos da lista



# imprime elemento por elemento

29

======= 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: ")) # insere um elemento no fim da lista x.append(num) for i in range(n): # elimina o espaço print('x[',i,'] = ', x[i], sep='') print("Lista: ", x) Teste do Programa: ==== RESTART: /Users/pluzzardi/Desktop/Python/Python/Lista2.py ==== Número de Elementos: 4 Digite um Número: 10 Digite um Número: 20 Digite um Número: 30 Digite um Número: 40 x[0] = 10 x[1] = 20 x[2] = 30 x[3] = 40 Lista: [10, 20, 30, 40] >>>

Exemplo: Lista3.py # ------------------------------ Lista3.py x = [10, 20, 30] y = x print("x = ", x, "y = ", y) print(x is y) print(id(x)) print(id(y)) t = x[:] # cria uma cópia da lista x ... t = x.copy() print(t is x) print(id(t)) print("Número de Elementos: ", len(x)) Teste do Programa: ======== RESTART: /Users/pluzzardi/Documents/Lista3.py ========== x = [10, 20, 30] y = [10, 20, 30]

30

True 4380371208 4380371208 False 4320652552 Número de Elementos: 3 >>>

Exemplo: Lista4.py # -------------------------------- Lista4.py nome = [] nota = [] soma = 0.0 numeroAlunos = 4 for i in range(numeroAlunos): nome.append(input("Nome do Aluno: ")) nota.append(float(input("Nota do " + nome[i] + ": "))) soma = soma + nota[i] media = soma / numeroAlunos print("Média da Turma:", media) Teste do Programa: ======== RESTART: /Users/pluzzardi/Documents/Lista4.py ============= Nome do Aluno: Paulo Nota do Paulo: 7 Nome do Aluno: Roberto Nota do Roberto: 8 Nome do Aluno: Gomes Nota do Gomes: 9 Nome do Aluno: Luzzardi Nota do Luzzardi: 10 Média da Turma: 8.5 >>>

Imprimir Listas utilizando o comando for: # lista de números inteiros lista = {10, 20, 30, 40, 50} 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))

31

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 in : # Teste do Programa: ===== RESTART: /Users/pluzzardi/Desktop/Python/Python/For.py ===== 0 1 2 3 4 5 Lista sem Ordenação 40 10 50 20 30 Lista Ordenada 10 20 30 40 50 0 - 40 1 - 10 2 - 50 3 - 20 4 - 30 5 6 7 8 9 10 11 12 13 14 [5, 6, 7, 8, 9, 10, 11, 12, 13, 14] Ana Beatriz Carla

32

Debora Eva

Funções para operar listas:

Anexar o elemento no final da lista: append lista.append(elemento) Remove o elemento da lista: remove lista.remove(elemento) Limpa toda a lista, ou seja, apaga todos os elementos da lista: clear lista.clear() Insere o elemento antes do índice: insert lista.insert(índice, elemento) Remove o último elemento e retorna o valor: pop ultimo = lista.pop() Reverte os elementos da lista (muda a ordem): reverse lista.reverse() Cria uma cópia da lista: copy temp = lista.copy() Ordena uma lista: sort lista.sort() ou lista.sort(reverse = True) Número de elementos de uma lista: len n = len(lista)

Retorna o número de vezes de um elemento dentro de uma lista: count vezes = lista.count(elemento)

33

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) # ordena em ordem decrescente lista.sort(reverse=True) print(lista) # insert(posição, valor) lista.insert(1, 15) # insere o elemento antes da posição print(lista) print(lista.count(20)) # exibe o número de vezes do elemento print(lista.index(20)) # exibe o índice do elemento ultimo = lista.pop() # remove o último elemento print("Último elemento: ", ultimo) print(lista) lista.reverse() # inverte a lista (ordem dos elementos) print(lista) temp = lista.copy() print("Lista Nova: ", temp) Teste do programa: =============== RESTART: /Users/pluzzardi/Desktop/Lista.py ========= [10, 20, 30, 40, 50] [50, 40, 30, 20, 10] [50, 15, 40, 30, 20, 10] 1 4 Último elemento: 10 [50, 15, 40, 30, 20] [20, 30, 40, 15, 50] Lista Nova: [20, 30, 40, 15, 50] >>>

O programa a seguir mostra a criação aleatória de palpites para a MegaSena. # ---------------------------- MegaSena.py import random

34

# ---------------------------- repetido def repetido(num, n, t): for i in range(n): if num[i] == t: return(True) return(False) # ---------------------------- imprime def imprime(num): for i in range(len(num)): t = num[i] print("%2d " %t, sep='', end='') print() ch = 's' while ch in ['S', 's']: palpites = int(input("Número de palpites: ")) for i in range(palpites): num = [] n = 1 num.append(random.randint(1, 60)) while n != 6: t = random.randint(1, 60) if not(repetido(num, n, t)): num.append(t) n = n + 1 num.sort() # ordena a lista imprime(num) ch = input("Continua [s/n]?") Teste do Programa: ======== RESTART: /Users/pluzzardi/Desktop/MegaSena.py ============= Número de palpites: 5 3 9 14 17 26 40 2 7 10 12 28 54 9 13 16 30 36 39 2 26 29 43 47 54 5 12 23 31 37 55 Continua [s/n]?s Número de palpites: 6 9 11 23 26 33 34 8 28 31 40 43 50 9 17 22 24 28 47 22 31 33 36 39 45 16 27 39 40 43 46 15 31 36 42 48 60 Continua [s/n]?n >>>

19.1 Lista de Exercícios de Vetores (listas)

35

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 . 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 Letra: I Letra: M Letra: A Letra: [‘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 Idade: 30 
 Idade: 60 
 Idade: 10 
 Idade: 50 
 Idade: 20 
 Idade: 40 
 Idade para consulta: 50 Antes: 3 Depois: 2
 Continua [S/N]? n

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 
 Número: 30 


36

Número: 20 
 Número: 10 
 Número: 40 
 Número: 0 
 Valor: 20 
 Posição no vetor: 2
 Valor: 40 
 Posição no vetor: 4
 Valor: 60 
 ERRO: Número não encontrado Valor: 0 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 Conceito: A Conceito: E Conceito: B Conceito: D Conceito: C Conceito: A Conceito: E Conceito: f 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 . 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 Nome: Roberto Nome: Renato Nome: Pedro Nome: Fabio Nome: Letra: R Nome: Roberto

37

Nome: Renato Letra: P Nome: Paulo Nome: Pedro Letra: T Letra:

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 
 Idade: 12 Continua [S/N]? s Nome: Beatriz Idade: 13 Continua [S/N]? s Nome: Carla Idade: 14 Continua [S/N]? N Carla 14 Beatriz 13 Ana 12

20. Questões de prova

A seguir são apresentadas diversas questões de provas. Resolvaas, 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 Abreviatura: Paulo R. G. Luzzardi Palavras abreviadas: 2 Teste do programa (2): Nome: adriane maria machado freitas luzzardi Abreviatura: adriane m. m. f. luzzardi Palavras abreviadas: 3

38

2. Escreva um programa em Python que lê nomes via teclado. Para cada nome digitado pelo usuário, armazene em uma Lista [f] para feminino, [m] para masculino ou [i] para indeterminado, conforme exemplo abaixo. Ao final imprima a Lista, o total de homens, o total de mulheres e o total de indeterminados. Teste do programa: Nome: Debora Nome: Carla Nome: Beatriz Nome: Paulo Nome: Renato Nome: Lista: [‘f’, ‘f’, ‘i’, ‘m’, 2 homens 2 mulheres 1 indeterminados

‘m’]

3. Escreva um programa em Python que recebe “n” nomes via teclado (até que o usuário digite apenas ). 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 Nome: Carla Nome: Eva Nome: Beatriz Nome: Ana Nome: 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 Invertido: idrazzul semog otrebor oluap Total de Letras: 25 Total de Espaços: 3

5. Escreva um programa em Python que recebe via teclado: valor inicial, valor final e intervalo. O programa deve inserir “n” valores em uma Lista (desde o valor inicial até o valor final levando em consideração o intervalo entre eles, conforme exemplos abaixo. Ao final, o programa deve exibir a Lista criada com estes valores. 39

Teste do programa: Valor Inicial: 10 Valor Final: 70 Intervalo: 10 Lista: [10, 20, 30, 40, 50, 60, 70] Valor Inicial: 60 Valor Final: 20 Intervalo: 5 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 Valor: 20 Valor: 30 Valor: 40 Valor: 50 Valor: 0 Lista: [10, 20, 30, 40, 50] Valor a consultar: 30 Antecessor: 20 Sucessor: 40 Valor a consultar: 10 Antecessor não existe Sucessor: 20 Valor a consultar: 60 Antecessor não existe Erro: Elemento não encontrado Sucessor não existe Valor a consultar: 0

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 Idade: 49 Idade: 51 Idade: 48 Idade: 50 Idades Ordenadas: [48, 49, 50, 51] Maior Idade: 51 Menor Idade: 48 Média de Idades: 49.5

40

8. Escreva um programa em Python que lê um vetor R de 5 elementos contendo o gabarito da LOTO. A seguir, ler um vetor A de 10 elementos contendo uma aposta. A seguir imprima quantos pontos fez o apostador. Teste do programa: [Entrada] R: 4 12 34 25 17 (gabarito) A: 3 17 55 21 34 4 27 29 20 11 (aposta) [Saída] 3 (pontos)

9. Dada a seguinte tela: Salário Mensal (R$): 900 Férias (R$): 450 13 Salário (R$): 780 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 Menor ou igual a 1.058,00 Maior que 1.058,00 Maior que 2.700,00

Alíquota do Imposto de Renda Isento 15% 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 Inverso: 0.25 Quadrado: 16 Raiz Quadrada: 2 Cubo: 64

11. Dado os seguintes exemplos de entrada de dados: a = 1 b = -4 c = 2

a = 1 b = 2 c = 3

Raízes Reais

Raízes Complexas

x1 = 3.41 x2 = 0.59

x1 = -1.00 + 1.41 i x2 = -1.00 - 1.41 i

41

Escreva um programa em Python que recebe via teclado: os coeficientes a, b e c de uma equação do segundo grau. O programa deve calcular e imprimir na tela: as raízes x1 e x2. a . x2

+ b . x + c = 0

# equação de segundo grau

Atenção: Note que as raízes podem ser Reais ou Complexas. delta = b2 – 4ac

Raízes Reais:

+------b +- \/ delta x1,2 = -----------------2.a

-b Raízes Complexas: x1,2 = ----- +2.a

“delta maior ou igual a zero”

+--------\/ | delta | ------------- i “delta menor que zero” 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

42

programa deve imprimir na tela todos os nomes e idades em ordem alfabética (conforme exemplo abaixo). Teste do programa:

Nome: Beatriz Idade: 12 Continua [S/N]? s Nome: Carla Idade: 13 Continua [S/N]? s Nome: Debora Idade: 15 Continua [S/N]? s Nome: Ana Idade: 14 Continua [S/N]? N 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 Quantidade: 3 Valor: 20 Quantidade: 4 Valor: 30 Quantidade: 2 Valor: 0 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

43

a, b = 10, 20 print(a, b) # ==================== None (nulo ou null x = None # None é nulo ou null x = 5 print(x) # ===================== imprimir várias variáveis x = 10 y = 20 print("x = %d - y = %d\n" %(x, y)) # print formatado # ===================== definição de uma função em Python def maior(x, y): if x > y: return(x) else: return(y) print(maior(3,4)) # ============================== if simples x = int(input("Digite um Número: ")) if x < 0: print('Valor Negativo') print("Número Digitado: ", x) # ============================== imprimir uma string for letter in "python": print(letter) # ============================== if ... elif ... else ... numero = int(input("Digite um Número: ")) if numero > 0: print("Positivo") elif numero < 0: print("Negativo") else: print("Zero") # ================================== data e hora from datetime import datetime data = datetime.now()

44

print(data) print("Data: %02d/%02d/%d" %(data.day, data.month, data.year)) print("Tempo: %02d:%02d:%02d" %(data.hour, data.minute, data.second)) Teste do Programa:

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

# ----------------------------------- str.py s = "" for i in range(10): s = s + str(i) + ", " # forma uma string com números print(s) Teste do Programa: ========== RESTART: /Users/pluzzardi/Documents/str.py =========== 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, >>>

22. Funções escritas pelo programador em Python

Em Python é possível o programador escrever suas próprias funções, ou seja, dividir os programas em módulos menores (programação modular ou estruturada ou dividir para conquistar). Uma função deve ser uma caixa preta, que depois de funcionar não precisa mais manutenção. Uma função pode ou não receber argumentos (parâmetros) e retornar ou não um valor.

45

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



Exemplo usando uma função Raiz, usando um conceito da matemática:

46

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 Digite outro valor (b): 4 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 >>



O programa a seguir, calcula o valor da série de Fibonacci:

# ...................... Fibonacci.py def Fibonacci(n): if n == 0:

47

return(0) if n == 1 or n == 2: return(1) else: return(Fibonacci(n-1) + Fibonacci(n-2)) n = int(input("Fibonacci de: ")) print("A sequência de Fibonacci é: ", sep='', end='') for i in range(n): print(Fibonacci(i), ", ", end='', sep='')

Teste do Programa:

Fibonacci de: 15 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 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

48

for i in range(n): if s[i] == ',': s = s.replace(',','.') # trocar vírgula por ponto if s[i] == '-' and i != 0: # verifica o sinal negativo temLetras = True; break if s[i] not in ['.', ',', '-', '0', '1', '2', '3', '4', '5', '6', '7', '8','9']:

temLetras = True break if not temLetras: numero = float(s) return(numero) else: print("ERRO: Conversão Inválida") return(-1) def INTEIRO(s): n = len(s) temLetras = False for i in range(n): if s[i] == '-' and i != 0: temLetras = True; break if s[i] not in ['-', '0', '1', '2', '3', '4', '5', '6', '7', '8','9']: temLetras = True break if not temLetras: numero = int(s) return(numero) else: print("ERRO: Conversão Inválida") return(-1) s = input("Digite um Real: ") numero = REAL(s) if numero != -1: print("Real digitado foi: ", numero) while numero == -1: s = input("Digite um Real: ") numero = REAL(s) print("Número digitado: ", numero) s = input("Digite um Inteiro: ") numero = INTEIRO(s) if numero != -1: print("Inteiro digitado foi: ", numero) while numero == -1: s = input("Digite um Inteiro: ") numero = INTEIRO(s) print("Número digitado: ", numero) Teste do Programa: ===== RESTART: /Users/pluzzardi/Desktop/Python/Python/float.py =====

49

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)

50

x = float(input("Digite um Valor: ")) y = float(input("Digite outro Valor: ")) operador = input("Operação [+ - * / **]: ") valor = calculadora(x, y, operador) print(valor) Teste 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

51

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 b = 4 Hipotenusa é: 5.00

b) No exercício a seguir, implemente a função Bhaskara, que recebe três (3) parâmetros: a, b e c e retorna as duas (2) variáveis: x1 e x2 se existirem, para que o programa funcione conforme exemplos a seguir: x1, x2 = -b +- raiz(b2 – 4.a.c) dividido por 2 . a delta = b2 – 4.a.c Se delta >= 0: Raízes_reais Existe x1 e x2 Senão: Raizes_complexas Trecho do programa principal: a = float(input("a = ")) b = float(input("b = "))

52

c = float(input("c = ")) x1, x2 = Bhaskara(a, b, c) if x1 != -1 and x2 != -1: print("Raizes Reais") print("x1 = ", x1) print("x2 = ", x2) else: print("Raizes Complexas") Teste do Programa: a = 1 b = 2 c = -3 Raizes Reais x1 = 1.0 x2 = -3.0 Teste do Programa: a = 1 b = 2 c = 3 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 Seu nome tem 4 palavra(s)

d)Implemente a função Verifica_Data que recebe uma string no formato “dd/mm/aaaa” e retorna o dia, mês e ano (como inteiros) contidos na string de entrada, conforme exemplo a seguir:

Trecho do programa principal: data = input("Data [dd/mm/aaaa]: ") dia, mes, ano = Verifica_Data(data) if dia != -1: print("Dia: %d" %dia) if mes != -1: print("Mês: %d" %mes) if ano != -1: print("Ano: %d" %ano)

53

Teste do Programa: Data [dd/mm/aaaa]: 25/03/2018 Dia: 25 Mês: 3 Ano: 2018 Teste do Programa: Data [dd/mm/aaaa]: 25/03/18 ERRO: Formato Inválido Teste do Programa: Data [dd/mm/aaaa]: 32/03/18 ERRO: Dia Inválido

e)Implemente a função Verifica_Quadrante que recebe dois valores inteiros: x e y e retorna o quadrante (1, 2, 3 ou 4) destas coordenadas, conforme exemplo a seguir:

Trecho do programa principal: x = int(input("x = ")) y = int(input('y = ')) n = Verifica_Quadrante(x, y) print("Quadrante: %d" %n) Teste do Programa: x = 2 y = -2 Quadrante: 4

f)Implemente a função Final_Placa que recebe uma string no formato “xxx9999” (placa) e devolve o final da placa com dois dígitos, conforme exemplo a seguir:

Trecho do programa principal: placa = input("Placa [xxx9999]: ") final = FinalPlaca(placa) if final != -1: print("Final da Placa é: %d" %final) Teste do Programa: Placa [xxx9999]: etq1234 Final da Placa é: 34 Teste do Programa: Placa [xxx9999]: etq123 ERRO: Formato Inválido

54



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)

55

def menor(x, y): if x = y: return(x) else: return(y) def menor(x, y): if x >>

24. Tratamento de erros (exceções)

58

Na execução de um programa em Python, podem ocorrer erros não previstos que podem interromper a execução normal do programa. Tais erros podem ser: • • • • • •

Conversão numérica inválida; Limite de um vetor (acessar um índice inválido) Problemas em arquivos: abertura, criação ou caminho (path); Overflow; 
 Erro de entrada e saída (input/output); 
 Divisão por zero.

Python pode assumir o controle da execução em caso que ocorra uma situação de erro não prevista. Isso é feito através do mecanismo de tratamento de exceções que ao detectar uma situação de erro, o programa em Python gera uma exceção. Se o programa que estiver sendo executado possuir um tratamento de exceções (try: ... except ...:), ele assume o controle da execução. Mas se a exceção não tiver um tratamento associado, o programa é interrompido e é exibida uma mensagem de erro e o programa é abortado. Uma exceção é um evento que indica uma condição anormal que interrompe a execução normal de um programa. O tratamento de erros no Python cria objetos da classe error, o tratamento destes erros é feita pela manipulação destes objetos. Analise o exemplo abaixo, aonde são testados a conversão de string para inteiro (comando input) e raiz quadrada de número negativo (math.sqrt()).

Tipo de Exceção: ValueError # -------------------------- ValueError.py import math try: num = int(input("Digite um Número: ")) try: raiz = math.sqrt(num) print("Raiz Quadrada: ", raiz) except ValueError as error: print("Erro: ", error) except ValueError as error: print("Erro: ", error) Teste do Programa:

59

========== RESTART: /Users/pluzzardi/Documents/ValueError.py ======= Digite um Número: paulo Erro: invalid literal for int() with base 10: 'paulo' >>> ========= RESTART: /Users/pluzzardi/Documents/ValueError.py ======== Digite um Número: -16 Erro: math domain error >>> ======= RESTART: /Users/pluzzardi/Documents/ValueError.py ========= Digite um Número: 16 Raiz Quadrada: 4.0 >>>

O tratamento de erros em Python baseia-se no comando try. A sintaxe é a seguinte: try: comando comando except erro: comando comando A execução de um bloco de código, protegido por um tratamento de erros, é feito colocando o bloco no try, e para cada erro que se deseja tratar, deve-se colocar uma cláusula except tipo_de_erro as variável_erro: Exceções são instâncias de classes geradas quando houver erro. Estas exceções podem ser captadas e tratadas para que não ocorra erros em tempo de execução.

Tipo de Exceção: ZeroDivisionError # ------------------------------- Zero.py try: x = float(input("Digite um Valor: ")) y = float(input("Digite outro Valor: ")) try: divisão = x / y print("Divisão é: ", divisão) except ZeroDivisionError as error: print("Erro: ", error) except ValueError as error: print('Erro: ', error) Teste 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

60

Erro: >>>

float division by zero

Tipo de Exceção: NameError e TypeError # ------------------------------------ NameError.py try: num = int(input("Valor: ")) print("Soma: ", soma + num) except NameError as error: print("ERRO: ", error) try: a = 5 soma = 'a' + print("Soma: except TypeError print("ERRO:

a ", soma) as error: ", error)

# soma não está definido # erro por nome

# tipos diferentes # erro por tipo

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 >

Tipo de Exceção: IOError (Arquivos) # ---------------------------------------- FileCria.py nomeArquivo = input("Nome do Arquivo: ") try:

61

file = open(nomeArquivo, 'r') except IOError as error: print("Erro: ", error) else: print("Nome do Arquivo: ", nomeArquivo) file.close() Teste 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 ( # identificador id integer, nome text, fone text) ''') id = 1 nome = "Pessoa" while nome != "": print("id: ", id) nome = input("Nome: ") if nome != "": fone = input("Fone: ")

62

cursor.execute(''' insert into agenda (id, nome, fone) values(?, ?, ?) ''', (id, nome, fone)) conector.commit() id = id + 1 cursor.close() conector.close() print("Banco de Dados foi CRIADO: ", nomeBD) Teste do Programa: ====== RESTART: /Users/pluzzardi/Desktop/Python/SQLiteCriaBD.py ===== Nome do Banco de Dados: Agenda.bd id: 1 Nome: Paulo Roberto Fone: 99164-8037 id: 2 Nome: Adriane Maria Fone: 99145-6789 id: 3 Nome: Paola Maria Fone: 98478-7856 id: 4 Nome: Banco de Dados foi CRIADO: Agenda.bd >>>

O programa a seguir faz uma leitura dos campos do banco de dados (Agenda.bd) gerado pelo programa anterior. # -------------------------- SQLiteLeBD.py import sqlite3 # as lite import os nomeBD = input("Nome do Banco de Dados: ") try: # tratamento de exceção conector = sqlite3.connect(nomeBD) cursor = conector.cursor() numRegistros = 0 cursor.execute("SELECT * FROM agenda") result = cursor.fetchall() for contato in result: print("id: %d\nNome: %s \nFone: %s" % (contato)) numRegistros += 1 print(numRegistros, "registro(s)") cursor.close() conector.close() except sqlite3.Error as error: # executa quando ocorre um erro print("Erro: BD não encontrado") print("Erro: ", error) os.remove(nomeBD) # remove arquivo criado

63

Teste do Programa: ====== RESTART: /Users/pluzzardi/Desktop/Python/SQLiteLeBD.py ======= Nome do Banco de Dados: Luzzardi.bd id: 1 Nome: Paulo Roberto Fone: 99164-8037 id: 2 Nome: Adriane Maria Fone: 99156-4567 id: 3 Nome: Paola Maria Fone: 98434-1234 3 registro(s) >>>

O programa a seguir faz uma consulta dos campos do banco de dados (Agenda.bd) gerados pelo programa anterior através da leitura via teclado do identificador (id). # ------------------------ SQLiteConsultaBD.py import sqlite3, os nomeBD = input("Nome do Banco de Dados: ") try: conector = sqlite3.connect(nomeBD) id = '1' cursor = conector.cursor() while id != '0': id = input('Digite o índice [0 - Sair]: ') if id != '0': cursor.execute("SELECT * FROM agenda WHERE id=?",(id)) result = cursor.fetchall() achei = False for contato in result: print("id: %d\nNome: %s \nFone: %s" % (contato)) achei = True if not achei: print("Erro: Contato não Encontrado") cursor.close() conector.close() except sqlite3.Error as error: print("ERRO: BD não encontrado") print("Erro: ", error) # remove arquivo criado os.remove(nomeBD) Teste do Programa: === RESTART: /Users/pluzzardi/Desktop/Python/SQLiteConsultaBD.py ==== Nome do Banco de Dados: Agenda.bd

64

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

65

Fone: 99164-8037 id: 2 Nome: Adriane Maria Fone: 99156-4567 >>> # ------------------------ SQLiteAppendBD.py import sqlite3, os nomeBD = input("Nome do Banco de Dados: ") try: conector = sqlite3.connect(nomeBD) cursor = conector.cursor() id = 1 cursor.execute("SELECT * FROM agenda") result = cursor.fetchall() for contato in result: id += 1 nome = "Pessoa" while nome != "": print("id: ", id) nome = input("Nome: ") if nome != "": fone = input("Fone: ") cursor.execute(''' INSERT INTO agenda (id, nome, fone) values(?, ?, ?) ''', (id, nome, fone)) conector.commit() id = id + 1 cursor.close() conector.close() except sqlite3.Error as error: print("Erro: BD não encontrado") print("Erro: ", error) os.remove(nomeBD) Teste do Programa: ==== RESTART: /Users/pluzzardi/Desktop/Python/SQLiteAppendBD.py ===== Nome do Banco de Dados: Agenda.bd id: 4 Nome: Renato Luis Fone: 99134-2345 id: 5 Nome: Cacaio Fone: 99891-3456 id: 6 Nome: >>>

66

Execução do programa SQLiteLeBD.py ======= RESTART: /Users/pluzzardi/Desktop/Python/SQLiteLeBD.py ===== Nome do Banco de Dados: Agenda.bd id: 1 Nome: Paulo Roberto Fone: 99164-8037 id: 2 Nome: Adriane Maria Fone: 99156-4567 id: 3 Nome: Paola Maria Fone: 98434-1234 id: 4 Nome: Renato Luis Fone: 99134-2345 id: 5 Nome: Cacaio Fone: 99891-3456 5 registro(s) >>>

26. Sistema de Arquivos em Python

Python permite operar com arquivos binários e texto através de algumas funções, tais como: open, write, read, close, etc. Um arquivo texto é formado de linhas de caracteres terminados com um ‘\n’. Conforme exemplo abaixo: Dados.txt. Sintaxe do comando open: file = open(nomeArquivo, modo) Modo:

‘r’ ‘w’ ‘a’ ‘r+’ ‘b’

read (leitura) write (escrita) append (anexar no fim) read e write (leitura e escrita) binary (binário)

Comandos para operar arquivos: read(): Permite ler o conteúdo do arquivo. readline(): Permite ler uma única linha do arquivo. seek(colunas, posição): Posiciona o arquivo no ponto do arquivo: Posição 0 é o início do arquivo, 1 é a posição do arquivo atual e 2 é o final do arquivo. write(string): Grava o conteúdo da string para o arquivo, retornando o número de caracteres escritos. close(): Fecha o arquivo aberto. Arquivo texto: Dados.txt

67

1;Paulo Roberto;99164-8037; 2;Adriane Maria;99156-2345; 3;Paola Freitas;98678-1234; # -------------------------------------- FileLeTexto.py nomeFile = input("Nome do Arquivo: ") try: file = open(nomeFile, "r") for linha in file: campos = linha.split(';') print(campos) file.close() except IOError as error: print("ERRO: ", error) Teste 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' >>>

68

# -------------------------------------- FileAnexaTexto.py nomeFile = input("Nome do Arquivo: ") try: file = open(nomeFile, 'r') id = 1 for linha in file: id = id + 1 # contar o número de registros file.close() file = open(nomeFile,'a') # anexando no fim do arquivo nome = "Pessoa" while nome != "": print("id: ", id) nome = input("Nome: ") if nome != "": fone = input("Fone: ") linha = str(id) + ";" + nome + ";" + fone + ";" + "\n" file.write(linha) id = id + 1 file.close() except IOError as error: print("ERRO: ", error) Teste 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 != "":

69

fone = input("Fone: ") linha = str(id) + ";" + nome + ";" + fone + ";" + "\n" file.write(linha) id = id + 1 file.close() except IOError as error: print("ERRO: ", error) Teste 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

70

id: 1 Nome: Paulo Roberto Fone: 99164-8037 Posição [0 - Sair]: 2 id: 2 Nome: Adriane Maria Fone: 99156-2345 Posição [0 - Sair]: 3 id: 3 Nome: Paola Freitas Fone: 98678-1234 Posição [0 - Sair]: 4 id: 4 Nome: Renato Luis Fone: 98778-3456 Posição [0 - Sair]: 5 id: 5 Nome: Francisco Carlos Fone: 98178-5678 Posição [0 - Sair]: 6 Erro: Registro não encontrado Posição [0 - Sair]: 7 Erro: Registro não encontrado Posição [0 - Sair]: 8 Erro: Registro não encontrado Posição [0 - Sair]: 9 Erro: Registro não encontrado Posição [0 - Sair]: 0 Erro: Registro não encontrado >>> # ------------------------------------ FileBuscaDadosTexto.py nomeFile = input("Nome do Arquivo: ") try: file = open(nomeFile, "r") nome = "Pessoa" while nome != "": nome = input("Nome: ") file.seek(0, 0) imprimiu = False for linha in file: campos = linha.split(';') if nome == campos[1]: imprimiu = True print("id: ", campos[0]) print("Nome: ", campos[1]) print("Fone: ", campos[2]) if not imprimiu: print("Erro: Nome não encontrado") file.close() except IOError as error: print("ERRO: ", error) Teste do Programa: RESTART: /Users/pluzzardi/Desktop/Python/Python/File/FileBuscaDadosTexto.py Nome do Arquivo: Dados.txt Nome: Paulo Erro: Nome não encontrado

71

Nome: Paulo Roberto id: 1 Nome: Paulo Roberto Fone: 99164-8037 Nome: Renato Luis id: 4 Nome: Renato Luis Fone: 98778-3456 Nome: Erro: Nome não encontrado >>>

29. Arquivos Binários em Python

Como foi visto no capítulo 26, Python permite operar com arquivos binários e textos através de algumas funções, tais como: open, write, read, close, etc. Enquanto um arquivo texto é formado de linhas de caracteres terminados com um ‘\n’, um arquivo binário possui campos de vários tipos, tais como: inteiro, real, string, etc.

pickle é um módulo do Python que permite a serialização de objetos, ou seja, transforma objetos em sequências de bytes. Outros módulos similares podem ser utilizados, tais como: Marshal, Struct (como na linguagem C), JSON e Shelve. Exemplo de um programa em Python que grava em um arquivo binário: teste.bin os seguintes campos: nome (string), telefone (string) e idade (inteiro). # ........................ GravaBin.py import pickle nomeArquivo = input("Nome do Arquivo Binário: ") try: file = open(nomeArquivo, "rb") file.close() ch = input("Atenção: Arquivo já existe, sobre-escrever [s/n]") if ch == "S" or ch == "s": try: file = open(nomeArquivo, "wb") except IOError as error: print("Erro: Impossível criar o arquivo: %s" %nomeArquivo) n = int(input("Número de Elementos: ")) pickle.dump(n, file) for i in range(n): nome = input("Nome: ") pickle.dump(nome, file) telefone = input("Telefone: ") pickle.dump(telefone, file) idade = int(input("Idade: ")) pickle.dump(idade, file) file.close() except IOError as error:

72

print("Atenção: Arquivo não existe") try: file = open(nomeArquivo, "wb") except IOError as error: print("Erro: Impossível criar o arquivo: %s" %nomeArquivo) n = int(input("Número de Elementos: ")) pickle.dump(n, file) for i in range(n): nome = input("Nome: ") pickle.dump(nome, file) telefone = input("Telefone: ") pickle.dump(telefone, file) idade = int(input("Idade: ")) pickle.dump(idade, file) file.close() Observação: Note que o número 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 Número de Elementos: 3 Nome: Paulo Roberto Telefone: 99164-8037 Idade: 56 Nome: Adriane Maria Telefone: 99156-3334 Idade: 48 Nome: Paola Freitas Telefone: 99167-4567 Idade: 19 # ........................ 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

73

Número de Elementos: 3 Nome: Paulo Roberto Telefone: 99164-8037 Idade: 56 Nome: Adriane Maria Telefone: 99156-3334 Idade: 48 Nome: Paola Freitas Telefone: 99167-4567 Idade: 19

Exemplo de um programa em Python que grava em um arquivo binário: dados.bin uma lista (vetor) contendo os seguintes campos: nome (string), telefone (string) e idade (inteiro). # ........................... GravaBinario import pickle nomeArquivo = input("Nome lista = ["Paulo Roberto", "Adriane Maria", "Paola Freitas", n = len(lista) print("n = ", n)

do Arquivo Binário: ") "99164-8037", 56, "99156-3334", 48, "99181-3456", 19]

try: file = open(nomeArquivo, "wb") except IOError as error: print("Atenção: Impossível criar o arquivo") pickle.dump(lista, file) file.close() print("Okay, Arquivo %s criado" %nomeArquivo) Teste do Programa: Nome do Arquivo Binário: dados.bin n = 9 Okay, Arquivo dados.bin criado # ............................. LeBinario import pickle lista = [] nomeArquivo = input("Nome do Arquivo Binário: ") try: file = open(nomeArquivo, "rb") except IOError as errror: print("Atenção: Arquivo Inexistente") lista = pickle.load(file) print("Lista: ", lista) file.close() Teste do Programa: Nome do Arquivo Binário: dados.bin

74

Lista: ['Paulo Roberto', '99164-8037', 56, 'Adriane Maria', '99156-3334', 48, 'Paola Freitas', '99181-3456', 19] Arquivo Texto: Frutas.txt Abacate Ameixa Banana Bergamota Anana Morango Caqui Uva Laranja Lima Goiaba Damasco Tangerina # ........................... Letexto.py nomeArquivo = input("Nome do Arquivo Texto: ") linha = [] try: file = open(nomeArquivo, "r") for linha in file: linha = file.read() print(linha) file.close() except IOError as error: print("Atenção: Arquivo Inexistente") Teste do Programa: Nome do Arquivo Texto: Frutas.txt Abacate Ameixa Banana Bergamota Anana Morango Caqui Uva Laranja Lima Goiaba Damasco Tangerina # .............................. ConverteTextoBinario.py import pickle nomeArquivoTexto = input("Nome do Arquivo Texto: ") nomeArquivoBinario = input("Nome do Arquivo Binário: ")

75

try: fileTexto = open(nomeArquivoTexto, "r") try: fileBinario = open(nomeArquivoBinario, "wb") # cuidado: apaga arquivo se já existir except IOError as error: print("Atenção Impossível CRIAR Arquivo Binário") for linha in fileTexto: linha = fileTexto.read() pickle.dump(linha, fileBinario) print(linha) fileTexto.close() fileBinario.close() except IOError as error: print("Atenção: Arquivo texto inexistente") Teste do Programa: Nome do Arquivo Texto: Frutas.txt Nome do Arquivo Binário: Frutas.bin Abacate Ameixa Banana Bergamota Anana Morango Caqui Uva Laranja Lima Goiaba Damasco Tangerina # ........................ LeTextoConvertidoBinario.py import pickle nomeArquivo = input("Nome do Arquivo Binário: ") try: file = open(nomeArquivo, "rb") try: while True: linha = pickle.load(file)

76

print(linha) file.close() except EOFError as error: print("Atenção: Final do Arquivo") except IOError as error: print('Atenção: Arquivo não Existe', nomeArquivo) print(error) Teste do Programa: Nome do Arquivo Binário: Frutas.bin Abacate Banana Anana Caqui Laranja Goiaba Tangerina Atenção: Final do Arquivo Atenção: Função que verifica se um arquivo já existe: def ArquivoExiste(nomeArquivo): try: file = open(nomeArquivo, "r") except IOError: return False

# se não precisar da variável error não precisa #

definir

file.close() return True # .............................. GravaDados.py

import pickle def ArquivoExiste(nomeArquivo): try: file = open(nomeArquivo, "r") except IOError: return False file.close() return True nomeArquivo = input("Nome Arquivo Binário: ") if not(ArquivoExiste(nomeArquivo)): try:

77

file = open(nomeArquivo, "wb") ch = "S" while ch == "S" or ch == "s": nome = input("Nome: ") pickle.dump(nome, file) idade = int(input("Idade: ")) pickle.dump(idade, file) ch = input("Continua [s/n]? ") file.close() except IOError as error: print("Atenção: Impossível CRIAR o Arquivo") Teste do Programa: Nome Arquivo Binário: Dados.bin Nome: Paulo Roberto Idade: 56 Continua [s/n]? s Nome: Adriane Maria Idade: 48 Continua [s/n]? s Nome: Paola Freitas Idade: 19 Continua [s/n]? s Nome: Julia Helena Idade: 58 Continua [s/n]? s Nome: Ana Maria Idade: 59 Continua [s/n]? n

30. Sockets em Python

Socket é um mecanismo para comunicação de programas em dois sentidos que funcionam em uma rede computadores. O cliente solicita que uma conexão seja estabelecida com o servidor através de um Socket. Quando o servidor aceita o pedido de conexão, ele cria um novo socket por uma porta diferente. No cliente, outro socket é criado e então é utilizado para a comunicação com este servidor. Programas que utilizam sockets trabalham sempre em formato cliente-servidor, e para isto é necessário criar um programa servidor, que “escutará” as conexões em uma porta, e o programa cliente, que faz a conexão com algum socket disponível em alguma porta. Os principais comandos para uso de sockets em Python são os seguintes:

78

accept( ): aceita uma nova conexão e retorna os valores: o novo objeto socket e o endereço que o socket está se comunicando. bind((hostname,port)): porta.

conecta

o

socket

ao

endereço

da

close(): fecha o socket. connect((hostname,port)): conecta-se com outro socket, que pode ser externo ou local. Para conexões locais utiliza-se localhost ou 127.0.0.1 getpeername(): retorna o endereço IP e a porta na qual o socket está conectado. getsocketname(): retorna o endereço IP da porta do próprio socket. listen(max_connections): inicia ouvindo a porta e fica esperando outras conexões. O sistema operacional recusa novas conexões quando ela atingir o valor máximo de conexões. send(string): Envia uma string de dados pelo socket. Para a criação de programas que utilizem sockets no lado do servidor é necessário principalmente o uso dos seguintes comandos: serverSocket=socket.socket(socket.AF_INET,socket.SOCK_STREA M): para definir o protocolo a ser utilizado. serverSocket.bind((host,porta)): conexões no lado do servidor.

iniciando

serverSocket.listen(1): realiza o controle simultâneas que o servidor suportará.

a

escuta de

de

conexões

serverSocket.send(dados): para enviar dados. serverSocket.recv(1024): para receber dados controlando o tamanho do buffer. Para a criação de programas que utilizem sockets no lado do cliente é necessário principalmente o uso dos seguintes comandos: clientSocket.socket(socket.AF_INET,socket.SOCK_STREAM): para definir o protocolo a ser utilizado.

79

clientSocket.connect((servidor,porta)): para criar o objeto de conexão que irá conectar em um servidor. clientSocket.send(dados) : para enviar dados. clientSocket.recv(1024): para receber dados controlando o tamanho do buffer.

Exemplo da criação de uma conexão do lado do Cliente: # ...................... Cliente.py import socket # define host e porta HOST = "127.0.0.1" PORTA = 5000 # define o protocolo cliente = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # tenta conectar ao servidor cliente.connect((HOST, PORTA)) # envia mensagem cliente.send("Olá!! Boa Noite!".encode("utf-8")) print("Mensagem Enviada") # fecha a conexão cliente.close()

Exemplo da “escuta” de uma conexão do lado do Servidor: # ..................... Servidor.py import socket # define host e porta HOST = "127.0.0.1" PORTA = 5000 # define protocolo servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM) print("Na escuta ...") # inicia a escuta do lado servidor servidor.bind((HOST, PORTA)) # define o número máximo de conexões na fila servidor.listen(1) # para aceitar novas conexões conexao, endereco = servidor.accept()

80

# recebe os dados enviados pelo cliente dados = conexao.recv(1024) # exibe os dados recebidos print("Dados Recebidos: ", dados.decode("utf-8")) print("Conectado por: ", endereco) # fecha a conexão conexao.close()

Observação: Tem que se executar os dois programas ao mesmo tempo, isto pode ser feito via abertura de dois terminais, pois um programa “conversa” com o outro. Teste do Programa:

81

82

31. Threads em Python

Forma de um processo dividir-se em duas ou mais tarefas que podem ser executadas concorrentemente, ou seja, pode ser visto como um fluxo de controle sequencial isolado dentro do programa. Uma thread tem começo, fim e uma sequência de comandos. Uma thread em Python não é um programa, pois não executa sozinha, ela executa dentro de um programa. Threads permitem que um programa simples possa executar várias tarefas diferentes ao mesmo tempo, independentemente uma das outras. Programas multithreaded são programas que contém várias threads, executando tarefas distintas simultaneamente. 32. Módulo tkinter para GUI em Python

Existe um módulo não-nativo no Python que permite desenvolver interfaces gráficas (GUI - Graphics User Interface). Este módulo se chama “tkinter” (tk interface ou toolkit interface). Onde tk vem de toolkit, ou seja, um conjunto de ferramentas gráficas. Ele é baseado em tcl/tk. Tcl é Tool Command Language (Linguagem de Comandos de Ferramentas), ou seja, uma linguagem de programação para scripts. Link para vídeo aulas sobre o módulo “tkinter”: https://www.youtube.com/watch?v=vmoH9I9d570&list=PLesCEcYj003ShHnUT83gQEH6KtG8uysUE&index=2

Elementos de interface (widgets) correspondem a objetos de diversas classes. São alguns exemplos de widgets: • Frame (área retangular) • Button (botão) • Label (rótulo) • Text (caixa de texto) • Canvas (caixa de desenho)

83

Exemplo de como criar uma janela gráfica na aplicação utilizando o módulo tkinter: # ........................ Tk_1.py import tkinter as tk

# renomear um módulo

janela = tk.Tk() janela.mainloop()

No programa acima é necessário importar o módulo “tkinter”. A chamada janela = tk.Tk() cria e exibe uma janela gráfica na aplicação. A instrução janela.mainloop() faz com que a janela fique ativa, até que o usuário resolva fechar a janela no “x” (entrar em modo de tratamento de eventos). Resultado do programa:



No programa abaixo é possível colocar o nome na janela, neste caso: “Calculadora”, através da instrução janela.title(“Calculadora”). # .............................. Tk_2.py import tkinter as tk janela = tk.Tk() janela.title("Calculadora") janela.mainloop() Resultado do programa:

84





No programa abaixo é possível trocar a cor do background (fundo) através da instrução janela[“bg”] = “blue) ou janela[“background”] = “blue”. # .......................... Tk_3.py import tkinter as tk janela = tk.Tk() janela.title("Chat") janela["bg"] = "blue"

# bg é background

janela.mainloop() Resultado do programa:





85

No programa abaixo é possível especificar o tamanho e a posição da janela gráfica, isto é feito através da instrução janela.geometry(“LxA+E+T”), onde “L” é a largura, “A” é a altura, “E” é a distância da origem até a esquerda da janela e “T” é a distância da origem até o topo da janela. Alias a origem é na esquerda x topo da janela. # .............................. Tk_4.py import tkinter as tk janela = tk.Tk() janela.title("Chat") janela["background"] = "blue"

# bg ou background

janela.geometry("300x300+200+100")

#LarguraxAltura+distânciaEsquerda+distância_Topo, alguns são opcionais

janela.mainloop() Resultado do programa:





86

No programa abaixo é possível inserir texto na janela gráfica, isto é feito através das instruções lb = Label(janela, text=mensagem[i]) e lb.place(x=10, y=yc).

Label é um objeto tipo rótulo. Place é responsável pela posição de onde a mensagem vai ser colocada, ou seja, posição “x” e “y” em relação a origem (0,0) [left, top]. # ............................ Tk_5.py from tkinter import * janela = Tk() janela.title("Chat") xMax = 300 yMax = 300 left = 100 top = 200 s = str(xMax) + "x" + str(yMax) + "+" + str(left) + "+" + str(top) janela.geometry(s) mensagem = ["Olá, tudo bem", "Quando vais vir?", "Não demora", "Abraços"] n = len(mensagem) yc = 10 for i in range(n): lb = Label(janela, text=mensagem[i]) lb.place(x=10, y=yc) yc = yc + 20 janela.mainloop() Resultado do programa:



87



No programa abaixo é possível inserir um botão na janela gráfica, isto é feito através das instruções botao = tk.Button(janela, text=" Aperte ", command= Mensagem) [insere o botão na janela da aplicação] e botao.pack() [exibe o botão]. # ........................... Tk_6.py import tkinter as tk def Mensagem(): print("Olá, tudo bem?") janela = tk.Tk() janela.title("Tkinter") janela.geometry("300x300+200+100") botao = tk.Button(janela, text=" Aperte ", command=Mensagem) botao.pack() janela.mainloop() Resultado do programa:





Note que quando o botão foi pressionado, foi impressa a mensagem “Olá, tudo bem” na tela em modo texto (ou terminal).

88

O programa a seguir contém um botão (chamado “aperte”) que quando pressionado imprime a mensagem “Olá, tudo bem?” na janela gráfica. # ........................... Tk_7.py import tkinter as tk from tkinter import * def Mensagem(): mensagem = "Olá, tudo bem?" lb = Label(janela, text=mensagem) lb.place(x=100, y=200) janela = tk.Tk() janela.title("Tkinter") janela.geometry("300x300+200+100") botao = tk.Button(janela, text=" Aperte ", command=Mensagem) botao.pack() janela.mainloop()

O programa a seguir contém uma caixa de diálogo que permite a entrada de dados reais e exibe um somador (acumulador). 89

# ........................ Tk_8.py import tkinter as tk from tkinter import * def Soma(x): somador.set(somador.get() + valor.get()) def Mensagem(): mensagem = "Digite um valor e pressione " lb = Label(janela, text=mensagem) lb.place(x=25, y=200) janela = tk.Tk() janela.title("Acumulador") janela["background"] = "lightblue" janela.geometry("300x300+200+100") Mensagem() somador = DoubleVar(janela) valor = DoubleVar(janela) lSomador = Label(textvar=somador) eValor = Entry(textvar=valor) eValor.bind("", Soma) lSomador.pack() eValor.pack() janela.mainloop()

90



No programa acima, a caixa de diálogo foi realizada através da instrução: eValor = Entry(textvar=valor). O programa a seguir, mostra como encerrar uma aplicação através de um botão (Button) e uma chamada de um comando do Sistema Operacional: exit, por isto o import sys (from sys import exit). # .............................. Tk_9.py from sys import exit import tkinter as tk from tkinter import * janela = tk.Tk() janela.title("Tkinter") janela["background"] = "lightblue" janela.geometry("300x300+200+100") Button(janela, text=' Quit ', command=exit).pack() janela.mainloop()

O programa a seguir, mostra como configurar um rótulo, ou seja, selecionar a fonte, background , borda e etc através da instrução rotulo.configure(relief="ridge", font="Arial 24 bold", border=5, background="yellow"). 91

# ............................. Tk_10.py from tkinter import * janela = Tk() janela.title("Rótulo") janela.geometry("400x100") frame = Frame() ; frame.pack() rotulo = Label(frame, text=" Configurando um Rótulo ", foreground="blue") rotulo.pack() rotulo.configure(relief="ridge", font="Arial 24 bold", border=5, background="yellow") janela.mainloop()

O programa a seguir exibe a posição x e y do cursor do mouse. # ........................ Tk_11.py from tkinter import * def clique(e): txt = "Mouse: %d x %d" %(e.x,e.y) r.configure(text=txt) janela = Tk() janela.title("Mouse") r = Label() r.pack(expand=True, fill="both") r.master.geometry("200x200") r.bind("", clique) mainloop()

92

O programa a seguir exibe uma listbox. # ............................ Tk_12.py from tkinter import * root = Tk() listbox = Listbox(root) listbox.pack() for i in range(10): listbox.insert(END, " -> "+str(i)) mainloop()

O seguinte programa mostra como exibir na tela gráfica, texto colorido, configurando a cor da frente (foreground = fg) e a cor de fundo (background = bg), através da instrução: rot = Label(janela, text="Red", bg="red", fg="white"). # ............................ Tk_13.py from tkinter import * janela = Tk() janela.title("Cores") janela.geometry("300x300+200+100") rot = Label(janela, text="Red", bg="red", fg="white") rot.pack(fill=X) rot = Label(janela, text="Green", bg="green", fg="black") rot.pack(fill=X) rot = Label(janela, text="Blue", bg="blue", fg="white") rot.pack(fill=X) janela.mainloop()

93

94